This commit was manufactured by cvs2svn to create tag 'RC_1_30_2'.

[SVN r19443]

build/Jamfile

@@ -23,43 +23,61 @@ if [ check-python-config ]
       bpl-linkflags = <linkflags>"-e initlibboost_python" ;
   }
 
+  # Enabling intrinsics (/0i) or maximize speed (/02) seem to cause
+  # internal compiler errors with this toolset.
+  local msvc-stlport-workarounds
+    = <optimization>off "<cxxflags>-Ogty -O1 -Gs" ;
+    
+  local sources =
+    numeric.cpp
+    list.cpp
+    long.cpp
+    dict.cpp
+    tuple.cpp
+    str.cpp
+
+    aix_init_module.cpp
+    converter/from_python.cpp
+    converter/registry.cpp
+    converter/type_id.cpp
+    object/enum.cpp
+    object/class.cpp
+    object/function.cpp
+    object/inheritance.cpp
+    object/life_support.cpp
+    object/pickle_support.cpp
+    errors.cpp
+    module.cpp
+    converter/builtin_converters.cpp
+    converter/arg_to_python_base.cpp
+    object/iterator.cpp
+    object_protocol.cpp
+    object_operators.cpp
+    ;
+  
   dll boost_python
-    : 
-    ../src/numeric.cpp
-
-    ../src/list.cpp
-    ../src/long.cpp
-    ../src/dict.cpp
-    ../src/tuple.cpp
-    ../src/str.cpp
-
-    ../src/aix_init_module.cpp
-    ../src/converter/from_python.cpp
-    ../src/converter/registry.cpp
-    ../src/converter/type_id.cpp
-    ../src/object/enum.cpp
-    ../src/object/class.cpp
-    ../src/object/function.cpp
-    ../src/object/inheritance.cpp
-    ../src/object/life_support.cpp
-    ../src/object/pickle_support.cpp
-    ../src/errors.cpp
-    ../src/module.cpp
-    ../src/converter/builtin_converters.cpp
-    ../src/converter/arg_to_python_base.cpp
-    ../src/object/iterator.cpp
-    ../src/object_protocol.cpp
-    ../src/object_operators.cpp
-    :
-    $(BOOST_PYTHON_V2_PROPERTIES)
+    : ../src/$(sources)
+    : $(BOOST_PYTHON_V2_PROPERTIES)
       <define>BOOST_PYTHON_SOURCE
       $(bpl-linkflags)
+        <msvc-stlport><release>$(msvc-stlport-workarounds)
       ;
 
-  stage bin-stage : <dll>boost_python
-    :
-        <tag><debug>"_debug"
-        <tag><debug-python>"_pydebug"
+  lib boost_python
+    : # sources
+      ../src/$(sources)
+        
+    : # requirements
+      $(BOOST_PYTHON_V2_PROPERTIES)
+      <define>BOOST_PYTHON_SOURCE
+      <define>BOOST_STATIC_LIB
+      $(bpl-linkflags)
+        <msvc-stlport><release>$(msvc-stlport-workarounds)
+      ;
+
+  stage bin-stage : <dll>boost_python <lib>boost_python
+    : <tag><debug>"_debug"
+      <tag><debug-python>"_pydebug"
     :
         debug release
     ;

build/Jamfile.v2

@@ -0,0 +1,85 @@
+import os ;
+
+# Use a very crude way to sense there python is locatted
+
+local PYTHON_PATH ;
+
+if [ GLOB /usr/local/include/python2.2 : * ]
+{
+    PYTHON_PATH = /usr/local ;
+}
+else if [ GLOB /usr/include/python2.2 : * ] 
+{
+    PYTHON_PATH = /usr ;
+}
+
+if [ os.name ] in CYGWIN NT
+{
+    lib_condition = <link>shared: ;
+    defines = USE_DL_IMPORT ;
+   
+    # Declare a target for the python interpreter library
+    lib python : : <name>python2.2.dll ;
+    PYTHON_LIB = python ;    
+} 
+else 
+{
+   lib python : : <name>python2.2 ;
+   PYTHON_LIB = python ;    
+}
+
+
+
+if $(PYTHON_PATH) {
+    
+
+project boost/python
+    : source-location ../src
+        : requirements <include>$(PYTHON_PATH)/include/python2.2  
+          $(lib_condition)<library-path>$(PYTHON_PATH)/lib/python2.2/config
+            <link>shared:<library>$(PYTHON_LIB)
+            <define>$(defines)
+        : usage-requirements # requirement that will be propageted to *users* of this library
+          <include>$(PYTHON_PATH)/include/python2.2       
+
+# We have a bug which causes us to conclude that conditionalized
+# properties in this section are not free.
+#          $(lib_condition)<library-path>$(PYTHON_PATH)/lib/python2.2/config
+#            <shared>true:<find-library>$(PYTHON_LIB)
+            
+          <library-path>$(PYTHON_PATH)/lib/python2.2/config
+            <library>$(PYTHON_LIB)
+    ;
+
+lib boost_python
+    : 
+    numeric.cpp
+
+    list.cpp
+    long.cpp
+    dict.cpp
+    tuple.cpp
+    str.cpp
+
+    aix_init_module.cpp
+    converter/from_python.cpp
+    converter/registry.cpp
+    converter/type_id.cpp
+    object/enum.cpp
+    object/class.cpp
+    object/function.cpp
+    object/inheritance.cpp
+    object/life_support.cpp
+    object/pickle_support.cpp
+    errors.cpp
+    module.cpp
+    converter/builtin_converters.cpp
+    converter/arg_to_python_base.cpp
+    object/iterator.cpp
+    object_protocol.cpp
+    object_operators.cpp
+    :   <link>static:<define>BOOST_PYTHON_STATIC_LIB 
+        <define>BOOST_PYTHON_SOURCE
+    : <link>shared
+      ;
+}

build/VisualStudio/boost_python.dsp

@@ -0,0 +1,882 @@
+# 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\aix_init_module.cpp
+# End Source File
+# 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\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
+# 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\aix_init_module.hpp
+# End Source File
+# 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\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\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

@@ -0,0 +1,29 @@
+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/PyConDC_2003/bpl.txt

@@ -0,0 +1,947 @@
++++++++++++++++++++++++++++++++++++++++++++
+ Building Hybrid Systems with Boost.Python
++++++++++++++++++++++++++++++++++++++++++++
+
+:Author: David Abrahams
+:Contact: dave@boost-consulting.com
+:organization: `Boost Consulting`_
+:date: $Date$
+
+:Author: Ralf W. Grosse-Kunstleve
+
+:copyright: Copyright David Abrahams and Ralf W. Grosse-Kunstleve 2003. All rights reserved
+
+.. contents:: Table of Contents
+
+.. _`Boost Consulting`: http://www.boost-consulting.com
+
+==========
+ Abstract
+==========
+
+Boost.Python is an open source C++ library which provides a concise
+IDL-like interface for binding C++ classes and functions to
+Python. Leveraging the full power of C++ compile-time introspection
+and of recently developed metaprogramming techniques, this is achieved
+entirely in pure C++, without introducing a new syntax.
+Boost.Python's rich set of features and high-level interface make it
+possible to engineer packages from the ground up as hybrid systems,
+giving programmers easy and coherent access to both the efficient
+compile-time polymorphism of C++ and the extremely convenient run-time
+polymorphism of Python.
+
+==============
+ Introduction
+==============
+
+Python and C++ are in many ways as different as two languages could
+be: while C++ is usually compiled to machine-code, Python is
+interpreted.  Python's dynamic type system is often cited as the
+foundation of its flexibility, while in C++ static typing is the
+cornerstone of its efficiency. C++ has an intricate and difficult
+compile-time meta-language, while in Python, practically everything
+happens at runtime.
+
+Yet for many programmers, these very differences mean that Python and
+C++ complement one another perfectly.  Performance bottlenecks in
+Python programs can be rewritten in C++ for maximal speed, and
+authors of powerful C++ libraries choose Python as a middleware
+language for its flexible system integration capabilities.
+Furthermore, the surface differences mask some strong similarities:
+
+* 'C'-family control structures (if, while, for...)
+
+* Support for object-orientation, functional programming, and generic
+  programming (these are both *multi-paradigm* programming languages.)
+
+* Comprehensive operator overloading facilities, recognizing the
+  importance of syntactic variability for readability and
+  expressivity.
+
+* High-level concepts such as collections and iterators.
+
+* High-level encapsulation facilities (C++: namespaces, Python: modules)
+  to support the design of re-usable libraries.
+
+* Exception-handling for effective management of error conditions.
+
+* C++ idioms in common use, such as handle/body classes and
+  reference-counted smart pointers mirror Python reference semantics.
+
+Given Python's rich 'C' interoperability API, it should in principle
+be possible to expose C++ type and function interfaces to Python with
+an analogous interface to their C++ counterparts.  However, the
+facilities provided by Python alone for integration with C++ are
+relatively meager.  Compared to C++ and Python, 'C' has only very
+rudimentary abstraction facilities, and support for exception-handling
+is completely missing.  'C' extension module writers are required to
+manually manage Python reference counts, which is both annoyingly
+tedious and extremely error-prone. Traditional extension modules also
+tend to contain a great deal of boilerplate code repetition which
+makes them difficult to maintain, especially when wrapping an evolving
+API.
+
+These limitations have lead to the development of a variety of wrapping
+systems.  SWIG_ is probably the most popular package for the
+integration of C/C++ and Python. A more recent development is SIP_,
+which was specifically designed for interfacing Python with the Qt_
+graphical user interface library.  Both SWIG and SIP introduce their
+own specialized languages for customizing inter-language bindings.
+This has certain advantages, but having to deal with three different
+languages (Python, C/C++ and the interface language) also introduces
+practical and mental difficulties.  The CXX_ package demonstrates an
+interesting alternative.  It shows that at least some parts of
+Python's 'C' API can be wrapped and presented through a much more
+user-friendly C++ interface. However, unlike SWIG and SIP, CXX does
+not include support for wrapping C++ classes as new Python types.
+
+The features and goals of Boost.Python_ overlap significantly with
+many of these other systems.  That said, Boost.Python attempts to
+maximize convenience and flexibility without introducing a separate
+wrapping language.  Instead, it presents the user with a high-level
+C++ interface for wrapping C++ classes and functions, managing much of
+the complexity behind-the-scenes with static metaprogramming.
+Boost.Python also goes beyond the scope of earlier systems by
+providing:
+
+* Support for C++ virtual functions that can be overridden in Python.
+
+* Comprehensive lifetime management facilities for low-level C++
+  pointers and references.
+
+* Support for organizing extensions as Python packages,
+  with a central registry for inter-language type conversions.
+
+* A safe and convenient mechanism for tying into Python's powerful
+  serialization engine (pickle).
+
+* Coherence with the rules for handling C++ lvalues and rvalues that
+  can only come from a deep understanding of both the Python and C++
+  type systems.
+
+The key insight that sparked the development of Boost.Python is that
+much of the boilerplate code in traditional extension modules could be
+eliminated using C++ compile-time introspection.  Each argument of a
+wrapped C++ function must be extracted from a Python object using a
+procedure that depends on the argument type.  Similarly the function's
+return type determines how the return value will be converted from C++
+to Python.  Of course argument and return types are part of each
+function's type, and this is exactly the source from which
+Boost.Python deduces most of the information required.
+
+This approach leads to *user guided wrapping*: as much information is
+extracted directly from the source code to be wrapped as is possible
+within the framework of pure C++, and some additional information is
+supplied explicitly by the user.  Mostly the guidance is mechanical
+and little real intervention is required.  Because the interface
+specification is written in the same full-featured language as the
+code being exposed, the user has unprecedented power available when
+she does need to take control.
+
+.. _Python: http://www.python.org/
+.. _SWIG: http://www.swig.org/
+.. _SIP: http://www.riverbankcomputing.co.uk/sip/index.php
+.. _Qt: http://www.trolltech.com/
+.. _CXX: http://cxx.sourceforge.net/
+.. _Boost.Python: http://www.boost.org/libs/python/doc
+
+===========================
+ Boost.Python Design Goals 
+===========================
+
+The primary goal of Boost.Python is to allow users to expose C++
+classes and functions to Python using nothing more than a C++
+compiler.  In broad strokes, the user experience should be one of
+directly manipulating C++ objects from Python.
+
+However, it's also important not to translate all interfaces *too*
+literally: the idioms of each language must be respected.  For
+example, though C++ and Python both have an iterator concept, they are
+expressed very differently.  Boost.Python has to be able to bridge the
+interface gap.
+
+It must be possible to insulate Python users from crashes resulting
+from trivial misuses of C++ interfaces, such as accessing
+already-deleted objects.  By the same token the library should
+insulate C++ users from low-level Python 'C' API, replacing
+error-prone 'C' interfaces like manual reference-count management and
+raw ``PyObject`` pointers with more-robust alternatives.
+
+Support for component-based development is crucial, so that C++ types
+exposed in one extension module can be passed to functions exposed in
+another without loss of crucial information like C++ inheritance
+relationships.
+
+Finally, all wrapping must be *non-intrusive*, without modifying or
+even seeing the original C++ source code.  Existing C++ libraries have
+to be wrappable by third parties who only have access to header files
+and binaries.
+
+==========================
+ Hello Boost.Python World
+==========================
+
+And now for a preview of Boost.Python, and how it improves on the raw
+facilities offered by Python. Here's a function we might want to
+expose::
+
+    char const* greet(unsigned x)
+    {
+       static char const* const msgs[] = { "hello", "Boost.Python", "world!" };
+
+       if (x > 2) 
+           throw std::range_error("greet: index out of range");
+
+       return msgs[x];
+    }
+
+To wrap this function in standard C++ using the Python 'C' API, we'd
+need something like this::
+
+    extern "C" // all Python interactions use 'C' linkage and calling convention
+    {
+        // Wrapper to handle argument/result conversion and checking
+        PyObject* greet_wrap(PyObject* args, PyObject * keywords)
+        {
+             int x;
+             if (PyArg_ParseTuple(args, "i", &x))    // extract/check arguments
+             {
+                 char const* result = greet(x);      // invoke wrapped function
+                 return PyString_FromString(result); // convert result to Python
+             }
+             return 0;                               // error occurred
+        }
+
+        // Table of wrapped functions to be exposed by the module
+        static PyMethodDef methods[] = {
+            { "greet", greet_wrap, METH_VARARGS, "return one of 3 parts of a greeting" }
+            , { NULL, NULL, 0, NULL } // sentinel
+        };
+
+        // module initialization function
+        DL_EXPORT init_hello()
+        {
+            (void) Py_InitModule("hello", methods); // add the methods to the module
+        }
+    }
+
+Now here's the wrapping code we'd use to expose it with Boost.Python::
+
+    #include <boost/python.hpp>
+    using namespace boost::python;
+    BOOST_PYTHON_MODULE(hello)
+    {
+        def("greet", greet, "return one of 3 parts of a greeting");
+    }
+
+and here it is in action::
+
+    >>> import hello
+    >>> for x in range(3):
+    ...     print hello.greet(x)
+    ...
+    hello
+    Boost.Python
+    world!
+
+Aside from the fact that the 'C' API version is much more verbose,
+it's worth noting a few things that it doesn't handle correctly:
+
+* The original function accepts an unsigned integer, and the Python
+  'C' API only gives us a way of extracting signed integers. The
+  Boost.Python version will raise a Python exception if we try to pass
+  a negative number to ``hello.greet``, but the other one will proceed
+  to do whatever the C++ implementation does when converting an
+  negative integer to unsigned (usually wrapping to some very large
+  number), and pass the incorrect translation on to the wrapped
+  function.
+
+* That brings us to the second problem: if the C++ ``greet()``
+  function is called with a number greater than 2, it will throw an
+  exception.  Typically, if a C++ exception propagates across the
+  boundary with code generated by a 'C' compiler, it will cause a
+  crash.  As you can see in the first version, there's no C++
+  scaffolding there to prevent this from happening.  Functions wrapped
+  by Boost.Python automatically include an exception-handling layer
+  which protects Python users by translating unhandled C++ exceptions
+  into a corresponding Python exception.
+
+* A slightly more-subtle limitation is that the argument conversion
+  used in the Python 'C' API case can only get that integer ``x`` in
+  *one way*.  PyArg_ParseTuple can't convert Python ``long`` objects
+  (arbitrary-precision integers) which happen to fit in an ``unsigned
+  int`` but not in a ``signed long``, nor will it ever handle a
+  wrapped C++ class with a user-defined implicit ``operator unsigned
+  int()`` conversion. Boost.Python's dynamic type conversion
+  registry allows users to add arbitrary conversion methods.
+
+==================
+ Library Overview
+==================
+
+This section outlines some of the library's major features.  Except as
+neccessary to avoid confusion, details of library implementation are
+omitted.
+
+------------------
+ Exposing Classes
+------------------
+
+C++ classes and structs are exposed with a similarly-terse interface.
+Given::
+
+    struct World
+    {
+        void set(std::string msg) { this->msg = msg; }
+        std::string greet() { return msg; }
+        std::string msg;
+    };
+
+The following code will expose it in our extension module::
+    
+    #include <boost/python.hpp>
+    BOOST_PYTHON_MODULE(hello)
+    {
+        class_<World>("World")
+            .def("greet", &World::greet)
+            .def("set", &World::set)
+        ;
+    }
+
+Although this code has a certain pythonic familiarity, people
+sometimes find the syntax bit confusing because it doesn't look like
+most of the C++ code they're used to. All the same, this is just
+standard C++.  Because of their flexible syntax and operator
+overloading, C++ and Python are great for defining domain-specific
+(sub)languages
+(DSLs), and that's what we've done in Boost.Python. To break it down::
+
+    class_<World>("World")
+
+constructs an unnamed object of type ``class_<World>`` and passes
+``"World"`` to its constructor.  This creates a new-style Python class
+called ``World`` in the extension module, and associates it with the
+C++ type ``World`` in the Boost.Python type conversion registry.  We
+might have also written::
+
+    class_<World> w("World");
+
+but that would've been more verbose, since we'd have to name ``w``
+again to invoke its ``def()`` member function::
+
+        w.def("greet", &World::greet)
+
+There's nothing special about the location of the dot for member
+access in the original example: C++ allows any amount of whitespace on
+either side of a token, and placing the dot at the beginning of each
+line allows us to chain as many successive calls to member functions
+as we like with a uniform syntax.  The other key fact that allows
+chaining is that ``class_<>`` member functions all return a reference
+to ``*this``.
+
+So the example is equivalent to::
+
+    class_<World> w("World");
+    w.def("greet", &World::greet);
+    w.def("set", &World::set);
+
+It's occasionally useful to be able to break down the components of a
+Boost.Python class wrapper in this way, but the rest of this article
+will stick to the terse syntax.
+
+For completeness, here's the wrapped class in use: ::
+
+    >>> import hello
+    >>> planet = hello.World()
+    >>> planet.set('howdy')
+    >>> planet.greet()
+    'howdy'
+
+Constructors
+============
+
+Since our ``World`` class is just a plain ``struct``, it has an
+implicit no-argument (nullary) constructor.  Boost.Python exposes the
+nullary constructor by default, which is why we were able to write: ::
+
+  >>> planet = hello.World()
+
+However, well-designed classes in any language may require constructor
+arguments in order to establish their invariants.  Unlike Python,
+where ``__init__`` is just a specially-named method, In C++
+constructors cannot be handled like ordinary member functions.  In
+particular, we can't take their address: ``&World::World`` is an
+error.  The library provides a different interface for specifying
+constructors.  Given::
+
+    struct World
+    {
+        World(std::string msg); // added constructor
+        ...
+
+we can modify our wrapping code as follows::
+
+    class_<World>("World", init<std::string>())
+        ...
+
+of course, a C++ class may have additional constructors, and we can
+expose those as well by passing more instances of ``init<...>`` to
+``def()``::
+
+    class_<World>("World", init<std::string>())
+        .def(init<double, double>())
+        ...
+
+Boost.Python allows wrapped functions, member functions, and
+constructors to be overloaded to mirror C++ overloading.
+
+Data Members and Properties
+===========================
+
+Any publicly-accessible data members in a C++ class can be easily
+exposed as either ``readonly`` or ``readwrite`` attributes::
+
+    class_<World>("World", init<std::string>())
+        .def_readonly("msg", &World::msg)
+        ...
+
+and can be used directly in Python: ::
+
+    >>> planet = hello.World('howdy')
+    >>> planet.msg
+    'howdy'
+
+This does *not* result in adding attributes to the ``World`` instance
+``__dict__``, which can result in substantial memory savings when
+wrapping large data structures.  In fact, no instance ``__dict__``
+will be created at all unless attributes are explicitly added from
+Python. Boost.Python owes this capability to the new Python 2.2 type
+system, in particular the descriptor interface and ``property`` type.
+
+In C++, publicly-accessible data members are considered a sign of poor
+design because they break encapsulation, and style guides usually
+dictate the use of "getter" and "setter" functions instead.  In
+Python, however, ``__getattr__``, ``__setattr__``, and since 2.2,
+``property`` mean that attribute access is just one more
+well-encapsulated syntactic tool at the programmer's disposal.
+Boost.Python bridges this idiomatic gap by making Python ``property``
+creation directly available to users.  If ``msg`` were private, we
+could still expose it as attribute in Python as follows::
+
+    class_<World>("World", init<std::string>())
+        .add_property("msg", &World::greet, &World::set)
+        ...
+
+The example above mirrors the familiar usage of properties in Python
+2.2+: ::
+
+    >>> class World(object):
+    ...     __init__(self, msg):
+    ...         self.__msg = msg
+    ...     def greet(self):
+    ...         return self.__msg
+    ...     def set(self, msg):
+    ...         self.__msg = msg
+    ...     msg = property(greet, set)
+
+Operator Overloading
+====================
+
+The ability to write arithmetic operators for user-defined types has
+been a major factor in the success of both languages for numerical
+computation, and the success of packages like NumPy_ attests to the
+power of exposing operators in extension modules.  Boost.Python
+provides a concise mechanism for wrapping operator overloads. The
+example below shows a fragment from a wrapper for the Boost rational
+number library::
+
+    class_<rational<int> >("rational_int")
+      .def(init<int, int>()) // constructor, e.g. rational_int(3,4)
+      .def("numerator", &rational<int>::numerator)
+      .def("denominator", &rational<int>::denominator)
+      .def(-self)        // __neg__ (unary minus)
+      .def(self + self)  // __add__ (homogeneous)
+      .def(self * self)  // __mul__
+      .def(self + int()) // __add__ (heterogenous)
+      .def(int() + self) // __radd__
+      ...
+
+The magic is performed using a simplified application of "expression
+templates" [VELD1995]_, a technique originally developed for
+optimization of high-performance matrix algebra expressions.  The
+essence is that instead of performing the computation immediately,
+operators are overloaded to construct a type *representing* the
+computation.  In matrix algebra, dramatic optimizations are often
+available when the structure of an entire expression can be taken into
+account, rather than evaluating each operation "greedily".
+Boost.Python uses the same technique to build an appropriate Python
+method object based on expressions involving ``self``.
+
+.. _NumPy: http://www.pfdubois.com/numpy/
+
+Inheritance
+===========
+
+C++ inheritance relationships can be represented to Boost.Python by adding
+an optional ``bases<...>`` argument to the ``class_<...>`` template
+parameter list as follows::
+
+     class_<Derived, bases<Base1,Base2> >("Derived")
+          ...
+
+This has two effects:  
+
+1. When the ``class_<...>`` is created, Python type objects
+   corresponding to ``Base1`` and ``Base2`` are looked up in
+   Boost.Python's registry, and are used as bases for the new Python
+   ``Derived`` type object, so methods exposed for the Python ``Base1``
+   and ``Base2`` types are automatically members of the ``Derived``
+   type.  Because the registry is global, this works correctly even if
+   ``Derived`` is exposed in a different module from either of its
+   bases.
+
+2. C++ conversions from ``Derived`` to its bases are added to the
+   Boost.Python registry.  Thus wrapped C++ methods expecting (a
+   pointer or reference to) an object of either base type can be
+   called with an object wrapping a ``Derived`` instance.  Wrapped
+   member functions of class ``T`` are treated as though they have an
+   implicit first argument of ``T&``, so these conversions are
+   neccessary to allow the base class methods to be called for derived
+   objects.
+
+Of course it's possible to derive new Python classes from wrapped C++
+class instances.  Because Boost.Python uses the new-style class
+system, that works very much as for the Python built-in types.  There
+is one significant detail in which it differs: the built-in types
+generally establish their invariants in their ``__new__`` function, so
+that derived classes do not need to call ``__init__`` on the base
+class before invoking its methods : ::
+
+    >>> class L(list):
+    ...      def __init__(self):
+    ...          pass
+    ...
+    >>> L().reverse()
+    >>> 
+
+Because C++ object construction is a one-step operation, C++ instance
+data cannot be constructed until the arguments are available, in the
+``__init__`` function: ::
+
+    >>> class D(SomeBoostPythonClass):
+    ...      def __init__(self):
+    ...          pass
+    ...
+    >>> D().some_boost_python_method()
+    Traceback (most recent call last):
+      File "<stdin>", line 1, in ?
+    TypeError: bad argument type for built-in operation
+
+This happened because Boost.Python couldn't find instance data of type
+``SomeBoostPythonClass`` within the ``D`` instance; ``D``'s ``__init__``
+function masked construction of the base class.  It could be corrected
+by either removing ``D``'s ``__init__`` function or having it call
+``SomeBoostPythonClass.__init__(...)`` explicitly.
+
+Virtual Functions
+=================
+
+Deriving new types in Python from extension classes is not very
+interesting unless they can be used polymorphically from C++.  In
+other words, Python method implementations should appear to override
+the implementation of C++ virtual functions when called *through base
+class pointers/references from C++*.  Since the only way to alter the
+behavior of a virtual function is to override it in a derived class,
+the user must build a special derived class to dispatch a polymorphic
+class' virtual functions::
+
+    //
+    // interface to wrap:
+    //
+    class Base
+    {
+     public:
+        virtual int f(std::string x) { return 42; }
+        virtual ~Base();
+    };
+
+    int calls_f(Base const& b, std::string x) { return b.f(x); }
+
+    //
+    // Wrapping Code
+    //
+
+    // Dispatcher class
+    struct BaseWrap : Base
+    {
+        // Store a pointer to the Python object
+        BaseWrap(PyObject* self_) : self(self_) {}
+        PyObject* self;
+
+        // Default implementation, for when f is not overridden
+        int f_default(std::string x) { return this->Base::f(x); }
+        // Dispatch implementation
+        int f(std::string x) { return call_method<int>(self, "f", x); }
+    };
+
+    ...
+        def("calls_f", calls_f);
+        class_<Base, BaseWrap>("Base")
+            .def("f", &Base::f, &BaseWrap::f_default)
+            ;
+
+Now here's some Python code which demonstrates: ::
+
+    >>> class Derived(Base):
+    ...     def f(self, s):
+    ...          return len(s)
+    ...
+    >>> calls_f(Base(), 'foo')
+    42
+    >>> calls_f(Derived(), 'forty-two')
+    9
+
+Things to notice about the dispatcher class:
+
+* The key element which allows overriding in Python is the
+  ``call_method`` invocation, which uses the same global type
+  conversion registry as the C++ function wrapping does to convert its
+  arguments from C++ to Python and its return type from Python to C++.
+
+* Any constructor signatures you wish to wrap must be replicated with
+  an initial ``PyObject*`` argument
+
+* The dispatcher must store this argument so that it can be used to
+  invoke ``call_method``
+
+* The ``f_default`` member function is needed when the function being
+  exposed is not pure virtual; there's no other way ``Base::f`` can be
+  called on an object of type ``BaseWrap``, since it overrides ``f``.
+
+Deeper Reflection on the Horizon?
+=================================
+
+Admittedly, this formula is tedious to repeat, especially on a project
+with many polymorphic classes.  That it is neccessary reflects some
+limitations in C++'s compile-time introspection capabilities: there's
+no way to enumerate the members of a class and find out which are
+virtual functions.  At least one very promising project has been
+started to write a front-end which can generate these dispatchers (and
+other wrapping code) automatically from C++ headers.  
+
+Pyste_ is being developed by Bruno da Silva de Oliveira.  It builds on
+GCC_XML_, which generates an XML version of GCC's internal program
+representation.  Since GCC is a highly-conformant C++ compiler, this
+ensures correct handling of the most-sophisticated template code and
+full access to the underlying type system.  In keeping with the
+Boost.Python philosophy, a Pyste interface description is neither
+intrusive on the code being wrapped, nor expressed in some unfamiliar
+language: instead it is a 100% pure Python script.  If Pyste is
+successful it will mark a move away from wrapping everything directly
+in C++ for many of our users.  It will also allow us the choice to
+shift some of the metaprogram code from C++ to Python.  We expect that
+soon, not only our users but the Boost.Python developers themselves
+will be "thinking hybrid" about their own code.
+
+.. _`GCC_XML`: http://www.gccxml.org/HTML/Index.html
+.. _`Pyste`: http://www.boost.org/libs/python/pyste
+
+---------------
+ Serialization
+---------------
+
+*Serialization* is the process of converting objects in memory to a
+form that can be stored on disk or sent over a network connection. The
+serialized object (most often a plain string) can be retrieved and
+converted back to the original object. A good serialization system will
+automatically convert entire object hierarchies. Python's standard
+``pickle`` module is just such a system.  It leverages the language's strong
+runtime introspection facilities for serializing practically arbitrary
+user-defined objects. With a few simple and unintrusive provisions this
+powerful machinery can be extended to also work for wrapped C++ objects.
+Here is an example::
+
+    #include <string>
+
+    struct World
+    {
+        World(std::string a_msg) : msg(a_msg) {}
+        std::string greet() const { return msg; }
+        std::string msg;
+    };
+
+    #include <boost/python.hpp>
+    using namespace boost::python;
+
+    struct World_picklers : pickle_suite
+    {
+      static tuple
+      getinitargs(World const& w) { return make_tuple(w.greet()); }
+    };
+
+    BOOST_PYTHON_MODULE(hello)
+    {
+        class_<World>("World", init<std::string>())
+            .def("greet", &World::greet)
+            .def_pickle(World_picklers())
+        ;
+    }
+
+Now let's create a ``World`` object and put it to rest on disk::
+
+    >>> import hello
+    >>> import pickle
+    >>> a_world = hello.World("howdy")
+    >>> pickle.dump(a_world, open("my_world", "w"))
+
+In a potentially *different script* on a potentially *different
+computer* with a potentially *different operating system*::
+
+    >>> import pickle
+    >>> resurrected_world = pickle.load(open("my_world", "r"))
+    >>> resurrected_world.greet()
+    'howdy'
+
+Of course the ``cPickle`` module can also be used for faster
+processing.
+
+Boost.Python's ``pickle_suite`` fully supports the ``pickle`` protocol
+defined in the standard Python documentation. Like a __getinitargs__
+function in Python, the pickle_suite's getinitargs() is responsible for
+creating the argument tuple that will be use to reconstruct the pickled
+object.  The other elements of the Python pickling protocol,
+__getstate__ and __setstate__ can be optionally provided via C++
+getstate and setstate functions.  C++'s static type system allows the
+library to ensure at compile-time that nonsensical combinations of
+functions (e.g. getstate without setstate) are not used.
+
+Enabling serialization of more complex C++ objects requires a little
+more work than is shown in the example above. Fortunately the
+``object`` interface (see next section) greatly helps in keeping the
+code manageable.
+
+------------------
+ Object interface
+------------------
+
+Experienced 'C' language extension module authors will be familiar
+with the ubiquitous ``PyObject*``, manual reference-counting, and the
+need to remember which API calls return "new" (owned) references or
+"borrowed" (raw) references.  These constraints are not just
+cumbersome but also a major source of errors, especially in the
+presence of exceptions.
+
+Boost.Python provides a class ``object`` which automates reference
+counting and provides conversion to Python from C++ objects of
+arbitrary type.  This significantly reduces the learning effort for
+prospective extension module writers.
+
+Creating an ``object`` from any other type is extremely simple::
+
+    object s("hello, world");  // s manages a Python string
+
+``object`` has templated interactions with all other types, with
+automatic to-python conversions. It happens so naturally that it's
+easily overlooked::
+
+   object ten_Os = 10 * s[4]; // -> "oooooooooo"
+
+In the example above, ``4`` and ``10`` are converted to Python objects
+before the indexing and multiplication operations are invoked.
+
+The ``extract<T>`` class template can be used to convert Python objects
+to C++ types::
+
+    double x = extract<double>(o);
+
+If a conversion in either direction cannot be performed, an
+appropriate exception is thrown at runtime.
+
+The ``object`` type is accompanied by a set of derived types
+that mirror the Python built-in types such as ``list``, ``dict``,
+``tuple``, etc. as much as possible. This enables convenient
+manipulation of these high-level types from C++::
+
+    dict d;
+    d["some"] = "thing";
+    d["lucky_number"] = 13;
+    list l = d.keys();
+
+This almost looks and works like regular Python code, but it is pure
+C++.  Of course we can wrap C++ functions which accept or return
+``object`` instances.
+
+=================
+ Thinking hybrid
+=================
+
+Because of the practical and mental difficulties of combining
+programming languages, it is common to settle a single language at the
+outset of any development effort.  For many applications, performance
+considerations dictate the use of a compiled language for the core
+algorithms.  Unfortunately, due to the complexity of the static type
+system, the price we pay for runtime performance is often a
+significant increase in development time.  Experience shows that
+writing maintainable C++ code usually takes longer and requires *far*
+more hard-earned working experience than developing comparable Python
+code.  Even when developers are comfortable working exclusively in
+compiled languages, they often augment their systems by some type of
+ad hoc scripting layer for the benefit of their users without ever
+availing themselves of the same advantages.
+
+Boost.Python enables us to *think hybrid*.  Python can be used for
+rapidly prototyping a new application; its ease of use and the large
+pool of standard libraries give us a head start on the way to a
+working system.  If necessary, the working code can be used to
+discover rate-limiting hotspots.  To maximize performance these can
+be reimplemented in C++, together with the Boost.Python bindings
+needed to tie them back into the existing higher-level procedure.
+
+Of course, this *top-down* approach is less attractive if it is clear
+from the start that many algorithms will eventually have to be
+implemented in C++.  Fortunately Boost.Python also enables us to
+pursue a *bottom-up* approach.  We have used this approach very
+successfully in the development of a toolbox for scientific
+applications.  The toolbox started out mainly as a library of C++
+classes with Boost.Python bindings, and for a while the growth was
+mainly concentrated on the C++ parts.  However, as the toolbox is
+becoming more complete, more and more newly added functionality can be
+implemented in Python.
+
+.. image:: python_cpp_mix.jpg
+
+This figure shows the estimated ratio of newly added C++ and Python
+code over time as new algorithms are implemented.  We expect this
+ratio to level out near 70% Python.  Being able to solve new problems
+mostly in Python rather than a more difficult statically typed
+language is the return on our investment in Boost.Python.  The ability
+to access all of our code from Python allows a broader group of
+developers to use it in the rapid development of new applications.
+
+=====================
+ Development history
+=====================
+
+The first version of Boost.Python was developed in 2000 by Dave
+Abrahams at Dragon Systems, where he was privileged to have Tim Peters
+as a guide to "The Zen of Python".  One of Dave's jobs was to develop
+a Python-based natural language processing system.  Since it was
+eventually going to be targeting embedded hardware, it was always
+assumed that the compute-intensive core would be rewritten in C++ to
+optimize speed and memory footprint [#proto]_.  The project also wanted to
+test all of its C++ code using Python test scripts [#test]_.  The only
+tool we knew of for binding C++ and Python was SWIG_, and at the time
+its handling of C++ was weak.  It would be false to claim any deep
+insight into the possible advantages of Boost.Python's approach at
+this point.  Dave's interest and expertise in fancy C++ template
+tricks had just reached the point where he could do some real damage,
+and Boost.Python emerged as it did because it filled a need and
+because it seemed like a cool thing to try.
+
+This early version was aimed at many of the same basic goals we've
+described in this paper, differing most-noticeably by having a
+slightly more cumbersome syntax and by lack of special support for
+operator overloading, pickling, and component-based development.
+These last three features were quickly added by Ullrich Koethe and
+Ralf Grosse-Kunstleve [#feature]_, and other enthusiastic contributors arrived
+on the scene to contribute enhancements like support for nested
+modules and static member functions.
+
+By early 2001 development had stabilized and few new features were
+being added, however a disturbing new fact came to light: Ralf had
+begun testing Boost.Python on pre-release versions of a compiler using
+the EDG_ front-end, and the mechanism at the core of Boost.Python
+responsible for handling conversions between Python and C++ types was
+failing to compile.  As it turned out, we had been exploiting a very
+common bug in the implementation of all the C++ compilers we had
+tested.  We knew that as C++ compilers rapidly became more
+standards-compliant, the library would begin failing on more
+platforms.  Unfortunately, because the mechanism was so central to the
+functioning of the library, fixing the problem looked very difficult.
+
+Fortunately, later that year Lawrence Berkeley and later Lawrence
+Livermore National labs contracted with `Boost Consulting`_ for support
+and development of Boost.Python, and there was a new opportunity to
+address fundamental issues and ensure a future for the library.  A
+redesign effort began with the low level type conversion architecture,
+building in standards-compliance and support for component-based
+development (in contrast to version 1 where conversions had to be
+explicitly imported and exported across module boundaries).  A new
+analysis of the relationship between the Python and C++ objects was
+done, resulting in more intuitive handling for C++ lvalues and
+rvalues.
+
+The emergence of a powerful new type system in Python 2.2 made the
+choice of whether to maintain compatibility with Python 1.5.2 easy:
+the opportunity to throw away a great deal of elaborate code for
+emulating classic Python classes alone was too good to pass up.  In
+addition, Python iterators and descriptors provided crucial and
+elegant tools for representing similar C++ constructs.  The
+development of the generalized ``object`` interface allowed us to
+further shield C++ programmers from the dangers and syntactic burdens
+of the Python 'C' API.  A great number of other features including C++
+exception translation, improved support for overloaded functions, and
+most significantly, CallPolicies for handling pointers and
+references, were added during this period.
+
+In October 2002, version 2 of Boost.Python was released.  Development
+since then has concentrated on improved support for C++ runtime
+polymorphism and smart pointers.  Peter Dimov's ingenious
+``boost::shared_ptr`` design in particular has allowed us to give the
+hybrid developer a consistent interface for moving objects back and
+forth across the language barrier without loss of information.  At
+first, we were concerned that the sophistication and complexity of the
+Boost.Python v2 implementation might discourage contributors, but the
+emergence of Pyste_ and several other significant feature
+contributions have laid those fears to rest.  Daily questions on the
+Python C++-sig and a backlog of desired improvements show that the
+library is getting used.  To us, the future looks bright.
+
+.. _`EDG`: http://www.edg.com
+
+=============
+ Conclusions
+=============
+
+Boost.Python achieves seamless interoperability between two rich and
+complimentary language environments.  Because it leverages template
+metaprogramming to introspect about types and functions, the user
+never has to learn a third syntax: the interface definitions are
+written in concise and maintainable C++.  Also, the wrapping system
+doesn't have to parse C++ headers or represent the type system: the
+compiler does that work for us.
+
+Computationally intensive tasks play to the strengths of C++ and are
+often impossible to implement efficiently in pure Python, while jobs
+like serialization that are trivial in Python can be very difficult in
+pure C++.  Given the luxury of building a hybrid software system from
+the ground up, we can approach design with new confidence and power.
+
+===========
+ Citations
+===========
+
+.. [VELD1995] T. Veldhuizen, "Expression Templates," C++ Report,
+   Vol. 7 No. 5 June 1995, pp. 26-31.
+   http://osl.iu.edu/~tveldhui/papers/Expression-Templates/exprtmpl.html
+
+===========
+ Footnotes
+===========
+
+.. [#proto] In retrospect, it seems that "thinking hybrid" from the
+        ground up might have been better for the NLP system: the
+        natural component boundaries defined by the pure python
+        prototype turned out to be inappropriate for getting the
+        desired performance and memory footprint out of the C++ core,
+        which eventually caused some redesign overhead on the Python
+        side when the core was moved to C++.
+
+.. [#test] We also have some reservations about driving all C++
+        testing through a Python interface, unless that's the only way
+        it will be ultimately used.  Any transition across language
+        boundaries with such different object models can inevitably
+        mask bugs.
+
+.. [#feature] These features were expressed very differently in v1 of
+        Boost.Python

doc/PyConDC_2003/bpl_mods.txt

@@ -0,0 +1,908 @@
+.. This is a comment. Note how any initial comments are moved by
+   transforms to after the document title, subtitle, and docinfo.
+
+.. Need intro and conclusion
+.. Exposing classes
+    .. Constructors
+    .. Overloading
+    .. Properties and data members
+    .. Inheritance
+    .. Operators and Special Functions
+    .. Virtual Functions
+.. Call Policies
+
+++++++++++++++++++++++++++++++++++++++++++++++
+ Introducing Boost.Python (Extended Abstract)
+++++++++++++++++++++++++++++++++++++++++++++++
+
+
+.. bibliographic fields (which also require a transform):
+
+:Author: David Abrahams
+:Address: 45 Walnut Street
+          Somerville, MA 02143
+:Contact: dave@boost-consulting.com
+:organization: `Boost Consulting`_
+:date: $Date$
+:status: This is a "work in progress"
+:version: 1
+:copyright: Copyright David Abrahams 2002. All rights reserved
+
+:Dedication:
+
+    For my girlfriend, wife, and partner Luann
+
+:abstract:
+
+    This paper describes the Boost.Python library, a system for
+    C++/Python interoperability.
+
+.. meta::
+   :keywords: Boost,python,Boost.Python,C++
+   :description lang=en: C++/Python interoperability with Boost.Python
+
+.. contents:: Table of Contents
+.. section-numbering::
+
+
+.. _`Boost Consulting`: http://www.boost-consulting.com
+
+==============
+ Introduction
+==============
+
+Python and C++ are in many ways as different as two languages could
+be: while C++ is usually compiled to machine-code, Python is
+interpreted.  Python's dynamic type system is often cited as the
+foundation of its flexibility, while in C++ static typing is the
+cornerstone of its efficiency. C++ has an intricate and difficult
+meta-language to support compile-time polymorphism, while Python is
+a uniform language with convenient runtime polymorphism.
+
+Yet for many programmers, these very differences mean that Python and
+C++ complement one another perfectly.  Performance bottlenecks in
+Python programs can be rewritten in C++ for maximal speed, and
+authors of powerful C++ libraries choose Python as a middleware
+language for its flexible system integration capabilities.
+Furthermore, the surface differences mask some strong similarities:
+
+* 'C'-family control structures (if, while, for...)
+
+* Support for object-orientation, functional programming, and generic
+  programming (these are both *multi-paradigm* programming languages.)
+
+* Comprehensive operator overloading facilities, recognizing the
+  importance of syntactic variability for readability and
+  expressivity.
+
+* High-level concepts such as collections and iterators.
+
+* High-level encapsulation facilities (C++: namespaces, Python: modules)
+  to support the design of re-usable libraries.
+
+* Exception-handling for effective management of error conditions.
+
+* C++ idioms in common use, such as handle/body classes and
+  reference-counted smart pointers mirror Python reference semantics.
+
+Python provides a rich 'C' API for writers of 'C' extension modules.
+Unfortunately, using this API directly for exposing C++ type and
+function interfaces to Python is much more tedious than it should be.
+This is mainly due to the limitations of the 'C' language.  Compared to
+C++ and Python, 'C' has only very rudimentary abstraction facilities.
+Support for exception-handling is completely missing. One important
+undesirable consequence is that 'C' extension module writers are
+required to manually manage Python reference counts. Another unpleasant
+consequence is a very high degree of repetition of similar code in 'C'
+extension modules. Of course highly redundant code does not only cause
+frustration for the module writer, but is also very difficult to
+maintain.
+
+The limitations of the 'C' API have lead to the development of a
+variety of wrapping systems. SWIG_ is probably the most popular package
+for the integration of C/C++ and Python. A more recent development is
+the SIP_ package, which is specifically designed for interfacing Python
+with the Qt_ graphical user interface library. Both SWIG and SIP
+introduce a new specialized language for defining the inter-language
+bindings. Of course being able to use a specialized language has
+advantages, but having to deal with three different languages (Python,
+C/C++ and the interface language) also introduces practical and mental
+difficulties. The CXX_ package demonstrates an interesting alternative.
+It shows that at least some parts of Python's 'C' API can be wrapped
+and presented through a much more user-friendly C++ interface. However,
+unlike SWIG and SIP, CXX does not include support for wrapping C++
+classes as new Python types. CXX is also no longer actively developed.
+
+In some respects Boost.Python combines ideas from SWIG and SIP with
+ideas from CXX. Like SWIG and SIP, Boost.Python is a system for
+wrapping C++ classes as new Python "built-in" types, and C/C++
+functions as Python functions. Like CXX, Boost.Python presents Python's
+'C' API through a C++ interface. Boost.Python goes beyond the scope of
+other systems with the unique support for C++ virtual functions that
+are overrideable in Python, support for organizing extensions as Python
+packages with a central registry for inter-language type conversions,
+and a convenient mechanism for tying into Python's serialization engine
+(pickle). Importantly, all this is achieved without introducing a new
+syntax. Boost.Python leverages the power of C++ meta-programming
+techniques to introspect about the C++ type system, and presents a
+simple, IDL-like C++ interface for exposing C/C++ code in extension
+modules. Boost.Python is a pure C++ library, the inter-language
+bindings are defined in pure C++, and other than a C++ compiler only
+Python itself is required to get started with Boost.Python. Last but
+not least, Boost.Python is an unrestricted open source library. There
+are no strings attached even for commercial applications.
+
+.. _SWIG: http://www.swig.org/
+.. _SIP: http://www.riverbankcomputing.co.uk/sip/index.php
+.. _Qt: http://www.trolltech.com/
+.. _CXX: http://cxx.sourceforge.net/
+
+===========================
+ Boost.Python Design Goals 
+===========================
+
+The primary goal of Boost.Python is to allow users to expose C++
+classes and functions to Python using nothing more than a C++
+compiler.  In broad strokes, the user experience should be one of
+directly manipulating C++ objects from Python.
+
+However, it's also important not to translate all interfaces *too*
+literally: the idioms of each language must be respected.  For
+example, though C++ and Python both have an iterator concept, they are
+expressed very differently.  Boost.Python has to be able to bridge the
+interface gap.
+
+It must be possible to insulate Python users from crashes resulting
+from trivial misuses of C++ interfaces, such as accessing
+already-deleted objects.  By the same token the library should
+insulate C++ users from low-level Python 'C' API, replacing
+error-prone 'C' interfaces like manual reference-count management and
+raw ``PyObject`` pointers with more-robust alternatives.
+
+Support for component-based development is crucial, so that C++ types
+exposed in one extension module can be passed to functions exposed in
+another without loss of crucial information like C++ inheritance
+relationships.
+
+Finally, all wrapping must be *non-intrusive*, without modifying or
+even seeing the original C++ source code.  Existing C++ libraries have
+to be wrappable by third parties who only have access to header files
+and binaries.
+
+==========================
+ Hello Boost.Python World
+==========================
+
+And now for a preview of Boost.Python, and how it improves on the raw
+facilities offered by Python. Here's a function we might want to
+expose::
+
+    char const* greet(unsigned x)
+    {
+       static char const* const msgs[] = { "hello", "Boost.Python", "world!" };
+
+       if (x > 2) 
+           throw std::range_error("greet: index out of range");
+
+       return msgs[x];
+    }
+
+To wrap this function in standard C++ using the Python 'C' API, we'd
+need something like this::
+
+    extern "C" // all Python interactions use 'C' linkage and calling convention
+    {
+        // Wrapper to handle argument/result conversion and checking
+        PyObject* greet_wrap(PyObject* args, PyObject * keywords)
+        {
+             int x;
+             if (PyArg_ParseTuple(args, "i", &x))    // extract/check arguments
+             {
+                 char const* result = greet(x);      // invoke wrapped function
+                 return PyString_FromString(result); // convert result to Python
+             }
+             return 0;                               // error occurred
+        }
+
+        // Table of wrapped functions to be exposed by the module
+        static PyMethodDef methods[] = {
+            { "greet", greet_wrap, METH_VARARGS, "return one of 3 parts of a greeting" }
+            , { NULL, NULL, 0, NULL } // sentinel
+        };
+
+        // module initialization function
+        DL_EXPORT init_hello()
+        {
+            (void) Py_InitModule("hello", methods); // add the methods to the module
+        }
+    }
+
+Now here's the wrapping code we'd use to expose it with Boost.Python::
+
+    #include <boost/python.hpp>
+    using namespace boost::python;
+    BOOST_PYTHON_MODULE(hello)
+    {
+        def("greet", greet, "return one of 3 parts of a greeting");
+    }
+
+and here it is in action::
+
+    >>> import hello
+    >>> for x in range(3):
+    ...     print hello.greet(x)
+    ...
+    hello
+    Boost.Python
+    world!
+
+Aside from the fact that the 'C' API version is much more verbose than
+the BPL one, it's worth noting that it doesn't handle a few things
+correctly:
+
+* The original function accepts an unsigned integer, and the Python
+  'C' API only gives us a way of extracting signed integers. The
+  Boost.Python version will raise a Python exception if we try to pass
+  a negative number to ``hello.greet``, but the other one will proceed
+  to do whatever the C++ implementation does when converting an
+  negative integer to unsigned (usually wrapping to some very large
+  number), and pass the incorrect translation on to the wrapped
+  function.
+
+* That brings us to the second problem: if the C++ ``greet()``
+  function is called with a number greater than 2, it will throw an
+  exception.  Typically, if a C++ exception propagates across the
+  boundary with code generated by a 'C' compiler, it will cause a
+  crash.  As you can see in the first version, there's no C++
+  scaffolding there to prevent this from happening.  Functions wrapped
+  by Boost.Python automatically include an exception-handling layer
+  which protects Python users by translating unhandled C++ exceptions
+  into a corresponding Python exception.
+
+* A slightly more-subtle limitation is that the argument conversion
+  used in the Python 'C' API case can only get that integer ``x`` in
+  *one way*.  PyArg_ParseTuple can't convert Python ``long`` objects
+  (arbitrary-precision integers) which happen to fit in an ``unsigned
+  int`` but not in a ``signed long``, nor will it ever handle a
+  wrapped C++ class with a user-defined implicit ``operator unsigned
+  int()`` conversion.  The BPL's dynamic type conversion registry
+  allows users to add arbitrary conversion methods.
+
+==================
+ Library Overview
+==================
+
+This section outlines some of the library's major features.  Except as
+neccessary to avoid confusion, details of library implementation are
+omitted.
+
+-------------------------------------------
+ The fundamental type-conversion mechanism
+-------------------------------------------
+
+XXX This needs to be rewritten.
+
+Every argument of every wrapped function requires some kind of
+extraction code to convert it from Python to C++.  Likewise, the
+function return value has to be converted from C++ to Python.
+Appropriate Python exceptions must be raised if the conversion fails.
+Argument and return types are part of the function's type, and much of
+this tedium can be relieved if the wrapping system can extract that
+information through  introspection.
+
+Passing a wrapped C++ derived class instance to a C++ function
+accepting a pointer or reference to a base class requires knowledge of
+the inheritance relationship and how to translate the address of a base
+class into that of a derived class.
+
+------------------
+ Exposing Classes
+------------------
+
+C++ classes and structs are exposed with a similarly-terse interface.
+Given::
+
+    struct World
+    {
+        void set(std::string msg) { this->msg = msg; }
+        std::string greet() { return msg; }
+        std::string msg;
+    };
+
+The following code will expose it in our extension module::
+    
+    #include <boost/python.hpp>
+    BOOST_PYTHON_MODULE(hello)
+    {
+        class_<World>("World")
+            .def("greet", &World::greet)
+            .def("set", &World::set)
+        ;
+    }
+
+Although this code has a certain pythonic familiarity, people
+sometimes find the syntax bit confusing because it doesn't look like
+most of the C++ code they're used to. All the same, this is just
+standard C++.  Because of their flexible syntax and operator
+overloading, C++ and Python are great for defining domain-specific
+(sub)languages
+(DSLs), and that's what we've done in BPL.  To break it down::
+
+    class_<World>("World")
+
+constructs an unnamed object of type ``class_<World>`` and passes
+``"World"`` to its constructor.  This creates a new-style Python class
+called ``World`` in the extension module, and associates it with the
+C++ type ``World`` in the BPL type conversion registry.  We might have
+also written::
+
+    class_<World> w("World");
+
+but that would've been more verbose, since we'd have to name ``w``
+again to invoke its ``def()`` member function::
+
+        w.def("greet", &World::greet)
+
+There's nothing special about the location of the dot for member
+access in the original example: C++ allows any amount of whitespace on
+either side of a token, and placing the dot at the beginning of each
+line allows us to chain as many successive calls to member functions
+as we like with a uniform syntax.  The other key fact that allows
+chaining is that ``class_<>`` member functions all return a reference
+to ``*this``.
+
+So the example is equivalent to::
+
+    class_<World> w("World");
+    w.def("greet", &World::greet);
+    w.def("set", &World::set);
+
+It's occasionally useful to be able to break down the components of a
+Boost.Python class wrapper in this way, but the rest of this paper
+will tend to stick to the terse syntax.
+
+For completeness, here's the wrapped class in use:
+
+>>> import hello
+>>> planet = hello.World()
+>>> planet.set('howdy')
+>>> planet.greet()
+'howdy'
+
+Constructors
+============
+
+Since our ``World`` class is just a plain ``struct``, it has an
+implicit no-argument (nullary) constructor.  Boost.Python exposes the
+nullary constructor by default, which is why we were able to write:
+
+>>> planet = hello.World()
+
+However, well-designed classes in any language may require constructor
+arguments in order to establish their invariants.  Unlike Python,
+where ``__init__`` is just a specially-named method, In C++
+constructors cannot be handled like ordinary member functions.  In
+particular, we can't take their address: ``&World::World`` is an
+error.  The library provides a different interface for specifying
+constructors.  Given::
+
+    struct World
+    {
+        World(std::string msg); // added constructor
+        ...
+
+we can modify our wrapping code as follows::
+
+    class_<World>("World", init<std::string>())
+        ...
+
+of course, a C++ class may have additional constructors, and we can
+expose those as well by passing more instances of ``init<...>`` to
+``def()``::
+
+    class_<World>("World", init<std::string>())
+        .def(init<double, double>())
+        ...
+
+Boost.Python allows wrapped functions, member functions, and
+constructors to be overloaded to mirror C++ overloading.
+
+Data Members and Properties
+===========================
+
+Any publicly-accessible data members in a C++ class can be easily
+exposed as either ``readonly`` or ``readwrite`` attributes::
+
+    class_<World>("World", init<std::string>())
+        .def_readonly("msg", &World::msg)
+        ...
+
+and can be used directly in Python:
+
+>>> planet = hello.World('howdy')
+>>> planet.msg
+'howdy'
+
+This does *not* result in adding attributes to the ``World`` instance
+``__dict__``, which can result in substantial memory savings when
+wrapping large data structures.  In fact, no instance ``__dict__``
+will be created at all unless attributes are explicitly added from
+Python.  BPL owes this capability to the new Python 2.2 type system,
+in particular the descriptor interface and ``property`` type.
+
+In C++, publicly-accessible data members are considered a sign of poor
+design because they break encapsulation, and style guides usually
+dictate the use of "getter" and "setter" functions instead.  In
+Python, however, ``__getattr__``, ``__setattr__``, and since 2.2,
+``property`` mean that attribute access is just one more
+well-encapsulated syntactic tool at the programmer's disposal.  BPL
+bridges this idiomatic gap by making Python ``property`` creation
+directly available to users.  So if ``msg`` were private, we could
+still expose it as attribute in Python as follows::
+
+    class_<World>("World", init<std::string>())
+        .add_property("msg", &World::greet, &World::set)
+        ...
+
+The example above mirrors the familiar usage of properties in Python
+2.2+:
+
+>>> class World(object):
+...     __init__(self, msg):
+...         self.__msg = msg
+...     def greet(self):
+...         return self.__msg
+...     def set(self, msg):
+...         self.__msg = msg
+...     msg = property(greet, set)
+
+Operators and Special Functions
+===============================
+
+The ability to write arithmetic operators for user-defined types that
+C++ and Python both allow the definition of has been a major factor in
+the popularity of both languages for scientific computing.  The
+success of packages like NumPy attests to the power of exposing
+operators in extension modules.  In this example we'll wrap a class
+representing a position in a large file::
+
+    class FilePos { /*...*/ };
+
+    // Linear offset
+    FilePos     operator+(FilePos, int);
+    FilePos     operator+(int, FilePos);
+    FilePos     operator-(FilePos, int);
+    
+    // Distance between two FilePos objects
+    int         operator-(FilePos, FilePos);
+
+    // Offset with assignment
+    FilePos&    operator+=(FilePos&, int);
+    FilePos&    operator-=(FilePos&, int);
+
+    // Comparison
+    bool        operator<(FilePos, FilePos);
+
+The wrapping code looks like this::
+
+    class_<FilePos>("FilePos")
+        .def(self + int())     // __add__
+        .def(int() + self)     // __radd__
+        .def(self - int())     // __sub__
+
+        .def(self - self)      // __sub__
+
+        .def(self += int())    // __iadd__
+        .def(self -= int())    // __isub__
+
+        .def(self < self);     // __lt__
+        ;
+
+The magic is performed using a simplified application of "expression
+templates" [VELD1995]_, a technique originally developed by for
+optimization of high-performance matrix algebra expressions.  The
+essence is that instead of performing the computation immediately,
+operators are overloaded to construct a type *representing* the
+computation.  In matrix algebra, dramatic optimizations are often
+available when the structure of an entire expression can be taken into
+account, rather than processing each operation "greedily".
+Boost.Python uses the same technique to build an appropriate Python
+callable object based on an expression involving ``self``, which is
+then added to the class.
+
+Inheritance
+===========
+
+C++ inheritance relationships can be represented to Boost.Python by adding
+an optional ``bases<...>`` argument to the ``class_<...>`` template
+parameter list as follows::
+
+     class_<Derived, bases<Base1,Base2> >("Derived")
+          ...
+
+This has two effects:  
+
+1. When the ``class_<...>`` is created, Python type objects
+   corresponding to ``Base1`` and ``Base2`` are looked up in the BPL
+   registry, and are used as bases for the new Python ``Derived`` type
+   object [#mi]_, so methods exposed for the Python ``Base1`` and
+   ``Base2`` types are automatically members of the ``Derived`` type.
+   Because the registry is global, this works correctly even if
+   ``Derived`` is exposed in a different module from either of its
+   bases.
+
+2. C++ conversions from ``Derived`` to its bases are added to the
+   Boost.Python registry.  Thus wrapped C++ methods expecting (a
+   pointer or reference to) an object of either base type can be
+   called with an object wrapping a ``Derived`` instance.  Wrapped
+   member functions of class ``T`` are treated as though they have an
+   implicit first argument of ``T&``, so these conversions are
+   neccessary to allow the base class methods to be called for derived
+   objects.
+
+Of course it's possible to derive new Python classes from wrapped C++
+class instances.  Because Boost.Python uses the new-style class
+system, that works very much as for the Python built-in types.  There
+is one significant detail in which it differs: the built-in types
+generally establish their invariants in their ``__new__`` function, so
+that derived classes do not need to call ``__init__`` on the base
+class before invoking its methods :
+
+>>> class L(list):
+...      def __init__(self):
+...          pass
+...
+>>> L().reverse()
+>>> 
+
+Because C++ object construction is a one-step operation, C++ instance
+data cannot be constructed until the arguments are available, in the
+``__init__`` function:
+
+>>> class D(SomeBPLClass):
+...      def __init__(self):
+...          pass
+...
+>>> D().some_bpl_method()
+Traceback (most recent call last):
+  File "<stdin>", line 1, in ?
+TypeError: bad argument type for built-in operation
+
+This happened because Boost.Python couldn't find instance data of type
+``SomeBPLClass`` within the ``D`` instance; ``D``'s ``__init__``
+function masked construction of the base class.  It could be corrected
+by either removing ``D``'s ``__init__`` function or having it call
+``SomeBPLClass.__init__(...)`` explicitly.
+
+Virtual Functions
+=================
+
+Deriving new types in Python from extension classes is not very
+interesting unless they can be used polymorphically from C++.  In
+other words, Python method implementations should appear to override
+the implementation of C++ virtual functions when called *through base
+class pointers/references from C++*.  Since the only way to alter the
+behavior of a virtual function is to override it in a derived class,
+the user must build a special derived class to dispatch a polymorphic
+class' virtual functions::
+
+    //
+    // interface to wrap:
+    //
+    class Base
+    {
+     public:
+        virtual int f(std::string x) { return 42; }
+        virtual ~Base();
+    };
+
+    int calls_f(Base const& b, std::string x) { return b.f(x); }
+
+    //
+    // Wrapping Code
+    //
+
+    // Dispatcher class
+    struct BaseWrap : Base
+    {
+        // Store a pointer to the Python object
+        BaseWrap(PyObject* self_) : self(self_) {}
+        PyObject* self;
+
+        // Default implementation, for when f is not overridden
+        int f_default(std::string x) { return this->Base::f(x); }
+        // Dispatch implementation
+        int f(std::string x) { return call_method<int>(self, "f", x); }
+    };
+
+    ...
+        def("calls_f", calls_f);
+        class_<Base, BaseWrap>("Base")
+            .def("f", &Base::f, &BaseWrap::f_default)
+            ;
+
+Now here's some Python code which demonstrates:
+
+>>> class Derived(Base):
+...     def f(self, s):
+...          return len(s)
+...
+>>> calls_f(Base(), 'foo')
+42
+>>> calls_f(Derived(), 'forty-two')
+9
+
+Things to notice about the dispatcher class:
+
+* The key element which allows overriding in Python is the
+  ``call_method`` invocation, which uses the same global type
+  conversion registry as the C++ function wrapping does to convert its
+  arguments from C++ to Python and its return type from Python to C++.
+
+* Any constructor signatures you wish to wrap must be replicated with
+  an initial ``PyObject*`` argument
+
+* The dispatcher must store this argument so that it can be used to
+  invoke ``call_method``
+
+* The ``f_default`` member function is needed when the function being
+  exposed is not pure virtual; there's no other way ``Base::f`` can be
+  called on an object of type ``BaseWrap``, since it overrides ``f``.
+
+Admittedly, this formula is tedious to repeat, especially on a project
+with many polymorphic classes; that it is neccessary reflects
+limitations in C++'s compile-time reflection capabilities.  Several
+efforts are underway to write front-ends for Boost.Python which can
+generate these dispatchers (and other wrapping code) automatically.
+If these are successful it will mark a move away from wrapping
+everything directly in pure C++ for many of our users.
+
+---------------
+ Serialization
+---------------
+
+*Serialization* is the process of converting objects in memory to a
+form that can be stored on disk or sent over a network connection. The
+serialized object (most often a plain string) can be retrieved and
+converted back to the original object. A good serialization system will
+automatically convert entire object hierarchies. Python's standard
+``pickle`` module is such a system.  It leverages the language's strong
+runtime introspection facilities for serializing practically arbitrary
+user-defined objects. With a few simple and unintrusive provisions this
+powerful machinery can be extended to also work for wrapped C++ objects.
+Here is an example::
+
+    #include <string>
+
+    struct World
+    {
+        World(std::string a_msg) : msg(a_msg) {}
+        std::string greet() const { return msg; }
+        std::string msg;
+    };
+
+    #include <boost/python.hpp>
+    using namespace boost::python;
+
+    struct World_picklers : pickle_suite
+    {
+      static tuple
+      getinitargs(World const& w) { return make_tuple(w.greet()); }
+    };
+
+    BOOST_PYTHON_MODULE(hello)
+    {
+        class_<World>("World", init<std::string>())
+            .def("greet", &World::greet)
+            .def_pickle(World_picklers())
+        ;
+    }
+
+Now let's create a ``World`` object and put it to rest on disk::
+
+    >>> import hello
+    >>> import pickle
+    >>> a_world = hello.World("howdy")
+    >>> pickle.dump(a_world, open("my_world", "w"))
+
+In a potentially *different script* on a potentially *different
+computer* with a potentially *different operating system*::
+
+    >>> import pickle
+    >>> resurrected_world = pickle.load(open("my_world", "r"))
+    >>> resurrected_world.greet()
+    'howdy'
+
+Of course the ``cPickle`` module can also be used for faster
+processing.
+
+Boost.Python's ``pickle_suite`` fully supports the ``pickle`` protocol
+defined in the standard Python documentation. There is a one-to-one
+correspondence between the standard pickling methods (``__getinitargs__``,
+``__getstate__``, ``__setstate__``) and the functions defined by the
+user in the class derived from ``pickle_suite`` (``getinitargs``,
+``getstate``, ``setstate``). The ``class_::def_pickle()`` member function
+is used to establish the Python bindings for all user-defined functions
+simultaneously. Correct signatures for these functions are enforced at
+compile time. Non-sensical combinations of the three pickle functions
+are also rejected at compile time. These measures are designed to
+help the user in avoiding obvious errors.
+
+Enabling serialization of more complex C++ objects requires a little
+more work than is shown in the example above. Fortunately the
+``object`` interface (see next section) greatly helps in keeping the
+code manageable.
+
+------------------
+ Object interface
+------------------
+
+Experienced extension module authors will be familiar with the 'C' view
+of Python objects, the ubiquitous ``PyObject*``. Most if not all Python
+'C' API functions involve ``PyObject*`` as arguments or return type.  A
+major complication is the raw reference counting interface presented to
+the 'C' programmer. E.g. some API functions return *new references* and
+others return *borrowed references*. It is up to the extension module
+writer to properly increment and decrement reference counts.  This
+quickly becomes cumbersome and error prone, especially if there are
+multiple execution paths.
+
+Boost.Python provides a type ``object`` which is essentially a high
+level wrapper around ``PyObject*``. ``object`` automates reference
+counting as much as possible. It also provides the facilities for
+converting arbitrary C++ types to Python objects and vice versa.
+This significantly reduces the learning effort for prospective
+extension module writers.
+
+Creating an ``object`` from any other type is extremely simple::
+
+    object o(3);
+
+``object`` has templated interactions with all other types, with
+automatic to-python conversions. It happens so naturally that it's
+easily overlooked.
+
+The ``extract<T>`` class template can be used to convert Python objects
+to C++ types::
+
+    double x = extract<double>(o);
+
+All registered user-defined conversions are automatically accessible
+through the ``object`` interface. With reference to the ``World`` class
+defined in previous examples::
+
+    object as_python_object(World("howdy"));
+    World back_as_c_plus_plus_object = extract<World>(as_python_object);
+
+If a C++ type cannot be converted to a Python object an appropriate
+exception is thrown at runtime.  Similarly, an appropriate exception is
+thrown if a C++ type cannot be extracted from a Python object.
+``extract<T>`` provides facilities for avoiding exceptions if this is
+desired.
+
+The ``object::attr()`` member function is available for accessing
+and manipulating attributes of Python objects. For example::
+
+    object planet(World());
+    planet.attr("set")("howdy");
+
+``planet.attr("set")`` returns a callable ``object``.  ``"howdy"`` is
+converted to a Python string object which is then passed as an argument
+to the ``set`` method.
+
+The ``object`` type is accompanied by a set of derived types
+that mirror the Python built-in types such as ``list``, ``dict``,
+``tuple``, etc. as much as possible. This enables convenient
+manipulation of these high-level types from C++::
+
+    dict d;
+    d["some"] = "thing";
+    d["lucky_number"] = 13;
+    list l = d.keys();
+
+This almost looks and works like regular Python code, but it is pure C++.
+
+=================
+ Thinking hybrid
+=================
+
+For many applications runtime performance considerations are very
+important. This is particularly true for most scientific applications.
+Often the performance considerations dictate the use of a compiled
+language for the core algorithms. Traditionally the decision to use a
+particular programming language is an exclusive one. Because of the
+practical and mental difficulties of combining different languages many
+systems are written in just one language. This is quite unfortunate
+because the price payed for runtime performance is typically a
+significant overhead due to static typing. For example, our experience
+shows that developing maintainable C++ code is typically much more
+time-consuming and requires much more hard-earned working experience
+than developing useful Python code. A related observation is that many
+compiled packages are augmented by some type of rudimentary scripting
+layer. These ad hoc solutions clearly show that many times a compiled
+language alone does not get the job done. On the other hand it is also
+clear that a pure Python implementation is too slow for numerically
+intensive production code.
+
+Boost.Python enables us to *think hybrid* when developing new
+applications. Python can be used for rapidly prototyping a
+new application. Python's ease of use and the large pool of standard
+libraries give us a head start on the way to a first working system. If
+necessary, the working procedure can be used to discover the
+rate-limiting algorithms. To maximize performance these can be
+reimplemented in C++, together with the Boost.Python bindings needed to
+tie them back into the existing higher-level procedure.
+
+Of course, this *top-down* approach is less attractive if it is clear
+from the start that many algorithms will eventually have to be
+implemented in a compiled language. Fortunately Boost.Python also
+enables us to pursue a *bottom-up* approach. We have used this approach
+very successfully in the development of a toolbox for scientific
+applications (scitbx) that we will describe elsewhere. The toolbox
+started out mainly as a library of C++ classes with Boost.Python
+bindings, and for a while the growth was mainly concentrated on the C++
+parts. However, as the toolbox is becoming more complete, more and more
+newly added functionality can be implemented in Python. We expect this
+trend to continue, as illustrated qualitatively in this figure:
+
+.. image:: python_cpp_mix.png
+
+This figure shows the ratio of newly added C++ and Python code over
+time as new algorithms are implemented. We expect this ratio to level
+out near 70% Python. The increasing ability to solve new problems
+mostly with the easy-to-use Python language rather than a necessarily
+more arcane statically typed language is the return on the investment
+of learning how to use Boost.Python. The ability to solve some problems
+entirely using only Python will enable a larger group of people to
+participate in the rapid development of new applications.
+
+=============
+ Conclusions
+=============
+
+The examples in this paper illustrate that Boost.Python enables
+seamless interoperability between C++ and Python. Importantly, this is
+achieved without introducing a third syntax: the Python/C++ interface
+definitions are written in pure C++. This avoids any problems with
+parsing the C++ code to be interfaced to Python, yet the interface
+definitions are concise and maintainable. Freed from most of the
+development-time penalties of crossing a language boundary, software
+designers can take full advantage of two rich and complimentary
+language environments. In practice it turns out that some things are
+very difficult to do with pure Python/C (e.g. an efficient array
+library with an intuitive interface in the compiled language) and
+others are very difficult to do with pure C++ (e.g. serialization).
+If one has the luxury of being able to design a software system as a
+hybrid system from the ground up there are many new ways of avoiding
+road blocks in one language or the other.
+
+.. I'm not ready to give up on all of this quite yet
+
+.. Perhaps one day we'll have a language with the simplicity and
+   expressive power of Python and the compile-time muscle of C++.  Being
+   able to take advantage of all of these facilities without paying the
+   mental and development-time penalties of crossing a language barrier
+   would bring enormous benefits.  Until then, interoperability tools
+   like Boost.Python can help lower the barrier and make the benefits of
+   both languages more accessible to both communities.
+
+===========
+ Footnotes
+===========
+
+.. [#mi] For hard-core new-style class/extension module writers it is
+   worth noting that the normal requirement that all extension classes
+   with data form a layout-compatible single-inheritance chain is
+   lifted for Boost.Python extension classes.  Clearly, either
+   ``Base1`` or ``Base2`` has to occupy a different offset in the
+   ``Derived`` class instance.  This is possible because the wrapped
+   part of BPL extension class instances is never assumed to have a
+   fixed offset within the wrapper.
+
+===========
+ Citations
+===========
+
+.. [VELD1995] T. Veldhuizen, "Expression Templates," C++ Report,
+   Vol. 7 No. 5 June 1995, pp. 26-31.
+   http://osl.iu.edu/~tveldhui/papers/Expression-Templates/exprtmpl.html

doc/PyConDC_2003/default.css

@@ -0,0 +1,188 @@
+/*
+:Author: David Goodger
+:Contact: goodger@users.sourceforge.net
+:date: $Date$
+:version: $Revision$
+:copyright: This stylesheet has been placed in the public domain.
+
+Default cascading style sheet for the HTML output of Docutils.
+*/
+
+.first {
+  margin-top: 0 }
+
+.last {
+  margin-bottom: 0 }
+
+a.toc-backref {
+  text-decoration: none ;
+  color: black }
+
+dd {
+  margin-bottom: 0.5em }
+
+div.abstract {
+  margin: 2em 5em }
+
+div.abstract p.topic-title {
+  font-weight: bold ;
+  text-align: center }
+
+div.attention, div.caution, div.danger, div.error, div.hint,
+div.important, div.note, div.tip, div.warning {
+  margin: 2em ;
+  border: medium outset ;
+  padding: 1em }
+
+div.attention p.admonition-title, div.caution p.admonition-title,
+div.danger p.admonition-title, div.error p.admonition-title,
+div.warning p.admonition-title {
+  color: red ;
+  font-weight: bold ;
+  font-family: sans-serif }
+
+div.hint p.admonition-title, div.important p.admonition-title,
+div.note p.admonition-title, div.tip p.admonition-title {
+  font-weight: bold ;
+  font-family: sans-serif }
+
+div.dedication {
+  margin: 2em 5em ;
+  text-align: center ;
+  font-style: italic }
+
+div.dedication p.topic-title {
+  font-weight: bold ;
+  font-style: normal }
+
+div.figure {
+  margin-left: 2em }
+
+div.footer, div.header {
+  font-size: smaller }
+
+div.system-messages {
+  margin: 5em }
+
+div.system-messages h1 {
+  color: red }
+
+div.system-message {
+  border: medium outset ;
+  padding: 1em }
+
+div.system-message p.system-message-title {
+  color: red ;
+  font-weight: bold }
+
+div.topic {
+  margin: 2em }
+
+h1.title {
+  text-align: center }
+
+h2.subtitle {
+  text-align: center }
+
+hr {
+  width: 75% }
+
+ol.simple, ul.simple {
+  margin-bottom: 1em }
+
+ol.arabic {
+  list-style: decimal }
+
+ol.loweralpha {
+  list-style: lower-alpha }
+
+ol.upperalpha {
+  list-style: upper-alpha }
+
+ol.lowerroman {
+  list-style: lower-roman }
+
+ol.upperroman {
+  list-style: upper-roman }
+
+p.caption {
+  font-style: italic }
+
+p.credits {
+  font-style: italic ;
+  font-size: smaller }
+
+p.label {
+  white-space: nowrap }
+
+p.topic-title {
+  font-weight: bold }
+
+pre.address {
+  margin-bottom: 0 ;
+  margin-top: 0 ;
+  font-family: serif ;
+  font-size: 100% }
+
+pre.line-block {
+  font-family: serif ;
+  font-size: 100% }
+
+pre.literal-block, pre.doctest-block {
+  margin-left: 2em ;
+  margin-right: 2em ;
+  background-color: #eeeeee }
+
+span.classifier {
+  font-family: sans-serif ;
+  font-style: oblique }
+
+span.classifier-delimiter {
+  font-family: sans-serif ;
+  font-weight: bold }
+
+span.interpreted {
+  font-family: sans-serif }
+
+span.option-argument {
+  font-style: italic }
+
+span.pre {
+  white-space: pre }
+
+span.problematic {
+  color: red }
+
+table {
+  margin-top: 0.5em ;
+  margin-bottom: 0.5em }
+
+table.citation {
+  border-left: solid thin gray ;
+  padding-left: 0.5ex }
+
+table.docinfo {
+  margin: 2em 4em }
+
+table.footnote {
+  border-left: solid thin black ;
+  padding-left: 0.5ex }
+
+td, th {
+  padding-left: 0.5em ;
+  padding-right: 0.5em ;
+  vertical-align: top }
+
+th.docinfo-name, th.field-name {
+  font-weight: bold ;
+  text-align: left ;
+  white-space: nowrap }
+
+h1 tt, h2 tt, h3 tt, h4 tt, h5 tt, h6 tt {
+  font-size: 100% }
+
+tt {
+  background-color: #eeeeee }
+
+ul.auto-toc {
+  list-style-type: none }

doc/building.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="index.html">Boost.Python</a></h1>
 
           <h2 align="center">Building and Testing</h2>
         </td>
@@ -41,27 +41,47 @@
 
           <dt><a href="#results">Results</a></dt>
 
+          <dt><a href="#cygwin">Notes for Cygwin GCC Users</a></dt>
+
           <dt><a href="#testing">Testing</a></dt>
         </dl>
       </dd>
 
       <dt><a href="#building_ext">Building your Extension Module</a></dt>
 
+      <dd>
+        <dl>
+          <dt><a href="#easy">The Easy Way</a></dt>
+
+          <dt><a href="#outside">Building your module outside the Boost
+          project tree</a></dt>
+        </dl>
+      </dd>
+
       <dt><a href="#variants">Build Variants</a></dt>
+
+      <dt><a href="#VisualStudio">Building Using the Microsoft Visual Studio
+      IDE</a></dt>
     </dl>
     <hr>
 
     <h2><a name="requirements">Requirements</a></h2>
-    Boost.Python requires <a href="http://www.python.org">Python</a> 2.2 or
-    later. 
+    <b>Boost.Python</b> version 2 requires <a href=
+    "http://www.python.org/2.2">Python 2.2</a> <i>or <a href=
+    "http://www.python.org">newer</a></i>. An unsupported archive of
+    Boost.Python version 1, which works with versions of Python since 1.5.2,
+    is available <a href="../build/python_v1.zip">here</a>. 
 
     <h2><a name="building">Building Boost.Python</a></h2>
 
-    <p>Every Boost.Python extension module must be linked with the
-    <code>boost_python</code> shared library. To build
-    <code>boost_python</code>, use <a href=
-    "../../../tools/build/index.html">Boost.Build</a> in the usual way from
-    the <code>libs/python/build</code> subdirectory of your boost
+    <p>Normally, Boost.Python extension modules must be linked with the
+    <code>boost_python</code> shared library. In special circumstances you
+    may want to link to a static version of the <code>boost_python</code>
+    library, but if multiple Boost.Pythone extension modules are used
+    together, it will prevent sharing of types across extension modules, and
+    consume extra code space. To build <code>boost_python</code>, use <a
+    href="../../../tools/build/index.html">Boost.Build</a> in the usual way
+    from the <code>libs/python/build</code> subdirectory of your boost
     installation (if you have already built boost from the top level this may
     have no effect, since the work is already done).</p>
 
@@ -120,49 +140,77 @@
       </tr>
 
       <tr>
-        <td><code>PYTHON_STDLIB_PATH</code></td>
+        <td><code>CYGWIN_PYTHON_[DEBUG_]VERSION</code></td>
 
-        <td>path to Python standard library modules</td>
+        <td>The version of python being used under Cygwin. </td>
 
-        <td>Autoconfigured from <code>PYTHON_ROOT</code></td>
-      </tr>
+        <td>$(PYTHON_VERSION)
 
-      <tr>
-        <td><code>CYGWIN_ROOT</code></td>
-
-        <td>path to the user's Cygwin installation</td>
-
-        <td>
         </td>
 
-        <td><a href="http://www.cygwin.com">Cygwin</a> only. This and the
-        following two settings are useful when building with multiple
-        toolsets on Windows, since Cygwin requires a different build of
-        Python.</td>
-      </tr>
+        <td>Use only when building with <a href=
+        "http://www.cygwin.com">Cygwin</a> GCC. This and the following
+        settings are useful when building with multiple toolsets on
+        Windows, since Cygwin GCC requires a different build of
+        Python.</td> </tr>
 
       <tr>
-        <td><code>GCC_PYTHON_ROOT</code></td>
+        <td><code>CYGWIN_PYTHON_[DEBUG_]ROOT</code></td>
 
-        <td>path to the user's Cygwin Python installation</td>
+        <td>unix-style path containing the <code>include/</code>
+        directory containing
+        <code>python$(CYGWIN_PYTHON_[DEBUG_]VERSION)/python.h</code>. </td>
 
-        <td><code>$(CYGWIN_ROOT)/usr/local</code></td>
+        <td>$(PYTHON_ROOT)
 
-        <td><a href="http://www.cygwin.com">Cygwin</a> only</td>
-      </tr>
+        </td>
+
+        <td>Use only when building with <a href=
+        "http://www.cygwin.com">Cygwin</a> GCC.</td> </tr>
 
       <tr>
-        <td><code>GCC_DEBUG_PYTHON_ROOT</code></td>
+        <td><code>CYGWIN_PYTHON_[DEBUG_]LIB_PATH</code></td>
 
-        <td>path to the user's Cygwin <code><a href=
-        "#variants">pydebug</a></code> build</td>
+        <td>path containing the user's Cygwin Python import lib
+        <code>libpython$(CYGWIN_PYTHON_[DEBUG_]VERSION).dll.a</code></td>
 
-        <td><code>$(CYGWIN_ROOT)/usr/local/pydebug</code></td>
+        <td>Autoconfigured from <code>CYGWIN_PYTHON_ROOT</code></td>
+
+        <td>Use only when building with <a href=
+        "http://www.cygwin.com">Cygwin</a> GCC.</td> </tr>
+
+      <tr>
+        <td><code>CYGWIN_PYTHON_[DEBUG_]DLL_PATH</code></td>
+
+        <td>path containing the user's Cygwin Python dll
+        (<code>libpython$(CYGWIN_PYTHON_[DEBUG_]VERSION).dll</code>)</td>
+
+        <td><code>/bin</code></td>
+
+        <td>Use only when building with <a href=
+        "http://www.cygwin.com">Cygwin</a> GCC.</td> </tr>
 
-        <td><a href="http://www.cygwin.com">Cygwin</a> only</td>
       </tr>
     </table>
 
+    <h3><a name="cygwin">Notes for Cygwin GCC Users</a></h3>
+
+    <p>If you are using Cygwin GCC to build extension modules, you must use a
+    Cygwin build of Python. The regular Win32 Python installation that you
+    can download from <a href="http://www.python.org">python.org</a> will not
+    work with your compiler because the dynamic linking conventions are
+    different (you can use <a href="http://www.mingw.org/">MinGW</a> GCC if
+    you want to build extension modules which are compatible with a stock
+    Win32 Python). The Cygwin installer may be able to install an appropriate
+    version of Python, or you can follow the traditional <a href=
+    "http://www.python.org/download/download_source.html">Unix installation
+    process</a> to build Python from source.</p>
+
+    <p>The special build configuration variables listed above as "Cygwin
+    only" make it possible to use a regular Win32 build of bjam to build and
+    test Boost.Python and Boost.Python extensions using Cygwin GCC and
+    targeting a Cygwin build of Python.</p>
+
     <h3><a name="results">Results</a></h3>
 
     <p>The build process will create a
@@ -200,13 +248,19 @@ bjam -sTOOLS=<i><a href=
     passes. 
 
     <h2><a name="building_ext">Building your Extension Module</a></h2>
-    Though there are other approaches, the easiest way to build an extension
-    module using Boost.Python is with Boost.Build. Until Boost.Build v2 is
-    released, cross-project build dependencies are not supported, so it works
-    most smoothly if you add a new subproject to your boost installation. The
-    <code>libs/python/example</code> subdirectory of your boost installation
-    contains a minimal example (along with many extra sources). To copy the
-    example subproject: 
+    Though there are other approaches, the best way to build an extension
+    module using Boost.Python is with Boost.Build. If you have to use another
+    build system, you should use Boost.Build at least once with the
+    "<code><b>-n</b></code>" option so you can see the command-lines it uses,
+    and replicate them. You are likely to run into compilation or linking
+    problems otherwise. 
+
+    <h3><a name="easy">The Easy Way</a></h3>
+    Until Boost.Build v2 is released, cross-project build dependencies are
+    not supported, so it works most smoothly if you add a new subproject to
+    your boost installation. The <code>libs/python/example</code>
+    subdirectory of your boost installation contains a minimal example (along
+    with many extra sources). To copy the example subproject: 
 
     <ol>
       <li>Create a new subdirectory in, <code>libs/python</code>, say
@@ -220,9 +274,14 @@ bjam -sTOOLS=<i><a href=
       change the "<code>subproject</code>" rule invocation at the top, and
       the names of some of the source files and/or targets.</li>
     </ol>
-    If you can't modify or copy your boost installation, the alternative is
-    to create your own Boost.Build project. A similar example you can use as
-    a starting point is available in <code><a href=
+    The instructions <a href="#testing">above</a> for testing Boost.Python
+    apply equally to your new extension modules in this subproject. 
+
+    <h3><a name="outside">Building your module outside the Boost project
+    tree</a></h3>
+    If you can't (or don't wish to) modify your boost installation, the
+    alternative is to create your own Boost.Build project. A similar example
+    you can use as a starting point is available in <code><a href=
     "../example/project.zip">this archive</a></code>. You'll need to edit the
     Jamfile and Jamrules files, depending on the relative location of your
     Boost installation and the new project. Note that automatic testing of
@@ -280,6 +339,55 @@ bjam -sTOOLS=<i><a href=
     instead of the usual <tt>Python.h</tt>, or you will have link
     incompatibilities.<br>
     </p>
+
+    <h2><a name="VisualStudio">Building Using the Microsoft Visual Studio
+    IDE</a></h2>
+
+    <p>For the those of you who feel more comfortable in the IDE world, a
+    workspace and project file have been included in the <a href=
+    "../build/VisualStudio">libs/python/build/VisualStudio</a> subdirectory.
+    It builds release and debug versions of the Boost.Python libraries and
+    places them and the same directory as Jamfile build does, though the
+    intermediate object files are placed in a different directory. The files
+    have been created using Microsoft Visual C++ version 6, but they should
+    work for later versions as well. You will need to tell the IDE where to
+    find the Python <code>Include/</code> and <code>Libs/</code> directories.
+    Under <b>Tools&gt;Options&gt;Directories</b>, add an entry for the Python
+    include dir (i.e. <code>c:/Python22/Include</code>), and one for the Lib
+    (i.e. <code>c:/Python/Libs</code>. Make sure it is <code>Libs</code> with
+    an "<code>s</code>" and not just <code>Lib</code>).</p>
+
+    <h3>Using the IDE for your own projects</h3>
+
+    <p>Building your own projects using the IDE is slightly more complicated.
+    Firstly, you need to make sure that the project you create as the right
+    kind. It should be a "Win32 Dynamic-Link Library". The default one that
+    Visual Studio 6 creates needs some modifications: turn on RTTI, and
+    change the debug and release builds to use the respective debug and
+    release Multithreaded DLL versions. You should probably turn off
+    incremental linking too -- I believe it a bit flaky. If you do this, then
+    change the "Debug Info" to "Program Database" to get rid of the Edit and
+    Continue warning.</p>
+
+    <p>You'll need to add the Boost root directory under
+    <b>Tools&gt;Options&gt;Directories</b> to get your code compiling. To
+    make it link, add the above <code>boost_python.dsp</code> file to your
+    workspace, and make your project depend upon it (under
+    <b>Project&gt;Dependencies</b>). You should be able to build now.</p>
+
+    <p>Lastly, go to the <b>Project Settings&gt;Debug</b> Page and add the
+    <code>Python.exe</code> as the executable for the project. Set a startup
+    directory, and make sure that your current project's output dll, the
+    <code>boost_python.dll</code> and the <code>python22.dll</code> are on
+    the current <code>PATH</code>. If you have a python script that tests
+    your dll, then add it in the "Program Arguments". Now, if all went well,
+    you should be able to hit the Run (F5) button, and debug your code.</p>
+
+    <blockquote>
+      <em>The Visual Studio project files are graciously contributed and
+      maintained by <a href="mailto:brett.calcott@paradise.net.nz">Brett
+      Calcott</a></em>.
+    </blockquote>
     <hr>
 
     <p>&copy; Copyright David Abrahams 2002. Permission to copy, use, modify,
@@ -288,7 +396,7 @@ bjam -sTOOLS=<i><a href=
     express or implied warranty, and with no claim as to its suitability for
     any purpose.</p>
 
-    <p>Updated: O8 October, 2002 (David Abrahams)</p>
+    <p>Updated: 29 December, 2002 (David Abrahams)</p>
   </body>
 </html>
 

doc/index.html

@@ -28,6 +28,58 @@
     </table>
     <hr>
 
+    <h2>Synopsis</h2>
+    Welcome to version 2 of <b>Boost.Python</b>, a C++ library which enables
+    seamless interoperability between C++ and the <a href=
+    "http://www.python.org">Python</a> programming language. The new version
+    has been rewritten from the ground up, with a more convenient and
+    flexible interface, and many new capabilities, including support for: 
+
+    <ul>
+      <li>References and Pointers</li>
+
+      <li>Globally Registered Type Coercions</li>
+
+      <li>Automatic Cross-Module Type Conversions</li>
+
+      <li>Efficient Function Overloading</li>
+
+      <li>C++ to Python Exception Translation</li>
+
+      <li>Default Arguments</li>
+
+      <li>Keyword Arguments</li>
+
+      <li>Manipulating Python objects in C++</li>
+
+      <li>Exporting C++ Iterators as Python Iterators</li>
+
+      <li>Documentation Strings</li>
+    </ul>
+    The development of these features was funded in part by grants to <a
+    href="http://www.boost-consulting.com">Boost Consulting</a> from the <a
+    href="http://www.llnl.gov/">Lawrence Livermore National Laboratories</a>
+    and by the <a href="http://cci.lbl.gov/">Computational Crystallography
+    Initiative</a> at Lawrence Berkeley National Laboratories. 
+    <hr>
+
+    <h2>Note for Python 2.3 users</h2>
+
+    This is a bugfix release only, and is <b>not</b> compatible with
+    Python 2.3.  Boost 1.31.0, which will be compatible with Python
+    2.3, is due out shortly.  In the meantime, if you need Python 2.3
+    compatibility, we suggest you get a CVS snapshot, either from the
+    <a href="../../../more/download.html#CVS">SourceForge anonymous
+    CVS</a> or from our mirror, updated nightly:
+
+<pre>
+cvs -d :pserver:anonymous@boost-consulting.com:/boost login
+<i>no password; just hit return</i>
+
+cvs -d :pserver:anonymous@boost-consulting.com:/boost co boost
+</pre>
+
+<hr>
     <h2>Contents</h2>
 
     <dl class="index">
@@ -35,25 +87,34 @@
 
       <dt><a href="building.html">Building and Testing</a></dt>
 
-      <dt><a href="v2/reference.html">Reference</a></dt>
+      <dt><a href="v2/reference.html">Reference Manual</a></dt>
 
       <dt><a href="v2/configuration.html">Configuration Information</a></dt>
 
-      <dt><a href="v2/rationale.html">Rationale</a></dt>
+      <dt><a href="v2/platforms.html">Known Working Platforms and
+      Compilers</a></dt>
 
       <dt><a href="v2/definitions.html">Definitions</a></dt>
 
-      <dt><a href="v2/faq.html">Frequently Asked Questions (FAQs)</a></dt>
+      <dt><a href="projects.html">Projects using Boost.Python</a></dt>
 
-      <dt><a href="v2/progress_reports.html">Progress Reports</a></dt>
+      <dt><a href="support.html">Support Resources</a></dt>
+
+      <dt><a href="v2/faq.html">Frequently Asked Questions (FAQs)</a></dt>
+      
+      <dt><a href="../pyste/index.html">Pyste (Boost.Python code generator)</a></dt>
+
+      <dt><a href="news.html">News/Change Log</a></dt>
+
+      <dt><a href="v2/progress_reports.html">LLNL Progress Reports</a></dt>
 
       <dt><a href="v2/acknowledgments.html">Acknowledgments</a></dt>
     </dl>
     <hr>
 
-    <p>Revised
+    <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     08 October, 2002
+     4 August, 2003
     <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 

doc/new-conversions.html

@@ -318,7 +318,9 @@ until the result object is retrieved.</font>
 Special Edition Addison-Wesley, ISBN 0-201-70073-5.
 
 <hr>
-<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B %Y" startspan -->19 December 2001<!--webbot bot="Timestamp" endspan i-checksum="31283" --></p>
+<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B %Y" startspan -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="31283" --></p>
 <p>© Copyright David Abrahams, 2001</p>
 
 </body>

doc/news.html

@@ -0,0 +1,109 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<html>
+  <head>
+    <meta name="generator" content=
+    "HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="boost.css">
+
+    <title>Boost.Python - News/Change Log</title>
+  </head>
+
+  <body link="#0000ff" vlink="#800080">
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../c++boost.gif" border="0"></a></h3>
+        </td>
+
+        <td valign="top">
+          <h1 align="center"><a href="index.html">Boost.Python</a></h1>
+
+          <h2 align="center">News/Change Log</h2>
+        </td>
+      </tr>
+    </table>
+    <hr>
+
+    <dl class="page-index">
+      <dt>24 February 2003</dt>
+
+      <dd>Finished improved support
+      for <code>boost::shared_ptr</code>.  Now any wrapped object of
+      C++ class <code>X</code> can be converted automatically
+      to <code>shared_ptr&lt;X&gt;</code>, regardless of how it was
+      wrapped.  The <code>shared_ptr</code> will manage the lifetime
+      of the Python object which supplied the <code>X</code>, rather
+      than just the <code>X</code> object itself, and when such
+      a <code>shared_ptr</code> is converted back to Python, the
+      original Python object will be returned.</dd>
+      
+      <dt>19 January 2003</dt>
+
+      <dd>Integrated <code>staticmethod</code> support from <a href=
+      "mailto:nickm-at-sitius.com">Nikolay Mladenov</a>. Thanks,
+      Nikolay!</dd>
+
+      <dt>29 December 2002</dt>
+
+      <dd>Added Visual Studio project file and instructions from Brett
+      Calcott. Thanks, Brett!</dd>
+
+      <dt>20 December 2002</dt>
+
+      <dd>Added automatic downcasting for pointers, references, and smart
+      pointers to polymorphic class types upon conversion to python</dd>
+
+      <dt>18 December 2002</dt>
+
+      <dd>Optimized from_python conversions for wrapped classes by putting
+      the conversion logic in the shared library instead of registering
+      separate converters for each class in each extension module</dd>
+
+      <dt>19 November 2002</dt>
+
+      <dd>Removed the need for users to cast base class member function
+      pointers when used as arguments to <a href=
+      "v2/class.html#class_-spec-modifiers">add_property</a></dd>
+
+      <dt>13 December 2002</dt>
+
+      <dd>Allow exporting of <a href=
+      "v2/enum.html#enum_-spec"><code>enum_</code></a> values into enclosing
+      <a href="v2/scope.html#scope-spec"><code>scope</code></a>.<br>
+       Fixed unsigned integer conversions to deal correctly with numbers that
+      are out-of-range of <code>signed long</code>.</dd>
+
+      <dt>14 November 2002</dt>
+
+      <dd>Auto-detection of class data members wrapped with <a href=
+      "v2/data_members.html#make_getter-spec"><code>make_getter</code></a></dd>
+
+      <dt>13 November 2002</dt>
+
+      <dd>Full Support for <code>std::auto_ptr&lt;&gt;</code> added.</dd>
+
+      <dt>October 2002</dt>
+
+      <dd>Ongoing updates and improvements to tutorial documentation</dd>
+
+      <dt>10 October 2002</dt>
+
+      <dd>Boost.Python V2 is released!</dd>
+    </dl>
+    <hr>
+
+    <p>Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+     20 December, 2002 
+    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+    </p>
+
+    <p><i>&copy; Copyright <a href="../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i></p>
+  </body>
+</html>
+

doc/polymorphism.txt

@@ -0,0 +1,217 @@
+How Runtime Polymorphism is expressed in Boost.Python:
+-----------------------------------------------------
+
+   struct A { virtual std::string f(); virtual ~A(); };
+
+   std::string call_f(A& x) { return x.f(); }
+
+   struct B { virtual std::string f() { return "B"; } };
+
+   struct Bcb : B
+   { 
+      Bcb(PyObject* self) : m_self(self) {}
+
+      virtual std::string f() { return call_method<std::string>(m_sef, "f"); }
+      static std::string f_default(B& b) { return b.B::f(); }
+
+      PyObject* m_self;
+   };
+
+   struct C : B
+   {
+      virtual std::string f() { return "C"; }
+   };
+
+   >>> class D(B):
+   ...     def f():
+   ...         return 'D'
+   ...
+   >>> class E(B): pass
+   ...
+
+
+When we write, "invokes B::f non-virtually", we mean:
+
+  void g(B& x) { x.B::f(); }
+
+This will call B::f() regardless of the dynamic type of x. Any other
+way of invoking B::f, including through a function pointer, is a
+"virtual invocation", and will call the most-derived override of f().
+
+Case studies
+
+   C++\Python class
+       \___A_____B_____C_____D____E___
+       |
+   A   |   1
+       |
+   B   |   2     3
+       |
+   Bcb |         4           5    6
+       |
+   C   |         7     8
+       |
+
+
+1. Simple case
+
+2. Python A holds a B*. Probably won't happen once we have forced
+   downcasting. 
+
+   Requires:
+         x.f() -> 'B'
+         call_f(x) -> 'B'
+
+   Implies: A.f invokes A::f() (virtually or otherwise)
+
+3. Python B holds a B*. 
+
+   Requires:
+        x.f() -> 'B'
+        call_f(x) -> 'B'
+   
+   Implies: B.f invokes B::f (virtually or otherwise)
+
+
+4. B constructed from Python
+
+   Requires:
+
+        x.f() -> 'B'
+        call_f(x) -> 'B'
+
+   Implies: B.f invokes B::f non-virtually. Bcb::f invokes B::f
+            non-virtually.
+
+   Question: Does it help if we arrange for Python B construction to
+   build a true B object? Then this case doesn't arise.
+
+
+5. D is a Python class derived from B
+
+   Requires:
+
+        x.f() -> 'D'
+        call_f(x) -> 'D'
+
+   Implies: Bcb::f must invoke call_method to look up the Python
+            method override, otherwise call_f wouldn't work.
+
+6. E is like D, but doesn't override f
+
+   Requires:
+
+        x.f() -> 'B'
+        call_f(x) -> 'B'
+
+   Implies: B.f invokes B::f non-virtually. If it were virtual, x.f()
+            would cause infinite recursion, because we've already
+            determined that Bcb::f must invoke call_method to look up
+            the Python method override.
+
+7. Python B object holds a C*
+
+   Requires:
+        
+        x.f() -> 'C'
+        call_f(x) -> 'C'
+
+   Implies: B.f invokes B::f virtually. 
+
+8. C object constructed from Python
+
+   Requires:
+
+        x.f() -> 'C'
+        call_f(x) -> 'C'
+
+   Implies: nothing new.
+
+------
+
+Total implications:
+
+2: A.f invokes A::f() (virtually or otherwise)
+3: B.f invokes B::f (virtually or otherwise)
+4: B.f invokes B::f non-virtually. Bcb::f invokes B::f non-virtually
+6: B.f invokes B::f non-virtually. 
+7: B.f invokes B::f virtually. 
+
+5: Bcb::f invokes call_method to look up the Python method
+
+Though (4) is avoidable, clearly 6 and 7 are not, and they
+conflict. The implication is that B.f must choose its behavior
+according to the type of the contained C++ object. If it is Bcb, a
+non-virtual call to B::f must occur. Otherwise, a virtual call to B::f
+must occur. This is essentially the same scheme we had with
+Boost.Python v1.
+
+Note: in early versions of Boost.Python v1, we solved this problem by
+introducing a new Python class in the hierarchy, so that D and E
+actually derive from a B', and B'.f invokes B::f non-virtually, while
+B.f invokes B::f virtually. However, people complained about the
+artificial class in the hierarchy, which was revealed when they tried
+to do normal kinds of Python introspection.
+
+-------
+
+Assumption: we will have a function which builds a virtual function
+dispatch callable Python object.
+
+     make_virtual_function(pvmf, default_impl, call_policies, dispatch_type)
+
+Pseudocode:
+
+     Get first argument from Python arg tuple
+     if it contains dispatch_type
+        call default_impl
+     else
+        call through pvmf
+
+
+Open questions:
+
+   1. What about Python multiple inheritance? Do we have the right
+      check in the if clause above?
+      
+      A: Not quite. The correct test looks like:
+
+      Deduce target type of pvmf, i.e. T in R(T::*)(A1...AN).
+      Find holder in first argument which holds T
+      if it holds dispatch_type...
+
+   2. Can we make this more efficient?
+     
+     The current "returning" mechanism will look up a holder for T
+     again. I don't know if we know how to avoid that.
+
+
+  OK, the solution involves reworking the call mechanism. This is
+  neccesary anyway in order to enable wrapping of function objects.
+
+  It can result in a reduction in the overall amount of source code,
+  because returning<> won't need to be specialized for every
+  combination of function and member function... though it will still
+  need a void specialization. We will still need a way to dispatch to
+  member functions through a regular function interface. mem_fn is
+  almost the right tool, but it only goes up to 8
+  arguments. Forwarding is tricky if you don't want to incur copies.
+  I think the trick is to use arg_from_python<T>::result_type for each
+  argument to the forwarder.
+
+  Another option would be to use separate function, function object,
+  and member function dispatchers. Once you know you have a member
+  function, you don't need cv-qualified overloads to call it.
+
+  Hmm, while we're at this, maybe we should solve the write-back
+  converter problem. Can we do it? Maybe not. Ralf doesn't want to
+  write special write-back functions here, does he? He wants the
+  converter to do the work automatically. We could add
+  cleanup/destructor registration. That would relieve the client from
+  having accessible destructors for types which are being converted by
+  rvalue. I'm not sure that this will really save any code,
+  however. It rather depends on the linker, doesn't it? I wonder if
+  this can be done in a backwards-compatible fashion by generating the
+  delete function when it's not supplied?
+
+  

doc/projects.html

@@ -0,0 +1,224 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<html>
+  <head>
+    <meta name="generator" content=
+    "HTML Tidy for Cygwin (vers 1st April 2002), see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="boost.css">
+
+    <title>Boost.Python - Projects using Boost.Python</title>
+  </head>
+
+  <body link="#0000ff" vlink="#800080">
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../c++boost.gif" border="0"></a></h3>
+        </td>
+
+        <td valign="top">
+          <h1 align="center"><a href="index.html">Boost.Python</a></h1>
+
+          <h2 align="center">Projects using Boost.Python</h2>
+        </td>
+      </tr>
+    </table>
+    <hr>
+
+    <h2>Introduction</h2>
+
+    <p>This is a partial list of projects using Boost.Python. If you are
+    using Boost.Python as your Python/C++ binding solution, we'd be proud to
+    list your project on this page. Just <a href=
+    "mailto:c++-sig@python.org">post</a> a short description of your project
+    and how Boost.Python helps you get the job done, and we'll add it to this
+    page .</p>
+    <hr>
+
+    <h3>Enterprise Software</h3>
+
+    <dl class="page-index">
+      <dt><b><a href="http://openwbem.sourceforge.net">OpenWBEM</a></b></dt>
+
+      <dd>
+        The OpenWBEM project is an effort to develop an open-source
+        implementation of Web Based Enterprise Management suitable for
+        commercial and non-commercial application 
+
+        <p><a href="mailto:dnuffer@sco.com">Dan Nuffer</a> writes:</p>
+
+        <blockquote>
+          I'm using Boost.Python to wrap the client API of OpenWBEM.This will
+          make it easier to do rapid prototyping, testing, and scripting when
+          developing management solutions that use WBEM.
+        </blockquote>
+      </dd>
+    </dl>
+
+    <h3>Financial Analysis</h3>
+
+    <dl class="page-index">
+      <dt><b>TSLib</b> - <a href="http://www.fortressinv.com">Fortress
+      Investment Group LLC</a></dt>
+
+      <dd>
+        Fortress Investment Group has contracted <a href=
+        "http://www.boost-consulting.com">Boost Consulting</a> to develop
+        core internal financial analysis tools in C++ and to prepare Python
+        bindings for them using Boost.Python. 
+
+        <p>Tom Barket of Fortress writes:</p>
+
+        <blockquote>
+          We have a large C++ analytical library specialized for research in
+          finance and economics, built for speed and mission critical
+          stability. Yet Python offers us the flexibility to test out new
+          ideas quickly and increase the productivity of our time versus
+          working in C++. There are several key features which make Python
+          stand out. Its elegance, stability, and breadth of resources on the
+          web are all valuable, but the most important is its extensibility,
+          due to its open source transparency. Boost.Python makes Python
+          extensibility extremely simple and straightforward, yet preserves a
+          great deal of power and control.
+        </blockquote>
+      </dd>
+    </dl>
+
+    <h3>Graphics</h3>
+
+    <dl class="page-index">
+      <dt><b><a href=
+      "http://www.openscenegraph.org">OpenSceneGraph</a></b></dt>
+
+      <dd><a href="mailto:gideon@computer.org">Gideon May</a> has created a
+      set of bindings for OpenSceneGraph, a cross-platform C++/OpenGL library
+      for the real-time visualization. You can read the release announcement
+      at <a href="http://www.hypereyes.com">www.hypereyes.com</a>. <a href=
+      "mailto:gideon@computer.org">Contact Gideon</a> for more
+      information.<br>
+       &nbsp;</dd>
+
+      <dt><a href=
+      "http://pythonmagick.procoders.net/"><b>PythonMagick</b></a></dt>
+
+      <dd>PythonMagick binds the <a href=
+      "http://www.imagemagick.org">ImageMagick</a> image manipulation library
+      to Python.<br>
+       &nbsp;</dd>
+
+      <dt><b><a href=
+      "http://www.slac.stanford.edu/grp/ek/hippodraw/index.html">HippoDraw</a></b></dt>
+
+      <dd>
+        HippoDraw is a data analysis environment consisting of a canvas upon
+        which graphs such as histograms, scattter plots, etc, are prsented.
+        It has a highly interactive GUI interface, but some things you need
+        to do with scripts. HippoDraw can be run as Python extension module
+        so that all the manipulation can be done from either Python or the
+        GUI. 
+
+        <p>Before the web page came online, <a
+        href="mailto:Paul_Kunz@SLAC.Stanford.EDU">Paul F. Kunz</a>
+        wrote:</p>
+
+        <blockquote>
+          Don't have a web page for the project, but the organization's is <a
+          href=
+          "http://www.slac.stanford.edu">http://www.slac.stanford.edu</a>
+          (the first web server site in America, I installed it).
+        </blockquote>
+        Which was just too cool a piece of trivia to omit.<br>
+         &nbsp;
+      </dd>
+    </dl>
+
+    <h3>Scientific Computing</h3>
+
+    <dl class="page index">
+      <dt><a href="http://camfr.sourceforge.net"><b>CAMFR</b></a></dt>
+
+      <dd>
+        CAMFR is a photonics and electromagnetics modelling tool. Python is
+        used for computational steering. 
+
+        <p><a href="mailto:Peter.Bienstman@rug.ac.be">Peter Bienstman</a>
+        writes:</p>
+
+        <blockquote>
+          Thanks for providing such a great tool!
+        </blockquote>
+      </dd>
+
+      <dt><a href="http://cctbx.sourceforge.net"><b>cctbx - Computational
+      Crystallography Toolbox</b></a></dt>
+
+      <dd>
+        Computational Crystallography is concerned with the derivation of
+        atomic models of crystal structures, given experimental X-ray
+        diffraction data. The cctbx is an open-source library of fundamental
+        algorithms for crystallographic computations. The core algorithms are
+        implemented in C++ and accessed through higher-level Python
+        interfaces. 
+
+        <p>The cctbx grew together with Boost.Python and is designed from the
+        ground up as a hybrid Python/C++ system. With one minor exception,
+        run-time polymorphism is completely handled by Python. C++
+        compile-time polymorphism is used to implement performance critical
+        algorithms. The Python and C++ layers are seamlessly integrated using
+        Boost.Python.</p>
+
+        <p>The SourceForge cctbx project is organized in modules to
+        facilitate use in non-crystallographic applications. The scitbx
+        module implements a general purpose array family for scientific
+        applications and pure C++ ports of FFTPACK and the LBFGS conjugate
+        gradient minimizer.</p>
+      </dd>
+
+      <dt><a href="http://www.llnl.gov/CASC/emsolve"><b>EMSolve</b></a></dt>
+
+      <dd>EMSolve is a provably stable, charge conserving, and energy
+      conserving solver for Maxwell's equations.<br>
+       &nbsp;</dd>
+
+      <dt><b><a href="http://cern.ch/gaudi">Gaudi</a></b> and <b><a href=
+      "http://cern.ch/Gaudi/RootPython/">RootPython</a></b></dt>
+
+      <dd>
+        Gaudi is a framework for particle physics collision data processing
+        applications developed in the context of the LHCb and ATLAS
+        experiments at CERN. 
+
+        <p><a href="mailto:Pere.Mato@cern.ch">Pere Mato Vila</a> writes:</p>
+
+        <blockquote>
+          We are using Boost.Python to provide scripting/interactive
+          capability to our framework. We have a module called "GaudiPython"
+          implemented using Boost.Python that allows the interaction with any
+          framework service or algorithm from python. RootPython also uses
+          Boost.Python to provide a generic "gateway" between the <a href=
+          "http://root.cern.ch">ROOT</a> framework and python 
+
+          <p>Boost.Python is great. We managed very quickly to interface our
+          framework to python, which is great language. We are trying to
+          facilitate to our physicists (end-users) a rapid analysis
+          application development environment based on python. For that,
+          Boost.Python plays and essential role.</p>
+        </blockquote>
+      </dd>
+    </dl>
+    <hr>
+
+    <p>Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+     22 March, 2003
+    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+    </p>
+
+    <p><i>&copy; Copyright <a href="../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002-2003. All Rights Reserved.</i></p>
+  </body>
+</html>
+

doc/support.html

@@ -0,0 +1,68 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<html>
+  <head>
+    <meta name="generator" content=
+    "HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="boost.css">
+
+    <title>Boost.Python - Support Resources</title>
+  </head>
+
+  <body link="#0000ff" vlink="#800080">
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../c++boost.gif" border="0"></a></h3>
+        </td>
+
+        <td valign="top">
+          <h1 align="center"><a href="index.html">Boost.Python</a></h1>
+
+          <h2 align="center">Support Resources</h2>
+        </td>
+      </tr>
+    </table>
+    <hr>
+
+    <h2>Synopsis</h2>
+
+    <p>This is a list of available resources for support with Boost.Python
+    problems and feature requests.</p>
+    <hr>
+
+    <dl class="page-index">
+      <dt><b><a href="http://www.boost-consulting.com">Boost
+      Consulting</a></b> - Commercial support, development, training, and
+      distribution for all the Boost libraries, from the people who brought
+      you Boost.Python.<br>
+       &nbsp;</dt>
+
+      <dt><b><a href="http://www.python.org/sigs/c++-sig/">The Python
+      C++-sig</a></b> mailing list is a forum for discussing Python/C++
+      interoperability, and Boost.Python in particular.<br>
+       &nbsp;</dt>
+
+      <dt>The <b>Boost.Python <a href=
+      "http://www.python.org/cgi-bin/moinmoin/boost_2epython">Wiki
+      Pages</a></b> established by Mike Rovner as part of the <a href=
+      "http://www.python.org/cgi-bin/moinmoin">PythonInfo Wiki</a> serves as
+      a forum to gather peoples' experience and as a cookbook.<br>
+      &nbsp;</dt>
+    </dl>
+    <hr>
+
+    <p>Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+     17 November, 2002 
+    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+    </p>
+
+    <p><i>&copy; Copyright <a href="../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i></p>
+  </body>
+</html>
+

doc/tutorial/doc/auto_overloading.html

@@ -0,0 +1,112 @@
+<html>
+<head>
+<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
+<title>Auto-Overloading</title>
+<link rel="stylesheet" href="theme/style.css" type="text/css">
+<link rel="prev" href="default_arguments.html">
+<link rel="next" href="object_interface.html">
+</head>
+<body>
+<table width="100%" height="48" border="0" cellspacing="2">
+  <tr>
+    <td><img src="theme/c%2B%2Bboost.gif">
+    </td>
+    <td width="85%">
+      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Auto-Overloading</b></font>
+    </td>
+  </tr>
+</table>
+<br>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="default_arguments.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="object_interface.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<p>
+It was mentioned in passing in the previous section that
+<tt>BOOST_PYTHON_FUNCTION_OVERLOADS</tt> and <tt>BOOST_PYTHON_FUNCTION_OVERLOADS</tt>
+can also be used for overloaded functions and member functions with a
+common sequence of initial arguments. Here is an example:</p>
+<code><pre>
+     <span class=keyword>void </span><span class=identifier>foo</span><span class=special>()
+     {
+        /*...*/
+     }
+
+     </span><span class=keyword>void </span><span class=identifier>foo</span><span class=special>(</span><span class=keyword>bool </span><span class=identifier>a</span><span class=special>)
+     {
+        /*...*/
+     }
+
+     </span><span class=keyword>void </span><span class=identifier>foo</span><span class=special>(</span><span class=keyword>bool </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=keyword>void </span><span class=identifier>foo</span><span class=special>(</span><span class=keyword>bool </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=keyword>char </span><span class=identifier>c</span><span class=special>)
+     {
+        /*...*/
+     }
+</span></pre></code>
+<p>
+Like in the previous section, we can generate thin wrappers for these
+overloaded functions in one-shot:</p>
+<code><pre>
+    <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></code>
+<p>
+Then...</p>
+<code><pre>
+    <span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;foo&quot;</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></code>
+<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="manual_wrapping"></a><h2>Manual Wrapping</h2><p>
+It is important to emphasize however that <b>the overloaded functions must
+have a common sequence of initial arguments</b>. Otherwise, our scheme above
+will not work. If this is not the case, we have to wrap our functions
+<a href="overloading.html">
+manually</a>.</p>
+<p>
+Actually, we can mix and match manual wrapping of overloaded functions and
+automatic wrapping through <tt>BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt> and
+its sister, <tt>BOOST_PYTHON_FUNCTION_OVERLOADS</tt>. Following up on our example
+presented in the section <a href="overloading.html">
+on overloading</a>, since the
+first 4 overload functins have a common sequence of initial arguments, we
+can use <tt>BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt> to automatically wrap the
+first three of the <tt>def</tt>s and manually wrap just the last. Here's
+how we'll do this:</p>
+<code><pre>
+    <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></code>
+<p>
+Create a member function pointers as above for both X::f overloads:</p>
+<code><pre>
+    <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>)    = &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>)        = &amp;</span><span class=identifier>X</span><span class=special>::</span><span class=identifier>f</span><span class=special>;
+</span></pre></code>
+<p>
+Then...</p>
+<code><pre>
+    <span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</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=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</span><span class=special>, </span><span class=identifier>fx2</span><span class=special>)
+</span></pre></code>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="default_arguments.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="object_interface.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
+<font size="2">Permission to copy, use, modify, sell and distribute this document
+ is granted provided this copyright notice appears in all copies. This document
+ is provided &quot;as is&quot; without express or implied warranty, and with
+ no claim as to its suitability for any purpose. </font> </p>
+</body>
+</html>

doc/tutorial/doc/basic_interface.html

@@ -34,7 +34,7 @@ To illustrate, this Python code snippet:</p>
 <code><pre>
     <span class=identifier>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=literal>'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=literal>'bar'
+             </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=literal>'bar'
          </span><span class=keyword>else</span><span class=special>:
              </span><span class=identifier>x</span><span class=special>.</span><span class=identifier>items </span><span class=special>+= </span><span class=identifier>y</span><span class=special>(</span><span class=number>3</span><span class=special>, </span><span class=identifier>x</span><span class=special>)
          </span><span class=keyword>return </span><span class=identifier>x
@@ -45,16 +45,16 @@ To illustrate, this Python code snippet:</p>
 <p>
 Can be rewritten in C++ using Boost.Python facilities this way:</p>
 <code><pre>
-    <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 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=keyword>if </span><span class=special>(</span><span class=identifier>y </span><span class=special>== </span><span class=string>&quot;foo&quot;</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>&quot;bar&quot;</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=string>&quot;bar&quot;</span><span class=special>;
          </span><span class=keyword>else
-             </span><span class=identifier>x</span><span class=special>.</span><span class=identifier>attr</span><span class=special>(</span><span class=string>&quot;items&quot;</span><span class=special>) </span><span class=special>+= </span><span class=identifier>y</span><span class=special>(</span><span class=number>3</span><span class=special>, </span><span class=identifier>x</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>&quot;items&quot;</span><span class=special>) += </span><span class=identifier>y</span><span class=special>(</span><span class=number>3</span><span class=special>, </span><span class=identifier>x</span><span class=special>);
          </span><span class=keyword>return </span><span class=identifier>x</span><span class=special>;
-    </span><span class=special>}
-    </span><span class=identifier>object </span><span class=identifier>getfunc</span><span class=special>() </span><span class=special>{
+    }
+    </span><span class=identifier>object </span><span class=identifier>getfunc</span><span class=special>() {
         </span><span class=keyword>return </span><span class=identifier>object</span><span class=special>(</span><span class=identifier>f</span><span class=special>);
-    </span><span class=special>}
+    }
 </span></pre></code>
 <p>
 Apart from cosmetic differences due to the fact that we are writing the
@@ -68,7 +68,7 @@ coder.</p>
    </tr>
 </table>
 <br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
 <font size="2">Permission to copy, use, modify, sell and distribute this document
  is granted provided this copyright notice appears in all copies. This document
  is provided &quot;as is&quot; without express or implied warranty, and with

doc/tutorial/doc/building_an_extension_module.html

@@ -1,186 +0,0 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Building an Extension Module </title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="class_data_members.html">
-<link rel="next" href="inheritance.html">
-</head>
-<body>
-<table width="100%" height="48" border="0" cellspacing="2">
-  <tr>
-    <td><img src="theme/c%2B%2Bboost.gif">
-    </td>
-    <td width="85%"> <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><strong>Building 
-      an Extension Module</strong></font> </td>
-  </tr>
-</table>
-<br>
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><img src="theme/l_arr.gif" border="0"></td>
-    <td width="20"><img src="theme/r_arr.gif" border="0"></td>
-   </tr>
-</table>
-<h2>Building Boost.Python</h2>
-<p>Every Boost.Python extension module must be linked with the boost_python shared 
-  library. To build boost_python, use <a href="file:///C:/dev/boost/tools/build/index.html">Boost.Build</a> 
-  in the usual way from the <tt>libs/python/build</tt> subdirectory of your boost 
-  installation (if you have already built boost from the top level this may have 
-  no effect, since the work is already done).</p>
-<h2>Configuration</h2>
-<p>You may need to configure the following variables to point Boost.Build at your 
-  Python installation:</p>
-<table width="95%" border="0" align="center">
-  <tr class="table_title"> 
-    <td width="24%">Variable Name</td>
-    <td width="20%">Semantics</td>
-    <td width="21%">Default</td>
-    <td width="35%">Notes</td>
-  </tr>
-  <tr class="table_cells"> 
-    <td><tt>PYTHON_ROOT</tt></td>
-    <td> The root directory of your Python installation</td>
-    <td>Windows: <tt><br>
-      c:/tools/python <br>
-      Unix: /usr/local</tt></td>
-    <td>On Unix, this is the <tt>--with-prefix=</tt> directory used to configure 
-      Python</td>
-  </tr>
-  <tr class="table_cells"> 
-    <td><tt>PYTHON_VERSION</tt></td>
-    <td> The The 2-part python Major.Minor version number</td>
-    <td>Windows: 2.1 Unix: 1.5</td>
-    <td>Be sure not to include a third number, e.g. not &quot;2.2.1&quot;, even 
-      if that's the version you have.</td>
-  </tr>
-  <tr class="table_cells"> 
-    <td><tt>PYTHON_INCLUDES</tt></td>
-    <td> path to Python <span class="preprocessor">#include</span> directories</td>
-    <td>Autoconfigured from <tt><br>
-      PYTHON_ROOT</tt></td>
-    <td>&nbsp;</td>
-  </tr>
-  <tr class="table_cells"> 
-    <td><tt>PYTHON_LIB_PATH</tt></td>
-    <td>path to Python library object.</td>
-    <td>Autoconfigured from <tt><br>
-      PYTHON_ROOT</tt></td>
-    <td>&nbsp;</td>
-  </tr>
-  <tr class="table_cells"> 
-    <td><tt>PYTHON_STDLIB_PATH</tt></td>
-    <td>path to Python standard library modules</td>
-    <td>Autoconfigured from <tt><br>
-      PYTHON_ROOT</tt></td>
-    <td>&nbsp;</td>
-  </tr>
-  <tr class="table_cells"> 
-    <td height="129"><tt>CYGWIN_ROOT</tt></td>
-    <td> path to the user's Cygwin installation</td>
-    <td>Autoconfigured from <tt><br>
-      PYTHON_ROOT</tt></td>
-    <td><a href="http://www.cygwin.com">Cygwin</a> only. This and the following 
-      two settings are useful when building with multiple toolsets on Windows, 
-      since Cygwin requires a different build of Python.</td>
-  </tr>
-  <tr class="table_cells"> 
-    <td height="21"><tt>GCC_PYTHON_ROOT</tt></td>
-    <td>path to the user's Cygwin Python installation</td>
-    <td><tt>$(CYGWIN_ROOT)<br>
-      /usr/local</tt></td>
-    <td> <a href="http://www.cygwin.com">Cygwin</a> only</td>
-  </tr>
-  <tr class="table_cells"> 
-    <td><tt>GCC_DEBUG_PYTHON_ROOT</tt></td>
-    <td> path to the user's Cygwin <a href="#variants">pydebug</a> 
-      build</td>
-    <td><tt>$(CYGWIN_ROOT)<br>
-      /usr/local/pydebug</tt></td>
-    <td> <a href="http://www.cygwin.com">Cygwin</a> only</td>
-  </tr>
-</table>
-<h2>Results</h2>
-<p>The build process will create a <tt>libs/python/build/bin-stage</tt> subdirectory 
-  of the boost root (or of <tt>$(ALL_LOCATE_TARGET)</tt>, if you have set that 
-  variable), containing the built libraries. The libraries are actually built 
-  to unique directories for each toolset and variant elsewhere in the filesystem, 
-  and copied to the bin-stage directory as a convenience, so if you build with 
-  multiple toolsets at once, the product of later toolsets will overwrite that 
-  of earlier toolsets in bin-stage.</p>
-<h2>Testing</h2>
-<p>To build and test Boost.Python from within the <tt>libs/python/build directory</tt>, 
-  invoke</p>
-<pre>    bjam -sTOOLS=<a href="../../../tools/build/index.html">toolset</a> test</pre>
-<p>This will update all of the Boost.Python v1 test and example targets. The tests 
-  are relatively quiet by default. To get more-verbose output, you might try</p>
-<pre>    bjam -sTOOLS=<a href="../../../tools/build/index.html">toolset</a> -sPYTHON_TEST_ARGS=-v test</pre>
-<p>which will print each test's Python code with the expected output as it passes.</p>
-<h2>Building your Extension Module</h2>
-<p>Though there are other approaches, the easiest way to build an extension module 
-  using Boost.Python is with Boost.Build. Until Boost.Build v2 is released, cross-project 
-  build dependencies are not supported, so it works most smoothly if you add a 
-  new subproject to your boost installation. The <tt>libs/python/example</tt> 
-  subdirectory of your boost installation contains a minimal example (along with 
-  many extra sources). To copy the example subproject:</p>
-<ol>
-  <li> Create a new subdirectory in,<tt> libs/python</tt>, say <tt>libs/python/my_project</tt>.</li>
-  <li> Copy <a href="../example/Jamfile"><tt>libs/python/example/Jamfile</tt></a> 
-    to your new directory.</li>
-  <li> Edit the Jamfile as appropriate for your project. You'll want to change 
-    the <tt>subproject</tt> rule invocation at the top, and the names of some 
-    of the source files and/or targets.</li>
-</ol>
-<p>If you can't modify or copy your boost installation, the alternative is to 
-  create your own Boost.Build project. A similar example you can use as a starting 
-  point is available in <a href="../example/project.zip">this archive</a>. You'll 
-  need to edit the Jamfile and Jamrules files, depending on the relative location 
-  of your Boost installation and the new project. Note that automatic testing 
-  of extension modules is not available in this configuration.</p>
-<h2>Build Variants</h2>
-<p>Three variant configurations of all python-related targets are supported, and 
-  can be selected by setting the BUILD variable:</p>
-<p> * <tt>release</tt> (optimization, <tt>-DNDEBUG</tt>)<br>
-  * <tt>debug</tt> (no optimization <tt>-D_DEBUG</tt>)<br>
-  * <tt>debug-python</tt> (no optimization, <tt>-D_DEBUG -DBOOST_DEBUG_PYTHON</tt>)</p>
-<p>The first two variants of the boost_python library are built by default, and 
-  are compatible with the default Python distribution. The debug-python variant 
-  corresponds to a specially-built debugging version of Python. On Unix platforms, 
-  this python is built by adding <tt>--with-pydebug</tt> when configuring the 
-  Python build. On Windows, the debugging version of Python is generated by the 
-  &quot;Win32 Debug&quot; target of the PCBuild.dsw Visual C++ 6.0 project in 
-  the PCBuild subdirectory of your Python distribution. Extension modules built 
-  with Python debugging enabled are not link-compatible with a non-debug build 
-  of Python. Since few people actually have a debug build of Python (it doesn't 
-  come with the standard distribution), the normal debug variant builds modules 
-  which are compatible with ordinary Python.</p>
-<p>On many windows compilers, when extension modules are built with <tt>-D_DEBUG</tt>, 
-  Python defaults to force linking with a special debugging version of the Python 
-  DLL. Since this debug DLL isn't supplied with the default Python installation 
-  for Windows, Boost.Python uses <a href="../../../boost/python/detail/wrap_python.hpp"><tt>boost/python/detail/wrap_python.hpp</tt></a> 
-  to temporarily undefine <tt>_DEBUG</tt> when <tt>Python.h</tt> is <span class="preprocessor">#included</span> 
-  - unless <tt>BOOST_DEBUG_PYTHON</tt> is defined.</p>
-<p>If you want the extra runtime checks available with the debugging version of 
-  the library, <span class="preprocessor">#define</span> <tt>BOOST_DEBUG_PYTHON</tt> 
-  to re-enable python debuggin, and link with the debug-python variant of boost_python.</p>
-<p>If you do not <span class="preprocessor">#define</span> <tt>BOOST_DEBUG_PYTHON</tt>, 
-  be sure that any source files in your extension module <span class="preprocessor">#include</span> 
-  <tt>&lt;boost/python/detail/wrap_python.hpp&gt;</tt> instead of the usual <tt>Python.h</tt>, 
-  or you will have link incompatibilities.</p>
-<code></code> 
-<table border="0">
-  <tr>
-    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><img src="theme/l_arr.gif" border="0"></td>
-    <td width="20"><img src="theme/r_arr.gif" border="0"></td>
-   </tr>
-</table>
-<br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
-<font size="2">Permission to copy, use, modify, sell and distribute this document
- is granted provided this copyright notice appears in all copies. This document
- is provided &quot;as is&quot; without express or implied warranty, and with
- no claim as to its suitability for any purpose. </font> </p>
-</body>
-</html>

doc/tutorial/doc/building_hello_world.html

@@ -182,7 +182,7 @@ You may now fire up Python and run our hello module:</p>
    </tr>
 </table>
 <br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
 <font size="2">Permission to copy, use, modify, sell and distribute this document
  is granted provided this copyright notice appears in all copies. This document
  is provided &quot;as is&quot; without express or implied warranty, and with

doc/tutorial/doc/call_policies.html

@@ -4,7 +4,7 @@
 <title>Call Policies</title>
 <link rel="stylesheet" href="theme/style.css" type="text/css">
 <link rel="prev" href="functions.html">
-<link rel="next" href="default_arguments.html">
+<link rel="next" href="overloading.html">
 </head>
 <body>
 <table width="100%" height="48" border="0" cellspacing="2">
@@ -21,7 +21,7 @@
   <tr>
     <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
     <td width="30"><a href="functions.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="default_arguments.html"><img src="theme/r_arr.gif" border="0"></a></td>
+    <td width="20"><a href="overloading.html"><img src="theme/r_arr.gif" border="0"></a></td>
    </tr>
 </table>
 <p>
@@ -43,9 +43,9 @@ 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>
 <code><pre>
-    <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=identifier>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 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=identifier>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=identifier>CRASH</span><span class=special>!
+    </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=identifier>CRASH</span><span class=special>!
 </span></pre></code>
 <p>
 What's the problem?</p>
@@ -53,10 +53,10 @@ What's the problem?</p>
 Well, what if f() was implemented as shown below:</p>
 <code><pre>
     <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><span class=special>}
+    }
 </span></pre></code>
 <p>
 The problem is that the lifetime of result X&amp; is tied to the lifetime
@@ -70,8 +70,8 @@ Here's what's happening:</p>
 <ol><li><tt>f</tt> is called passing in a reference to <tt>y</tt> and a pointer to <tt>z</tt></li><li>A reference to <tt>y.x</tt> is returned</li><li><tt>y</tt> is deleted. <tt>x</tt> is a dangling reference</li><li><tt>x.some_method()</tt> is called</li><li><b>BOOM!</b></li></ol><p>
 We could copy result into a new object:</p>
 <code><pre>
-    <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=identifier>Result </span><span class=identifier>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=identifier>No </span><span class=identifier>crash</span><span class=special>, </span><span class=identifier>but </span><span class=identifier>still </span><span class=identifier>bad
+    <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=identifier>Result </span><span class=identifier>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=identifier>No </span><span class=identifier>crash</span><span class=special>, </span><span class=identifier>but </span><span class=identifier>still </span><span class=identifier>bad
     </span><span class=number>3.14
 </span></pre></code>
 <p>
@@ -84,25 +84,25 @@ Our problems do not end there. Suppose Y is implemented as follows:</p>
     <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><span class=special>};
+        </span><span class=keyword>int </span><span class=identifier>z_value</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></pre></code>
 <p>
 Notice that the data member <tt>z</tt> is held by class Y using a raw
 pointer. Now we have a potential dangling pointer problem inside Y:</p>
 <code><pre>
-    <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=identifier>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=identifier>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=identifier>CRASH</span><span class=special>!
+    <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=identifier>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=identifier>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=identifier>CRASH</span><span class=special>!
 </span></pre></code>
 <p>
 For reference, here's the implementation of <tt>f</tt> again:</p>
 <code><pre>
     <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><span class=special>}
+    }
 </span></pre></code>
 <p>
 Here's what's happening:</p>
@@ -113,7 +113,7 @@ are our friends:</p>
 <code><pre>
     <span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</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><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; &gt;());
 </span></pre></code>
 <p>
 What are the <tt>1</tt> and <tt>2</tt> parameters, you ask?</p>
@@ -138,7 +138,7 @@ or more policies can be composed by chaining. Here's the general syntax:</p>
 <code><pre>
     <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><span class=identifier>policy3</span><span class=special>&lt;</span><span class=identifier>args</span><span class=special>...&gt; &gt; &gt;
 </span></pre></code>
 <p>
 Here is the list of predefined call policies. A complete reference detailing
@@ -156,11 +156,11 @@ here</a>.</p>
   <tr>
     <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
     <td width="30"><a href="functions.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="default_arguments.html"><img src="theme/r_arr.gif" border="0"></a></td>
+    <td width="20"><a href="overloading.html"><img src="theme/r_arr.gif" border="0"></a></td>
    </tr>
 </table>
 <br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
 <font size="2">Permission to copy, use, modify, sell and distribute this document
  is granted provided this copyright notice appears in all copies. This document
  is provided &quot;as is&quot; without express or implied warranty, and with

doc/tutorial/doc/class_data_members.html

@@ -32,23 +32,24 @@ member that we wish to be exposed may be regarded as <b>read-only</b> or
 <code><pre>
     <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>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=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=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><span class=keyword>float </span><span class=identifier>value</span><span class=special>;
-    </span><span class=special>};
+    };
 </span></pre></code>
 <p>
 Our C++ <tt>Var</tt> class and its data members can be exposed to Python:</p>
 <code><pre>
     <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>Var</span><span class=special>&gt;(</span><span class=string>&quot;Var&quot;</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>&quot;name&quot;</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>&quot;value&quot;</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><span class=identifier>def_readonly</span><span class=special>(</span><span class=string>&quot;name&quot;</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=identifier>def_readwrite</span><span class=special>(</span><span class=string>&quot;value&quot;</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></code>
 <p>
-Then, in Python:</p>
+Then, in Python, assuming we have placed our Var class inside the namespace
+hello as we did before:</p>
 <code><pre>
-    <span class=special>&gt;&gt;&gt; </span><span class=identifier>x </span><span class=special>= </span><span class=identifier>Var</span><span class=special>(</span><span class=literal>'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 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=literal>'pi'</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>print </span><span class=identifier>x</span><span class=special>.</span><span class=identifier>name</span><span class=special>, </span><span class=literal>'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=identifier>is </span><span class=identifier>around </span><span class=number>3.14
 </span></pre></code>
@@ -68,7 +69,7 @@ as <b>read-write</b>.</p>
    </tr>
 </table>
 <br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
 <font size="2">Permission to copy, use, modify, sell and distribute this document
  is granted provided this copyright notice appears in all copies. This document
  is provided &quot;as is&quot; without express or implied warranty, and with

doc/tutorial/doc/class_operators_special_functions.html

@@ -3,7 +3,7 @@
 <!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
 <title>Class Operators/Special Functions</title>
 <link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="class_virtual_functions.html">
+<link rel="prev" href="virtual_functions_with_default_implementations.html">
 <link rel="next" href="functions.html">
 </head>
 <body>
@@ -20,7 +20,7 @@
 <table border="0">
   <tr>
     <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="class_virtual_functions.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="30"><a href="virtual_functions_with_default_implementations.html"><img src="theme/l_arr.gif" border="0"></a></td>
     <td width="20"><a href="functions.html"><img src="theme/r_arr.gif" border="0"></a></td>
    </tr>
 </table>
@@ -32,7 +32,7 @@ this and makes it easy to wrap C++ operator-powered classes.</p>
 Consider a file position class <tt>FilePos</tt> and a set of operators that take
 on FilePos instances:</p>
 <code><pre>
-    <span class=keyword>class </span><span class=identifier>FilePos </span><span class=special>{ </span><span class=comment>/*...*/ </span><span class=special>};
+    <span class=keyword>class </span><span class=identifier>FilePos </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>);
@@ -47,13 +47,13 @@ The class and the various operators can be mapped to Python rather easily
 and intuitively:</p>
 <code><pre>
     <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>FilePos</span><span class=special>&gt;(</span><span class=string>&quot;FilePos&quot;</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__
-        </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>// __rsub__
-        </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>// __iadd__
+        .</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=identifier>__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=identifier>self</span><span class=special>)          // </span><span class=identifier>__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=identifier>__sub__
+        </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=identifier>__sub__
+        </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=identifier>__iadd__
         </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>other</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;())
-        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>self </span><span class=special>&lt; </span><span class=identifier>self</span><span class=special>);          </span><span class=comment>// __lt__
+        .</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>self </span><span class=special>&lt; </span><span class=identifier>self</span><span class=special>);          // </span><span class=identifier>__lt__
 </span></pre></code>
 <p>
 The code snippet above is very clear and needs almost no explanation at
@@ -69,17 +69,17 @@ similar set of intuitive interfaces can also be used to wrap C++ functions
 that correspond to these Python <i>special functions</i>. Example:</p>
 <code><pre>
     <span class=keyword>class </span><span class=identifier>Rational
-    </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=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=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><span class=identifier>Rational </span><span class=identifier>abs</span><span class=special>(</span><span class=identifier>Rational</span><span class=special>);
     </span><span class=identifier>ostream</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>&lt;&lt;(</span><span class=identifier>ostream</span><span class=special>&amp;,</span><span class=identifier>Rational</span><span class=special>);
 
     </span><span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>Rational</span><span class=special>&gt;()
-        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>float_</span><span class=special>(</span><span class=identifier>self</span><span class=special>))                  </span><span class=comment>// __float__
-        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>pow</span><span class=special>(</span><span class=identifier>self</span><span class=special>, </span><span class=identifier>other</span><span class=special>&lt;</span><span class=identifier>Rational</span><span class=special>&gt;))    </span><span class=comment>// __pow__
-        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>abs</span><span class=special>(</span><span class=identifier>self</span><span class=special>))                     </span><span class=comment>// __abs__
-        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>str</span><span class=special>(</span><span class=identifier>self</span><span class=special>))                     </span><span class=comment>// __str__
+        .</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>float_</span><span class=special>(</span><span class=identifier>self</span><span class=special>))                  // </span><span class=identifier>__float__
+        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>pow</span><span class=special>(</span><span class=identifier>self</span><span class=special>, </span><span class=identifier>other</span><span class=special>&lt;</span><span class=identifier>Rational</span><span class=special>&gt;))    // </span><span class=identifier>__pow__
+        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>abs</span><span class=special>(</span><span class=identifier>self</span><span class=special>))                     // </span><span class=identifier>__abs__
+        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=identifier>str</span><span class=special>(</span><span class=identifier>self</span><span class=special>))                     // </span><span class=identifier>__str__
         </span><span class=special>;
 </span></pre></code>
 <p>
@@ -95,12 +95,12 @@ Well, the method <tt>str</tt> requires the <tt>operator&lt;&lt;</tt> to do its w
 <table border="0">
   <tr>
     <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="class_virtual_functions.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="30"><a href="virtual_functions_with_default_implementations.html"><img src="theme/l_arr.gif" border="0"></a></td>
     <td width="20"><a href="functions.html"><img src="theme/r_arr.gif" border="0"></a></td>
    </tr>
 </table>
 <br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
 <font size="2">Permission to copy, use, modify, sell and distribute this document
  is granted provided this copyright notice appears in all copies. This document
  is provided &quot;as is&quot; without express or implied warranty, and with

doc/tutorial/doc/class_properties.html

@@ -36,8 +36,8 @@ properties. Here's an example:</p>
         </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><span class=keyword>void </span><span class=identifier>set</span><span class=special>(</span><span class=keyword>float </span><span class=identifier>value</span><span class=special>);
-        </span><span class=special>...
-    </span><span class=special>};
+        ...
+    };
 </span></pre></code>
 <p>
 However, in Python attribute access is fine; it doesn't neccessarily break
@@ -46,23 +46,23 @@ attributes can just be a different syntax for a method call. Wrapping our
 <tt>Num</tt> class using Boost.Python:</p>
 <code><pre>
     <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>Num</span><span class=special>&gt;(</span><span class=string>&quot;Num&quot;</span><span class=special>)
-        </span><span class=special>.</span><span class=identifier>add_property</span><span class=special>(</span><span class=string>&quot;rovalue&quot;</span><span class=special>, </span><span class=special>&amp;</span><span class=identifier>Var</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>&quot;value&quot;</span><span class=special>, </span><span class=special>&amp;</span><span class=identifier>Var</span><span class=special>::</span><span class=identifier>get</span><span class=special>, </span><span class=special>&amp;</span><span class=identifier>Var</span><span class=special>::</span><span class=identifier>set</span><span class=special>);
+        .</span><span class=identifier>add_property</span><span class=special>(</span><span class=string>&quot;rovalue&quot;</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=identifier>add_property</span><span class=special>(</span><span class=string>&quot;value&quot;</span><span class=special>, &amp;</span><span class=identifier>Num</span><span class=special>::</span><span class=identifier>get</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></code>
 <p>
 And at last, in Python:</p>
 <code><pre>
     <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
+    &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><span class=special>&gt;&gt;&gt; </span><span class=identifier>x</span><span class=special>.</span><span class=identifier>rovalue </span><span class=special>= </span><span class=number>2.17 </span>#<span class=identifier>error</span><span class=special>!
+    &gt;&gt;&gt; </span><span class=identifier>x</span><span class=special>.</span><span class=identifier>rovalue </span><span class=special>= </span><span class=number>2.17 </span>##<span class=identifier>error</span><span class=special>!
 </span></pre></code>
 <p>
 Take note that the class property <tt>rovalue</tt> is exposed as <b>read-only</b>
 since the <tt>rovalue</tt> setter member function is not passed in:</p>
 <code><pre>
-    <span class=special>.</span><span class=identifier>add_property</span><span class=special>(</span><span class=string>&quot;rovalue&quot;</span><span class=special>, </span><span class=special>&amp;</span><span class=identifier>Var</span><span class=special>::</span><span class=identifier>get</span><span class=special>)
+    <span class=special>.</span><span class=identifier>add_property</span><span class=special>(</span><span class=string>&quot;rovalue&quot;</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></code>
 <table border="0">
   <tr>
@@ -72,7 +72,7 @@ since the <tt>rovalue</tt> setter member function is not passed in:</p>
    </tr>
 </table>
 <br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
 <font size="2">Permission to copy, use, modify, sell and distribute this document
  is granted provided this copyright notice appears in all copies. This document
  is provided &quot;as is&quot; without express or implied warranty, and with

doc/tutorial/doc/class_virtual_functions.html

@@ -4,7 +4,7 @@
 <title>Class Virtual Functions</title>
 <link rel="stylesheet" href="theme/style.css" type="text/css">
 <link rel="prev" href="inheritance.html">
-<link rel="next" href="class_operators_special_functions.html">
+<link rel="next" href="deriving_a_python_class.html">
 </head>
 <body>
 <table width="100%" height="48" border="0" cellspacing="2">
@@ -21,7 +21,7 @@
   <tr>
     <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
     <td width="30"><a href="inheritance.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="class_operators_special_functions.html"><img src="theme/r_arr.gif" border="0"></a></td>
+    <td width="20"><a href="deriving_a_python_class.html"><img src="theme/r_arr.gif" border="0"></a></td>
    </tr>
 </table>
 <p>
@@ -31,8 +31,8 @@ add a virtual function to our <tt>Base</tt> class:</p>
 <code><pre>
     <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><span class=keyword>virtual </span><span class=keyword>int </span><span class=identifier>f</span><span class=special>() = </span><span class=number>0</span><span class=special>;
+    };
 </span></pre></code>
 <p>
 Since <tt>f</tt> is a pure virtual function, <tt>Base</tt> is now an abstract
@@ -40,7 +40,7 @@ class. Given an instance of our class, the free function <tt>call_f</tt>
 calls some implementation of this virtual function in a concrete
 derived class:</p>
 <code><pre>
-    <span class=keyword>int </span><span class=identifier>call_f</span><span class=special>(</span><span class=identifier>Base</span><span class=special>&amp; </span><span class=identifier>b</span><span class=special>) </span><span class=special>{ </span><span class=keyword>return </span><span class=identifier>b</span><span class=special>.</span><span class=identifier>f</span><span class=special>(); </span><span class=special>}
+    <span class=keyword>int </span><span class=identifier>call_f</span><span class=special>(</span><span class=identifier>Base</span><span class=special>&amp; </span><span class=identifier>b</span><span class=special>) { </span><span class=keyword>return </span><span class=identifier>b</span><span class=special>.</span><span class=identifier>f</span><span class=special>(); }
 </span></pre></code>
 <p>
 To allow this function to be implemented in a Python derived class, we
@@ -49,10 +49,10 @@ need to create a class wrapper:</p>
     <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>BaseWrap</span><span class=special>(</span><span class=identifier>PyObject</span><span class=special>* </span><span class=identifier>self_</span><span class=special>)
-            </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=special>{}
-        </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=identifier>call_method</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;(</span><span class=identifier>self</span><span class=special>, </span><span class=string>&quot;f&quot;</span><span class=special>); </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=keyword>int </span><span class=identifier>f</span><span class=special>() { </span><span class=keyword>return </span><span class=identifier>call_method</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;(</span><span class=identifier>self</span><span class=special>, </span><span class=string>&quot;f&quot;</span><span class=special>); }
         </span><span class=identifier>PyObject</span><span class=special>* </span><span class=identifier>self</span><span class=special>;
-    </span><span class=special>};
+    };
 </span></pre></code>
 <table width="80%" border="0" align="center">
   <tr>
@@ -93,7 +93,7 @@ polymorphically <i>from</i> <b>C++</b>.    </td>
 Wrapping <tt>Base</tt> and the free function <tt>call_f</tt>:</p>
 <code><pre>
     <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>Base</span><span class=special>, </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>&quot;Base&quot;</span><span class=special>, </span><span class=identifier>no_init</span><span class=special>)
-        </span><span class=special>;
+        ;
     </span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;call_f&quot;</span><span class=special>, </span><span class=identifier>call_f</span><span class=special>);
 </span></pre></code>
 <p>
@@ -106,119 +106,21 @@ available, since Base is an abstract class.</p>
 In Python, let us try to instantiate our <tt>Base</tt> class:</p>
 <code><pre>
     <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=identifier>AttributeError</span><span class=special>: </span><span class=special>...
+    </span><span class=identifier>RuntimeError</span><span class=special>: </span><span class=identifier>This </span><span class=keyword>class </span><span class=identifier>cannot </span><span class=identifier>be </span><span class=identifier>instantiated </span><span class=identifier>from </span><span class=identifier>Python
 </span></pre></code>
 <p>
 Why is it an error? <tt>Base</tt> is an abstract class. As such it is advisable
 to define the Python wrapper with <tt>no_init</tt> as we have done above. Doing
 so will disallow abstract base classes such as <tt>Base</tt> to be instantiated.</p>
-<a name="deriving_a_python_class"></a><h2>Deriving a Python class</h2><p>
-Now, at last, we can even derive from our base class <tt>Base</tt> in Python:</p>
-<code><pre>
-    <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=identifier>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><span class=special>...
-</span></pre></code>
-<p>
-Cool eh? A Python class deriving from a C++ class!</p>
-<p>
-Let's now make an instance of our Python class <tt>Derived</tt>:</p>
-<code><pre>
-    <span class=special>&gt;&gt;&gt; </span><span class=identifier>derived </span><span class=special>= </span><span class=identifier>Derived</span><span class=special>()
-</span></pre></code>
-<p>
-Calling <tt>derived.f()</tt>:</p>
-<code><pre>
-    <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></code>
-<p>
-Will yield the expected result. Finally, calling calling the free function
-<tt>call_f</tt> with <tt>derived</tt> as argument:</p>
-<code><pre>
-    <span class=special>&gt;&gt;&gt; </span><span class=identifier>call_f</span><span class=special>(</span><span class=identifier>derived</span><span class=special>)
-    </span><span class=number>42
-</span></pre></code>
-<p>
-Will also yield the expected result.</p>
-<p>
-Here's what's happening:</p>
-<ol><li><tt>call_f(derived)</tt> is called in Python</li><li>This corresponds to <tt>def(&quot;call_f&quot;, call_f);</tt>. Boost.Python dispatches this call.</li><li><tt>int call_f(Base&amp; b) { return b.f(); }</tt> accepts the call.</li><li>The overridden virtual function <tt>f</tt> of <tt>BaseWrap</tt> is called.</li><li><tt>call_method&lt;int&gt;(self, &quot;f&quot;);</tt> dispatches the call back to Python.</li><li><tt>def f(self): return 42</tt> is finally called.</li></ol><p>
-Rewind back to our <tt>Base</tt> class, if its member function <tt>f</tt> was not
-declared as pure virtual:</p>
-<code><pre>
-    <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=keyword>return </span><span class=number>0</span><span class=special>; </span><span class=special>}
-    </span><span class=special>};
-</span></pre></code>
-<p>
-And instead is implemented to return <tt>0</tt>, as shown above.</p>
-<code><pre>
-    <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>BaseWrap</span><span class=special>(</span><span class=identifier>PyObject</span><span class=special>* </span><span class=identifier>self_</span><span class=special>)
-            </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=special>{}
-        </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=identifier>call_method</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;(</span><span class=identifier>self</span><span class=special>, </span><span class=string>&quot;f&quot;</span><span class=special>); </span><span class=special>}
-        </span><span class=keyword>static </span><span class=keyword>int </span><span class=identifier>default_f</span><span class=special>(</span><span class=identifier>Base</span><span class=special>* </span><span class=identifier>b</span><span class=special>) </span><span class=special>{ </span><span class=keyword>return </span><span class=identifier>b</span><span class=special>-&gt;</span><span class=identifier>Base</span><span class=special>::</span><span class=identifier>f</span><span class=special>(); </span><span class=special>} </span><span class=comment>// &lt;&lt;=== added
-        </span><span class=identifier>PyObject</span><span class=special>* </span><span class=identifier>self</span><span class=special>;
-    </span><span class=special>};
-</span></pre></code>
-<p>
-then, our Boost.Python wrapper:</p>
-<code><pre>
-    <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>Base</span><span class=special>, </span><span class=identifier>BaseWrap</span><span class=special>&gt;(</span><span class=string>&quot;Base&quot;</span><span class=special>)
-        </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</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></code>
-<p>
-Note that we are allowing <tt>Base</tt> objects to be instantiated this time,
-unlike before where we specifically defined the <tt>class_&lt;Base&gt;</tt> with
-<tt>no_init</tt>.</p>
-<p>
-In Python, the results would be as expected:</p>
-<code><pre>
-    <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=identifier>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><span class=special>...
-    </span><span class=special>&gt;&gt;&gt; </span><span class=identifier>derived </span><span class=special>= </span><span class=identifier>Derived</span><span class=special>()
-</span></pre></code>
-<p>
-Calling <tt>base.f()</tt>:</p>
-<code><pre>
-    <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></code>
-<p>
-Calling <tt>derived.f()</tt>:</p>
-<code><pre>
-    <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></code>
-<p>
-Calling <tt>call_f</tt>, passing in a <tt>base</tt> object:</p>
-<code><pre>
-    <span class=special>&gt;&gt;&gt; </span><span class=identifier>call_f</span><span class=special>(</span><span class=identifier>base</span><span class=special>)
-    </span><span class=number>0
-</span></pre></code>
-<p>
-Calling <tt>call_f</tt>, passing in a <tt>derived</tt> object:</p>
-<code><pre>
-    <span class=special>&gt;&gt;&gt; </span><span class=identifier>call_f</span><span class=special>(</span><span class=identifier>derived</span><span class=special>)
-    </span><span class=number>42
-</span></pre></code>
 <table border="0">
   <tr>
     <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
     <td width="30"><a href="inheritance.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="class_operators_special_functions.html"><img src="theme/r_arr.gif" border="0"></a></td>
+    <td width="20"><a href="deriving_a_python_class.html"><img src="theme/r_arr.gif" border="0"></a></td>
    </tr>
 </table>
 <br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
 <font size="2">Permission to copy, use, modify, sell and distribute this document
  is granted provided this copyright notice appears in all copies. This document
  is provided &quot;as is&quot; without express or implied warranty, and with

doc/tutorial/doc/constructors.html

@@ -38,11 +38,11 @@ build on our previous example:</p>
 <code><pre>
     <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><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><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=identifier>added </span><span class=identifier>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=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=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>greet</span><span class=special>() { </span><span class=keyword>return </span><span class=identifier>msg</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></pre></code>
 <p>
 This time <tt>World</tt> has no default constructor; our previous
@@ -54,12 +54,12 @@ expose instead.</p>
     </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><span class=special>{
+    {
         </span><span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>World</span><span class=special>&gt;(</span><span class=string>&quot;World&quot;</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=string>&quot;greet&quot;</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>&quot;set&quot;</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><span class=special>;
-    </span><span class=special>}
+            .</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;greet&quot;</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=identifier>def</span><span class=special>(</span><span class=string>&quot;set&quot;</span><span class=special>, &amp;</span><span class=identifier>World</span><span class=special>::</span><span class=identifier>set</span><span class=special>)
+        ;
+    }
 </span></pre></code>
 <p>
 <tt>init&lt;std::string&gt;()</tt> exposes the constructor taking in a
@@ -71,10 +71,10 @@ the <tt>def()</tt> member function. Say for example we have another World
 constructor taking in two doubles:</p>
 <code><pre>
     <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>World</span><span class=special>&gt;(</span><span class=string>&quot;World&quot;</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>&quot;greet&quot;</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>&quot;set&quot;</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><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=identifier>def</span><span class=special>(</span><span class=string>&quot;greet&quot;</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=identifier>def</span><span class=special>(</span><span class=string>&quot;set&quot;</span><span class=special>, &amp;</span><span class=identifier>World</span><span class=special>::</span><span class=identifier>set</span><span class=special>)
+    ;
 </span></pre></code>
 <p>
 On the other hand, if we do not wish to expose any constructors at
@@ -93,7 +93,7 @@ Python RuntimeError exception.</p>
    </tr>
 </table>
 <br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
 <font size="2">Permission to copy, use, modify, sell and distribute this document
  is granted provided this copyright notice appears in all copies. This document
  is provided &quot;as is&quot; without express or implied warranty, and with

doc/tutorial/doc/default_arguments.html

@@ -3,8 +3,8 @@
 <!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
 <title>Default Arguments</title>
 <link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="call_policies.html">
-<link rel="next" href="object_interface.html">
+<link rel="prev" href="overloading.html">
+<link rel="next" href="auto_overloading.html">
 </head>
 <body>
 <table width="100%" height="48" border="0" cellspacing="2">
@@ -20,8 +20,8 @@
 <table border="0">
   <tr>
     <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="call_policies.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="object_interface.html"><img src="theme/r_arr.gif" border="0"></a></td>
+    <td width="30"><a href="overloading.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="auto_overloading.html"><img src="theme/r_arr.gif" border="0"></a></td>
    </tr>
 </table>
 <p>
@@ -29,43 +29,46 @@ Boost.Python wraps (member) function pointers. Unfortunately, C++ function
 pointers carry no default argument info. Take a function <tt>f</tt> with default
 arguments:</p>
 <code><pre>
-    <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>&quot;hello&quot;</span><span class=special>);
+    <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=string>&quot;hello&quot;</span><span class=special>);
 </span></pre></code>
 <p>
 But the type of a pointer to the function <tt>f</tt> has no information
 about its default arguments:</p>
 <code><pre>
-    <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 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=identifier>f</span><span class=special>;    // </span><span class=identifier>defaults </span><span class=identifier>lost</span><span class=special>!
 </span></pre></code>
 <p>
 When we pass this function pointer to the <tt>def</tt> function, there is no way
 to retrieve the default arguments:</p>
 <code><pre>
-    <span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</span><span class=special>, </span><span class=identifier>f</span><span class=special>);                            </span><span class=comment>// defaults lost!
+    <span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</span><span class=special>, </span><span class=identifier>f</span><span class=special>);                            // </span><span class=identifier>defaults </span><span class=identifier>lost</span><span class=special>!
 </span></pre></code>
 <p>
-Because of this, when wrapping C++ code in earlier versions of
-Boost.Python, we had to resort to writing thin wrappers:</p>
+Because of this, when wrapping C++ code, we had to resort to manual
+wrapping as outlined in the <a href="overloading.html">
+previous section</a>, or
+writing thin wrappers:</p>
 <code><pre>
     <span class=comment>// write &quot;thin wrappers&quot;
-    </span><span class=keyword>int </span><span class=identifier>f1</span><span class=special>(</span><span class=keyword>int </span><span class=identifier>x</span><span class=special>) </span><span class=special>{ </span><span class=identifier>f</span><span class=special>(</span><span class=identifier>x</span><span class=special>); </span><span class=special>}
-    </span><span class=keyword>int </span><span class=identifier>f2</span><span class=special>(</span><span class=keyword>int </span><span class=identifier>x</span><span class=special>, </span><span class=keyword>double </span><span class=identifier>y</span><span class=special>) </span><span class=special>{ </span><span class=identifier>f</span><span class=special>(</span><span class=identifier>x</span><span class=special>,</span><span class=identifier>y</span><span class=special>); </span><span class=special>}
+    </span><span class=keyword>int </span><span class=identifier>f1</span><span class=special>(</span><span class=keyword>int </span><span class=identifier>x</span><span class=special>) { </span><span class=identifier>f</span><span class=special>(</span><span class=identifier>x</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=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=comment>/*...*/
+    /*...*/
 
-        // in module init
-        </span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</span><span class=special>, </span><span class=identifier>f</span><span class=special>);  </span><span class=comment>// all arguments
-        </span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</span><span class=special>, </span><span class=identifier>f2</span><span class=special>); </span><span class=comment>// two arguments
-        </span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</span><span class=special>, </span><span class=identifier>f1</span><span class=special>); </span><span class=comment>// one argument
+        // </span><span class=identifier>in </span><span class=identifier>module </span><span class=identifier>init
+        </span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</span><span class=special>, </span><span class=identifier>f</span><span class=special>);  // </span><span class=identifier>all </span><span class=identifier>arguments
+        </span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</span><span class=special>, </span><span class=identifier>f2</span><span class=special>); // </span><span class=identifier>two </span><span class=identifier>arguments
+        </span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</span><span class=special>, </span><span class=identifier>f1</span><span class=special>); // </span><span class=identifier>one </span><span class=identifier>argument
 </span></pre></code>
 <p>
 When you want to wrap functions (or member functions) that either:</p>
-<ul><li>have default arguments, or</li><li>are overloaded with a common sequence of initial arguments</li></ul><p>
-Boost.Python now has a way to make it easier.</p>
-<p>
-For instance, given a function:</p>
+<ul><li>have default arguments, or</li><li>are overloaded with a common sequence of initial arguments</li></ul><a name="boost_python_function_overloads"></a><h2>BOOST_PYTHON_FUNCTION_OVERLOADS</h2><p>
+Boost.Python now has a way to make it easier. For instance, given a function:</p>
 <code><pre>
-    <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 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></code>
 <p>
 The macro invocation:</p>
@@ -73,7 +76,7 @@ The macro invocation:</p>
     <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></code>
 <p>
-Will automatically create the thin wrappers for us. This macro will create
+will automatically create the thin wrappers for us. This macro will create
 a class <tt>foo_overloads</tt> that can be passed on to <tt>def(...)</tt>. The third
 and fourth macro argument are the minimum arguments and maximum arguments,
 respectively. In our <tt>foo</tt> function the minimum number of arguments is 1
@@ -82,21 +85,58 @@ automatically add all the foo variants for us:</p>
 <code><pre>
     <span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;foo&quot;</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></code>
+<a name="boost_python_member_function_overloads"></a><h2>BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</h2><p>
+Objects here, objects there, objects here there everywhere. More frequently
+than anything else, we need to expose member functions of our classes to
+Python. Then again, we have the same inconveniences as before when default
+arguments or overloads with a common sequence of initial arguments come
+into play. Another macro is provided to make this a breeze.</p>
 <p>
+Like <tt>BOOST_PYTHON_FUNCTION_OVERLOADS</tt>,
+<tt>BOOST_PYTHON_FUNCTION_OVERLOADS</tt> may be used to automatically create
+the thin wrappers for wrapping member functions. Let's have an example:</p>
+<code><pre>
+    <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=literal>'x'</span><span class=special>)
+        {
+            /*...*/
+        }
+    };
+</span></pre></code>
+<p>
+The macro invocation:</p>
+<code><pre>
+    <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></code>
+<p>
+will generate a set of thin wrappers for george's <tt>wack_em</tt> member function
+accepting a minimum of 1 and a maximum of 3 arguments (i.e. the third and
+fourth macro argument). The thin wrappers are all enclosed in a class named
+<tt>george_overloads</tt> that can then be used as an argument to <tt>def(...)</tt>:</p>
+<code><pre>
+    <span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;wack_em&quot;</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></code>
+<p>
+See the <a href="../../v2/overloads.html#BOOST_PYTHON_FUNCTION_OVERLOADS-spec">
+overloads reference</a>
+for details.</p>
+<a name="init_and_optional"></a><h2>init and optional</h2><p>
 A similar facility is provided for class constructors, again, with
-default arguments or a sequence of overloads. Remember init&lt;...&gt;? For example,
+default arguments or a sequence of overloads. Remember <tt>init&lt;...&gt;</tt>? For example,
 given a class X with a constructor:</p>
 <code><pre>
     <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=literal>'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>&quot;constructor&quot;</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><span class=special>}
+        /*...*/
+    }
 </span></pre></code>
 <p>
 You can easily add this constructor to Boost.Python in one shot:</p>
 <code><pre>
-    <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 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; &gt;())
 </span></pre></code>
 <p>
 Notice the use of <tt>init&lt;...&gt;</tt> and <tt>optional&lt;...&gt;</tt> to signify the default
@@ -104,12 +144,12 @@ Notice the use of <tt>init&lt;...&gt;</tt> and <tt>optional&lt;...&gt;</tt> to s
 <table border="0">
   <tr>
     <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="call_policies.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="object_interface.html"><img src="theme/r_arr.gif" border="0"></a></td>
+    <td width="30"><a href="overloading.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="auto_overloading.html"><img src="theme/r_arr.gif" border="0"></a></td>
    </tr>
 </table>
 <br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
 <font size="2">Permission to copy, use, modify, sell and distribute this document
  is granted provided this copyright notice appears in all copies. This document
  is provided &quot;as is&quot; without express or implied warranty, and with

doc/tutorial/doc/derived_object_types.html

@@ -30,7 +30,7 @@ that of Python's:</p>
 <ul><li>list</li><li>dict</li><li>tuple</li><li>str</li><li>long_</li><li>enum</li></ul><p>
 These derived <tt>object</tt> types act like real Python types. For instance:</p>
 <code><pre>
-    <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>&quot;1&quot;
+    <span class=identifier>str</span><span class=special>(</span><span class=number>1</span><span class=special>) ==&gt; </span><span class=string>&quot;1&quot;
 </span></pre></code>
 <p>
 Wherever appropriate, a particular derived <tt>object</tt> has corresponding
@@ -50,11 +50,11 @@ declared below, is wrapped, it will only accept instances of Python's
 <tt>str</tt> type and subtypes.</p>
 <code><pre>
     <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>&quot;upper&quot;</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
+    {
+        </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>&quot;upper&quot;</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>upper</span><span class=special>()
+        </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=identifier>better
         </span><span class=identifier>object </span><span class=identifier>msg </span><span class=special>= </span><span class=string>&quot;%s is bigger than %s&quot; </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><span class=special>}
+    }
 </span></pre></code>
 <p>
 In finer detail:</p>
@@ -76,14 +76,14 @@ of most of Python's mutable types make copies, just as in Python.</p>
 <p>
 Python:</p>
 <code><pre>
-    <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=identifier>copies </span><span class=identifier>x</span><span class=special>.</span><span class=identifier>__dict__
-    </span><span class=special>&gt;&gt;&gt; </span><span class=identifier>d</span><span class=special>[</span><span class=literal>'whatever'</span><span class=special>]            </span>#<span class=identifier>modifies </span><span class=identifier>the </span><span class=identifier>copy
+    <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=identifier>copies </span><span class=identifier>x</span><span class=special>.</span><span class=identifier>__dict__
+    </span><span class=special>&gt;&gt;&gt; </span><span class=identifier>d</span><span class=special>[</span><span class=literal>'whatever'</span><span class=special>]            </span>##<span class=identifier>modifies </span><span class=identifier>the </span><span class=identifier>copy
 </span></pre></code>
 <p>
 C++:</p>
 <code><pre>
-    <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>&quot;__dict__&quot;</span><span class=special>));  </span>#<span class=identifier>copies </span><span class=identifier>x</span><span class=special>.</span><span class=identifier>__dict__
-    </span><span class=identifier>d</span><span class=special>[</span><span class=literal>'whatever'</span><span class=special>] </span><span class=special>= </span><span class=number>3</span><span class=special>;           </span>#<span class=identifier>modifies </span><span class=identifier>the </span><span class=identifier>copy
+    <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>&quot;__dict__&quot;</span><span class=special>));  </span>##<span class=identifier>copies </span><span class=identifier>x</span><span class=special>.</span><span class=identifier>__dict__
+    </span><span class=identifier>d</span><span class=special>[</span><span class=literal>'whatever'</span><span class=special>] = </span><span class=number>3</span><span class=special>;           </span>##<span class=identifier>modifies </span><span class=identifier>the </span><span class=identifier>copy
 </span></pre></code>
 <a name="class__lt_t_gt__as_objects"></a><h2>class_&lt;T&gt; as objects</h2><p>
 Due to the dynamic nature of Boost.Python objects, any <tt>class_&lt;T&gt;</tt> may
@@ -92,13 +92,13 @@ also be one of these types! The following code snippet wraps the class
 <p>
 We can use this to create wrapped instances. Example:</p>
 <code><pre>
-    <span class=identifier>object </span><span class=identifier>vec345 </span><span class=special>= </span><span class=special>(
+    <span class=identifier>object </span><span class=identifier>vec345 </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>&quot;Vec2&quot;</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>&quot;length&quot;</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>&quot;angle&quot;</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><span class=special>)(</span><span class=number>3.0</span><span class=special>, </span><span class=number>4.0</span><span class=special>);
+            .</span><span class=identifier>def_readonly</span><span class=special>(</span><span class=string>&quot;length&quot;</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=identifier>def_readonly</span><span class=special>(</span><span class=string>&quot;angle&quot;</span><span class=special>, &amp;</span><span class=identifier>Point</span><span class=special>::</span><span class=identifier>angle</span><span class=special>)
+        )(</span><span class=number>3.0</span><span class=special>, </span><span class=number>4.0</span><span class=special>);
 
-    </span><span class=identifier>assert</span><span class=special>(</span><span class=identifier>vec345</span><span class=special>.</span><span class=identifier>attr</span><span class=special>(</span><span class=string>&quot;length&quot;</span><span class=special>) </span><span class=special>== </span><span class=number>5.0</span><span class=special>);
+    </span><span class=identifier>assert</span><span class=special>(</span><span class=identifier>vec345</span><span class=special>.</span><span class=identifier>attr</span><span class=special>(</span><span class=string>&quot;length&quot;</span><span class=special>) == </span><span class=number>5.0</span><span class=special>);
 </span></pre></code>
 <table border="0">
   <tr>
@@ -108,7 +108,7 @@ We can use this to create wrapped instances. Example:</p>
    </tr>
 </table>
 <br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
 <font size="2">Permission to copy, use, modify, sell and distribute this document
  is granted provided this copyright notice appears in all copies. This document
  is provided &quot;as is&quot; without express or implied warranty, and with

doc/tutorial/doc/deriving_a_python_class.html

@@ -0,0 +1,83 @@
+<html>
+<head>
+<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
+<title>Deriving a Python Class</title>
+<link rel="stylesheet" href="theme/style.css" type="text/css">
+<link rel="prev" href="class_virtual_functions.html">
+<link rel="next" href="virtual_functions_with_default_implementations.html">
+</head>
+<body>
+<table width="100%" height="48" border="0" cellspacing="2">
+  <tr>
+    <td><img src="theme/c%2B%2Bboost.gif">
+    </td>
+    <td width="85%">
+      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Deriving a Python Class</b></font>
+    </td>
+  </tr>
+</table>
+<br>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="class_virtual_functions.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="virtual_functions_with_default_implementations.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<p>
+Continuing, we can derive from our base class Base in Python and override
+the virtual function in Python. Before we can do that, we have to set up
+our <tt>class_</tt> wrapper as:</p>
+<code><pre>
+    <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>Base</span><span class=special>, </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>&quot;Base&quot;</span><span class=special>)
+        ;
+</span></pre></code>
+<p>
+Otherwise, we have to suppress the Base class' <tt>no_init</tt> by adding an
+<tt>__init__()</tt> method to all our derived classes. <tt>no_init</tt> actually adds
+an <tt>__init__</tt> method that raises a Python RuntimeError exception.</p>
+<code><pre>
+    <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=identifier>def </span><span class=identifier>f</span><span class=special>(</span><span class=identifier>self</span><span class=special>):
+    ...         </span><span class=keyword>return </span><span class=number>42
+    </span><span class=special>...
+</span></pre></code>
+<p>
+Cool eh? A Python class deriving from a C++ class!</p>
+<p>
+Let's now make an instance of our Python class <tt>Derived</tt>:</p>
+<code><pre>
+    <span class=special>&gt;&gt;&gt; </span><span class=identifier>derived </span><span class=special>= </span><span class=identifier>Derived</span><span class=special>()
+</span></pre></code>
+<p>
+Calling <tt>derived.f()</tt>:</p>
+<code><pre>
+    <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></code>
+<p>
+Will yield the expected result. Finally, calling calling the free function
+<tt>call_f</tt> with <tt>derived</tt> as argument:</p>
+<code><pre>
+    <span class=special>&gt;&gt;&gt; </span><span class=identifier>call_f</span><span class=special>(</span><span class=identifier>derived</span><span class=special>)
+    </span><span class=number>42
+</span></pre></code>
+<p>
+Will also yield the expected result.</p>
+<p>
+Here's what's happening:</p>
+<ol><li><tt>call_f(derived)</tt> is called in Python</li><li>This corresponds to <tt>def(&quot;call_f&quot;, call_f);</tt>. Boost.Python dispatches this call.</li><li><tt>int call_f(Base&amp; b) { return b.f(); }</tt> accepts the call.</li><li>The overridden virtual function <tt>f</tt> of <tt>BaseWrap</tt> is called.</li><li><tt>call_method&lt;int&gt;(self, &quot;f&quot;);</tt> dispatches the call back to Python.</li><li><tt>def f(self): return 42</tt> is finally called.</li></ol><table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="class_virtual_functions.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="virtual_functions_with_default_implementations.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
+<font size="2">Permission to copy, use, modify, sell and distribute this document
+ is granted provided this copyright notice appears in all copies. This document
+ is provided &quot;as is&quot; without express or implied warranty, and with
+ no claim as to its suitability for any purpose. </font> </p>
+</body>
+</html>

doc/tutorial/doc/embedding.html

@@ -0,0 +1,97 @@
+<html>
+<head>
+<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
+<title>Embedding</title>
+<link rel="stylesheet" href="theme/style.css" type="text/css">
+<link rel="prev" href="enums.html">
+<link rel="next" href="using_the_interpreter.html">
+</head>
+<body>
+<table width="100%" height="48" border="0" cellspacing="2">
+  <tr>
+    <td><img src="theme/c%2B%2Bboost.gif">
+    </td>
+    <td width="85%">
+      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Embedding</b></font>
+    </td>
+  </tr>
+</table>
+<br>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="enums.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="using_the_interpreter.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<p>
+By now you should know how to use Boost.Python to call your C++ code from
+Python. However, sometimes you may need to do the reverse: call Python code
+from the C++-side. This requires you to <i>embed</i> the Python interpreter
+into your C++ program.</p>
+<p>
+Currently, Boost.Python does not directly support everything you'll need
+when embedding. Therefore you'll need to use the
+<a href="http://www.python.org/doc/current/api/api.html">
+Python/C API</a> to fill in
+the gaps. However, Boost.Python already makes embedding a lot easier and,
+in a future version, it may become unnecessary to touch the Python/C API at
+all. So stay tuned... <img src="theme/smiley.gif"></img></p>
+<a name="building_embedded_programs"></a><h2>Building embedded programs</h2><p>
+To be able to use embedding in your programs, they have to be linked to
+both Boost.Python's and Python's static link library.</p>
+<p>
+Boost.Python's static link library comes in two variants. Both are located
+in Boost's <tt>/libs/python/build/bin-stage</tt> subdirectory. On Windows, the
+variants are called <tt>boost_python.lib</tt> (for release builds) and
+<tt>boost_python_debug.lib</tt> (for debugging). If you can't find the
+libraries, you probably haven't built Boost.Python yet. See <a
+href="../../building.html">Building and Testing</a> on how to do
+this.</p>
+<p>
+Python's static link library can be found in the <tt>/libs</tt> subdirectory of
+your Python directory. On Windows it is called pythonXY.lib where X.Y is
+your major Python version number.</p>
+<p>
+Additionally, Python's <tt>/include</tt> subdirectory has to be added to your
+include path.</p>
+<p>
+In a Jamfile, all the above boils down to:</p>
+<code><pre>
+    projectroot c:\projects\embedded_program ; # location of the program
+
+    # bring in the rules for python
+    SEARCH on python.jam = $(BOOST_BUILD_PATH) ;
+    include python.jam ;
+
+    exe embedded_program # name of the executable
+      : #sources
+         embedded_program.cpp
+      : # requirements
+         &lt;find-library&gt;boost_python &lt;library-path&gt;c:\boost\libs\python
+      $(PYTHON_PROPERTIES)
+        &lt;library-path&gt;$(PYTHON_LIB_PATH)
+        &lt;find-library&gt;$(PYTHON_EMBEDDED_LIBRARY) ;
+</pre></code><a name="getting_started"></a><h2>Getting started</h2><p>
+Being able to build is nice, but there is nothing to build yet. Embedding
+the Python interpreter into one of your C++ programs requires these 4
+steps:</p>
+<ol><li>#include <tt>&lt;boost/python.hpp&gt;</tt><br><br></li><li>Call <a href="http://www.python.org/doc/current/api/initialization.html#l2h-652">
+Py_Initialize</a>() to start the interpreter and create the <tt>__main__</tt> module.<br><br></li><li>Call other Python C API routines to use the interpreter.<br><br></li><li>Call <a href="http://www.python.org/doc/current/api/initialization.html#l2h-656">
+Py_Finalize</a>() to stop the interpreter and release its resources.</li></ol><p>
+(Of course, there can be other C++ code between all of these steps.)</p>
+<blockquote><p><i><b>Now that we can embed the interpreter in our programs, lets see how to put it to use...</b></i></p></blockquote><table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="enums.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="using_the_interpreter.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 Dirk Gerrits<br><br>
+<font size="2">Permission to copy, use, modify, sell and distribute this document
+ is granted provided this copyright notice appears in all copies. This document
+ is provided &quot;as is&quot; without express or implied warranty, and with
+ no claim as to its suitability for any purpose. </font> </p>
+</body>
+</html>

doc/tutorial/doc/enums.html

@@ -4,7 +4,7 @@
 <title>Enums</title>
 <link rel="stylesheet" href="theme/style.css" type="text/css">
 <link rel="prev" href="extracting_c___objects.html">
-<link rel="next" href="iterators.html">
+<link rel="next" href="embedding.html">
 </head>
 <body>
 <table width="100%" height="48" border="0" cellspacing="2">
@@ -21,7 +21,7 @@
   <tr>
     <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
     <td width="30"><a href="extracting_c___objects.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="iterators.html"><img src="theme/r_arr.gif" border="0"></a></td>
+    <td width="20"><a href="embedding.html"><img src="theme/r_arr.gif" border="0"></a></td>
    </tr>
 </table>
 <p>
@@ -38,9 +38,9 @@ enums). To illustrate, given a C++ enum:</p>
 the construct:</p>
 <code><pre>
     <span class=identifier>enum_</span><span class=special>&lt;</span><span class=identifier>choice</span><span class=special>&gt;(</span><span class=string>&quot;choice&quot;</span><span class=special>)
-        </span><span class=special>.</span><span class=identifier>value</span><span class=special>(</span><span class=string>&quot;red&quot;</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>&quot;blue&quot;</span><span class=special>, </span><span class=identifier>blue</span><span class=special>)
-        </span><span class=special>;
+        .</span><span class=identifier>value</span><span class=special>(</span><span class=string>&quot;red&quot;</span><span class=special>, </span><span class=identifier>red</span><span class=special>)
+        .</span><span class=identifier>value</span><span class=special>(</span><span class=string>&quot;blue&quot;</span><span class=special>, </span><span class=identifier>blue</span><span class=special>)
+        ;
 </span></pre></code>
 <p>
 can be used to expose to Python. The new enum type is created in the
@@ -67,26 +67,26 @@ You can access those values in Python as</p>
 where my_module is the module where the enum is declared. You can also
 create a new scope around a class:</p>
 <code><pre>
-    <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>&quot;X&quot;</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 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>&quot;X&quot;</span><span class=special>)
+                    .</span><span class=identifier>def</span><span class=special>( ... )
+                    .</span><span class=identifier>def</span><span class=special>( ... )
+                ;
 
-    </span><span class=comment>// Expose X::nested as X.nested
+    // </span><span class=identifier>Expose </span><span class=identifier>X</span><span class=special>::</span><span class=identifier>nested </span><span class=identifier>as </span><span class=identifier>X</span><span class=special>.</span><span class=identifier>nested
     </span><span class=identifier>enum_</span><span class=special>&lt;</span><span class=identifier>X</span><span class=special>::</span><span class=identifier>nested</span><span class=special>&gt;(</span><span class=string>&quot;nested&quot;</span><span class=special>)
-        </span><span class=special>.</span><span class=identifier>value</span><span class=special>(</span><span class=string>&quot;red&quot;</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>&quot;blue&quot;</span><span class=special>, </span><span class=identifier>blue</span><span class=special>)
-        </span><span class=special>;
+        .</span><span class=identifier>value</span><span class=special>(</span><span class=string>&quot;red&quot;</span><span class=special>, </span><span class=identifier>red</span><span class=special>)
+        .</span><span class=identifier>value</span><span class=special>(</span><span class=string>&quot;blue&quot;</span><span class=special>, </span><span class=identifier>blue</span><span class=special>)
+        ;
 </span></pre></code>
 <table border="0">
   <tr>
     <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
     <td width="30"><a href="extracting_c___objects.html"><img src="theme/l_arr.gif" border="0"></a></td>
-    <td width="20"><a href="iterators.html"><img src="theme/r_arr.gif" border="0"></a></td>
+    <td width="20"><a href="embedding.html"><img src="theme/r_arr.gif" border="0"></a></td>
    </tr>
 </table>
 <br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
 <font size="2">Permission to copy, use, modify, sell and distribute this document
  is granted provided this copyright notice appears in all copies. This document
  is provided &quot;as is&quot; without express or implied warranty, and with

doc/tutorial/doc/exception_translation.html

@@ -35,13 +35,13 @@ then gives up:</p>
 Users may provide custom translation. Here's an example:</p>
 <code><pre>
     <span class=keyword>struct </span><span class=identifier>PodBayDoorException</span><span class=special>;
-    </span><span class=keyword>void </span><span class=identifier>translator</span><span class=special>(</span><span class=identifier>PodBayDoorException</span><span class=special>&amp; </span><span class=identifier>x</span><span class=special>) </span><span class=special>{
+    </span><span class=keyword>void </span><span class=identifier>translator</span><span class=special>(</span><span class=identifier>PodBayDoorException </span><span class=keyword>const</span><span class=special>&amp; </span><span class=identifier>x</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>&quot;I'm sorry Dave...&quot;</span><span class=special>);
-    </span><span class=special>}
-    </span><span class=identifier>BOOST_PYTHON_MODULE</span><span class=special>(</span><span class=identifier>kubrick</span><span class=special>) </span><span class=special>{
+    }
+    </span><span class=identifier>BOOST_PYTHON_MODULE</span><span class=special>(</span><span class=identifier>kubrick</span><span class=special>) {
          </span><span class=identifier>register_exception_translator</span><span class=special>&lt;
               </span><span class=identifier>PodBayDoorException</span><span class=special>&gt;(</span><span class=identifier>translator</span><span class=special>);
-         </span><span class=special>...
+         ...
 </span></pre></code>
 <table border="0">
   <tr>
@@ -51,7 +51,7 @@ Users may provide custom translation. Here's an example:</p>
    </tr>
 </table>
 <br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
 <font size="2">Permission to copy, use, modify, sell and distribute this document
  is granted provided this copyright notice appears in all copies. This document
  is provided &quot;as is&quot; without express or implied warranty, and with

doc/tutorial/doc/exposing_classes.html

@@ -31,10 +31,10 @@ Consider a C++ class/struct that we want to expose to Python:</p>
 <code><pre>
     <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><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=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=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>greet</span><span class=special>() { </span><span class=keyword>return </span><span class=identifier>msg</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></pre></code>
 <p>
 We can expose this to Python by writing a corresponding Boost.Python
@@ -44,12 +44,12 @@ C++ Wrapper:</p>
     </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><span class=special>{
+    {
         </span><span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>World</span><span class=special>&gt;(</span><span class=string>&quot;World&quot;</span><span class=special>)
-            </span><span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;greet&quot;</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>&quot;set&quot;</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><span class=special>;
-    </span><span class=special>}
+            .</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;greet&quot;</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=identifier>def</span><span class=special>(</span><span class=string>&quot;set&quot;</span><span class=special>, &amp;</span><span class=identifier>World</span><span class=special>::</span><span class=identifier>set</span><span class=special>)
+        ;
+    }
 </span></pre></code>
 <p>
 Here, we wrote a C++ class wrapper that exposes the member functions
@@ -58,8 +58,8 @@ may use our class <tt>World</tt> in Python. Here's a sample Python session:</p>
 <code><pre>
     <span class=special>&gt;&gt;&gt; </span><span class=identifier>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=literal>'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>()
+    &gt;&gt;&gt; </span><span class=identifier>planet</span><span class=special>.</span><span class=identifier>set</span><span class=special>(</span><span class=literal>'howdy'</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><span class=literal>'howdy'
 </span></pre></code>
 <table border="0">
@@ -70,7 +70,7 @@ may use our class <tt>World</tt> in Python. Here's a sample Python session:</p>
    </tr>
 </table>
 <br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
 <font size="2">Permission to copy, use, modify, sell and distribute this document
  is granted provided this copyright notice appears in all copies. This document
  is provided &quot;as is&quot; without express or implied warranty, and with

doc/tutorial/doc/extracting_c___objects.html

@@ -28,7 +28,7 @@
 At some point, we will need to get C++ values out of object instances. This
 can be achieved with the <tt>extract&lt;T&gt;</tt> function. Consider the following:</p>
 <code><pre>
-    <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>&quot;length&quot;</span><span class=special>); </span><span class=comment>// compile error
+    <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>&quot;length&quot;</span><span class=special>); // </span><span class=identifier>compile </span><span class=identifier>error
 </span></pre></code>
 <p>
 In the code above, we got a compiler error because Boost.Python
@@ -52,15 +52,15 @@ appropriate exception is thrown. To avoid an exception, we need to
 test for extractibility:</p>
 <code><pre>
     <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><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=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></pre></code>
 <p>
 <img src="theme/bulb.gif"></img> The astute reader might have noticed that the <tt>extract&lt;T&gt;</tt>
 facility in fact solves the mutable copying problem:</p>
 <code><pre>
     <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>&quot;__dict__&quot;</span><span class=special>));
-    </span><span class=identifier>d</span><span class=special>[</span><span class=literal>'whatever'</span><span class=special>] </span><span class=special>= </span><span class=number>3</span><span class=special>;          </span>#<span class=identifier>modifies </span><span class=identifier>x</span><span class=special>.</span><span class=identifier>__dict__ </span><span class=special>!
+    </span><span class=identifier>d</span><span class=special>[</span><span class=literal>'whatever'</span><span class=special>] = </span><span class=number>3</span><span class=special>;          </span>##<span class=identifier>modifies </span><span class=identifier>x</span><span class=special>.</span><span class=identifier>__dict__ </span><span class=special>!
 </span></pre></code>
 <table border="0">
   <tr>
@@ -70,7 +70,7 @@ facility in fact solves the mutable copying problem:</p>
    </tr>
 </table>
 <br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
 <font size="2">Permission to copy, use, modify, sell and distribute this document
  is granted provided this copyright notice appears in all copies. This document
  is provided &quot;as is&quot; without express or implied warranty, and with

doc/tutorial/doc/functions.html

@@ -64,7 +64,7 @@ But before you do, you might want to fire up Python 2.2 or later and type
    </tr>
 </table>
 <br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
 <font size="2">Permission to copy, use, modify, sell and distribute this document
  is granted provided this copyright notice appears in all copies. This document
  is provided &quot;as is&quot; without express or implied warranty, and with

doc/tutorial/doc/inheritance.html

@@ -33,7 +33,7 @@ abstract base classes.</p>
 <p>
 Consider this trivial inheritance structure:</p>
 <code><pre>
-    <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 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=keyword>struct </span><span class=identifier>Derived </span><span class=special>: </span><span class=identifier>Base </span><span class=special>{};
 </span></pre></code>
 <p>
@@ -42,22 +42,22 @@ instances:</p>
 <code><pre>
     <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><span class=identifier>Base</span><span class=special>* </span><span class=identifier>factory</span><span class=special>() { </span><span class=keyword>return </span><span class=keyword>new </span><span class=identifier>Derived</span><span class=special>; }
 </span></pre></code>
 <p>
 We've seen how we can wrap the base class <tt>Base</tt>:</p>
 <code><pre>
     <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>Base</span><span class=special>&gt;(</span><span class=string>&quot;Base&quot;</span><span class=special>)
-        </span><span class=comment>/*...*/
-        </span><span class=special>;
+        /*...*/
+        ;
 </span></pre></code>
 <p>
 Now we can inform Boost.Python of the inheritance relationship between
 <tt>Derived</tt> and its base class <tt>Base</tt>.  Thus:</p>
 <code><pre>
-    <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>&quot;Derived&quot;</span><span class=special>)
-        </span><span class=comment>/*...*/
-        </span><span class=special>;
+    <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; &gt;(</span><span class=string>&quot;Derived&quot;</span><span class=special>)
+        /*...*/
+        ;
 </span></pre></code>
 <p>
 Doing so, we get some things for free:</p>
@@ -89,7 +89,7 @@ call policies</a> later.</p>
    </tr>
 </table>
 <br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
 <font size="2">Permission to copy, use, modify, sell and distribute this document
  is granted provided this copyright notice appears in all copies. This document
  is provided &quot;as is&quot; without express or implied warranty, and with

doc/tutorial/doc/iterators.html

@@ -3,7 +3,7 @@
 <!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
 <title>Iterators</title>
 <link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="enums.html">
+<link rel="prev" href="using_the_interpreter.html">
 <link rel="next" href="exception_translation.html">
 </head>
 <body>
@@ -20,7 +20,7 @@
 <table border="0">
   <tr>
     <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="enums.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="30"><a href="using_the_interpreter.html"><img src="theme/l_arr.gif" border="0"></a></td>
     <td width="20"><a href="exception_translation.html"><img src="theme/r_arr.gif" border="0"></a></td>
    </tr>
 </table>
@@ -34,12 +34,12 @@ iterators, but these are two very different beasts.</p>
 <ul><li>1 category (forward)</li><li>1 operation category (next())</li><li>Raises StopIteration exception at end</li></ul><p>
 The typical Python iteration protocol: <tt><b>for y in x...</b></tt> is as follows:</p>
 <code><pre>
-    <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=identifier>get </span><span class=identifier>iterator
+    <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=identifier>get </span><span class=identifier>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=identifier>get </span><span class=identifier>each </span><span class=identifier>item
-        </span><span class=special>...                     </span>#<span class=identifier>process </span><span class=identifier>y
-    </span><span class=identifier>except </span><span class=identifier>StopIteration</span><span class=special>: </span><span class=identifier>pass  </span>#<span class=identifier>iterator </span><span class=identifier>exhausted
+        </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=identifier>get </span><span class=identifier>each </span><span class=identifier>item
+        </span><span class=special>...                     </span>##<span class=identifier>process </span><span class=identifier>y
+    </span><span class=identifier>except </span><span class=identifier>StopIteration</span><span class=special>: </span><span class=identifier>pass  </span>##<span class=identifier>iterator </span><span class=identifier>exhausted
 </span></pre></code>
 <p>
 Boost.Python provides some mechanisms to make C++ iterators play along
@@ -47,14 +47,14 @@ nicely as Python iterators. What we need to do is to produce
 appropriate __iter__ function from C++ iterators that is compatible
 with the Python iteration protocol. For example:</p>
 <code><pre>
-    <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 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; &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></code>
 <p>
 Or for use in class_&lt;&gt;:</p>
 <code><pre>
-    <span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;__iter__&quot;</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 class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;__iter__&quot;</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; &gt;())
 </span></pre></code>
 <p>
 <b>range</b></p>
@@ -81,18 +81,18 @@ bogon Particle accelerator code:</p>
 Now, our C++ Wrapper:</p>
 <code><pre>
     <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>F</span><span class=special>&gt;(</span><span class=string>&quot;Field&quot;</span><span class=special>)
-        </span><span class=special>.</span><span class=identifier>property</span><span class=special>(</span><span class=string>&quot;pions&quot;</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>&quot;bogons&quot;</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><span class=identifier>property</span><span class=special>(</span><span class=string>&quot;pions&quot;</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>, &amp;</span><span class=identifier>F</span><span class=special>::</span><span class=identifier>p_end</span><span class=special>))
+        .</span><span class=identifier>property</span><span class=special>(</span><span class=string>&quot;bogons&quot;</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>, &amp;</span><span class=identifier>F</span><span class=special>::</span><span class=identifier>b_end</span><span class=special>));
 </span></pre></code>
 <table border="0">
   <tr>
     <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="enums.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="30"><a href="using_the_interpreter.html"><img src="theme/l_arr.gif" border="0"></a></td>
     <td width="20"><a href="exception_translation.html"><img src="theme/r_arr.gif" border="0"></a></td>
    </tr>
 </table>
 <br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
 <font size="2">Permission to copy, use, modify, sell and distribute this document
  is granted provided this copyright notice appears in all copies. This document
  is provided &quot;as is&quot; without express or implied warranty, and with

doc/tutorial/doc/object_interface.html

@@ -3,7 +3,7 @@
 <!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
 <title>Object Interface</title>
 <link rel="stylesheet" href="theme/style.css" type="text/css">
-<link rel="prev" href="default_arguments.html">
+<link rel="prev" href="auto_overloading.html">
 <link rel="next" href="basic_interface.html">
 </head>
 <body>
@@ -20,7 +20,7 @@
 <table border="0">
   <tr>
     <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="default_arguments.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="30"><a href="auto_overloading.html"><img src="theme/l_arr.gif" border="0"></a></td>
     <td width="20"><a href="basic_interface.html"><img src="theme/r_arr.gif" border="0"></a></td>
    </tr>
 </table>
@@ -40,12 +40,12 @@ should minimize the learning curve significantly.</p>
 <table border="0">
   <tr>
     <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
-    <td width="30"><a href="default_arguments.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="30"><a href="auto_overloading.html"><img src="theme/l_arr.gif" border="0"></a></td>
     <td width="20"><a href="basic_interface.html"><img src="theme/r_arr.gif" border="0"></a></td>
    </tr>
 </table>
 <br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
 <font size="2">Permission to copy, use, modify, sell and distribute this document
  is granted provided this copyright notice appears in all copies. This document
  is provided &quot;as is&quot; without express or implied warranty, and with

doc/tutorial/doc/overloading.html

@@ -0,0 +1,88 @@
+<html>
+<head>
+<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
+<title>Overloading</title>
+<link rel="stylesheet" href="theme/style.css" type="text/css">
+<link rel="prev" href="call_policies.html">
+<link rel="next" href="default_arguments.html">
+</head>
+<body>
+<table width="100%" height="48" border="0" cellspacing="2">
+  <tr>
+    <td><img src="theme/c%2B%2Bboost.gif">
+    </td>
+    <td width="85%">
+      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Overloading</b></font>
+    </td>
+  </tr>
+</table>
+<br>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="call_policies.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="default_arguments.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<p>
+The following illustrates a scheme for manually wrapping an overloaded
+member functions. Of course, the same technique can be applied to wrapping
+overloaded non-member functions.</p>
+<p>
+We have here our C++ class:</p>
+<code><pre>
+    <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=keyword>return </span><span class=keyword>true</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=keyword>double </span><span class=identifier>b</span><span class=special>)
+        {
+            </span><span class=keyword>return </span><span class=keyword>true</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=keyword>double </span><span class=identifier>b</span><span class=special>, </span><span class=keyword>char </span><span class=identifier>c</span><span class=special>)
+        {
+            </span><span class=keyword>return </span><span class=keyword>true</span><span class=special>;
+        }
+
+        </span><span class=keyword>int </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=keyword>int </span><span class=identifier>b</span><span class=special>, </span><span class=keyword>int </span><span class=identifier>c</span><span class=special>)
+        {
+            </span><span class=keyword>return </span><span class=identifier>a </span><span class=special>+ </span><span class=identifier>b </span><span class=special>+ </span><span class=identifier>c</span><span class=special>;
+        };
+    };
+</span></pre></code>
+<p>
+Class X has 4 overloaded functions. We shall start by introducing some
+member function pointer variables:</p>
+<code><pre>
+    <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>)              = &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>)      = &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>)= &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>)    = &amp;</span><span class=identifier>X</span><span class=special>::</span><span class=identifier>f</span><span class=special>;
+</span></pre></code>
+<p>
+With these in hand, we can proceed to define and wrap this for Python:</p>
+<code><pre>
+    <span class=special>.</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</span><span class=special>, </span><span class=identifier>fx1</span><span class=special>)
+    .</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</span><span class=special>, </span><span class=identifier>fx2</span><span class=special>)
+    .</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</span><span class=special>, </span><span class=identifier>fx3</span><span class=special>)
+    .</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</span><span class=special>, </span><span class=identifier>fx4</span><span class=special>)
+</span></pre></code>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="call_policies.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="default_arguments.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
+<font size="2">Permission to copy, use, modify, sell and distribute this document
+ is granted provided this copyright notice appears in all copies. This document
+ is provided &quot;as is&quot; without express or implied warranty, and with
+ no claim as to its suitability for any purpose. </font> </p>
+</body>
+</html>

doc/tutorial/doc/quickstart.html

@@ -39,9 +39,9 @@ Following C/C++ tradition, let's start with the "hello, world". A C++
 Function:</p>
 <code><pre>
     <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>&quot;hello, world&quot;</span><span class=special>;
-    </span><span class=special>}
+    }
 </span></pre></code>
 <p>
 can be exposed to Python by writing a Boost.Python wrapper:</p>
@@ -50,9 +50,9 @@ can be exposed to Python by writing a Boost.Python wrapper:</p>
     </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><span class=special>{
+    {
         </span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;greet&quot;</span><span class=special>, </span><span class=identifier>greet</span><span class=special>);
-    </span><span class=special>}
+    }
 </span></pre></code>
 <p>
 That's it. We're done. We can now build this as a shared library. The
@@ -70,7 +70,7 @@ resulting DLL is now visible to Python. Here's a sample Python session:</p>
    </tr>
 </table>
 <br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
 <font size="2">Permission to copy, use, modify, sell and distribute this document
  is granted provided this copyright notice appears in all copies. This document
  is provided &quot;as is&quot; without express or implied warranty, and with

doc/tutorial/doc/quickstart.txt

@@ -339,9 +339,10 @@ Our C++ [^Var] class and its data members can be exposed to Python:
         .def_readonly("name", &Var::name)
         .def_readwrite("value", &Var::value);
 
-Then, in Python:
+Then, in Python, assuming we have placed our Var class inside the namespace
+hello as we did before:
 
-    >>> x = Var('pi')
+    >>> x = hello.Var('pi')
     >>> x.value = 3.14
     >>> print x.name, 'is around', x.value
     pi is around 3.14
@@ -378,8 +379,8 @@ attributes can just be a different syntax for a method call. Wrapping our
 [^Num] class using Boost.Python:
 
     class_<Num>("Num")
-        .add_property("rovalue", &Var::get)
-        .add_property("value", &Var::get, &Var::set);
+        .add_property("rovalue", &Num::get)
+        .add_property("value", &Num::get, &Num::set);
 
 And at last, in Python:
 
@@ -392,7 +393,7 @@ And at last, in Python:
 Take note that the class property [^rovalue] is exposed as [*read-only]
 since the [^rovalue] setter member function is not passed in:
 
-    .add_property("rovalue", &Var::get)
+    .add_property("rovalue", &Num::get)
 
 [page:1 Inheritance]
 
@@ -520,15 +521,24 @@ available, since Base is an abstract class.
 In Python, let us try to instantiate our [^Base] class:
 
     >>> base = Base()
-    AttributeError: ...
+    RuntimeError: This class cannot be instantiated from Python
 
 Why is it an error? [^Base] is an abstract class. As such it is advisable
 to define the Python wrapper with [^no_init] as we have done above. Doing
 so will disallow abstract base classes such as [^Base] to be instantiated.
 
-[h2 Deriving a Python class]
+[page:1 Deriving a Python Class]
 
-Now, at last, we can even derive from our base class [^Base] in Python:
+Continuing, we can derive from our base class Base in Python and override
+the virtual function in Python. Before we can do that, we have to set up
+our [^class_] wrapper as:
+
+    class_<Base, BaseWrap, boost::noncopyable>("Base")
+        ;
+
+Otherwise, we have to suppress the Base class' [^no_init] by adding an
+[^__init__()] method to all our derived classes. [^no_init] actually adds
+an [^__init__] method that raises a Python RuntimeError exception.
 
     >>> class Derived(Base):
     ...     def f(self):
@@ -563,30 +573,45 @@ Here's what's happening:
 # [^call_method<int>(self, "f");] dispatches the call back to Python.
 # [^def f(self): return 42] is finally called.
 
-Rewind back to our [^Base] class, if its member function [^f] was not
-declared as pure virtual:
+[page:1 Virtual Functions with Default Implementations]
+
+Recall that in the [@class_virtual_functions.html previous section], we
+wrapped a class with a pure virtual function that we then implemented in
+C++ or Python classes derived from it. Our base class:
+
+    struct Base
+    {
+        virtual int f() = 0;
+    };
+
+had a pure virtual function [^f]. If, however, its member function [^f] was
+not declared as pure virtual:
 
     struct Base
     {
         virtual int f() { return 0; }
     };
 
-And instead is implemented to return [^0], as shown above.
+and instead had a default implementation that returns [^0], as shown above,
+we need to add a forwarding function that calls the [^Base] default virtual
+function [^f] implementation:
 
     struct BaseWrap : Base
     {
         BaseWrap(PyObject* self_)
             : self(self_) {}
         int f() { return call_method<int>(self, "f"); }
-        static int default_f(Base* b) { return b->Base::f(); } // <<=== added
+        int default_f() { return Base::f(); } // <<=== ***ADDED***
         PyObject* self;
     };
 
-then, our Boost.Python wrapper:
+Then, Boost.Python needs to keep track of 1) the dispatch function [^f] and
+2) the forwarding function to its default implementation [^default_f].
+There's a special [^def] function for this purpose. Here's how it is
+applied to our example above:
 
     class_<Base, BaseWrap>("Base")
-        .def("f", &BaseWrap::default_f)
-        ;
+        .def("f", &Base::f, &BaseWrap::default_f)
 
 Note that we are allowing [^Base] objects to be instantiated this time,
 unlike before where we specifically defined the [^class_<Base>] with
@@ -649,7 +674,7 @@ and intuitively:
         .def(self + int())          // __add__
         .def(int() + self)          // __radd__
         .def(self - self)           // __sub__
-        .def(self - int())          // __rsub__
+        .def(self - int())          // __sub__
         .def(self += int())         // __iadd__
         .def(self -= other<int>())
         .def(self < self);          // __lt__
@@ -865,6 +890,52 @@ these can be found [@../../v2/reference.html#models_of_call_policies here].
 "Explicit is better than implicit"[br]
 "In the face of ambiguity, refuse the temptation to guess"[br]]
 
+[page:1 Overloading]
+
+The following illustrates a scheme for manually wrapping an overloaded
+member functions. Of course, the same technique can be applied to wrapping
+overloaded non-member functions.
+
+We have here our C++ class:
+
+    struct X
+    {
+        bool f(int a)
+        {
+            return true;
+        }
+
+        bool f(int a, double b)
+        {
+            return true;
+        }
+
+        bool f(int a, double b, char c)
+        {
+            return true;
+        }
+
+        int f(int a, int b, int c)
+        {
+            return a + b + c;
+        };
+    };
+
+Class X has 4 overloaded functions. We shall start by introducing some
+member function pointer variables:
+
+    bool    (X::*fx1)(int)              = &X::f;
+    bool    (X::*fx2)(int, double)      = &X::f;
+    bool    (X::*fx3)(int, double, char)= &X::f;
+    int     (X::*fx4)(int, int, int)    = &X::f;
+
+With these in hand, we can proceed to define and wrap this for Python:
+
+    .def("f", fx1)
+    .def("f", fx2)
+    .def("f", fx3)
+    .def("f", fx4)
+
 [page:1 Default Arguments]
 
 Boost.Python wraps (member) function pointers. Unfortunately, C++ function
@@ -883,8 +954,9 @@ to retrieve the default arguments:
 
     def("f", f);                            // defaults lost!
 
-Because of this, when wrapping C++ code in earlier versions of
-Boost.Python, we had to resort to writing thin wrappers:
+Because of this, when wrapping C++ code, we had to resort to manual
+wrapping as outlined in the [@overloading.html previous section], or
+writing thin wrappers:
 
     // write "thin wrappers"
     int f1(int x) { f(x); }
@@ -902,17 +974,20 @@ When you want to wrap functions (or member functions) that either:
 * have default arguments, or
 * are overloaded with a common sequence of initial arguments
 
-Boost.Python now has a way to make it easier.
+[h2 BOOST_PYTHON_FUNCTION_OVERLOADS]
 
-For instance, given a function:
+Boost.Python now has a way to make it easier. For instance, given a function:
 
-    int foo(int a, char b = 1, unsigned c = 2, double d = 3);
+    int foo(int a, char b = 1, unsigned c = 2, double d = 3)
+    {
+        /*...*/
+    }
 
 The macro invocation:
 
     BOOST_PYTHON_FUNCTION_OVERLOADS(foo_overloads, foo, 1, 4)
 
-Will automatically create the thin wrappers for us. This macro will create
+will automatically create the thin wrappers for us. This macro will create
 a class [^foo_overloads] that can be passed on to [^def(...)]. The third
 and fourth macro argument are the minimum arguments and maximum arguments,
 respectively. In our [^foo] function the minimum number of arguments is 1
@@ -921,8 +996,45 @@ automatically add all the foo variants for us:
 
     .def("foo", foo, foo_overloads());
 
+[h2 BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS]
+
+Objects here, objects there, objects here there everywhere. More frequently
+than anything else, we need to expose member functions of our classes to
+Python. Then again, we have the same inconveniences as before when default
+arguments or overloads with a common sequence of initial arguments come
+into play. Another macro is provided to make this a breeze.
+
+Like [^BOOST_PYTHON_FUNCTION_OVERLOADS],
+[^BOOST_PYTHON_FUNCTION_OVERLOADS] may be used to automatically create
+the thin wrappers for wrapping member functions. Let's have an example:
+
+    struct george
+    {
+        void
+        wack_em(int a, int b = 0, char c = 'x')
+        {
+            /*...*/
+        }
+    };
+
+The macro invocation:
+
+    BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(george_overloads, wack_em, 1, 3)
+
+will generate a set of thin wrappers for george's [^wack_em] member function
+accepting a minimum of 1 and a maximum of 3 arguments (i.e. the third and
+fourth macro argument). The thin wrappers are all enclosed in a class named
+[^george_overloads] that can then be used as an argument to [^def(...)]:
+
+    .def("wack_em", &george::wack_em, george_overloads());
+
+See the [@../../v2/overloads.html#BOOST_PYTHON_FUNCTION_OVERLOADS-spec overloads reference]
+for details.
+
+[h2 init and optional]
+
 A similar facility is provided for class constructors, again, with
-default arguments or a sequence of overloads. Remember init<...>? For example,
+default arguments or a sequence of overloads. Remember [^init<...>]? For example,
 given a class X with a constructor:
 
     struct X
@@ -938,6 +1050,73 @@ You can easily add this constructor to Boost.Python in one shot:
 Notice the use of [^init<...>] and [^optional<...>] to signify the default
 (optional arguments).
 
+[page:1 Auto-Overloading]
+
+It was mentioned in passing in the previous section that
+[^BOOST_PYTHON_FUNCTION_OVERLOADS] and [^BOOST_PYTHON_FUNCTION_OVERLOADS]
+can also be used for overloaded functions and member functions with a
+common sequence of initial arguments. Here is an example:
+
+     void foo()
+     {
+        /*...*/
+     }
+
+     void foo(bool a)
+     {
+        /*...*/
+     }
+
+     void foo(bool a, int b)
+     {
+        /*...*/
+     }
+
+     void foo(bool a, int b, char c)
+     {
+        /*...*/
+     }
+
+Like in the previous section, we can generate thin wrappers for these
+overloaded functions in one-shot:
+
+    BOOST_PYTHON_FUNCTION_OVERLOADS(foo_overloads, foo, 0, 3)
+
+Then...
+
+    .def("foo", foo, foo_overloads());
+
+Notice though that we have a situation now where we have a minimum of zero
+(0) arguments and a maximum of 3 arguments.
+
+[h2 Manual Wrapping]
+
+It is important to emphasize however that [*the overloaded functions must
+have a common sequence of initial arguments]. Otherwise, our scheme above
+will not work. If this is not the case, we have to wrap our functions
+[@overloading.html manually].
+
+Actually, we can mix and match manual wrapping of overloaded functions and
+automatic wrapping through [^BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS] and
+its sister, [^BOOST_PYTHON_FUNCTION_OVERLOADS]. Following up on our example
+presented in the section [@overloading.html on overloading], since the
+first 4 overload functins have a common sequence of initial arguments, we
+can use [^BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS] to automatically wrap the
+first three of the [^def]s and manually wrap just the last. Here's
+how we'll do this:
+
+    BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(xf_overloads, f, 1, 4)
+
+Create a member function pointers as above for both X::f overloads:
+
+    bool    (X::*fx1)(int, double, char)    = &X::f;
+    int     (X::*fx2)(int, int, int)        = &X::f;
+
+Then...
+
+    .def("f", fx1, xf_overloads());
+    .def("f", fx2)
+
 [page Object Interface]
 
 Python is dynamically typed, unlike C++ which is statically typed. Python
@@ -1140,10 +1319,10 @@ You can access those values in Python as
 where my_module is the module where the enum is declared. You can also
 create a new scope around a class:
 
-    scope in_X(class_<X>("X")
+    scope in_X = class_<X>("X")
                     .def( ... )
                     .def( ... )
-                );
+                ;
 
     // Expose X::nested as X.nested
     enum_<X::nested>("nested")
@@ -1237,7 +1416,7 @@ then gives up:
 Users may provide custom translation. Here's an example:
 
     struct PodBayDoorException;
-    void translator(PodBayDoorException& x) {
+    void translator(PodBayDoorException const& x) {
         PyErr_SetString(PyExc_UserWarning, "I'm sorry Dave...");
     }
     BOOST_PYTHON_MODULE(kubrick) {

doc/tutorial/doc/using_the_interpreter.html

@@ -0,0 +1,236 @@
+<html>
+<head>
+<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
+<title>Using the interpreter</title>
+<link rel="stylesheet" href="theme/style.css" type="text/css">
+<link rel="prev" href="embedding.html">
+<link rel="next" href="iterators.html">
+</head>
+<body>
+<table width="100%" height="48" border="0" cellspacing="2">
+  <tr>
+    <td><img src="theme/c%2B%2Bboost.gif">
+    </td>
+    <td width="85%">
+      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Using the interpreter</b></font>
+    </td>
+  </tr>
+</table>
+<br>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="embedding.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="iterators.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<p>
+As you probably already know, objects in Python are reference-counted.
+Naturally, the <tt>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/C API requires you to do it
+<a href="http://www.python.org/doc/current/api/refcounts.html">
+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">
+handle</a> class
+template to automate the process.</p>
+<a name="reference_counting_handles"></a><h2>Reference-counting handles</h2><p>
+There are two ways in which a function in the Python/C API can return a
+<tt>PyObject*</tt>: as a <i>borrowed reference</i> or as a <i>new reference</i>. Which of
+these a function uses, is listed in that function's documentation. The two
+require slightely different approaches to reference-counting but both can
+be 'handled' by Boost.Python.</p>
+<p>
+For a function returning a <i>borrowed reference</i> we'll have to tell the
+<tt>handle</tt> that the <tt>PyObject*</tt> is borrowed with the aptly named
+<a href="../../v2/handle.html#borrowed-spec">
+borrowed</a> function. Two functions
+returning borrowed references are <a href="http://www.python.org/doc/current/api/importing.html#l2h-125">
+PyImport_AddModule</a> and <a href="http://www.python.org/doc/current/api/moduleObjects.html#l2h-594">
+PyModule_GetDict</a>.
+The former returns a reference to an already imported module, the latter
+retrieves a module's namespace dictionary. Let's use them to retrieve the
+namespace of the <tt>__main__</tt> module:</p>
+<code><pre>
+    <span class=identifier>handle</span><span class=special>&lt;&gt; </span><span class=identifier>main_module</span><span class=special>(</span><span class=identifier>borrowed</span><span class=special>( </span><span class=identifier>PyImport_AddModule</span><span class=special>(</span><span class=string>&quot;__main__&quot;</span><span class=special>) ));
+    </span><span class=identifier>handle</span><span class=special>&lt;&gt; </span><span class=identifier>main_namespace</span><span class=special>(</span><span class=identifier>borrowed</span><span class=special>( </span><span class=identifier>PyModule_GetDict</span><span class=special>(</span><span class=identifier>main_module</span><span class=special>.</span><span class=identifier>get</span><span class=special>()) ));
+</span></pre></code>
+<p>
+Because the Python/C API doesn't know anything about <tt>handle</tt>s, we used
+the <a href="../../v2/handle.html#handle-spec-observers">
+get</a> member function to
+retrieve the <tt>PyObject*</tt> from which the <tt>handle</tt> was constructed.</p>
+<p>
+For a function returning a <i>new reference</i> we can just create a <tt>handle</tt>
+out of the raw <tt>PyObject*</tt> without wrapping it in a call to borrowed. One
+such function that returns a new reference is <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55">
+PyRun_String</a> which we'll
+discuss in the next section.</p>
+<table width="80%" border="0" align="center">
+  <tr>
+    <td class="note_box">
+<img src="theme/lens.gif"></img> <b>Handle is a class <i>template</i>, so why haven't we been using any template parameters?</b><br>
+<br>
+<tt>handle</tt> has a single template parameter specifying the type of the managed object. This type is <tt>PyObject</tt> 99% of the time, so the parameter was defaulted to <tt>PyObject</tt> for convenience. Therefore we can use the shorthand <tt>handle&lt;&gt;</tt> instead of the longer, but equivalent, <tt>handle&lt;PyObject&gt;</tt>.
+    </td>
+  </tr>
+</table>
+<a name="running_python_code"></a><h2>Running Python code</h2><p>
+To run Python code from C++ there is a family of functions in the API
+starting with the PyRun prefix. You can find the full list of these
+functions <a href="http://www.python.org/doc/current/api/veryhigh.html">
+here</a>. They
+all work similarly so we will look at only one of them, namely:</p>
+<code><pre>
+    <span class=identifier>PyObject</span><span class=special>* </span><span class=identifier>PyRun_String</span><span class=special>(</span><span class=keyword>char </span><span class=special>*</span><span class=identifier>str</span><span class=special>, </span><span class=keyword>int </span><span class=identifier>start</span><span class=special>, </span><span class=identifier>PyObject </span><span class=special>*</span><span class=identifier>globals</span><span class=special>, </span><span class=identifier>PyObject </span><span class=special>*</span><span class=identifier>locals</span><span class=special>)
+</span></pre></code>
+<p>
+<a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55">
+PyRun_String</a> takes the code to execute as a null-terminated (C-style)
+string in its <tt>str</tt> parameter. The function returns a new reference to a
+Python object. Which object is returned depends on the <tt>start</tt> paramater.</p>
+<p>
+The <tt>start</tt> parameter is the start symbol from the Python grammar to use
+for interpreting the code. The possible values are:</p>
+<table width="90%" border="0" align="center">  <tr>
+  <td class="table_title" colspan="6">
+Start symbols  </td>
+  </tr>
+<tr><tr><td class="table_cells"><a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-58">
+Py_eval_input</a></td><td class="table_cells">for interpreting isolated expressions</td></tr><td class="table_cells"><a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-59">
+Py_file_input</a></td><td class="table_cells">for interpreting sequences of statements</td></tr><td class="table_cells"><a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-60">
+Py_single_input</a></td><td class="table_cells">for interpreting a single statement</td></tr></table>
+<p>
+When using <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-58">
+Py_eval_input</a>, the input string must contain a single expression
+and its result is returned. When using <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-59">
+Py_file_input</a>, the string can
+contain an abitrary number of statements and None is returned.
+<a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-60">
+Py_single_input</a> works in the same way as <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-59">
+Py_file_input</a> but only accepts a
+single statement.</p>
+<p>
+Lastly, the <tt>globals</tt> and <tt>locals</tt> parameters are Python dictionaries
+containing the globals and locals of the context in which to run the code.
+For most intents and purposes you can use the namespace dictionary of the
+<tt>__main__</tt> module for both parameters.</p>
+<p>
+We have already seen how to get the <tt>__main__</tt> module's namespace so let's
+run some Python code in it:</p>
+<code><pre>
+    <span class=identifier>handle</span><span class=special>&lt;&gt; </span><span class=identifier>main_module</span><span class=special>(</span><span class=identifier>borrowed</span><span class=special>( </span><span class=identifier>PyImport_AddModule</span><span class=special>(</span><span class=string>&quot;__main__&quot;</span><span class=special>) ));
+    </span><span class=identifier>handle</span><span class=special>&lt;&gt; </span><span class=identifier>main_namespace</span><span class=special>(</span><span class=identifier>borrowed</span><span class=special>( </span><span class=identifier>PyModule_GetDict</span><span class=special>(</span><span class=identifier>main_module</span><span class=special>.</span><span class=identifier>get</span><span class=special>()) ));
+    </span><span class=identifier>handle</span><span class=special>&lt;&gt;( </span><span class=identifier>PyRun_String</span><span class=special>(</span><span class=string>&quot;hello = file('hello.txt', 'w')\n&quot;
+                           </span><span class=string>&quot;hello.write('Hello world!')\n&quot;
+                           </span><span class=string>&quot;hello.close()&quot;</span><span class=special>, </span><span class=identifier>Py_file_input</span><span class=special>,
+                           </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>get</span><span class=special>(), </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>get</span><span class=special>()) );
+</span></pre></code>
+<p>
+This should create a file called 'hello.txt' in the current directory
+containing a phrase that is well-known in programming circles.</p>
+<p>
+<img src="theme/note.gif"></img> <b>Note</b> that we wrap the return value of <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55">
+PyRun_String</a> in a
+(nameless) <tt>handle</tt> even though we are not interested in it. If we didn't
+do this, the the returned object would be kept alive unnecessarily. Unless
+you want to be a Dr. Frankenstein, always wrap <tt>PyObject*</tt>s in <tt>handle</tt>s.</p>
+<a name="beyond_handles"></a><h2>Beyond handles</h2><p>
+It's nice that <tt>handle</tt> manages the reference counting details for us, but
+other than that it doesn't do much. Often we'd like to have a more useful
+class to manipulate Python objects. But we have already seen such a class
+in the <a href="object_interface.html">
+previous section</a>: the aptly named <tt>object</tt>
+class and it's derivatives. What we haven't seen, is that they can be
+constructed from a <tt>handle</tt>. The following examples should illustrate this
+fact:</p>
+<code><pre>
+    <span class=identifier>handle</span><span class=special>&lt;&gt; </span><span class=identifier>main_module</span><span class=special>(</span><span class=identifier>borrowed</span><span class=special>( </span><span class=identifier>PyImport_AddModule</span><span class=special>(</span><span class=string>&quot;__main__&quot;</span><span class=special>) ));
+    </span><span class=identifier>main_namespace </span><span class=identifier>dict</span><span class=special>(</span><span class=identifier>handle</span><span class=special>&lt;&gt;(</span><span class=identifier>borrowed</span><span class=special>( </span><span class=identifier>PyModule_GetDict</span><span class=special>(</span><span class=identifier>main_module</span><span class=special>.</span><span class=identifier>get</span><span class=special>()) )));
+    </span><span class=identifier>handle</span><span class=special>&lt;&gt;( </span><span class=identifier>PyRun_String</span><span class=special>(</span><span class=string>&quot;result = 5 ** 2&quot;</span><span class=special>, </span><span class=identifier>Py_file_input</span><span class=special>,
+                           </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>ptr</span><span class=special>(), </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>ptr</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>&quot;result&quot;</span><span class=special>] );
+</span></pre></code>
+<p>
+Here we create a dictionary object for the <tt>__main__</tt> module's namespace.
+Then we assign 5 squared to the result variable and read this variable from
+the dictionary. Another way to achieve the same result is to let
+<a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55">
+PyRun_String</a> return the result directly with <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-58">
+Py_eval_input</a>:</p>
+<code><pre>
+    <span class=identifier>object </span><span class=identifier>result</span><span class=special>(</span><span class=identifier>handle</span><span class=special>&lt;&gt;( </span><span class=identifier>PyRun_String</span><span class=special>(</span><span class=string>&quot;5 ** 2&quot;</span><span class=special>, </span><span class=identifier>Py_eval_input</span><span class=special>,
+                                         </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>ptr</span><span class=special>(), </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>ptr</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></code>
+<p>
+<img src="theme/note.gif"></img> <b>Note</b> that <tt>object</tt>'s member function to return the wrapped
+<tt>PyObject*</tt> is called <tt>ptr</tt> instead of <tt>get</tt>. This makes sense if you
+take into account the different functions that <tt>object</tt> and <tt>handle</tt>
+perform.</p>
+<a name="exception_handling"></a><h2>Exception handling</h2><p>
+If an exception occurs in the execution of some Python code, the <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55">
+PyRun_String</a> function returns a null pointer. Constructing a <tt>handle</tt> out of this null pointer throws <a href="../../v2/errors.html#error_already_set-spec">
+error_already_set</a>, so basically, the Python exception is automatically translated into a C++ exception when using <tt>handle</tt>:</p>
+<code><pre>
+    <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>handle</span><span class=special>&lt;&gt;( </span><span class=identifier>PyRun_String</span><span class=special>(</span><span class=string>&quot;5/0&quot;</span><span class=special>, </span><span class=identifier>Py_eval_input</span><span class=special>,
+                                             </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>ptr</span><span class=special>(), </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>ptr</span><span class=special>()) ));
+        // </span><span class=identifier>execution </span><span class=identifier>will </span><span class=identifier>never </span><span class=identifier>get </span><span class=identifier>here</span><span class=special>:
+        </span><span class=keyword>int </span><span class=identifier>five_divided_by_zero </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><span class=keyword>catch</span><span class=special>(</span><span class=identifier>error_already_set</span><span class=special>)
+    {
+        // </span><span class=identifier>handle </span><span class=identifier>the </span><span class=identifier>exception </span><span class=identifier>in </span><span class=identifier>some </span><span class=identifier>way
+    </span><span class=special>}
+</span></pre></code>
+<p>
+The <tt>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">
+exception 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">
+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">
+standard exceptions</a>:</p>
+<code><pre>
+    <span class=keyword>catch</span><span class=special>(</span><span class=identifier>error_already_set</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=identifier>handle </span><span class=identifier>ZeroDivisionError </span><span class=identifier>specially
+        </span><span class=special>}
+        </span><span class=keyword>else
+        </span><span class=special>{
+            // </span><span class=identifier>print </span><span class=identifier>all </span><span class=identifier>other </span><span class=identifier>errors </span><span class=identifier>to </span><span class=identifier>stderr
+            </span><span class=identifier>PyErr_Print</span><span class=special>();
+        }
+    }
+</span></pre></code>
+<p>
+(To retrieve even more information from the exception you can use some of the other exception handling functions listed <a href="http://www.python.org/doc/api/exceptionHandling.html">
+here</a>.)</p>
+<p>
+If you'd rather not have <tt>handle</tt> throw a C++ exception when it is constructed, you can use the <a href="../../v2/handle.html#allow_null-spec">
+allow_null</a> function in the same way you'd use borrowed:</p>
+<code><pre>
+    <span class=identifier>handle</span><span class=special>&lt;&gt; </span><span class=identifier>result</span><span class=special>(</span><span class=identifier>allow_null</span><span class=special>( </span><span class=identifier>PyRun_String</span><span class=special>(</span><span class=string>&quot;5/0&quot;</span><span class=special>, </span><span class=identifier>Py_eval_input</span><span class=special>,
+                                             </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>ptr</span><span class=special>(), </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>ptr</span><span class=special>()) ));
+    </span><span class=keyword>if </span><span class=special>(!</span><span class=identifier>result</span><span class=special>)
+        // </span><span class=identifier>Python </span><span class=identifier>exception </span><span class=identifier>occurred
+    </span><span class=keyword>else
+        </span><span class=comment>// everything went okay, it's safe to use the result
+</span></pre></code>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="embedding.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="iterators.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 Dirk Gerrits<br><br>
+<font size="2">Permission to copy, use, modify, sell and distribute this document
+ is granted provided this copyright notice appears in all copies. This document
+ is provided &quot;as is&quot; without express or implied warranty, and with
+ no claim as to its suitability for any purpose. </font> </p>
+</body>
+</html>

doc/tutorial/doc/virtual_functions_with_default_implementations.html

@@ -0,0 +1,122 @@
+<html>
+<head>
+<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
+<title>Virtual Functions with Default Implementations</title>
+<link rel="stylesheet" href="theme/style.css" type="text/css">
+<link rel="prev" href="deriving_a_python_class.html">
+<link rel="next" href="class_operators_special_functions.html">
+</head>
+<body>
+<table width="100%" height="48" border="0" cellspacing="2">
+  <tr>
+    <td><img src="theme/c%2B%2Bboost.gif">
+    </td>
+    <td width="85%">
+      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Virtual Functions with Default Implementations</b></font>
+    </td>
+  </tr>
+</table>
+<br>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="deriving_a_python_class.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="class_operators_special_functions.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<p>
+Recall that in the <a href="class_virtual_functions.html">
+previous 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>
+<code><pre>
+    <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=number>0</span><span class=special>;
+    };
+</span></pre></code>
+<p>
+had a pure virtual function <tt>f</tt>. If, however, its member function <tt>f</tt> was
+not declared as pure virtual:</p>
+<code><pre>
+    <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=keyword>return </span><span class=number>0</span><span class=special>; }
+    };
+</span></pre></code>
+<p>
+and instead had a default implementation that returns <tt>0</tt>, as shown above,
+we need to add a forwarding function that calls the <tt>Base</tt> default virtual
+function <tt>f</tt> implementation:</p>
+<code><pre>
+    <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>BaseWrap</span><span class=special>(</span><span class=identifier>PyObject</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=identifier>self_</span><span class=special>) {}
+        </span><span class=keyword>int </span><span class=identifier>f</span><span class=special>() { </span><span class=keyword>return </span><span class=identifier>call_method</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;(</span><span class=identifier>self</span><span class=special>, </span><span class=string>&quot;f&quot;</span><span class=special>); }
+        </span><span class=keyword>int </span><span class=identifier>default_f</span><span class=special>() { </span><span class=keyword>return </span><span class=identifier>Base</span><span class=special>::</span><span class=identifier>f</span><span class=special>(); } // &lt;&lt;=== ***</span><span class=identifier>ADDED</span><span class=special>***
+        </span><span class=identifier>PyObject</span><span class=special>* </span><span class=identifier>self</span><span class=special>;
+    };
+</span></pre></code>
+<p>
+Then, Boost.Python needs to keep track of 1) the dispatch function <tt>f</tt> and
+2) the forwarding function to its default implementation <tt>default_f</tt>.
+There's a special <tt>def</tt> function for this purpose. Here's how it is
+applied to our example above:</p>
+<code><pre>
+    <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>Base</span><span class=special>, </span><span class=identifier>BaseWrap</span><span class=special>&gt;(</span><span class=string>&quot;Base&quot;</span><span class=special>)
+        .</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</span><span class=special>, &amp;</span><span class=identifier>Base</span><span class=special>::</span><span class=identifier>f</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></pre></code>
+<p>
+Note that we are allowing <tt>Base</tt> objects to be instantiated this time,
+unlike before where we specifically defined the <tt>class_&lt;Base&gt;</tt> with
+<tt>no_init</tt>.</p>
+<p>
+In Python, the results would be as expected:</p>
+<code><pre>
+    <span class=special>&gt;&gt;&gt; </span><span class=identifier>base </span><span class=special>= </span><span class=identifier>Base</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=identifier>def </span><span class=identifier>f</span><span class=special>(</span><span class=identifier>self</span><span class=special>):
+    ...         </span><span class=keyword>return </span><span class=number>42
+    </span><span class=special>...
+    &gt;&gt;&gt; </span><span class=identifier>derived </span><span class=special>= </span><span class=identifier>Derived</span><span class=special>()
+</span></pre></code>
+<p>
+Calling <tt>base.f()</tt>:</p>
+<code><pre>
+    <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></code>
+<p>
+Calling <tt>derived.f()</tt>:</p>
+<code><pre>
+    <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></code>
+<p>
+Calling <tt>call_f</tt>, passing in a <tt>base</tt> object:</p>
+<code><pre>
+    <span class=special>&gt;&gt;&gt; </span><span class=identifier>call_f</span><span class=special>(</span><span class=identifier>base</span><span class=special>)
+    </span><span class=number>0
+</span></pre></code>
+<p>
+Calling <tt>call_f</tt>, passing in a <tt>derived</tt> object:</p>
+<code><pre>
+    <span class=special>&gt;&gt;&gt; </span><span class=identifier>call_f</span><span class=special>(</span><span class=identifier>derived</span><span class=special>)
+    </span><span class=number>42
+</span></pre></code>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="deriving_a_python_class.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="class_operators_special_functions.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
+<font size="2">Permission to copy, use, modify, sell and distribute this document
+ is granted provided this copyright notice appears in all copies. This document
+ is provided &quot;as is&quot; without express or implied warranty, and with
+ no claim as to its suitability for any purpose. </font> </p>
+</body>
+</html>

doc/tutorial/index.html

@@ -60,6 +60,16 @@
         <a href="doc/class_virtual_functions.html">Class Virtual Functions</a>
     </td>
   </tr>
+  <tr>
+    <td class="toc_cells_L1">
+        <a href="doc/deriving_a_python_class.html">Deriving a Python Class</a>
+    </td>
+  </tr>
+  <tr>
+    <td class="toc_cells_L1">
+        <a href="doc/virtual_functions_with_default_implementations.html">Virtual Functions with Default Implementations</a>
+    </td>
+  </tr>
   <tr>
     <td class="toc_cells_L1">
         <a href="doc/class_operators_special_functions.html">Class Operators/Special Functions</a>
@@ -75,11 +85,21 @@
         <a href="doc/call_policies.html">Call Policies</a>
     </td>
   </tr>
+  <tr>
+    <td class="toc_cells_L1">
+        <a href="doc/overloading.html">Overloading</a>
+    </td>
+  </tr>
   <tr>
     <td class="toc_cells_L1">
         <a href="doc/default_arguments.html">Default Arguments</a>
     </td>
   </tr>
+  <tr>
+    <td class="toc_cells_L1">
+        <a href="doc/auto_overloading.html">Auto-Overloading</a>
+    </td>
+  </tr>
   <tr>
     <td class="toc_cells_L0">
         <a href="doc/object_interface.html">Object Interface</a>
@@ -105,6 +125,16 @@
         <a href="doc/enums.html">Enums</a>
     </td>
   </tr>
+  <tr>
+    <td class="toc_cells_L0">
+        <a href="doc/embedding.html">Embedding</a>
+    </td>
+  </tr>
+  <tr>
+    <td class="toc_cells_L1">
+        <a href="doc/using_the_interpreter.html">Using the interpreter</a>
+    </td>
+  </tr>
   <tr>
     <td class="toc_cells_L0">
         <a href="doc/iterators.html">Iterators</a>
@@ -117,7 +147,7 @@
   </tr>
 </table>
 <br>
-<hr size="1"><p class="copyright">Copyright &copy; 2002 David Abrahams<br>Copyright &copy; 2002 Joel de Guzman<br><br>
+<hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
 <font size="2">Permission to copy, use, modify, sell and distribute this document
  is granted provided this copyright notice appears in all copies. This document
  is provided &quot;as is&quot; without express or implied warranty, and with

doc/v2/Apr2002.html

@@ -13,7 +13,7 @@
           "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
     </td>
     <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
+      <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
       <h2 align="center">April 2002 Progress Report</h2>
     </td>
   </tr>
@@ -154,7 +154,7 @@ documentation).
 
 <p>Revised 
   <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  3 May, 2002 
+  13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 

doc/v2/CallPolicies.html

@@ -5,7 +5,7 @@
     <meta name="generator" content=
     "HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
     <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 - CallPolicies Concept</title>
   </head>
@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">CallPolicies Concept</h2>
         </td>
@@ -136,7 +136,8 @@
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     19 May, 2002 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=

doc/v2/Dereferenceable.html

@@ -1,7 +1,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">
@@ -12,7 +12,7 @@
       <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
     </td>
     <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
+      <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
       <h2 align="center">Dereferenceable Concept</h2>
     </td>
   </tr>
@@ -49,10 +49,25 @@ type is a model of Dereferenceable.
   </tr>
 </table>
 
+If <code><b>x</b></code> is not a pointer type, it also must satsify the following expression:
+
+<table summary="Dereferenceable expressions" border="1" cellpadding="5">
+
+  <tr> 
+    <td><b>Expression</b></td>
+    <td><b>Operational Semantics</b></td>
+  </tr>
+
+  <tr> 
+    <td valign="top"><code>x.get()</code></td>
+    <td><code>&amp;*x</code>, or a null pointer
+  </tr>
+</table>
+
 <hr>
 <p>Revised 
   <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  10 May, 2002
+  29 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
     <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave

doc/v2/Extractor.html

@@ -1,7 +1,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">
@@ -12,7 +12,7 @@
       <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
     </td>
     <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
+      <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
       <h2 align="center">Extractor Concept</h2>
     </td>
   </tr>
@@ -79,7 +79,7 @@ are layout-compatible with PyObject.
 <hr>
 <p>Revised 
   <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  22 May, 2002
+  13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
     <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave

doc/v2/HolderGenerator.html

@@ -1,7 +1,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">
@@ -12,7 +12,7 @@
       <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
     </td>
     <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
+      <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
       <h2 align="center">HolderGenerator Concept</h2>
     </td>
   </tr>
@@ -57,7 +57,7 @@ type.
 <hr>
 <p>Revised 
   <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  20 May, 2002
+  13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
     <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave

doc/v2/Jun2002.html

@@ -13,7 +13,7 @@
           "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
     </td>
     <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
+      <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
       <h2 align="center">June 2002 Progress Report</h2>
     </td>
   </tr>
@@ -217,7 +217,7 @@ you'll just have to wait till next month (hopefully the beginning).
 
 <p>Revised 
   <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  19 July, 2002 
+  13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 

doc/v2/Mar2002.html

@@ -13,7 +13,7 @@
           "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
     </td>
     <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
+      <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
       <h2 align="center">March 2002 Progress Report</h2>
     </td>
   </tr>
@@ -225,7 +225,7 @@ worth doing anything about it.
 
 <p>Revised 
   <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  1 April, 2002 
+  13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 

doc/v2/May2002.html

@@ -13,7 +13,7 @@
           "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
     </td>
     <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
+      <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
       <h2 align="center">May 2002 Progress Report</h2>
     </td>
   </tr>
@@ -300,7 +300,7 @@ to these issues will probably have to be formalized before long.
 
 <p>Revised 
   <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  11 June, 2002 
+  13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 

doc/v2/ObjectWrapper.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">ObjectWrapper and TypeWrapper Concepts</h2>
         </td>
@@ -139,7 +139,8 @@ instances of the associated Python type will be considered a match.
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     30 Sept, 2002 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=

doc/v2/ResultConverter.html

@@ -1,7 +1,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 - ResultConverter Concept</title>
 </head>
 <body link="#0000ff" vlink="#800080">
@@ -12,7 +12,7 @@
       <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
     </td>
     <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
+      <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
       <h2 align="center">ResultConverter Concept</h2>
     </td>
   </tr>

doc/v2/acknowledgments.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Acknowledgments</h2>
         </td>
@@ -31,19 +31,57 @@
     <p><a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> is
     the architect, designer, and implementor of <b>Boost.Python</b>.</p>
 
+    <p><a href="mailto:brett.calcott@paradise.net.nz">Brett Calcott</a>
+    contributed and maintains the Visual Studio project files and
+    documentation.</p>
+
+    <p><a href="mailto:Gottfried.Ganssauge-at-haufe.de">Gottfried
+    Ganßauge</a> supplied support for opaque pointer conversions,
+    complete with documentation and a regression test (and I didn't
+    even have to ask him for those)!
+
     <p>Joel de Guzman implemented the <a href="overloads.html">default
-    argument support</a> and wrote the excellent tutorial documentation.</p>
+    argument support</a> and wrote the excellent <a href=
+    "../tutorial/index.html">tutorial documentation</a>.</p>
 
     <p><a href="../../../../people/ralf_w_grosse_kunstleve.htm">Ralf W.
     Grosse-Kunstleve</a> implemented the <a href="pickle.html">pickle
     support</a>, and has enthusiastically supported the library since its
     birth, contributing to design decisions and providing invaluable
-    real-world insight into user requirements. Ralf has written some
-    extensions for converting C++ containers that I hope will be incorporated
-    into the library soon. He also implemented the cross-module support in
-    the first version of Boost.Python. More importantly, Ralf makes sure
-    nobody forgets the near-perfect synergy of C++ and Python for solving the
-    problems of large-scale software construction.</p>
+    real-world insight into user requirements. Ralf has written some <a href=
+    "faq.html#question2">extensions</a> for converting C++ containers that I
+    hope will be incorporated into the library soon. He also implemented the
+    cross-module support in the first version of Boost.Python. More
+    importantly, Ralf makes sure nobody forgets the near-perfect synergy of
+    C++ and Python for solving the problems of large-scale software
+    construction.</p>
+
+    <p><a href="../../../../people/aleksey_gurtovoy.htm">Aleksey Gurtovoy</a>
+    wrote an incredible C++ <a href="http://www.mywikinet.com/mpl">Template
+    Metaprogramming Library</a> which allows Boost.Python to perform much of
+    its compile-time magic. In addition, Aleksey very generously contributed
+    his time and deep knowledge of the quirks of various buggy compilers to
+    help us get around problems at crucial moments.</p>
+
+    <p><a href="../../../../people/paul_mensonides.htm">Paul Mensonides</a>,
+    building on the work <a href="../../../../people/vesa_karvonen.htm">Vesa
+    Karvonen</a>, wrote a similarly amazing <a href=
+    "../../../preprocessor/doc/index.html">Preprocessor Metaprogramming
+    Library</a>, and generously contributed the time and expertise to get it
+    working in the Boost.Python library, rewriting much of Boost.Python to
+    use the new preproccessor metaprogramming constructs and helping us to
+    work around buggy and slow C++ preprocessors.</p>
+
+    <p><a href="nicodemus-at-globalite.com.br">Bruno da Silva de
+    Oliveira</a> contributed the ingenious <a
+    href="../../pyste/index.html">Pyste</a> (&quot;Pie-Steh&quot;)
+    code generator.
+
+    <p><a href="mailto:nickm@sitius.com">Nikolay Mladenov</a> contributed
+    <code>staticmethod</code> support.</p>
+
+    <p>Martin Casado solved some sticky problems which allow us to build the
+    Boost.Python shared library for AIX's crazy dynamic linking model.</p>
 
     <p><a href="mailto:achim@procoders.net">Achim Domma</a> contributed some
     of the <a href="reference.html#object_wrappers">Object Wrappers</a> and
@@ -53,9 +91,6 @@
     definition syntax. Pearu Pearson wrote some of the test cases that are in
     the current test suite.</p>
 
-    <p>Martin Casado solved some sticky problems which allow us to build the
-    Boost.Python shared library for AIX's crazy dynamic linking model.</p>
-
     <p>The development of this version of Boost.Python was funded in part by
     the <a href="http://www.llnl.gov/">Lawrence Livermore National
     Laboratories</a> and by the <a href="http://cci.lbl.gov/">Computational
@@ -63,8 +98,21 @@
     Laboratories.</p>
 
     <p><a href="http://kogs-www.informatik.uni-hamburg.de/~koethe/">Ullrich
-    Koethe</a> provided the implementation of inheritance and special
-    method/operator support in the first version of Boost.Python.</p>
+    Koethe</a> had independently developed a similar system. When he
+    discovered Boost.Python v1, he generously contributed countless hours of
+    coding and much insight into improving it. He is responsible for an early
+    version of the support for function overloading and wrote the support for
+    reflecting C++ inheritance relationships. He has helped to improve
+    error-reporting from both Python and C++ (we hope to do as well in v2
+    again soon), and has designed the original support for exposing numeric
+    operators, including a way to avoid explicit coercion by means of
+    overloading.</p>
+
+    <p>The members of the boost mailing list and the Python community
+    supplied invaluable early feedback. In particular, Ron Clarke, Mark
+    Evans, Anton Gluck, Chuck Ingold, Prabhu Ramachandran, and Barry Scott
+    took the brave step of trying to use Boost.Python while it was still in
+    early stages of development.</p>
 
     <p>The first version of Boost.Python would not have been possible without
     the support of Dragon Systems, which supported its development and
@@ -73,7 +121,7 @@
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     08 October, 2002 
+     26 November, 2002 
     <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 

doc/v2/args.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header &lt;boost/python/args.hpp&gt;</h2>
         </td>

doc/v2/bibliography.html

@@ -13,7 +13,7 @@
           "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
     </td>
     <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
+      <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
       <h2 align="center">Bibliography</h2>
     </td>
   </tr>
@@ -23,7 +23,7 @@
 <hr>
 <p>Revised 
   <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  05 November, 2002 
+  13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 

doc/v2/call.html

@@ -13,7 +13,7 @@
           "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
     </td>
     <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
+      <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
       <h2 align="center">Header &lt;call.hpp&gt;</h2>
     </td>
   </tr>

doc/v2/call_method.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header &lt;call_method.hpp&gt;</h2>
         </td>
@@ -112,7 +112,7 @@ class Base_callback : public Base
  public:
    Base_callback(PyObject* self) : m_self(self) {}
 
-   char const* class_name() const { return <b>call_method</b>(m_self, "class_name"); }
+   char const* class_name() const { return <b>call_method</b>&lt;char const*&gt;(m_self, "class_name"); }
    char const* Base_name() const { return Base::class_name(); }
  private:
    PyObject* const m_self;
@@ -147,7 +147,8 @@ BOOST_PYTHON_MODULE(my_module)
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     28 Sept, 2002 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=

doc/v2/callbacks.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Calling Python Functions and Methods</h2>
         </td>
@@ -240,7 +240,8 @@ void apply(PyObject* callable, X&amp; x)
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     17 April, 2002 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=

doc/v2/class.html

@@ -21,7 +21,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Headers &lt;boost/python/class.hpp&gt;,
           &lt;boost/python/class_fwd.hpp&gt;</h2>
@@ -212,7 +212,7 @@
 namespace boost { namespace python
 {
   template &lt;class T
-   <font color="#007F00">       , class Bases = bases&lt;&gt;
+   <font color="#007F00">     , class Bases = bases&lt;&gt;
             , class HeldType = T
             , class NonCopyable = <i>unspecified</i>
            &gt;
@@ -242,6 +242,9 @@ namespace boost { namespace python
     template &lt;class Fn, class A1, class A2, class A3&gt;
     class_&amp; def(char const* name, Fn fn, A1 const&amp;, A2 const&amp;, A3 const&amp;);
 
+    // declaring method as static
+    class_&amp; staticmethod(char const* name);
+    
     // exposing operators
     template &lt;<i>unspecified</i>&gt;
     class_&amp; def(<a href=
@@ -344,10 +347,11 @@ class_&amp; def(Init init_expr);
       generated constructs an object of <code>HeldType</code> according to
       the semantics described <a href="#HeldType">above</a>, using a copy of
       <code>init_expr</code>'s <a href="CallPolicies.html">call policies</a>.
-      If the longest <a href="init.html#init-expressions">valid prefix</a> of <code>Init</code> contains <em>N</em>
-      types and <code>init_expr</code> holds <em>M</em> keywords, an initial
-      sequence of the keywords are used for all but the first
-      <em>N</em>&nbsp;-&nbsp;<em>M</em> arguments of each overload.</dt>
+      If the longest <a href="init.html#init-expressions">valid prefix</a> of
+      <code>Init</code> contains <em>N</em> types and <code>init_expr</code>
+      holds <em>M</em> keywords, an initial sequence of the keywords are used
+      for all but the first <em>N</em>&nbsp;-&nbsp;<em>M</em> arguments of
+      each overload.</dt>
 
       <dt><b>Returns:</b> <code>*this</code></dt>
 
@@ -378,20 +382,20 @@ class_&amp; def(char const* name, Fn fn, A1 const&amp; a1, A2 const&amp; a2, A3
           <li>
             If <code>a1</code> is the result of an <a href=
             "overloads.html#overload-dispatch-expression"><em>overload-dispatch-expression</em></a>,
-            only the second form is allowed and fn must be a pointer
-            to function or pointer to member function whose <a
-            href="definitions.html#arity">arity</a> is the same as A1's <a href=
-            "overloads.html#overload-dispatch-expression"><em>maximum arity</em></a>.
+            only the second form is allowed and fn must be a pointer to
+            function or pointer to member function whose <a href=
+            "definitions.html#arity">arity</a> is the same as A1's <a href=
+            "overloads.html#overload-dispatch-expression"><em>maximum
+            arity</em></a>. 
 
             <dl>
               <dt><b>Effects:</b> For each prefix <em>P</em> of
-              <code>Fn</code>'s sequence of argument types, beginning
-            with the one whose length is <code>A1</code>'s <a href=
-            "overloads.html#overload-dispatch-expression"><em>minimum
-            arity</em></a>, adds a
-              <code><em>name</em>(</code>...<code>)</code> method
-              overload to the extension class. Each overload generated
-              invokes
+              <code>Fn</code>'s sequence of argument types, beginning with
+              the one whose length is <code>A1</code>'s <a href=
+              "overloads.html#overload-dispatch-expression"><em>minimum
+              arity</em></a>, adds a
+              <code><em>name</em>(</code>...<code>)</code> method overload to
+              the extension class. Each overload generated invokes
               <code>a1</code>'s call-expression with <em>P</em>, using a copy
               of <code>a1</code>'s <a href="CallPolicies.html">call
               policies</a>. If the longest valid prefix of <code>A1</code>
@@ -477,6 +481,37 @@ class_&amp; def(char const* name, Fn fn, A1 const&amp; a1, A2 const&amp; a2, A3
       <dt><b>Returns:</b> <code>*this</code></dt>
     </dl>
 <pre>
+class_&amp; staticmethod(char const* name);
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> <code>name</code> is an <a href=
+      "definitions.html#ntbs">ntbs</a> which conforms to Python's <a href=
+      "http://www.python.org/doc/current/ref/identifiers.html">identifier
+      naming rules</a>, and corresponds to a method whose overloads have all
+      been defined.</dt>
+
+      <dt><b>Effects:</b> Replaces the existing named attribute <i>x</i> with
+      the result of invoking <code>staticmethod(</code><i>x</i><code>)</code>
+      in Python. Specifies that the corresponding method is static and
+      therefore no object instance will be passed to it. This is equivalent
+      to the Python statement:</dt>
+
+      <dd>
+<pre>
+setattr(self, name, staticmethod(getattr(self, name)))
+</pre>
+      </dd>
+
+      <dt><b>Note:</b> Attempting to invoke <code>def(name,...)</code> after
+      invoking <code>staticmethod(name)</code> will <a href=
+      "definitions.html#raise">raise</a> a RuntimeError.</dt>
+
+      <dt><b>Returns:</b> <code>*this</code></dt>
+    </dl>
+    <br>
+     
+<pre>
 template &lt;<i>unspecified</i>&gt;
 class_&amp; def(<a href=
 "operators.html#operator_-spec">detail::operator_</a>&lt;unspecified&gt;);
@@ -529,7 +564,7 @@ void add_property(char const* name, Get const&amp; fget, Set const&amp; fset);
       naming rules</a>.</dt>
 
       <dt><b>Effects:</b> Creates a new Python <a href=
-      "http://www.python.org/current/descrintro.html#property"><code>property</code></a>
+      "http://www.python.org/2.2.2/descrintro.html#property"><code>property</code></a>
       class instance, passing <code><a href=
       "object.html#object-spec-ctors">object</a>(fget)</code> (and <code><a
       href="object.html#object-spec-ctors">object</a>(fset)</code> in the
@@ -597,27 +632,21 @@ class_&amp; def_pickle(PickleSuite const&amp;);
 </pre>
 
     <dl class="function-semantics">
-      <dt><b>Requires:</b> PickleSuite must be publically derived from
-          <a href="pickle.html"
-          ><code>pickle_suite</code></a>.</dt>
+      <dt><b>Requires:</b> PickleSuite must be publically derived from <a
+      href="pickle.html"><code>pickle_suite</code></a>.</dt>
 
       <dt><b>Effects:</b> Defines a legal combination of the special
-          attributes and methods:
-          <code>__getinitargs__</code>,
-          <code>__getstate__</code>,
-          <code>__setstate__</code>,
-          <code>__getstate_manages_dict__</code>,
-          <code>__safe_for_unpickling__</code>,
-          <code>__reduce__</code>
-      </dt>
+      attributes and methods: <code>__getinitargs__</code>,
+      <code>__getstate__</code>, <code>__setstate__</code>,
+      <code>__getstate_manages_dict__</code>,
+      <code>__safe_for_unpickling__</code>, <code>__reduce__</code></dt>
 
       <dt><b>Returns:</b> <code>*this</code></dt>
 
-      <dt><b>Rationale:</b> Provides an
-          <a href="pickle.html"
-          >easy to use high-level interface</a>
-          for establishing complete pickle support for the wrapped class.
-          The user is protected by compile-time consistency checks.</dt>
+      <dt><b>Rationale:</b> Provides an <a href="pickle.html">easy to use
+      high-level interface</a> for establishing complete pickle support for
+      the wrapped class. The user is protected by compile-time consistency
+      checks.</dt>
     </dl>
     <br>
      
@@ -685,7 +714,8 @@ class_&lt;Derived, bases&lt;Base&gt; &gt;("Derived");
 </pre>
     Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     29 Sept, 2002 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+     13 November, 2002 
+    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
      
 
     <p><i>&copy; Copyright <a href=

doc/v2/configuration.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Configuration</h2>
         </td>
@@ -47,22 +47,22 @@
     <h2><a name="app-defined"></a>Application Defined Macros</h2>
 
     <p>These are the macros that may be defined by an application using
-    <b>Boost.Python</b>. Note that if you extend a strict interpretation of the C++
-    standard to cover dynamic libraries, using different values of these
-    macros when compiling different libraries (including extension modules
-    and the <b>Boost.Python</b> library itself) is a violation of the <a href=
-    "definitions.html#ODR">ODR</a>. However, we know of no C++
+    <b>Boost.Python</b>. Note that if you extend a strict interpretation of
+    the C++ standard to cover dynamic libraries, using different values of
+    these macros when compiling different libraries (including extension
+    modules and the <b>Boost.Python</b> library itself) is a violation of the
+    <a href="definitions.html#ODR">ODR</a>. However, we know of no C++
     implementations on which this particular violation is detectable or
     causes any problems.</p>
 
     <table summary="application defined macros" width="100%" cellpadding=
     "10">
       <tr>
-        <th align="left"><b>Macro</b></td>
+        <th align="left"><b>Macro</b></th>
 
-        <th><b>Default</b></td>
+        <th><b>Default</b></th>
 
-        <th align="left"><b>Meaning</b></td>
+        <th align="left"><b>Meaning</b></th>
       </tr>
 
       <tr>
@@ -70,15 +70,16 @@
 
         <td valign="top" align="center">15</td>
 
-        <td valign="top">The maximum <a href="definitions.html#arity">arity</a> of any
-        function, member function, or constructor to be wrapped, invocation
-        of a <b>Boost.Python</b> function wich is specified as taking arguments
+        <td valign="top">The maximum <a href=
+        "definitions.html#arity">arity</a> of any function, member function,
+        or constructor to be wrapped, invocation of a <b>Boost.Python</b>
+        function wich is specified as taking arguments
         <code>x1,&nbsp;x2,</code>...<code>X</code><i>n</i>. This includes, in
         particular, callback mechanisms such as <code><a href=
         "object.html#object-spec">object</a>::operator()(</code>...<code>)</code>
         or <code><a href=
-        "call_method.html#call_method-spec">call_method</a>&lt;R&gt;(</code>...<code>
-        )</code>.</td>
+        "call_method.html#call_method-spec">call_method</a>&lt;R&gt;(</code>...
+        <code>)</code>.</td>
       </tr>
 
       <tr>
@@ -86,28 +87,39 @@
 
         <td valign="top" align="center">10</td>
 
-        <td valign="top">The maximum number of template arguments to the <code><a href=
+        <td valign="top">The maximum number of template arguments to the
+        <code><a href=
         "class.html#bases-spec">bases</a>&lt;</code>...<code>&gt;</code>
         class template, which is used to specify the bases of a wrapped C++
         class..</td>
       </tr>
+
+      <tr>
+        <td valign="top"><code>BOOST_PYTHON_STATIC_MODULE</code></td>
+
+        <td valign="top" align="center"><i>not&nbsp;defined</i></td>
+
+        <td valign="top">If defined, prevents your module initialization
+        function from being treated as an exported symbol on platforms which
+        support that distinction in-code</td>
+      </tr>
     </table>
 
     <h2><a name="lib-defined-impl"></a>Library Defined Implementation
     Macros</h2>
 
-    <p>These macros are defined by <b>Boost.Python</b> and are
-    implementation details of interest only to implementors and those porting
-    to new platforms.</p>
+    <p>These macros are defined by <b>Boost.Python</b> and are implementation
+    details of interest only to implementors and those porting to new
+    platforms.</p>
 
     <table summary="library defined implementation macros" width="100%"
     cellpadding="10">
       <tr>
-        <th align="left"><b>Macro</b></td>
+        <th align="left"><b>Macro</b></th>
 
-        <th><b>Default</b></td>
+        <th><b>Default</b></th>
 
-        <th align="left"><b>Meaning</b></td>
+        <th align="left"><b>Meaning</b></th>
       </tr>
 
       <tr>
@@ -115,21 +127,21 @@
 
         <td valign="top" align="center"><i>not&nbsp;defined</i></td>
 
-        <td valign="top">If defined, this indicates that the type_info comparison across
-        shared library boundaries does not work on this platform. In other
-        words, if shared-lib-1 passes <code>typeid(T)</code> to a function in
-        shared-lib-2 which compares it to <code>typeid(T)</code>, that
-        comparison may return <code>false</code>. If this macro is #defined,
-        Boost.Python uses and compares <code>typeid(T).name()</code> instead
-        of using and comparing the <code>std::type_info</code> objects
-        directly.</td>
+        <td valign="top">If defined, this indicates that the type_info
+        comparison across shared library boundaries does not work on this
+        platform. In other words, if shared-lib-1 passes
+        <code>typeid(T)</code> to a function in shared-lib-2 which compares
+        it to <code>typeid(T)</code>, that comparison may return
+        <code>false</code>. If this macro is #defined, Boost.Python uses and
+        compares <code>typeid(T).name()</code> instead of using and comparing
+        the <code>std::type_info</code> objects directly.</td>
       </tr>
     </table>
     <hr>
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     04 October, 2002 
+     7 January, 2003 
     <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 

doc/v2/copy_const_reference.html

@@ -21,7 +21,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header
           &lt;boost/python/copy_const_reference.hpp&gt;</h2>
@@ -135,8 +135,8 @@ BOOST_PYTHON_MODULE(my_module)
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     29 September, 2002 
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=

doc/v2/copy_non_const_reference.html

@@ -21,7 +21,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header
           &lt;boost/python/copy_non_const_reference.hpp&gt;</h2>
@@ -135,8 +135,8 @@ BOOST_PYTHON_MODULE(my_module)
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     29 September, 2001 
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=

doc/v2/data_members.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header
           &lt;boost/python/data_members.hpp&gt;</h2>
@@ -77,7 +77,15 @@ template &lt;class C, class D, class Policies&gt;
       <code>C*</code>, and returns the corresponding member <code>D</code>
       member of the <code>C</code> object, converted <code>to_python</code>.
       If <code>policies</code> is supplied, it will be applied to the
-      function as described <a href="CallPolicies.html">here</a>.</dt>
+      function as described <a href="CallPolicies.html">here</a>. Otherwise,
+      the library attempts to determine whether <code>D</code> is a
+      user-defined class type, and if so uses <code><a href=
+      "return_internal_reference.html#return_internal_reference-spec">return_internal_reference</a>&lt;&gt;</code></dt>
+
+      <dt>for <code>Policies</code>. Note that this test may inappropriately
+      choose <code>return_internal_reference&lt;&gt;</code> in some cases
+      when <code>D</code> is a smart pointer type. This is a known
+      defect.</dt>
 
       <dt><b>Returns:</b> An instance of <a href=
       "object.html#object-spec">object</a> which holds the new Python
@@ -147,7 +155,7 @@ BOOST_PYTHON_MODULE_INIT(data_members_example)
 
     <p>
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     29 September 2002 
+     13 November, 2002 
     <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 

doc/v2/def.html

@@ -3,7 +3,7 @@
 <html>
   <head>
     <meta name="generator" content=
-    "HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
+    "HTML Tidy for Cygwin (vers 1st April 2002), see www.w3.org">
     <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
     <link rel="stylesheet" type="text/css" href="../boost.css">
 
@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header &lt;boost/python/def.hpp&gt;</h2>
         </td>
@@ -75,6 +75,12 @@ void def(char const* name, Fn fn, A1 const&amp;, A2 const&amp;, A3 const&amp;);
 
       <dd>
         <ul>
+          <li>If <code>Fn</code> is [derived from] <code><a href=
+          "object.html#object-spec">object</a></code>, it will be added to
+          the current scope as a single overload. To be useful,
+          <code>fn</code> should be <a href=
+          "http://www.python.org/doc/current/lib/built-in-funcs.html#l2h-6">callable</a>.</li>
+
           <li>
             If <code>a1</code> is the result of an <a href=
             "overloads.html#overload-dispatch-expression"><em>overload-dispatch-expression</em></a>,
@@ -104,67 +110,52 @@ void def(char const* name, Fn fn, A1 const&amp;, A2 const&amp;, A3 const&amp;);
             </dl>
           </li>
 
-          <li>
-            Otherwise, a single function overload built around fn (which must
-            not be null) is added to the <a href="scope.html">current
-            scope</a>: 
-
-            <ul>
-              <li>If fn is a function or member function pointer,
-              <code>a1</code>-<code>a3</code> (if supplied) may be selected
-              in any order from the table below.</li>
-
-              <li>Otherwise, <code>Fn</code> must be [derived from] <code><a
-              href="object.html#object-spec">object</a></code>, and
-              <code>a1-a2</code> (if supplied) may be selcted in any order
-              from the first two rows of the table below. To be useful,
-              <code>fn</code> should be <a href=
-              "http://www.python.org/doc/current/lib/built-in-funcs.html#l2h-6">
-              callable</a>.</li>
-            </ul>
-
-            <table border="1" summary="def() optional arguments">
-              <tr>
-                <th>Memnonic Name</th>
-
-                <th>Requirements/Type properties</th>
-
-                <th>Effects</th>
-              </tr>
-
-              <tr>
-                <td>docstring</td>
-
-                <td>Any <a href="definitions.html#ntbs">ntbs</a>.</td>
-
-                <td>Value will be bound to the <code>__doc__</code> attribute
-                of the resulting method overload.</td>
-              </tr>
-
-              <tr>
-                <td>policies</td>
-
-                <td>A model of <a href=
-                "CallPolicies.html">CallPolicies</a></td>
-
-                <td>A copy will be used as the call policies of the resulting
-                method overload.</td>
-              </tr>
-
-              <tr>
-                <td>keywords</td>
-
-                <td>The result of a <a href=
-                "args.html#keyword-expression"><em>keyword-expression</em></a>
-                specifying no more arguments than the <a href=
-                "definitions.html#arity">arity</a> of <code>fn</code>.</td>
-
-                <td>A copy will be used as the call policies of the resulting
-                method overload.</td>
-              </tr>
-            </table>
-          </li>
+          <li>Otherwise, fn must be a non-null function or member function
+          pointer, and a single function overload built around fn is added to
+          the <a href="scope.html">current scope</a>. If any of
+          <code>a1</code>-<code>a3</code> are supplied, they may be selected
+          in any order from the table below.</li>
         </ul>
+
+        <table border="1" summary="def() optional arguments">
+          <tr>
+            <th>Memnonic Name</th>
+
+            <th>Requirements/Type properties</th>
+
+            <th>Effects</th>
+          </tr>
+
+          <tr>
+            <td>docstring</td>
+
+            <td>Any <a href="definitions.html#ntbs">ntbs</a>.</td>
+
+            <td>Value will be bound to the <code>__doc__</code> attribute of
+            the resulting method overload.</td>
+          </tr>
+
+          <tr>
+            <td>policies</td>
+
+            <td>A model of <a href="CallPolicies.html">CallPolicies</a></td>
+
+            <td>A copy will be used as the call policies of the resulting
+            method overload.</td>
+          </tr>
+
+          <tr>
+            <td>keywords</td>
+
+            <td>The result of a <a href=
+            "args.html#keyword-expression"><em>keyword-expression</em></a>
+            specifying no more arguments than the <a href=
+            "definitions.html#arity">arity</a> of <code>fn</code>.</td>
+
+            <td>A copy will be used as the call policies of the resulting
+            method overload.</td>
+          </tr>
+        </table>
       </dd>
     </dl>
 
@@ -174,6 +165,8 @@ void def(char const* name, Fn fn, A1 const&amp;, A2 const&amp;, A3 const&amp;);
 #include &lt;boost/python/module.hpp&gt;
 #include &lt;boost/python/args.hpp&gt;
 
+using namespace boost::python;
+
 char const* foo(int x, int y) { return "foo"; }
 
 BOOST_PYTHON_MODULE(def_test)
@@ -184,7 +177,7 @@ BOOST_PYTHON_MODULE(def_test)
 
     <p>
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     03 October, 2002 
+     7 March, 2003
     <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 

doc/v2/default_call_policies.html

@@ -14,7 +14,7 @@
           "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header
           &lt;boost/python/default_call_policies.hpp&gt;</h2>
@@ -161,8 +161,8 @@ struct return_value_policy : Base
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     05 November, 2001 
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 
 
     <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave

doc/v2/definitions.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Definitions</h2>
         </td>
@@ -88,8 +88,8 @@
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     03 October, 2002 
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=

doc/v2/dict.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header &lt;boost/python/dict.hpp&gt;</h2>
         </td>

doc/v2/enum.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header &lt;boost/python/enum.hpp&gt;</h2>
         </td>
@@ -87,7 +87,8 @@ namespace boost { namespace python
   class enum_ : public <a href="object.html#object-spec">object</a>
   {
     enum_(char const* name);
-    inline enum_&lt;T&gt;&amp; value(char const* name, T);
+    enum_&lt;T&gt;&amp; value(char const* name, T);
+    enum_&lt;T&gt;&amp; export_values();
   };
 }}
 </pre>
@@ -133,6 +134,21 @@ inline enum_&lt;T&gt;&amp; value(char const* name, T x);
 
     </dl>
 
+<pre>
+inline enum_&lt;T&gt;&amp; export_values();
+</pre>
+
+    <dl class="function-semantics">
+
+      <dt><b>Effects:</b> sets attributes in the current <a
+        href="scope.html#scope-spec"><code>scope</code></a> with the
+        same names and values as all enumeration values exposed so far
+        by calling <code>value()</code></dt>.
+
+      <dt><b>Returns:</b> <code>*this</code></dt>
+
+    </dl>
+
     <h2><a name="examples"></a>Example(s)</h2>
 
     <p>C++ module definition
@@ -152,6 +168,7 @@ BOOST_PYTHON_MODULE(enums)
     enum_&lt;color&gt;(&quot;color&quot;)
         .value(&quot;red&quot;, red)
         .value(&quot;green&quot;, green)
+        .export_values()
         .value(&quot;blue&quot;, blue)
         ;
     
@@ -162,12 +179,23 @@ BOOST_PYTHON_MODULE(enums)
 <pre>
 &gt;&gt;&gt; from enums import *
 
+&gt;&gt;&gt; identity(red)
+enums.color.red
+
 &gt;&gt;&gt; identity(color.red)
 enums.color.red
 
+&gt;&gt;&gt; identity(green)
+enums.color.green
+
 &gt;&gt;&gt; identity(color.green)
 enums.color.green
 
+&gt;&gt;&gt; identity(blue)
+Traceback (most recent call last):
+  File &quot;&lt;stdin&gt;&quot;, line 1, in ?
+NameError: name blue' is not defined
+
 &gt;&gt;&gt; identity(color.blue)
 enums.color.blue
 
@@ -192,7 +220,8 @@ TypeError: bad argument type for built-in operation
 
     Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     03 October, 2002 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 December, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
      
 
     <p><i>&copy; Copyright <a href=

doc/v2/errors.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header &lt;boost/python/errors.hpp&gt;</h2>
         </td>
@@ -275,8 +275,8 @@ same_name2(PyObject* args, PyObject* keywords)
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     29 September, 2002 
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=

doc/v2/exception_translator.html

@@ -21,7 +21,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header
           &lt;boost/python/exception_translator.hpp&gt;</h2>

doc/v2/extract.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header &lt;boost/python/extract.hpp&gt;</h2>
         </td>
@@ -216,11 +216,11 @@ BOOST_PYTHON_MODULE(extract_ext)
     object x_obj = x_class(3);
 
     // Get a reference to the C++ object out of the Python object
-    X const&amp; x = extract&lt;X&amp;&gt;(x_obj);
+    X&amp; x = extract&lt;X&amp;&gt;(x_obj);
     assert(x.value() == 3);
 }
 </pre>
-    <p>Revised 30 September, 2002</p>
+    <p>Revised 15 November, 2002</p>
 
     <p><i>&copy; Copyright <a href=
     "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights

doc/v2/faq.html

@@ -3,8 +3,8 @@
 <html>
   <head>
     <meta name="generator" content=
-    "HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
-    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    "HTML Tidy for Cygwin (vers 1st April 2002), see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
     <link rel="stylesheet" type="text/css" href="../boost.css">
 
     <title>Boost.Python - FAQ</title>
@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Frequently Asked Questions (FAQs)</h2>
         </td>
@@ -29,14 +29,121 @@
     <hr>
 
     <dl class="page-index">
-      <dt><a href="#question1">Is return_internal reference
+
+      <dt><a href="#funcptr">How can I wrap a function which takes a
+      function pointer as an argument?</a><dd>
+
+      <dt><a href="#dangling">I'm getting the "attempt to return dangling
+      reference" error. What am I doing wrong?</a></dt>
+
+      <dt><a href="#question1">Is return_internal_reference
       efficient?</a></dt>
 
-      <dt><a href="#question2">How can I wrap containers which take C++
+      <dt><a href="#question2">How can I wrap functions which take C++
       containers as arguments?</a></dt>
-    </dl>
 
-    <h2><a name="question1"></a>Is return_internal reference efficient?</h2>
+      <dt><a href="#c1204">fatal error C1204:Compiler limit:internal
+      structure overflow</a></dt>
+
+      <dt><a href="#debugging">How do I debug my Python extensions?</a></dt>
+
+      <dt><a href="#imul">Why doesn't my <code>*=</code> operator
+      work?</a></dt>
+
+      <dt><a href="#macosx">Does Boost.Python work with Mac OS X?</a></dt>
+
+      <dt><a href="#xref">How can I find the existing PyObject that holds a
+      C++ object?</a></dt>
+
+      <dt><a href="#ownership">How can I wrap a function which needs to take
+      ownership of a raw pointer?</a></dt>
+    </dl>
+    <hr>
+
+    <h2><a name="funcptr">How can I wrap a function which takes a
+      function pointer as an argument?</a></h2>
+
+    If what you're trying to do is something like this:
+<pre>
+typedef boost::function&lt;void (string s) &gt; funcptr;
+
+void foo(funcptr fp)
+{
+    fp(&quot;hello,world!&quot;);
+}
+
+BOOST_PYTHON_MODULE(test)
+{
+    def(&quot;foo&quot;,foo) ;
+}
+</pre>
+
+And then:
+
+<pre>
+&gt;&gt;&gt; def hello(s):
+...    print s 
+...
+&gt;&gt;&gt; foo(hello)
+hello, world!
+</pre>
+
+    The short answer is: &quot;you can't&quot;.  This is not a
+    Boost.Python limitation so much as a limitation of C++.  The
+    problem is that a Python function is actually data, and the only
+    way of associating data with a C++ function pointer is to store it
+    in a static variable of the function.  The problem with that is
+    that you can only associate one piece of data with every C++
+    function, and we have no way of compiling a new C++ function
+    on-the-fly for every Python function you decide to pass
+    to <code>foo</code>.  In other words, this could work if the C++
+    function is always going to invoke the <em>same</em> Python
+    function, but you probably don't want that.
+
+    <p>If you have the luxury of changing the C++ code you're
+    wrapping, pass it an <code>object</code> instead and call that;
+    the overloaded function call operator will invoke the Python
+    function you pass it behind the <code>object</code>.
+
+    <p>For more perspective on the issue, see <a
+    href="http://aspn.activestate.com/ASPN/Mail/Message/1554837">this
+    posting</a>.
+
+    <hr>
+
+    <h2><a name="dangling">I'm getting the "attempt to return dangling
+    reference" error. What am I doing wrong?</a></h2>
+    That exception is protecting you from causing a nasty crash. It usually
+    happens in response to some code like this: 
+<pre>
+period const&amp; get_floating_frequency() const
+{
+  return boost::python::call_method&lt;period const&amp;&gt;(
+      m_self,"get_floating_frequency");
+}
+</pre>
+    And you get: 
+<pre>
+ReferenceError: Attempt to return dangling reference to object of type:
+class period
+</pre>
+
+    <p>In this case, the Python method invoked by <code>call_method</code>
+    constructs a new Python object. You're trying to return a reference to a
+    C++ object (an instance of <code>class period</code>) contained within
+    and owned by that Python object. Because the called method handed back a
+    brand new object, the only reference to it is held for the duration of
+    <code>get_floating_frequency()</code> above. When the function returns,
+    the Python object will be destroyed, destroying the instance of
+    <code>class period</code>, and leaving the returned reference dangling.
+    That's already undefined behavior, and if you try to do anything with
+    that reference you're likely to cause a crash. Boost.Python detects this
+    situation at runtime and helpfully throws an exception instead of letting
+    you do that.<br>
+     &nbsp;</p>
+    <hr>
+
+    <h2><a name="question1"></a>Is return_internal_reference efficient?</h2>
 
     <blockquote>
       <b>Q:</b> <i>I have an object composed of 12 doubles. A const&amp; to
@@ -59,6 +166,7 @@
       memory use and less fragmentation, also probably fewer total
       cycles.</p>
     </blockquote>
+    <hr>
 
     <h2><a name="question2"></a>How can I wrap functions which take C++
     containers as arguments?</h2>
@@ -152,15 +260,300 @@ cvs -d:pserver:anonymous@cvs.cctbx.sourceforge.net:/cvsroot/cctbx co scitbx
 </pre>
     <hr>
 
+    <h2><a name="c1204"></a>fatal error C1204:Compiler limit:internal
+    structure overflow</h2>
+
+    <blockquote>
+      <b>Q:</b> <i>I get this error message when compiling a large source
+      file. What can I do?</i> 
+
+      <p><b>A:</b> You have two choices:</p>
+
+      <ol>
+        <li>Upgrade your compiler (preferred)</li>
+
+        <li>
+          Break your source file up into multiple translation units. 
+
+          <p><code><b>my_module.cpp</b></code>:</p>
+<pre>
+...
+void more_of_my_module();
+BOOST_PYTHON_MODULE(my_module)
+{
+   def("foo", foo);
+   def("bar", bar);
+   ...
+   more_of_my_module();
+}
+</pre>
+          <code><b>more_of_my_module.cpp</b></code>: 
+<pre>
+void more_of_my_module()
+{
+   def("baz", baz);
+   ...
+}
+</pre>
+          If you find that a <code><a href=
+          "class.html#class_-spec">class_</a>&lt;...&gt;</code> declaration
+          can't fit in a single source file without triggering the error, you
+          can always pass a reference to the <code>class_</code> object to a
+          function in another source file, and call some of its member
+          functions (e.g. <code>.def(...)</code>) in the auxilliary source
+          file: 
+
+          <p><code><b>more_of_my_class.cpp</b></code>:</p>
+<pre>
+void more_of_my_class(class&lt;my_class&gt;&amp; x)
+{
+   x
+     .def("baz", baz)
+     .add_property("xx", &amp;my_class::get_xx, &amp;my_class::set_xx)
+     ;
+
+   ...
+}
+</pre>
+        </li>
+      </ol>
+    </blockquote>
+    <hr>
+
+    <h2><a name="debugging"></a>How do I debug my Python extensions?</h2>
+
+    <p>Greg Burley gives the following answer for Unix GCC users:</p>
+
+    <blockquote>
+      Once you have created a boost python extension for your c++ library or
+      class, you may need to debug the code. Afterall this is one of the
+      reasons for wrapping the library in python. An expected side-effect or
+      benefit of using BPL is that debugging should be isolated to the c++
+      library that is under test, given that python code is minimal and
+      boost::python either works or it doesn't. (ie. While errors can occur
+      when the wrapping method is invalid, most errors are caught by the
+      compiler ;-). 
+
+      <p>The basic steps required to initiate a gdb session to debug a c++
+      library via python are shown here. Note, however that you should start
+      the gdb session in the directory that contains your BPL my_ext.so
+      module.</p>
+<pre>
+(gdb) target exec python
+(gdb) run
+ &gt;&gt;&gt; from my_ext import *
+ &gt;&gt;&gt; [C-c]
+(gdb) break MyClass::MyBuggyFunction
+(gdb) cont
+ &gt;&gt;&gt; pyobj = MyClass()
+ &gt;&gt;&gt; pyobj.MyBuggyFunction()
+Breakpoint 1, MyClass::MyBuggyFunction ...
+Current language:  auto; currently c++
+(gdb) do debugging stuff
+</pre>
+    </blockquote>
+
+    <p>Greg's approach works even better using Emacs' "<code>gdb</code>"
+    command, since it will show you each line of source as you step through
+    it.</p>
+
+    <p>On <b>Windows</b>, my favorite debugging solution is the debugger that
+    comes with Microsoft Visual C++ 7. This debugger seems to work with code
+    generated by all versions of Microsoft and Metrowerks toolsets; it's rock
+    solid and "just works" without requiring any special tricks from the
+    user.</p>
+
+    <p>Unfortunately for Cygwin and MinGW users, as of this writing gdb on
+    Windows has a very hard time dealing with shared libraries, which could
+    make Greg's approach next to useless for you. My best advice for you is
+    to use Metrowerks C++ for compiler conformance and Microsoft Visual
+    Studio as a debugger when you need one.</p>
+
+    <h3>Debugging extensions through Boost.Build</h3>
+    If you are launching your extension module tests with <a href=
+    "../../../tools/build">Boost.Build</a> using the
+    <code>boost-python-runtest</code> rule, you can ask it to launch your
+    debugger for you by adding "-sPYTHON_LAUNCH=<i>debugger</i>" to your bjam
+    command-line: 
+<pre>
+bjam -sTOOLS=metrowerks "-sPYTHON_LAUNCH=devenv /debugexe" test
+bjam -sTOOLS=gcc -sPYTHON_LAUNCH=gdb test
+</pre>
+    It can also be extremely useful to add the <code>-d+2</code> option when
+    you run your test, because Boost.Build will then show you the exact
+    commands it uses to invoke it. This will invariably involve setting up
+    PYTHONPATH and other important environment variables such as
+    LD_LIBRARY_PATH which may be needed by your debugger in order to get
+    things to work right. 
+    <hr>
+
+    <h2><a name="imul"></a>Why doesn't my <code>*=</code> operator work?</h2>
+
+    <blockquote>
+      <b>Q:</b> <i>I have exported my class to python, with many overloaded
+      operators. it works fine for me except the</i> <code>*=</code>
+      <i>operator. It always tells me "can't multiply sequence with non int
+      type". If I use</i> <code>p1.__imul__(p2)</code> <i>instead of</i>
+      <code>p1 *= p2</code><i>, it successfully executes my code. What's
+      wrong with me?</i> 
+
+      <p><b>A:</b> There's nothing wrong with you. This is a bug in Python
+      2.2. You can see the same effect in Pure Python (you can learn a lot
+      about what's happening in Boost.Python by playing with new-style
+      classes in Pure Python).</p>
+<pre>
+&gt;&gt;&gt; class X(object):
+...     def __imul__(self, x):
+...         print 'imul'
+...
+&gt;&gt;&gt; x = X()
+&gt;&gt;&gt; x *= 1
+</pre>
+      To cure this problem, all you need to do is upgrade your Python to
+      version 2.2.1 or later.
+    </blockquote>
+    <hr>
+
+    <h2><a name="macosx"></a>Does Boost.Python work with Mac OS X?</h2>
+
+    <blockquote>
+      <p>The short answer: as of January 2003, unfortunately not.</p>
+
+      <p>The longer answer: using Mac OS 10.2.3 with the December Developer's
+      Kit, Python 2.3a1, and bjam's darwin-tools.jam, Boost.Python compiles
+      fine, including the examples. However, there are problems at runtime
+      (see <a href=
+      "http://mail.python.org/pipermail/c++-sig/2003-January/003267.html">http://mail.python.org/pipermail/c++-sig/2003-January/003267.html</a>).
+      Solutions are currently unknown.</p>
+
+      <p>It is known that under certain circumstances objects are
+      double-destructed. See <a href=
+      "http://mail.python.org/pipermail/c++-sig/2003-January/003278.html">http://mail.python.org/pipermail/c++-sig/2003-January/003278.html</a>
+      for details. It is not clear however if this problem is related to the
+      Boost.Python runtime issues.</p>
+    </blockquote>
+    <hr>
+
+    <h2><a name="xref">How can I find the existing PyObject that holds a C++
+    object?</a></h2>
+
+    <blockquote>
+      "I am wrapping a function that always returns a pointer to an
+      already-held C++ object."
+    </blockquote>
+    One way to do that is to hijack the mechanisms used for wrapping a class
+    with virtual functions. If you make a wrapper class with an initial
+    PyObject* constructor argument and store that PyObject* as "self", you
+    can get back to it by casting down to that wrapper type in a thin wrapper
+    function. For example: 
+<pre>
+class X { X(int); virtual ~X(); ... };
+X* f();  // known to return Xs that are managed by Python objects
+
+
+// wrapping code
+
+struct X_wrap : X
+{
+    X_wrap(PyObject* self, int v) : self(self), X(v) {}
+    PyObject* self;
+};
+
+handle&lt;&gt; f_wrap()
+{
+    X_wrap* xw = dynamic_cast&lt;X_wrap*&gt;(f());
+    assert(xw != 0);
+    return handle&lt;&gt;(borrowed(xw-&gt;self));
+}
+
+...
+
+def("f", f_wrap());
+class_&lt;X,X_wrap&gt;("X", init&lt;int&gt;())
+   ...
+   ;
+</pre>
+    Of course, if X has no virtual functions you'll have to use
+    <code>static_cast</code> instead of <code>dynamic_cast</code> with no
+    runtime check that it's valid. This approach also only works if the
+    <code>X</code> object was constructed from Python, because
+    <code>X</code>s constructed from C++ are of course never
+    <code>X_wrap</code> objects. 
+
+    <p>Another approach to this requires you to change your C++ code a bit;
+    if that's an option for you it might be a better way to go. work we've
+    been meaning to get to anyway. When a <code>shared_ptr&lt;X&gt;</code> is
+    converted from Python, the shared_ptr actually manages a reference to the
+    containing Python object. When a shared_ptr&lt;X&gt; is converted back to
+    Python, the library checks to see if it's one of those "Python object
+    managers" and if so just returns the original Python object. So you could
+    just write <code>object(p)</code> to get the Python object back. To
+    exploit this you'd have to be able to change the C++ code you're wrapping
+    so that it deals with shared_ptr instead of raw pointers.</p>
+
+    <p>There are other approaches too. The functions that receive the Python
+    object that you eventually want to return could be wrapped with a thin
+    wrapper that records the correspondence between the object address and
+    its containing Python object, and you could have your f_wrap function
+    look in that mapping to get the Python object out.</p>
+
+    <h2><a name="ownership">How can I wrap a function which needs to take
+    ownership of a raw pointer?</a></h2>
+
+    <blockquote>
+      <i>Part of an API that I'm wrapping goes something like this:</i> 
+<pre>
+struct A {}; struct B { void add( A* ); }
+where B::add() takes ownership of the pointer passed to it.
+</pre>
+
+      <p><i>However:</i></p>
+<pre>
+a = mod.A()
+b = mod.B()
+b.add( a )
+del a         
+del b
+# python interpreter crashes 
+# later due to memory corruption.
+</pre>
+
+      <p><i>Even binding the lifetime of a</i> to b via
+      with_custodian_and_ward doesn't prevent the python object a from
+      ultimately trying to delete the object it's pointing to. Is there a way
+      to accomplish a 'transfer-of-ownership' of a wrapped C++ object?</p>
+
+      <p><i>--Bruce Lowery</i></p>
+    </blockquote>
+    Yes: Make sure the C++ object is held by auto_ptr: 
+<pre>
+class_&lt;A, std::auto_ptr&lt;A&gt; &gt;("A")
+    ...
+    ;
+</pre>
+    Then make a thin wrapper function which takes an auto_ptr parameter: 
+<pre>
+void b_insert(B&amp; b, std::auto_ptr&lt;A&gt; a)
+{
+    b.insert(a.get());
+    a.release();
+}
+</pre>
+    Wrap that as B.add. Note that pointers returned via <code><a href=
+    "manage_new_object.html#manage_new_object-spec">manage_new_object</a></code>
+    will also be held by <code>auto_ptr</code>, so this transfer-of-ownership
+    will also work correctly. 
+    <hr>
+
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     05 November, 2002 
+     18 March, 2003 
     <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
-    Reserved.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002-2003. All
+    Rights Reserved.</i></p>
   </body>
 </html>
 

doc/v2/feb2002.html

@@ -20,7 +20,7 @@
           "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
         <td valign="top">
-          <h1 class="c1">Boost.Python</h1>
+          <h1 class="c1"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 class="c2">February 2002 Progress Report</h2>
     </table>
@@ -356,8 +356,8 @@
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     4 April, 2002 
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 
 
     <p class="c3">&copy; Copyright <a href= 

doc/v2/from_python.html

@@ -13,7 +13,7 @@
           "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header &lt;boost/python/from_python.hpp&gt;</h2>
     </table>
@@ -157,8 +157,8 @@ std::size_t length_if_string(PyObject* p)
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     05 November, 2001 
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 
 
     <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave

doc/v2/handle.html

@@ -14,7 +14,7 @@
  span.c3 {color: #ff0000}
  h2.c2 {text-align: center}
  h1.c1 {text-align: center}
-    </style>
+        </style>
   </head>
 
   <body>
@@ -27,7 +27,7 @@
         </td>
 
         <td valign="top">
-          <h1 class="c1">Boost.Python</h1>
+          <h1 class="c1"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 class="c2">Header &lt;boost/python/handle.hpp&gt;</h2>
         </td>
@@ -74,7 +74,6 @@
           <dt><a href="#allow_null-spec"><code>allow_null</code></a></dt>
         </dl>
       </dd>
-
     </dl>
     <hr>
 
@@ -91,13 +90,12 @@
     <p><code>handle</code> is a smart pointer to a Python object type; it
     holds a pointer of type <code>T*</code>, where T is its template
     parameter. <code>T</code> must be either a type derived from
-    <code>PyObject</code> or a <a href="definitions.html#POD">POD</a>
-    type whose initial <code>sizeof(PyObject)</code> bytes are
-    layout-compatible with <code>PyObject</code>. Use
-    <code>handle&lt;&gt;</code> at the boundary between tehe
-    Python/'C' API and high-level code; prefer <code><a
+    <code>PyObject</code> or a <a href="definitions.html#POD">POD</a> type
+    whose initial <code>sizeof(PyObject)</code> bytes are layout-compatible
+    with <code>PyObject</code>. Use <code>handle&lt;&gt;</code> at the
+    boundary between the Python/'C' API and high-level code; prefer <code><a
     href="object.html#object-spec">object</a></code> for a generalized
-    interface to Python objects.
+    interface to Python objects.</p>
 
     <p><a name="upcast"></a>In this document, the term "upcast" refers to an
     operation which converts a pointer <code>Y*</code> to a base class
@@ -154,6 +152,7 @@ namespace boost { namespace python
       T* operator-&gt; () const;
       T&amp; operator* () const;
       T* get() const;
+      void reset();
       T* release();
 
       operator bool_type() const; // never throws
@@ -173,7 +172,8 @@ virtual ~handle();
 </pre>
 
     <dl class="function-semantics">
-      <dt><b>Effects:</b> <code>Py_XDECREF(m_p)</code></dt>
+      <dt><b>Effects:</b>
+      <code>Py_XDECREF(</code><i>upcast</i><code>&lt;PyObject*&gt;(m_p))</code></dt>
     </dl>
 <pre>
 template &lt;class Y&gt;
@@ -181,7 +181,9 @@ explicit handle(detail::borrowed&lt;null_ok&lt;Y&gt; &gt;* p);
 </pre>
 
     <dl class="function-semantics">
-      <dt><b>Effects:</b> <code>Py_XDECREF(m_p)</code></dt>
+      <dt><b>Effects:</b>
+      <code>Py_XINCREF(</code><i>upcast</i><code>&lt;PyObject*&gt;(p));
+      m_p&nbsp;=&nbsp;</code><i>upcast</i><code>&lt;T*&gt;(p);</code></dt>
     </dl>
 <pre>
 template &lt;class Y&gt;
@@ -190,7 +192,8 @@ explicit handle(null_ok&lt;detail::borrowed&lt;Y&gt; &gt;* p);
 
     <dl class="function-semantics">
       <dt><b>Effects:</b>
-      <code>m_p&nbsp;=&nbsp;</code><i>upcast</i><code>&lt;T*&gt;(p);</code></dt>
+      <code>Py_XINCREF(</code><i>upcast</i><code>&lt;PyObject*&gt;(p));
+      m_p&nbsp;=&nbsp;</code><i>upcast</i><code>&lt;T*&gt;(p);</code></dt>
     </dl>
 <pre>
 template &lt;class Y&gt;
@@ -199,7 +202,8 @@ explicit handle(detail::borrowed&lt;Y&gt;* p);
 
     <dl class="function-semantics">
       <dt><b>Effects:</b>
-      <code>m_p&nbsp;=&nbsp;</code><i>upcast</i><code>&lt;T*&gt;(<a href=
+      <code>Py_XINCREF(</code><i>upcast</i><code>&lt;PyObject*&gt;(p));
+      m_p&nbsp;=&nbsp;</code><i>upcast</i><code>&lt;T*&gt;(<a href=
       "errors.html#expect_non_null-spec">expect_non_null</a>(p));</code></dt>
     </dl>
 <pre>
@@ -209,7 +213,7 @@ explicit handle(null_ok&lt;Y&gt;* p);
 
     <dl class="function-semantics">
       <dt><b>Effects:</b>
-      <code>Py_XINCREF(p);&nbsp;m_p&nbsp;=&nbsp;</code><i>upcast</i><code>&lt;T*&gt;(p);</code></dt>
+      <code>m_p&nbsp;=&nbsp;</code><i>upcast</i><code>&lt;T*&gt;(p);</code></dt>
     </dl>
 <pre>
 template &lt;class Y&gt;
@@ -218,8 +222,7 @@ explicit handle(Y* p);
 
     <dl class="function-semantics">
       <dt><b>Effects:</b>
-      <code>Py_XINCREF(p);&nbsp;m_p&nbsp;=&nbsp;</code><i>upcast</i><code>&lt;T*&gt;(<a
-       href=
+      <code>m_p&nbsp;=&nbsp;</code><i>upcast</i><code>&lt;T*&gt;(<a href=
       "errors.html#expect_non_null-spec">expect_non_null</a>(p));</code></dt>
     </dl>
 <pre>
@@ -237,7 +240,7 @@ handle(handle const&amp; r);
 
     <dl class="function-semantics">
       <dt><b>Effects:</b>
-      <code>m_p&nbsp;=&nbsp;r.m_p;&nbsp;Py_XINCREF(m_p);</code></dt>
+      <code>m_p&nbsp;=&nbsp;r.m_p;&nbsp;Py_XINCREF(</code><i>upcast</i><code>&lt;PyObject*&gt;(m_p));</code></dt>
     </dl>
 
     <h4><a name="handle-spec-modifiers">Class <code>handle</code>
@@ -250,7 +253,8 @@ handle&amp; operator=(handle&lt;Y&gt; const &amp; r); // never throws
 
     <dl class="function-semantics">
       <dt><b>Effects:</b>
-      <code>Py_XINCREF(r.m_p);&nbsp;Py_XDECREF(m_p);&nbsp;m_p&nbsp;=&nbsp;r.m_p;</code></dt>
+      <code>Py_XINCREF(</code><i>upcast</i><code>&lt;PyObject*&gt;(r.m_p));&nbsp;Py_XDECREF(</code><i>
+      upcast</i><code>&lt;PyObject*&gt;(m_p));&nbsp;m_p&nbsp;=&nbsp;r.m_p;</code></dt>
     </dl>
 <pre>
 T* release();
@@ -260,6 +264,14 @@ T* release();
       <dt><b>Effects:</b> <code>T* x = m_p;&nbsp;m_p&nbsp;=&nbsp;0;return
       x;</code></dt>
     </dl>
+<pre>
+void reset();
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Effects:</b>
+      <code>*this&nbsp;=&nbsp;handle&lt;T&gt;();</code></dt>
+    </dl>
 
     <h4><a name="handle-spec-observers">Class <code>handle</code>
     observers</a></h4>
@@ -291,27 +303,26 @@ operator bool_type() const; // never throws
 
     <h3><a name="borrowed-spec"></a><code>borrowed</code></h3>
 <pre>
-template <class T>
-detail::borrowed<T>* borrowed(T* p)
+template &lt;class T&gt;
+detail::borrowed&lt;T&gt;* borrowed(T* p)
 {
-    return (detail::borrowed<T>*)p;
+    return (detail::borrowed&lt;T&gt;*)p;
 }
 </pre>
 
     <h3><a name="allow_null-spec"></a><code>allow_null</code></h3>
-
 <pre>
-template <class T>
-null_ok<T>* allow_null(T* p)
+template &lt;class T&gt;
+null_ok&lt;T&gt;* allow_null(T* p)
 {
-    return (null_ok<T>*)p;
+    return (null_ok&lt;T&gt;*)p;
 }
 </pre>
 
-
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     03 October, 2002 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+     13 November, 2002 
+    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p class="c4">&copy; Copyright <a href=

doc/v2/has_back_reference.html

@@ -26,7 +26,7 @@
         </td>
 
         <td valign="top">
-          <h1 class="c1">Boost.Python</h1>
+          <h1 class="c1"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 class="c2">Header
           &lt;boost/python/has_back_reference.hpp&gt;</h2>
@@ -202,8 +202,8 @@ BOOST_PYTHON_MODULE(back_references)
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     29 September, 2002 
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p class="c3">&copy; Copyright <a href=

doc/v2/header.html

@@ -13,7 +13,7 @@
           "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header &lt;{{header}}&gt;</h2>
     </table>
@@ -279,8 +279,8 @@ namespace boost
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     05 November, 2001 
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 
 
     <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave

doc/v2/implicit.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header &lt;boost/python/implicit.hpp&gt;</h2>
         </td>
@@ -149,8 +149,8 @@ BOOST_PYTHON_MODULE(implicit_ext)
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     29 September, 2002 
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=

doc/v2/init.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Headers &lt;boost/python/init.hpp&gt;</h2>
         </td>
@@ -237,8 +237,8 @@ class_&lt;X&gt;("X", "This is X's docstring.",
     <hr>
     Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     1 October, 2002 
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
      
 
     <p><i>&copy; Copyright <a href=

doc/v2/instance_holder.html

@@ -22,7 +22,7 @@
           "0"></a></h3>
 
         <td valign="top">
-          <h1 class="c1">Boost.Python</h1>
+          <h1 class="c1"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 class="c2">Header &lt;boost/python/instance_holder.hpp&gt;</h2>
     </table>
@@ -199,8 +199,8 @@ struct pointer_holder : instance_holder
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     29 May, 2002 
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 
 
     <p class="c4">&copy; Copyright <a href= 

doc/v2/iterator.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header &lt;boost/python/iterator.hpp&gt;</h2>
         </td>
@@ -383,8 +383,8 @@ BOOST_PYTHON_MODULE(demo)
       <dd>
         <p>Revised 
         <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-         29 September, 2002 
-        <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
         </p>
 
         <p><i>&copy; Copyright <a href=

doc/v2/list.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header &lt;boost/python/list.hpp&gt;</h2>
         </td>

doc/v2/long.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header &lt;boost/python/long.hpp&gt;</h2>
         </td>

doc/v2/lvalue_from_pytype.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header
           &lt;boost/python/lvalue_from_pytype.hpp&gt;</h2>
@@ -238,8 +238,10 @@ static MemberType&amp; execute(InstanceType&amp; c);
 
     <h3>C++ module definition</h3>
 <pre>
-#include &lt;boost/python/reference.hpp&gt;
 #include &lt;boost/python/module.hpp&gt;
+#include &lt;boost/python/handle.hpp&gt;
+#include &lt;boost/python/borrowed.hpp&gt;
+#include &lt;boost/python/lvalue_from_pytype.hpp&gt;
 
 // definition lifted from the Python docs
 typedef struct {
@@ -247,7 +249,7 @@ typedef struct {
 } noddy_NoddyObject;
 
 using namespace boost::python;
-static reference&lt;PyObject&gt; cache;
+static handle&lt;noddy_NoddyObject&gt; cache;
 
 bool is_cached(noddy_NoddyObject* x)
 {
@@ -256,7 +258,7 @@ bool is_cached(noddy_NoddyObject* x)
 
 void set_cache(noddy_NoddyObject* x)
 {
-   cache.reset((PyObject*)x, ref::increment_count);
+   cache = handle&lt;noddy_NoddyObject&gt;(borrowed(x));
 }
 
 BOOST_PYTHON_MODULE(noddy_cache)
@@ -285,8 +287,8 @@ BOOST_PYTHON_MODULE(noddy_cache)
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     29 September, 2001 
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  20 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=

doc/v2/make_function.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header
           &lt;boost/python/make_function.hpp&gt;</h2>
@@ -170,8 +170,8 @@ BOOST_PYTHON_MODULE(make_function_test)
 
     <p>
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     29 September 2002 
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=

doc/v2/manage_new_object.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header
           &lt;boost/python/manage_new_object.hpp&gt;</h2>
@@ -131,8 +131,8 @@ BOOST_PYTHON_MODULE(my_module)
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     29 September 2002 
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=

doc/v2/module.html

@@ -13,7 +13,7 @@
           "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header &lt;boost/python/module.hpp&gt;</h2>
     </table>
@@ -99,8 +99,8 @@ RuntimeError: Unidentifiable C++ Exception
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     2 October, 2002
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 
 
     <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave

doc/v2/numeric.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header &lt;boost/python/numeric.hpp&gt;</h2>
         </td>

doc/v2/object.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header &lt;boost/python/object.hpp&gt;</h2>
         </td>
@@ -919,8 +919,8 @@ object sum_items(object seq)
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     02 October, 2002 
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=

doc/v2/opaque_pointer_converter.html

@@ -0,0 +1,142 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="../boost.css">
+
+    <title>Boost.Python - &lt;boost/python/opaque_pointer_converter.hpp&gt;</title>
+  </head>
+
+  <body>
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../../index.htm"><img height="86" width="277"
+          alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+        </td>
+
+        <td valign="top">
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
+
+          <h2 align="center">Header
+          &lt;boost/python/opaque_pointer_converter.hpp&gt;</h2>
+        </td>
+      </tr>
+    </table>
+    <hr>
+
+    <h2>Contents</h2>
+
+    <dl class="page-index">
+      <dt><a href="#classes">Classes</a></dt>
+
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#opaque_pointer_converter-spec">Class template
+          <code>opaque_pointer_converter&lt;P&gt;</code></a></dt>
+
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#opaque_pointer_converter-spec-synopsis">Class template
+              <code>opaque_pointer_converter</code> synopsis</a></dt>
+            </dl>
+          </dd>
+        </dl>
+      </dd>
+
+      <dt><a href="#macros">Macros</a></dt>
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID-spec">Macro
+          <code>BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID</code></a></dt>
+        </dl>
+      </dd>
+
+      <dt><a href="#examples">Example</a></dt>
+
+      <dt><a href="#see-also">See Also</a></dt>
+    </dl>
+    <hr>
+
+    <h2><a name="classes"></a>Classes</h2>
+
+    <h3><a name="opaque_pointer_converter-spec"></a>Class template
+    <code>opaque_pointer_converter&lt;P&gt;</code></h3>
+
+    <p><code>opaque_pointer_converter&lt;&gt;</code> is derived from 
+          <a href="to_python_converter.html#to_python_converter-spec">
+            <code>to_python_converter</code></a>
+          and registers itself as an
+          <a href="lvalue_from_pytype.html#lvalue_from_pytype-spec">
+            <code>lvalue_from_pytype</code></a> converter from Python objects
+          into pointers to undefined types.
+            Thus it may be used as a converter from opaque pointers into
+          Python objects and vice versa.</p>
+
+    <h4><a name="opaque_pointer_converter-spec-synopsis"></a>Class template
+    <code>opaque_pointer_converter</code> synopsis</h4>
+<pre>
+namespace boost { namespace python
+{
+    template&lt;class Pointer&gt;
+    struct opaque_pointer_converter
+        : to_python_converter&lt;
+          Pointer, opaque_pointer_converter&lt;Pointer&gt; &gt;
+    {
+        explicit opaque_pointer_converter(char const* name);
+    };
+}}
+</pre>
+
+    <h4><a name="opaque_pointer_converter-spec-constructor"></a>Class template
+    <code>opaque_pointer_converter</code> constructor</h4>
+<pre>
+explicit opaque_pointer_converter(char const* name);
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Effects:</b>
+            <p>Registers the instance as a 
+            <a href="lvalue_from_pytype.html#lvalue_from_pytype-spec">
+              <code>lvalue_from_pytype</code></a> converter from Python objects
+            into opaque pointers.</p>
+            <p>The name is used for the type of the Python Objects created;
+              it should be printable but needn't be an 
+              <a href="definitions.html#ntbs">ntbs</a> because the object type is
+              not supposed to be user constructible within python scripts.</p>
+          </dt>
+    </dl>
+
+    <h2><a name="macros"></a>Macros</h2>
+
+    <h3><a name="BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID-spec"></a>
+      Macro BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID(Pointee)</h3>
+    <p>This macro must be used to define specializations of the 
+      <a href="type_id.html#type_id-spec">type_id</a> function
+      which can't be instantiated for incomplete types.</p>
+    <h4>Note</h4>
+    <p>In order for this to work in a cross-module environment the macro must
+      be invoked in every translation unit which uses the
+      opaque_pointer_converter.</p>
+
+    <h2><a name="examples"></a>Example</h2>
+
+        please see example for <a href="return_opaque_pointer.html#example">
+          return_opaque_pointer</a>.
+
+    <h2><a name="see-also"></a>See Also</h2>
+        <p>
+          <a href="return_opaque_pointer.html">return_opaque_pointer</a>
+        </p>
+
+    <p>Revised 
+  10 March, 2003
+    </p>
+
+    <p><i>&copy; Copyright 2003 Haufe Mediengruppe. All Rights
+    Reserved.</i></p>
+  </body>
+</html>
+

doc/v2/operators.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header &lt;boost/python/operators.hpp&gt;</h2>
         </td>
@@ -876,7 +876,8 @@ BOOST_PYTHON_MODULE(demo)
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     29 Sept, 2002 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=

doc/v2/overloads.html

@@ -20,7 +20,7 @@
         </td>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header &lt;boost/python/overloads.hpp&gt;</h2>
         </td>
@@ -180,7 +180,7 @@ tuple f(int x = 1, double y = 4.25, char const* z = &quot;wow&quot;)
 
 BOOST_PYTHON_FUNCTION_OVERLOADS(f_overloads, f, 0, 3)
 
-stryct Y {};
+struct Y {};
 struct X
 {
     Y&amp; f(int x, double y = 4.25, char const* z = &quot;wow&quot;)
@@ -213,8 +213,8 @@ BOOST_PYTHON_MODULE(args_ext)
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     01 October, 2002 
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  15 December, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=

doc/v2/overview.html

@@ -13,7 +13,7 @@
           "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
     </td>
     <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
+      <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
       <h2 align="center">Overview</h2>
     </td>
   </tr>
@@ -39,7 +39,7 @@
 <hr>
 <p>Revised 
   <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  05 November, 2002 
+  13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 

doc/v2/platforms.html

@@ -0,0 +1,133 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<html>
+  <head>
+    <meta name="generator" content=
+    "HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="../boost.css">
+
+    <title>Boost.Python - Known Working Platforms and Compilers</title>
+  </head>
+
+  <body link="#0000ff" vlink="#800080">
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../../index.htm"><img height="86" width="277"
+          alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+        </td>
+
+        <td valign="top">
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
+
+          <h2 align="center">Known Working Platforms and Compilers</h2>
+        </td>
+      </tr>
+    </table>
+    <hr>
+    <b>Boost.Python</b> has been successfully tested on the following
+    platforms and compilers: 
+
+    <dl class="page-index">
+      <dt>Unix Platforms:</dt>
+
+      <dd>
+        <dl>
+          <dt>with Python <a href="http://www.python.org/2.2">2.2</a> and <a
+          href="http://www.python.org/2.2.2">2.2.2b1</a>:</dt>
+
+          <dd>
+            <dl>
+              <dt><a href="http://gcc.gnu.org">GCC</a> 2.95.3, 2.96, 3.0.4,
+              3.1, and 3.2 on <a href="http://www.redhat.com">RedHat Linux 7.3</a>
+              for Intel x86</dt>
+
+              <dt><a href=
+              "http://www.tru64unix.compaq.com/cplus/index.html">Tru64 CXX
+              6.5.1</a> on OSF v. 5.1 for Dec/Compaq Alpha</dt>
+
+              <dt><a href=
+              "http://www.sgi.com/developers/devtools/languages/mipspro.html">
+              MIPSPro 7.3.1.2m</a> on <a href=
+              "http://www.sgi.com/software/irix6.5/">IRIX 6.5</a> for SGI
+              mips</dt>
+
+              <dt><a href="http://gcc.gnu.org">GCC 3.1</a> on SunOS 5.8</dt>
+            </dl>
+          </dd>
+
+          <dt>with Python <a href=
+          "http://www.python.org/2.2.1">2.2.1</a></dt>
+
+          <dd>
+            <dl>
+              <dt><a href=
+              "http://developer.intel.com/software/products/kcc/">KCC
+              3.4d</a> on OSF v. 5.1 for Dec/Compaq Alpha</dt>
+
+              <dt><a href=
+              "http://developer.intel.com/software/products/kcc/">KCC
+              3.4d</a> on AIX</dt>
+            </dl>
+          </dd>
+        </dl>
+        <br>
+      </dd>
+
+      <dt><a href="http://www.microsoft.com/windowsxp/default.asp">Microsoft
+      Windows XP Professional</a> with Python <a href=
+      "http://www.python.org/2.2">2.2</a>, <a href=
+      "http://www.python.org/2.2.1">2.2.1</a>, and <a href=
+      "http://www.python.org/2.2.2">2.2.2b1</a>:</dt>
+
+      <dd>
+        <dl>
+          <dt><a href=
+          "http://msdn.microsoft.com/visualc/default.asp">Microsoft Visual
+          C++</a> 6, 7, and 7.1 beta</dt>
+
+          <dt><a href=
+          "http://msdn.microsoft.com/visualc/default.asp">Microsoft Visual
+          C++ 6</a> with <a href="http://www.stlport.org">STLPort
+          4.5.3</a></dt>
+
+          <dt><a href=
+          "http://www.metrowerks.com/MW/Develop/Desktop/Windows/Professional/Default.htm">
+          Metrowerks CodeWarrior</a> 7.2, 8.0, 8.2 and 8.3 beta</dt>
+
+          <dt><a href=
+          "http://www.intel.com/software/products/compilers/c60/">Intel
+          C++</a> 5.0, 6.0, and 7.0 beta</dt>
+
+          <dt><a href=
+          "http://www.intel.com/software/products/compilers/c60/">Intel C++
+          5.0</a> with <a href="http://www.stlport.org">STLPort
+          4.5.3</a></dt>
+
+          <dt><a href="http://www.cygwin.com">Cygwin</a> <a href=
+          "http://gcc.gnu.org">GCC</a> 3.0.4 and 3.2</dt>
+
+          <dt><a href="http://www.mingw.org">MinGW-1.1</a> (<a href=
+          "http://gcc.gnu.org">GCC 2.95.3-5</a>)</dt>
+
+          <dt><a href="http://www.mingw.org">MinGW-2.0</a> (<a href=
+          "http://gcc.gnu.org">GCC 3.2</a>)</dt>
+        </dl>
+      </dd>
+    </dl>
+    <hr>
+
+    <p>Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+    </p>
+
+    <p><i>&copy; Copyright <a href=
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. All Rights
+    Reserved.</i></p>
+  </body>
+</html>
+

doc/v2/pointee.html

@@ -13,7 +13,7 @@
           "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
         <td valign="top">
-          <h1 align="center">Boost.Python</h1>
+          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
           <h2 align="center">Header &lt;boost/python/pointee.hpp&gt;</h2>
     </table>
@@ -107,8 +107,8 @@ BOOST_PYTHON_MODULE(pointee_demo)
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     03 October, 2002
-    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+  13 November, 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 
 
     <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave

doc/v2/progress_reports.html

@@ -13,7 +13,7 @@
           "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
     </td>
     <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
+      <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
       <h2 align="center">Progress Reports</h2>
     </td>
   </tr>
@@ -35,7 +35,7 @@ design decisions and links to relevant discussions.
 <hr>
 <p>Revised 
   <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  18 July, 2002
+  13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a>