Release 1.47.0 beta 1

[SVN r72708]

build/Jamfile

@@ -1,99 +0,0 @@
-#  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
-#  distribute this software is granted provided this copyright notice appears
-#  in all copies. This software is provided "as is" without express or implied
-#  warranty, and with no claim as to its suitability for any purpose.
-#
-# Boost.Python library Jamfile
-
-
-# declare the location of this subproject relative to the root
-subproject libs/python/build ;
-
-# bring in the rules for python
-import python ;
-
-if [ check-python-config ]
-{
-    
-  local bpl-linkflags ;
-
-  if $(UNIX) && ( $(OS) = AIX )
-  {
-      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
-    slice.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/stl_iterator.cpp
-    object_protocol.cpp
-    object_operators.cpp
-    wrapper.cpp
-    exec.cpp
-    import.cpp
-    ;
-  
-  dll boost_python
-    : ../src/$(sources)
-    : $(BOOST_PYTHON_V2_PROPERTIES)
-      <define>BOOST_PYTHON_SOURCE
-      $(bpl-linkflags)
-        <msvc-stlport><release>$(msvc-stlport-workarounds)
-        <darwin><*><linkflags>-bind_at_load
-        <gcc-3_3-darwin><*><linkflags>-bind_at_load
-      ;
-
-  template extension
-    : <dll>boost_python
-    : <sysinclude>../../..
-    ;
-  
-  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
-    ;
-
-  install python lib
-    : <dll>boost_python <lib>boost_python
-    ;
-}

build/Jamfile.v2

@@ -1,69 +1,151 @@
+# Copyright David Abrahams 2001-2006. Distributed under the Boost
+# Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
 import os ;
+import indirect ;
 import modules ;
+import feature ;
 
 import python ;
 
-if [ python.configured ] {
+if ! [ python.configured ] && ! ( --without-python in  [ modules.peek : ARGV ] )
-    
+{
+    # Attempt default configuration of python
+    import toolset : using ;
+    using python ;
+}
 
-project boost/python
+if [ python.configured ] || ( --without-python in  [ modules.peek : ARGV ] )
-    : source-location ../src
+{
-        : requirements 
+    alias config-warning ;
-	#<include>$(PYTHON_PATH)/include
-        #  $(lib_condition)<library-path>$(PYTHON_PATH)/libs
-        #    <link>shared:<library>$(PYTHON_LIB)
-        #    <define>$(defines)
-        #: usage-requirements # requirement that will be propageted to *users* of this library
-        #  <include>$(PYTHON_PATH)/include
-
-# 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
-    slice.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/stl_iterator.cpp
-    object_protocol.cpp
-    object_operators.cpp
-    wrapper.cpp
-    import.cpp
-    exec.cpp
-    :   <link>static:<define>BOOST_PYTHON_STATIC_LIB 
-        <define>BOOST_PYTHON_SOURCE
-	<library>/python//python
-    : <link>shared
-    ;
 }
 else
 {
-    ECHO "warning: Python location is not configured" ;
+    message config-warning
-    ECHO "warning: the Boost.Python library won't be built" ;
+        : "warning: No python installation configured and autoconfiguration"
+        : "note: failed.  See http://www.boost.org/libs/python/doc/building.html"
+        : "note: for configuration instructions or pass --without-python to"
+        : "note: suppress this message and silently skip all Boost.Python targets"
+        ;
+}
+
+rule find-py3-version
+{
+    local versions = [ feature.values python ] ;
+    local py3ver ;
+    for local v in $(versions)
+    {
+        if $(v) >= 3.0
+        {
+            py3ver = $(v) ;
+        }
+    }
+    return $(py3ver) ;
+}
+
+py3-version = [ find-py3-version ] ;
+
+project boost/python
+  : source-location ../src
+  : requirements
+    -<tag>@$(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag
+    <tag>@$(__name__).tag
+  ;
+
+rule tag ( name : type ? : property-set )
+{
+    local result = $(name) ;
+    if $(type) in STATIC_LIB SHARED_LIB IMPORT_LIB
+    {
+        if $(name) = boost_python && $(PYTHON_ID)
+        {
+            result = $(result)-$(PYTHON_ID) ;
+        }
+    }
+    
+    # forward to the boost tagging rule
+    return  [ indirect.call $(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag 
+                $(result) : $(type) : $(property-set) ] ;
+}
+
+rule cond ( test ? : yes * : no * ) { if $(test) { return $(yes) ; } else { return $(no) ; } }
+rule unless ( test ? : yes * : no * ) { if ! $(test) { return $(yes) ; } else { return $(no) ; } }
+
+rule lib_boost_python ( is-py3 ? )
+{
+
+    lib [ cond $(is-py3) : boost_python3 : boost_python ]
+        : # sources
+        numeric.cpp
+        list.cpp
+        long.cpp
+        dict.cpp
+        tuple.cpp
+        str.cpp
+        slice.cpp
+
+        converter/from_python.cpp
+        converter/registry.cpp
+        converter/type_id.cpp
+        object/enum.cpp
+        object/class.cpp
+        object/function.cpp
+        object/inheritance.cpp
+        object/life_support.cpp
+        object/pickle_support.cpp
+        errors.cpp
+        module.cpp
+        converter/builtin_converters.cpp
+        converter/arg_to_python_base.cpp
+        object/iterator.cpp
+        object/stl_iterator.cpp
+        object_protocol.cpp
+        object_operators.cpp
+        wrapper.cpp
+        import.cpp
+        exec.cpp
+        object/function_doc_signature.cpp
+        :   # requirements
+            <link>static:<define>BOOST_PYTHON_STATIC_LIB 
+            <define>BOOST_PYTHON_SOURCE
+          
+            # On Windows, all code using Python has to link to the Python
+            # import library.
+            #
+            # On *nix we never link libboost_python to libpython.  When
+            # extending Python, all Python symbols are provided by the
+            # Python interpreter executable.  When embedding Python, the
+            # client executable is expected to explicitly link to
+            # /python//python (the target representing libpython) itself.
+            #
+            # python_for_extensions is a target defined by Boost.Build to
+            # provide the Python include paths, and on Windows, the Python
+            # import library, as usage requirements.
+            [ cond [ python.configured ] : <library>/python//python_for_extensions ]
+            
+            # we prevent building when there is no python available
+            # as it's not possible anyway, and to cause dependents to
+            # fail to build
+            [ unless [ python.configured ] : <build>no ]
+            <dependency>config-warning
+
+            <python-debugging>on:<define>BOOST_DEBUG_PYTHON
+            [ cond $(is-py3) : <python>$(py3-version) ]
+        :   # default build
+            <link>shared
+        :   # usage requirements
+            <link>static:<define>BOOST_PYTHON_STATIC_LIB
+            <python-debugging>on:<define>BOOST_DEBUG_PYTHON
+        ;
+
+}
+
+lib_boost_python ;
+boost-install boost_python ;
+
+if $(py3-version)
+{
+    lib_boost_python yes ;
+    boost-install boost_python3 ;
 }

build/VisualStudio/boost_python.dsp

@@ -1,910 +0,0 @@
-# Microsoft Developer Studio Project File - Name="boost_python" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
-
-CFG=BOOST_PYTHON - WIN32 RELEASE
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE 
-!MESSAGE NMAKE /f "boost_python.mak".
-!MESSAGE 
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE 
-!MESSAGE NMAKE /f "boost_python.mak" CFG="BOOST_PYTHON - WIN32 RELEASE"
-!MESSAGE 
-!MESSAGE Possible choices for configuration are:
-!MESSAGE 
-!MESSAGE "boost_python - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "boost_python - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE 
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-MTL=midl.exe
-RSC=rc.exe
-
-!IF  "$(CFG)" == "boost_python - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "../bin-stage"
-# PROP Intermediate_Dir "release-obj"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-F90=df.exe
-# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "BPL_EXPORTS" /YX /FD /Zm800 /Zm800 /Zm800 /c
-# ADD CPP /nologo /MD /W3 /GR /GX /O2 /I "../../../../" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "BOOST_PYTHON_DYNAMIC_LIB" /D "BOOST_PYTHON_SOURCE" /FD /Zm800 /Zm800 /Zm800 /Zm800 /c
-# SUBTRACT CPP /YX
-# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x1409 /d "NDEBUG"
-# ADD RSC /l 0x1409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
-# ADD LINK32 kernel32.lib user32.lib /nologo /dll /machine:I386
-
-!ELSEIF  "$(CFG)" == "boost_python - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "../bin-stage"
-# PROP Intermediate_Dir "debug-obj"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-F90=df.exe
-# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "BPL_EXPORTS" /YX /FD /Zm800 /Zm800 /Zm800 /GZ /c
-# ADD CPP /nologo /MDd /W3 /GR /GX /Zi /Od /I "../../../../" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "BOOST_PYTHON_DYNAMIC_LIB" /D "BOOST_PYTHON_SOURCE" /FD /Zm800 /Zm800 /Zm800 /Zm800 /Zm800 /GZ /c
-# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x1409 /d "_DEBUG"
-# ADD RSC /l 0x1409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib /nologo /dll /incremental:no /debug /machine:I386 /out:"../bin-stage/boost_python_debug.dll" /pdbtype:sept
-
-!ENDIF 
-
-# Begin Target
-
-# Name "boost_python - Win32 Release"
-# Name "boost_python - Win32 Debug"
-# Begin Group "Source Files"
-
-# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
-# Begin Source File
-
-SOURCE=..\..\src\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\slice.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\object\stl_iterator.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\str.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\tuple.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\converter\type_id.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\wrapper.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\import.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\exec.cpp
-# End Source File
-# End Group
-# Begin Group "Header Files"
-
-# PROP Default_Filter "h;hpp;hxx;hm;inl"
-# Begin Group "detail"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\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\stl_iterator_core.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\value_holder.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\value_holder_fwd.hpp
-# End Source File
-# End Group
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\arg_from_python.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\args.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\args_fwd.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\back_reference.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\base_type_traits.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\bases.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\borrowed.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\call.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\call_method.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\cast.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\class.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\class_fwd.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\copy_const_reference.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\copy_non_const_reference.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\data_members.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\def.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\default_call_policies.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\dict.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\enum.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\errors.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\exception_translator.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\extract.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\handle.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\handle_fwd.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\has_back_reference.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\implicit.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\init.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\instance_holder.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\iterator.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\list.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\long.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\lvalue_from_pytype.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\make_function.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\manage_new_object.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\module.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\module_init.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\numeric.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object_attributes.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object_call.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object_core.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object_fwd.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object_items.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object_operators.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object_protocol.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object_protocol_core.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object_slices.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\operators.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\operators2.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\other.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\overloads.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\pointee.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\proxy.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\ptr.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\refcount.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\reference_existing_object.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\return_internal_reference.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\return_value_policy.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\scope.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\self.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\signature.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\slice_nil.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\stl_iterator.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\str.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\tag.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\to_python_converter.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\to_python_indirect.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\to_python_value.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\tuple.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\type_id.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\with_custodian_and_ward.hpp
-# End Source File
-# End Group
-# Begin Group "Resource Files"
-
-# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
-# End Group
-# End Target
-# End Project

build/VisualStudio/boost_python.dsw

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

class.cpp

@@ -0,0 +1,28 @@
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#include <boost/python/module.hpp>
+#include <boost/python/def.hpp>
+#include <boost/python/object.hpp>
+#include <boost/python/class.hpp>
+
+using namespace boost::python;
+
+struct X
+{
+    int x;
+    X(int n) : x(n) { }
+};
+
+int x_function(X& x)
+{   return x.x;
+}
+
+
+BOOST_PYTHON_MODULE(class_ext)
+{
+    class_<X>("X", init<int>());
+    def("x_function", x_function);
+}
+
+#include "module_tail.cpp"

doc/Jamfile

@@ -0,0 +1,23 @@
+# Copyright David Abrahams 2006. Distributed under the Boost
+# Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+import docutils ;
+
+import path ;
+sources = building.rst ;
+bases = $(sources:S=) ;
+  
+# This is a path relative to the html/ subdirectory where the
+# generated output will eventually be moved.
+stylesheet = "--stylesheet=../../../rst.css" ;
+
+for local b in $(bases)
+{
+    html $(b) : $(b).rst : 
+      
+    <docutils-html>"-gdt --source-url="./$(b).rst" --link-stylesheet --traceback --trim-footnote-reference-space --footnote-references=superscript "$(stylesheet)
+  ;
+}
+
+alias htmls : $(bases) ;
+stage . : $(bases) ;

doc/PyConDC_2003/bpl.html

@@ -1,5 +1,11 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=

doc/PyConDC_2003/bpl.txt

@@ -1 +1,5 @@
+.. Copyright David Abrahams 2006. Distributed under the Boost
+.. Software License, Version 1.0. (See accompanying
+.. file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
 This file has been moved to http://www.boost-consulting.com/writing/bpl.txt.

doc/PyConDC_2003/bpl_mods.txt

@@ -1,3 +1,7 @@
+Copyright David Abrahams 2006. Distributed under the Boost
+Software License, Version 1.0. (See accompanying
+file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
 .. This is a comment. Note how any initial comments are moved by
    transforms to after the document title, subtitle, and docinfo.
 
@@ -23,7 +27,6 @@
           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

doc/PyConDC_2003/default.css

@@ -1,10 +1,10 @@
 /*
 :Author: David Goodger
 :Contact: goodger@users.sourceforge.net
-:date: $Date$
-:version: $Revision$
 :copyright: This stylesheet has been placed in the public domain.
 
+boostinspect:nolicense
+
 Default cascading style sheet for the HTML output of Docutils.
 */
 

doc/boost.css

@@ -1,3 +1,7 @@
+/* Copyright David Abrahams 2006. Distributed under the Boost
+   Software License, Version 1.0. (See accompanying 
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
 H1
 {
     FONT-SIZE: 200%

doc/building.rst

@@ -0,0 +1,680 @@
+.. Copyright David Abrahams 2006. Distributed under the Boost
+.. Software License, Version 1.0. (See accompanying
+.. file LICENSE_1_0.txt or copy at
+.. http://www.boost.org/LICENSE_1_0.txt)
+
+==============================================
+ |(logo)|__ Boost.Python Build and Test HOWTO
+==============================================
+
+.. |(logo)| image:: ../../../boost.png
+   :alt: Boost C++ Libraries:
+   :class: boost-logo
+
+__ ../index.html
+
+
+.. section-numbering::
+   :depth: 2
+
+.. contents:: Contents
+   :depth: 2
+   :class: sidebar small
+
+.. |newer| replace:: *newer*
+
+Requirements
+============
+
+Boost.Python requires `Python 2.2`_ [#2.2]_ *or* |newer|__.  
+
+.. _Python 2.2: http://www.python.org/2.2
+__ http://www.python.org
+
+Background
+==========
+
+There are two basic models for combining C++ and Python:
+
+- extending_, in which the end-user launches the Python interpreter
+  executable and imports Python “extension modules” written in C++.
+  Think of taking a library written in C++ and giving it a Python
+  interface so Python programmers can use it.  From Python, these
+  modules look just like regular Python modules.
+
+- embedding_, in which the end-user launches a program written
+  in C++ that in turn invokes the Python interpreter as a library
+  subroutine.  Think of adding scriptability to an existing
+  application.
+
+.. _extending: http://www.python.org/doc/current/ext/intro.html
+.. _embedding: http://www.python.org/doc/current/ext/embedding.html
+
+The key distinction between extending and embedding is the location
+of the C++ ``main()`` function: in the Python interpreter executable,
+or in some other program, respectively.  Note that even when
+embedding Python in another program, `extension modules are often
+the best way to make C/C++ functionality accessible to Python
+code`__, so the use of extension modules is really at the heart of
+both models.
+
+__ http://www.python.org/doc/current/ext/extending-with-embedding.html
+
+Except in rare cases, extension modules are built as
+dynamically-loaded libraries with a single entry point, which means
+you can change them without rebuilding either the other extension
+modules or the executable containing ``main()``.
+
+.. _quickstart:
+
+No-Install Quickstart
+=====================
+
+There is no need to “install Boost” in order to get started using
+Boost.Python.  These instructions use Boost.Build_ projects,
+which will build those binaries as soon as they're needed.  Your
+first tests may take a little longer while you wait for
+Boost.Python to build, but doing things this way will save you from
+worrying about build intricacies like which library binaries to use
+for a specific compiler configuration and figuring out the right
+compiler options to use yourself.
+
+.. .. raw:: html
+
+   <div style="width:50%">
+
+.. Note:: Of course it's possible to use other build systems to
+   build Boost.Python and its extensions, but they are not
+   officially supported by Boost.  Moreover **99% of all “I can't
+   build Boost.Python” problems come from trying to use another
+   build system** without first following these instructions.
+
+   If you want to use another system anyway, we suggest that you
+   follow these instructions, and then invoke ``bjam`` with the
+
+   .. parsed-literal::
+
+     ``-a -o``\ *filename* 
+
+   options to dump the build commands it executes to a file, so
+   you can see what your alternate build system needs to do.
+
+.. .. raw:: html
+ 
+   </div>
+
+.. _Boost.Build: ../../../tools/build/index.html
+
+Basic Procedure
+---------------
+
+1. Get Boost; see sections 1 and 2 [`Unix/Linux`__, `Windows`__\ ] of the
+   Boost `Getting Started Guide`_.
+
+   __ ../../../more/getting_started/unix-variants.html#get-boost
+   __ ../../../more/getting_started/windows.html#get-boost
+
+2. Get the ``bjam`` build driver.  See section 5 [`Unix/Linux`__,
+   `Windows`__\ ] of the Boost `Getting Started Guide`_.
+
+   __ ../../../more/getting_started/unix-variants.html#prepare-to-use-a-boost-library-binary
+   __ ../../../more/getting_started/windows.html#prepare-to-use-a-boost-library-binary
+
+
+3. cd into the ``libs/python/example/quickstart/`` directory of your
+   Boost installation, which contains a small example project.
+
+4. Invoke ``bjam``.  Replace the “\ ``stage``\ “ argument from the
+   example invocation from section 5 of the `Getting Started
+   Guide`_ with “\ ``test``\ ,“ to build all the test targets.  Also add
+   the argument “\ ``--verbose-test``\ ” to see the output generated by
+   the tests when they are run.
+
+   On Windows, your ``bjam`` invocation might look something like:
+
+   .. parsed-literal::
+
+     C:\\boost_1_34_0\\…\\quickstart> **bjam toolset=msvc --verbose-test test**
+
+   and on Unix variants, perhaps,
+
+   .. parsed-literal::
+
+     ~/boost_1_34_0/…/quickstart$ **bjam toolset=gcc --verbose-test test**
+
+.. Admonition:: Note to Windows Users
+
+   For the sake of concision, the rest of this guide will use
+   unix-style forward slashes in pathnames instead of the
+   backslashes with which you may be more familiar.  The forward
+   slashes should work everywhere except in `Command Prompt`_
+   windows, where you should use backslashes.
+
+   .. _Command Prompt: ../../../more/getting_started/windows.html#command-prompt
+
+If you followed this procedure successfully, you will have built an
+extension module called ``extending`` and tested it by running a
+Python script called ``test_extending.py``.  You will also have
+built and run a simple application called ``embedding`` that embeds
+python.
+
+.. _Getting Started Guide: ../../../more/getting_started/index.html
+
+In Case of Trouble
+------------------
+
+If you're seeing lots of compiler and/or linker error messages,
+it's probably because Boost.Build is having trouble finding your
+Python installation.  You might want to pass the
+``--debug-configuration`` option to ``bjam`` the first few times
+you invoke it, to make sure that Boost.Build is correctly locating
+all the parts of your Python installation.  If it isn't, consider
+`Configuring Boost.Build`_ as detailed below.
+
+If you're still having trouble, Someone on one of the following
+mailing lists may be able to help:
+
+* The `Boost.Build mailing list`__ for issues related to Boost.Build
+* The Python `C++ Sig`__ for issues specifically related to Boost.Python
+
+__ http://www.boost.org/more/mailing_lists.htm#jamboost
+__ http://www.boost.org/more/mailing_lists.htm#cplussig
+
+In Case Everything Seemed to Work
+---------------------------------
+
+Rejoice!  If you're new to Boost.Python, at this point it might be
+a good idea to ignore build issues for a while and concentrate on
+learning the library by going through the tutorial_ and perhaps
+some of the `reference documentation`_, trying out what you've
+learned about the API by modifying the quickstart project.
+
+.. _reference documentation: v2/reference.html
+.. _tutorial: tutorial/index.html
+
+Modifying the Example Project
+-----------------------------
+
+If you're content to keep your extension module forever in one
+source file called |extending.cpp|_, inside your Boost
+distribution, and import it forever as ``extending``, then you can
+stop here.  However, it's likely that you will want to make a few
+changes.  There are a few things you can do without having to learn
+Boost.Build_ in depth.
+
+The project you just built is specified in two files in the current
+directory: |boost-build.jam|_, which tells ``bjam`` where it can
+find the interpreted code of the Boost build system, and
+|Jamroot|_, which describes the targets you just built.  These
+files are heavily commented, so they should be easy to modify.
+Take care, however, to preserve whitespace.  Punctuation such as
+``;`` will not be recognized as intended by ``bjam`` if it is not
+surrounded by whitespace.
+
+.. |boost-build.jam| replace:: ``boost-build.jam``
+.. _boost-build.jam: ../example/quickstart/boost-build.jam
+
+.. |Jamroot| replace:: ``Jamroot``
+.. _Jamroot: ../example/quickstart/Jamroot
+
+.. |extending.cpp| replace:: ``extending.cpp``
+.. _extending.cpp: ../example/quickstart/extending.cpp
+
+Relocate the Project
+....................
+
+You'll probably want to copy this project elsewhere so you can
+change it without modifying your Boost distribution.  To do that,
+simply
+
+a. copy the entire ``libs/python/example/quickstart/`` directory
+   into a new directory.
+
+b. In the new copies of |boost-build.jam|_ and |Jamroot|_, locate
+   the relative path near the top of the file that is clearly
+   marked by a comment, and edit that path so that it refers to the
+   same directory your Boost distribution as it referred to when
+   the file was in its original location in the
+   ``libs/python/example/quickstart/`` directory.
+
+For example, if you moved the project from
+``/home/dave/boost_1_34_0/libs/python/example/quickstart`` to
+``/home/dave/my-project``, you could change the first path in
+|boost-build.jam|_ from
+
+.. parsed-literal::
+
+  **../../../..**\ /tools/build/v2
+
+to
+
+.. parsed-literal::
+
+  **/home/dave/boost_1_34_0**\ /tools/build/v2
+
+and change the first path in |Jamroot|_ from
+
+.. parsed-literal::
+
+  **../../../..**
+
+to
+
+.. parsed-literal::
+
+  **/home/dave/boost_1_34_0**
+
+Add New or Change Names of Existing Source Files
+................................................
+
+The names of additional source files involved in building your
+extension module or embedding application can be listed in
+|Jamroot|_ right alongside ``extending.cpp`` or ``embedding.cpp``
+respectively.  Just be sure to leave whitespace around each
+filename::
+
+  … file1.cpp file2.cpp file3.cpp …
+
+Naturally, if you want to change the name of a source file you can
+tell Boost.Build about it by editing the name in |Jamroot|_.
+
+Change the Name of your Extension Module
+........................................
+
+The name of the extension module is determined by two things:
+
+1. the name in |Jamroot|_ immediately following ``python-extension``, and 
+2. the name passed to ``BOOST_PYTHON_MODULE`` in |extending.cpp|_.
+
+To change the name of the extension module from ``extending`` to
+``hello``, you'd edit |Jamroot|_, changing
+
+.. parsed-literal::
+
+  python-extension **extending** : extending.cpp ;
+
+to
+
+.. parsed-literal::
+
+  python-extension **hello** : extending.cpp ;
+
+and you'd edit extending.cpp, changing
+
+.. parsed-literal::
+
+  BOOST_PYTHON_MODULE(\ **extending**\ )
+
+to
+
+.. parsed-literal::
+
+  BOOST_PYTHON_MODULE(\ **hello**\ )
+
+Installing Boost.Python on your System
+======================================
+
+Since Boost.Python is a separately-compiled (as opposed to
+`header-only`_) library, its user relies on the services of a
+Boost.Python library binary.  
+
+.. _header-only: ../../../more/getting_started/windows.html#header-only-libraries
+
+If you need a regular installation of the Boost.Python library
+binaries on your system, the Boost `Getting Started Guide`_ will
+walk you through the steps of creating one.  If building binaries
+from source, you might want to supply the ``--with-python``
+argument to ``bjam`` (or the ``--with-libraries=python`` argument
+to ``configure``), so only the Boost.Python binary will be built,
+rather than all the Boost binaries.
+
+
+Configuring Boost.Build
+=======================
+
+As described in the `Boost.Build reference manual`__, a file called
+``user-config.jam`` in your home directory [#home-dir]_ is used to
+specify the tools and libraries available to the build system. You
+may need to create or edit ``user-config.jam`` to tell Boost.Build
+how to invoke Python, ``#include`` its headers, and link with its
+libraries.
+
+__ http://www.boost.orgdoc/html/bbv2/advanced.html#bbv2.advanced.configuration
+
+.. Admonition:: Users of Unix-Variant OSes
+
+   If you are using a unix-variant OS and you ran Boost's
+   ``configure`` script, it may have generated a
+   ``user-config.jam`` for you. [#overwrite]_ If your ``configure``\
+   /\ ``make`` sequence was successful and Boost.Python binaries
+   were built, your ``user-config.jam`` file is probably already
+   correct.
+
+If you have one fairly “standard” python installation for your
+platform, you might not need to do anything special to describe it.  If
+you haven't configured python in ``user-config.jam`` (and you don't
+specify ``--without-python`` on the Boost.Build command line),
+Boost.Build will automatically execute the equivalent of ::
+
+  import toolset : using ; 
+  using python ;
+
+which automatically looks for Python in the most likely places.
+However, that only happens when using the Boost.Python project file
+(e.g. when referred to by another project as in the quickstart_
+method).  If instead you are linking against separately-compiled
+Boost.Python binaries, you should set up a ``user-config.jam`` file
+with at least the minimal incantation above.
+
+Python Configuration Parameters
+-------------------------------
+
+If you have several versions of Python installed, or Python is
+installed in an unusual way, you may want to supply any or all of
+the following optional parameters to ``using python``.
+
+version
+  the version of Python to use.  Should be in Major.Minor
+  format, for example, ``2.3``.  Do not include the subminor
+  version (i.e. *not* ``2.5.1``).  If you have multiple Python
+  versions installed, the version will usually be the only
+  configuration argument required.
+
+cmd-or-prefix
+  preferably, a command that invokes a Python interpreter.
+  Alternatively, the installation prefix for Python libraries and
+  header files.  Only use the alternative formulation if there is
+  no appropriate Python executable available.
+
+includes
+  the ``#include`` paths for Python headers.  Normally the correct
+  path(s) will be automatically deduced from ``version`` and/or
+  ``cmd-or-prefix``.  
+
+libraries
+  the path to Python library binaries.  On MacOS/Darwin,
+  you can also pass the path of the Python framework.  Normally the
+  correct path(s) will be automatically deduced from ``version``
+  and/or ``cmd-or-prefix``. 
+
+condition
+  if specified, should be a set of Boost.Build
+  properties that are matched against the build configuration when
+  Boost.Build selects a Python configuration to use.  See examples
+  below for details.
+
+extension-suffix
+  A string to append to the name of extension
+  modules before the true filename extension.  You almost certainly
+  don't need to use this.  Usually this suffix is only used when
+  targeting a Windows debug build of Python, and will be set
+  automatically for you based on the value of the
+  |python-debugging|_ feature.  However, at least one Linux
+  distribution (Ubuntu Feisty Fawn) has a specially configured
+  `python-dbg`__ package that claims to use such a suffix.
+
+.. |python-debugging| replace:: ``<python-debugging>``
+
+__ https://wiki.ubuntu.com/PyDbgBuilds
+
+
+Examples
+--------
+
+Note that in the examples below, case and *especially whitespace* are
+significant.
+
+- If you have both python 2.5 and python 2.4 installed,
+  ``user-config.jam`` might contain::
+  
+    using python : 2.5 ;  # Make both versions of Python available 
+
+    using python : 2.4 ;  # To build with python 2.4, add python=2.4 
+                          # to your command line.
+
+  The first version configured (2.5) becomes the default.  To build
+  against python 2.4, add ``python=2.4`` to the ``bjam`` command line.
+
+- If you have python installed in an unusual location, you might
+  supply the path to the interpreter in the ``cmd-or-prefix``
+  parameter::
+
+    using python : : /usr/local/python-2.6-beta/bin/python ;
+
+- If you have a separate build of Python for use with a particular
+  toolset, you might supply that toolset in the ``condition``
+  parameter::
+
+    using python ;  # use for most toolsets
+    
+    # Use with Intel C++ toolset
+    using python 
+         : # version
+         : c:\\Devel\\Python-2.5-IntelBuild\\PCBuild\\python # cmd-or-prefix
+         : # includes
+         : # libraries
+         : <toolset>intel # condition
+         ;
+
+
+- If you have downloaded the Python sources and built both the
+  normal and the “\ `python debugging`_\ ” builds from source on
+  Windows, you might see::
+
+    using python : 2.5 : C:\\src\\Python-2.5\\PCBuild\\python ;
+    using python : 2.5 : C:\\src\\Python-2.5\\PCBuild\\python_d
+      : # includes
+      : # libs
+      : <python-debugging>on ;
+
+- You can set up your user-config.jam so a bjam built under Windows 
+  can build/test both Windows and Cygwin_ python extensions.  Just pass
+  ``<target-os>cygwin`` in the ``condition`` parameter
+  for the cygwin python installation::
+
+    # windows installation
+    using python ;
+
+    # cygwin installation
+    using python : : c:\\cygwin\\bin\\python2.5 : : : <target-os>cygwin ;
+
+  when you put target-os=cygwin in your build request, it should build
+  with the cygwin version of python: [#flavor]_
+
+    bjam target-os=cygwin toolset=gcc 
+
+  This is supposed to work the other way, too (targeting windows
+  python with a Cygwin_ bjam) but it seems as though the support in
+  Boost.Build's toolsets for building that way is broken at the
+  time of this writing.
+
+- Note that because of `the way Boost.Build currently selects target
+  alternatives`__, you might have be very explicit in your build
+  requests.  For example, given::
+
+    using python : 2.5 ; # a regular windows build
+    using python : 2.4 : : : : <target-os>cygwin ;
+
+  building with ::
+
+    bjam target-os=cygwin
+
+  will yield an error.  Instead, you'll need to write::
+
+    bjam target-os=cygwin/python=2.4
+
+.. _Cygwin: http://cygwin.com
+
+__ http://zigzag.cs.msu.su/boost.build/wiki/AlternativeSelection
+
+Choosing a Boost.Python Library Binary
+======================================
+
+If—instead of letting Boost.Build construct and link with the right
+libraries automatically—you choose to use a pre-built Boost.Python
+library, you'll need to think about which one to link with.  The
+Boost.Python binary comes in both static and dynamic flavors.  Take
+care to choose the right flavor for your application. [#naming]_
+
+The Dynamic Binary
+------------------
+
+The dynamic library is the safest and most-versatile choice:
+
+- A single copy of the library code is used by all extension
+  modules built with a given toolset. [#toolset-specific]_
+
+- The library contains a type conversion registry.  Because one
+  registry is shared among all extension modules, instances of a
+  class exposed to Python in one dynamically-loaded extension
+  module can be passed to functions exposed in another such module.
+
+The Static Binary
+-----------------
+
+It might be appropriate to use the static Boost.Python library in
+any of the following cases:
+
+- You are extending_ python and the types exposed in your
+  dynamically-loaded extension module don't need to be used by any
+  other Boost.Python extension modules, and you don't care if the
+  core library code is duplicated among them.
+
+- You are embedding_ python in your application and either:
+
+  - You are targeting a Unix variant OS other than MacOS or AIX,
+    where the dynamically-loaded extension modules can “see” the
+    Boost.Python library symbols that are part of the executable.
+
+  - Or, you have statically linked some Boost.Python extension
+    modules into your application and you don't care if any
+    dynamically-loaded Boost.Python extension modules are able to
+    use the types exposed by your statically-linked extension
+    modules (and vice-versa).
+
+``#include`` Issues
+===================
+
+1. If you should ever have occasion to ``#include "python.h"``
+   directly in a translation unit of a program using Boost.Python,
+   use ``#include "boost/python/detail/wrap_python.hpp"`` instead.
+   It handles several issues necessary for use with Boost.Python,
+   one of which is mentioned in the next section.
+
+2. Be sure not to ``#include`` any system headers before
+   ``wrap_python.hpp``.  This restriction is actually imposed by
+   Python, or more properly, by Python's interaction with your
+   operating system.  See
+   http://docs.python.org/ext/simpleExample.html for details.
+
+.. _python-debugging:
+.. _python debugging:
+
+Python Debugging Builds
+=======================
+
+Python can be built in a special “python debugging” configuration
+that adds extra checks and instrumentation that can be very useful
+for developers of extension modules.  The data structures used by
+the debugging configuration contain additional members, so **a
+Python executable built with python debugging enabled cannot be
+used with an extension module or library compiled without it, and
+vice-versa.**
+
+Since pre-built “python debugging” versions of the Python
+executable and libraries are not supplied with most distributions
+of Python, [#get-debug-build]_ and we didn't want to force our users
+to build them, Boost.Build does not automatically enable python
+debugging in its ``debug`` build variant (which is the default).
+Instead there is a special build property called
+``python-debugging`` that, when used as a build property, will
+define the right preprocessor symbols and select the right
+libraries to link with.
+
+On unix-variant platforms, the debugging versions of Python's data
+structures will only be used if the symbol ``Py_DEBUG`` is defined.
+On many windows compilers, when extension modules are built with
+the preprocessor symbol ``_DEBUG``, Python defaults to force
+linking with a special debugging version of the Python DLL.  Since
+that symbol is very commonly used even when Python is not present,
+Boost.Python temporarily undefines _DEBUG when Python.h
+is #included from ``boost/python/detail/wrap_python.hpp`` - unless
+``BOOST_DEBUG_PYTHON`` is defined.  The upshot is that if you want
+“python debugging”and you aren't using Boost.Build, you should make
+sure ``BOOST_DEBUG_PYTHON`` is defined, or python debugging will be
+suppressed.
+
+Testing Boost.Python
+====================
+
+To run the full test suite for Boost.Python, invoke ``bjam`` in the
+``libs/python/test`` subdirectory of your Boost distribution.
+
+Notes for MinGW (and Cygwin with -mno-cygwin) GCC Users
+=======================================================
+
+If you are using a version of Python prior to 2.4.1 with a MinGW
+prior to 3.0.0 (with binutils-2.13.90-20030111-1), you will need to
+create a MinGW-compatible version of the Python library; the one
+shipped with Python will only work with a Microsoft-compatible
+linker. Follow the instructions in the “Non-Microsoft” section of
+the “Building Extensions: Tips And Tricks” chapter in `Installing
+Python Modules`__ to create ``libpythonXX.a``, where ``XX``
+corresponds to the major and minor version numbers of your Python
+installation.
+
+__ http://www.python.org/doc/current/inst/index.html
+
+-----------------------------
+
+.. [#2.2] Note that although we tested earlier versions of
+   Boost.Python with Python 2.2, and we don't *think* we've done
+   anything to break compatibility, this release of Boost.Python
+   may not have been tested with versions of Python earlier than
+   2.4, so we're not 100% sure that python 2.2 and 2.3 are
+   supported.
+
+.. [#naming] Information about how to identify the
+   static and dynamic builds of Boost.Python:
+
+   * `on Windows`__
+   * `on Unix variants`__
+
+   __ ../../../more/getting_started/windows.html#library-naming
+   __ ../../../more/getting_started/unix-variants.html#library-naming
+
+.. [#toolset-specific] Because of the way most \*nix platforms
+   share symbols among dynamically-loaded objects, I'm not certain
+   that extension modules built with different compiler toolsets
+   will always use different copies of the Boost.Python library
+   when loaded into the same Python instance.  Not using different
+   libraries could be a good thing if the compilers have compatible
+   ABIs, because extension modules built with the two libraries
+   would be interoperable.  Otherwise, it could spell disaster,
+   since an extension module and the Boost.Python library would
+   have different ideas of such things as class layout. I would
+   appreciate someone doing the experiment to find out what
+   happens.
+
+.. [#overwrite] ``configure`` overwrites the existing
+   ``user-config.jam`` in your home directory
+   (if any) after making a backup of the old version.
+
+.. [#flavor] Note that the ``<target-os>cygwin`` feature is
+   different from the ``<flavor>cygwin`` subfeature of the ``gcc``
+   toolset, and you might need handle both explicitly if you also
+   have a MinGW GCC installed.
+
+.. [#home-dir] Windows users, your home directory can be
+   found by typing::
+
+     ECHO %HOMEDRIVE%%HOMEPATH%
+
+   into a `command prompt`_ window.
+
+.. [#get-debug-build] On Unix and similar platforms, a debugging
+   python and associated libraries are built by adding
+   ``--with-pydebug`` when configuring the Python build. On
+   Windows, the debugging version of Python is generated by
+   the "Win32 Debug" target of the Visual Studio project in the
+   PCBuild subdirectory of a full Python source code distribution.

doc/index.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -144,7 +147,9 @@
 
       <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="http://www.language-binding.net/pyplusplus/pyplusplus.html">Py++ Boost.Python code generator</a></dt>
+
+      <dt><a href="../pyste/index.html">Pyste Boost.Python code generator (no longer maintained)</a></dt>
 
       <dt><a href="internals.html">Internals Documentation</a></dt>
 
@@ -172,7 +177,7 @@
     <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
-    <p><i>&copy; Copyright <a href="../../../people/dave_abrahams.htm">Dave
+    <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
     Abrahams</a> 2002-2003.</i></p>
   </body>
 </html>

doc/news.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
   <meta name="generator" content=
@@ -29,7 +32,79 @@
   <hr>
 
   <dl class="page-index">
-    <dt>Current CVS</dt>
+
+    <dt>Current SVN</dt>
+    <dd>
+      <ul>
+        <li>Python 3 support:</li>
+          <ul>
+              <li>All the current Boost.Python test cases passed. Extension modules using 
+                  Boost.Python expected to support Python 3 smoothly.</li>
+              <li>Introduced <code>object.contains</code> where <code>x.contains(y)</code>
+                   is equivalent to Python code <code>y in x</code>. 
+                  Now <code>dict.has_key</code> is just a wrapper of <code>object.contains</code>.
+              </li>
+              <li>When building against Python 3, <code>str.decode</code> will be removed.</li>
+              <li>When building against Python 3, the original signature of <code>list.sort</code>, which is:
+                  <pre>void sort(object_cref cmpfunc);</pre>
+                  will change to:
+                  <pre>void sort(args_proxy const &args, kwds_proxy const &kwds);</pre>
+
+                  This is because in Python 3 <code>list.sort</code> requires all its arguments be keyword arguments.
+                  So you should call it like this:
+                  <pre>x.sort(*tuple(), **dict(make_tuple(make_tuple("reverse", true))));</pre>
+
+              </li>
+              <li>According to <a href="http://www.python.org/dev/peps/pep-3123/">PEP 3123</a>, 
+                  when building Boost.Python against Python older than 2.6, the following macros will
+                  be defined in Boost.Python header:
+                <pre>
+# define Py_TYPE(o)    (((PyObject*)(o))->ob_type)
+# define Py_REFCNT(o)  (((PyObject*)(o))->ob_refcnt)
+# define Py_SIZE(o)    (((PyVarObject*)(o))->ob_size)</pre>
+                  So extension writers can use these macro directly, to make code clean and compatible with Python 3.
+              </li>
+          </ul> 
+      </ul>
+    </dd>
+
+    <dt>1.39.0 Release</dt>
+
+    <dd>
+      <ul>
+        <li>Pythonic signatures are now automatically appended to the
+        docstrings.
+
+        <li>Use <a href="v2/docstring_options.html"
+        ><code>docstring_options.hpp</code></a> header 
+        control the content of docstrings.
+	
+	<li>This new feature increases the size of the modules by about 14%.
+        If this is not acceptable it can be turned off by defining the macro
+        BOOST_PYTHON_NO_PY_SIGNATURES. Modules compiled with and without the macro
+        defined are compatible.
+        </li>
+	<li> If BOOST_PYTHON_NO_PY_SIGNATURES is undefined, this version defines the 
+        macro BOOST_PYTHON_SUPPORTS_PY_SIGNATURES. This allows writing code that will compile
+        with older version of Boost.Python (see <a href="v2/pytype_function.html#examples">here</a>).
+        </li>
+	<li>By defining BOOST_PYTHON_PY_SIGNATURES_PROPER_INIT_SELF_TYPE, and at a cost
+        of another 14% size increase, proper pythonic type is generated for the "self"
+        parameter of the __init__ methods.
+        </li>
+        
+        <li> To support this new feature changes were made to the 
+        <a href="v2/to_python_converter.html"><code>to_python_converter.hpp</code></a>, 
+        <a href="v2/default_call_policies.html"><code>default_call_policies</code></a>,
+        <a href="v2/ResultConverter.html"><code>ResultConverter</code></a>,
+        <a href="v2/CallPolicies.html"><code>CallPolicies</code></a> and some others.
+        Efforts were made not to have interface breaking changes. 
+        </li>
+
+      </ul>
+    </dd>
+
+    <dt>12 May 2007 - 1.34.0 release</dt>
 
     <dd>
       <ul>
@@ -39,6 +114,12 @@
         <li>New <a href="v2/docstring_options.html"
         ><code>docstring_options.hpp</code></a> header to
         control the content of docstrings.
+
+        <li>Support for converting <code>void*</code> to/from python,
+        with <code><a
+        href="v2/opaque.html">opaque_pointer_converter</a></code>
+        as the return value policy.  Thanks to Niall Douglas for the
+        initial patch.
       </ul>
     </dd>
 
@@ -210,7 +291,7 @@ BOOST_PYTHON_MODULE(test)
 
     <dd><a href="mailto:Gottfried.Ganssauge-at-haufe.de">Gottfried
     Gan&szlig;auge</a> has contributed <a href=
-    "v2/opaque_pointer_converter.html">opaque pointer support</a>.<br>
+    "v2/opaque.html">opaque pointer support</a>.<br>
     <a href="mailto:nicodemus-at-globalite.com.br">Bruno da Silva de
     Oliveira</a> has contributed the exciting <a href=
     "../pyste/index.html">Pyste</a> ("Pie-steh") package.</dd>
@@ -284,7 +365,7 @@ BOOST_PYTHON_MODULE(test)
    19 November 2004 
   <!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
 
-  <p><i>&copy; Copyright <a href="../../../people/dave_abrahams.htm">Dave
+  <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
   Abrahams</a> 2002-2003.</i></p>
 </body>
 </html>

doc/polymorphism.txt

@@ -1,3 +1,8 @@
+.. Copyright David Abrahams 2006. Distributed under the Boost
+.. Software License, Version 1.0. (See accompanying
+.. file LICENSE_1_0.txt or copy at
+.. http://www.boost.org/LICENSE_1_0.txt)
+
 How Runtime Polymorphism is expressed in Boost.Python:
 -----------------------------------------------------
 

doc/projects.html

@@ -1,436 +1,466 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
-  <head>
+<head>
-    <meta name="generator" content=
+  <meta name="generator" content=
-    "HTML Tidy for Cygwin (vers 1st April 2002), see www.w3.org">
+  "HTML Tidy for Cygwin (vers 1st September 2004), see www.w3.org">
-    <meta http-equiv="Content-Type" content="text/html; charset="utf-8">
+  <meta http-equiv="Content-Type" content="text/html">
-    <link rel="stylesheet" type="text/css" href="boost.css">
+  <link rel="stylesheet" type="text/css" href="boost.css">
-
+
-    <title>Boost.Python - Projects using Boost.Python</title>
+  <title>Boost.Python - Projects using Boost.Python</title>
-  </head>
+</head>
-
+
-  <body link="#0000ff" vlink="#800080">
+<body link="#0000FF" vlink="#800080">
-    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+  <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
-    "header">
+  "header">
-      <tr>
+    <tr>
-        <td valign="top" width="300">
+      <td valign="top" width="300">
-          <h3><a href="../../../index.htm"><img height="86" width="277" alt=
+        <h3><a href="../../../index.htm"><img height="86" width="277" alt=
-          "C++ Boost" src="../../../boost.png" border="0"></a></h3>
+        "C++ Boost" src="../../../boost.png" border="0"></a></h3>
-        </td>
+      </td>
-
+
-        <td valign="top">
+      <td valign="top">
-          <h1 align="center"><a href="index.html">Boost.Python</a></h1>
+        <h1 align="center"><a href="index.html">Boost.Python</a></h1>
-
+
-          <h2 align="center">Projects using Boost.Python</h2>
+        <h2 align="center">Projects using Boost.Python</h2>
-        </td>
+      </td>
-      </tr>
+    </tr>
-    </table>
+  </table>
-    <hr>
+  <hr>
-
+
-    <h2>Introduction</h2>
+  <h2>Introduction</h2>
-
+
-    <p>This is a partial list of projects using Boost.Python. If you are
+  <p>This is a partial list of projects using Boost.Python. If you are using
-    using Boost.Python as your Python/C++ binding solution, we'd be proud to
+  Boost.Python as your Python/C++ binding solution, we'd be proud to list
-    list your project on this page. Just <a href=
+  your project on this page. Just <a href=
-    "mailto:c++-sig@python.org">post</a> a short description of your project
+  "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
+  and how Boost.Python helps you get the job done, and we'll add it to this
-    page .</p>
+  page .</p>
-    <hr>
+  <hr>
-
+
-    <h3>Data Analysis</h3>
+  <h3>Data Analysis</h3>
-
+
-    <dl class="page-index">
+  <dl class="page-index">
-      <dt><b><a href=
+    <dt><b><a href="http://www.neuralynx.com">NeuraLab</a></b></dt>
-      "http://www.neuralynx.com">NeuraLab</a></b></dt>
+
-
+    <dd>Neuralab is a data analysis environment specifically tailored for
-      <dd>Neuralab is a data analysis environment specifically tailored for
+    neural data from <a href="http://www.neuralynx.com">Neuralynx</a>
-      neural data from <a href="http://www.neuralynx.com">Neuralynx</a>
+    acquisition systems. Neuralab combines presentation quality graphics, a
-      acquisition systems. Neuralab combines presentation quality graphics, a
+    numerical analysis library, and the <a href=
-      numerical analysis library, and the <a href=
+    "http://www.python.org">Python</a> scripting engine in a single
-      "http://www.python.org">Python</a> scripting engine in a single
+    application. With Neuralab, Neuralynx users can perform common analysis
-      application. With Neuralab, Neuralynx users can perform common analysis
+    tasks with just a few mouse clicks. More advanced users can create custom
-      tasks with just a few mouse clicks. More advanced users can create
+    Python scripts, which can optionally be assigned to menus and mouse
-      custom Python scripts, which can optionally be assigned to menus and
+    clicks.</dd>
-      mouse clicks.</dd>
+  </dl>
-    </dl>
+
-
+  <dl class="page-index">
-    <dl class="page-index">
+    <dt><b>TSLib</b> - <a href="http://www.fortressinv.com">Fortress
-      <dt><b>TSLib</b> - <a href="http://www.fortressinv.com">Fortress
+    Investment Group LLC</a></dt>
-      Investment Group LLC</a></dt>
+
-
+    <dd>
-      <dd>
+      Fortress Investment Group has contracted <a href=
-        Fortress Investment Group has contracted <a href=
+      "http://www.boost-consulting.com">Boost Consulting</a> to develop core
-        "http://www.boost-consulting.com">Boost Consulting</a> to develop
+      internal financial analysis tools in C++ and to prepare Python bindings
-        core internal financial analysis tools in C++ and to prepare Python
+      for them using Boost.Python.
-        bindings for them using Boost.Python. 
+
-
+      <p>Tom Barket of Fortress writes:</p>
-        <p>Tom Barket of Fortress writes:</p>
+
-
+      <blockquote>
-        <blockquote>
+        We have a large C++ analytical library specialized for research in
-          We have a large C++ analytical library specialized for research in
+        finance and economics, built for speed and mission critical
-          finance and economics, built for speed and mission critical
+        stability. Yet Python offers us the flexibility to test out new ideas
-          stability. Yet Python offers us the flexibility to test out new
+        quickly and increase the productivity of our time versus working in
-          ideas quickly and increase the productivity of our time versus
+        C++. There are several key features which make Python stand out. Its
-          working in C++. There are several key features which make Python
+        elegance, stability, and breadth of resources on the web are all
-          stand out. Its elegance, stability, and breadth of resources on the
+        valuable, but the most important is its extensibility, due to its
-          web are all valuable, but the most important is its extensibility,
+        open source transparency. Boost.Python makes Python extensibility
-          due to its open source transparency. Boost.Python makes Python
+        extremely simple and straightforward, yet preserves a great deal of
-          extensibility extremely simple and straightforward, yet preserves a
+        power and control.
-          great deal of power and control.
+      </blockquote>
-        </blockquote>
+    </dd>
-      </dd>
+  </dl>
-    </dl>
+
-
+  <h3>Educational</h3>
-    <h3>Educational</h3>
+
-
+  <dl class="page-index">
-    <dl class="page-index">
+    <dt><a href="http://edu.kde.org/kig"><b>Kig</b></a></dt>
-      <dt><a href="http://edu.kde.org/kig"><b>Kig</b></a></dt>
+
-
+    <dd>
-      <dd>
+      <p>KDE Interactive Geometry is a high-school level educational tool,
-        <p>KDE Interactive Geometry is a high-school level educational tool,
+      built for the KDE desktop. It is a nice tool to let students work with
-        built for the KDE desktop. It is a nice tool to let students work
+      geometrical constructions. It is meant to be the most intuitive, yet
-        with geometrical constructions. It is meant to be the most intuitive,
+      featureful application of its kind.</p>
-        yet featureful application of its kind.</p>
+
-
+      <p>Versions after 0.6.x (will) support objects built by the user
-        <p>Versions after 0.6.x (will) support objects built by the user
+      himself in the Python language. The exporting of the relevant internal
-        himself in the Python language. The exporting of the relevant
+      API's were done using Boost.Python, which made the process very
-        internal API's were done using Boost.Python, which made the process
+      easy.</p>
-        very easy.</p>
+    </dd>
-      </dd>
+  </dl>
-    </dl>
+
-
+  <h3>Enterprise Software</h3>
-    <h3>Enterprise Software</h3>
+
-
+  <dl class="page-index">
-    <dl class="page-index">
+    <dt><b><a href="http://openwbem.sourceforge.net">OpenWBEM</a></b></dt>
-      <dt><b><a href="http://openwbem.sourceforge.net">OpenWBEM</a></b></dt>
+
-
+    <dd>
-      <dd>
+      The OpenWBEM project is an effort to develop an open-source
-        The OpenWBEM project is an effort to develop an open-source
+      implementation of Web Based Enterprise Management suitable for
-        implementation of Web Based Enterprise Management suitable for
+      commercial and non-commercial application
-        commercial and non-commercial application 
+
-
+      <p><a href="mailto:dnuffer@sco.com">Dan Nuffer</a> writes:</p>
-        <p><a href="mailto:dnuffer@sco.com">Dan Nuffer</a> writes:</p>
+
-
+      <blockquote>
-        <blockquote>
+        I'm using Boost.Python to wrap the client API of OpenWBEM.This will
-          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
-          make it easier to do rapid prototyping, testing, and scripting when
+        developing management solutions that use WBEM.
-          developing management solutions that use WBEM.
+      </blockquote>
-        </blockquote>
+    </dd>
-      </dd>
+
-
+    <dt><b><a href="http://www.transversal.com">Metafaq</a></b></dt>
-      <dt><b><a href="http://www.transversal.com">Metafaq</a></b></dt>
+
-
+    <dd>
-      <dd>
+      Metafaq, from <a href="http://www.transversal.com">Transversal,
-        Metafaq, from <a href="http://www.transversal.com">Transversal,
+      Inc.</a>, is an enterprise level online knowledge base management
-        Inc.</a>, is an enterprise level online knowledge base management
+      system.
-        system. 
+
-
+      <p><a href="mailto:ben.young-at-transversal.com">Ben Young</a>
-        <p><a href="mailto:ben.young-at-transversal.com">Ben Young</a>
+      writes:</p>
-        writes:</p>
+
-
+      <blockquote>
-        <blockquote>
+        Boost.Python is used in an automated process to generate python
-          Boost.Python is used in an automated process to generate python
+        bindings to our api which is exposed though multiple backends and
-          bindings to our api which is exposed though multiple backends and
+        frontends. This allows us to write quick tests and bespoke scripts to
-          frontends. This allows us to write quick tests and bespoke scripts
+        perform one off tasks without having to go through the full
-          to perform one off tasks without having to go through the full
+        compilation cycle.
-          compilation cycle.
+      </blockquote>
-        </blockquote>
+    </dd>
-      </dd>
+  </dl>
-    </dl>
+
-
+  <h3>Games</h3>
-    <h3>Games</h3>
+
-
+  <dl>
-    <dl>
+    <dt><b><a href="http://www.firaxis.com">Civilization IV</a></b></dt>
-      <dt><b><a href="http://www.firaxis.com">Civilization IV</a></b></dt>
+  </dl>
-    </dl>
+
-
+  <blockquote>
-    <blockquote>
+    &ldquo;The fourth game in the PC strategy series that has sold over five
-      “The fourth game in the PC strategy series that has
+    million copies, Sid Meier's Civilization IV is a bold step forward for
-      sold over five million copies, Sid Meier's Civilization IV is a bold
+    the franchise, with spectacular new 3D graphics and all-new single and
-      step forward for the franchise, with spectacular new 3D graphics and
+    multiplayer content. Civilization IV will also set a new standard for
-      all-new single and multiplayer content. Civilization IV will also set a
+    user-modification, allowing gamers to create their own add-ons using
-      new standard for user-modification, allowing gamers to create their own
+    Python and XML.
-      add-ons using Python and XML. 
+
-
+    <p>Sid Meier's Civilization IV will be released for PC in late 2005. For
-      <p>Sid Meier's Civilization IV will be released for PC in late 2005.
+    more information please visit <a href=
-      For more information please visit <a href=
+    "http://www.firaxis.com">http://www.firaxis.com</a> or write <a href=
-      "http://www.firaxis.com">http://www.firaxis.com</a> or write <a href=
+    "mailto:kgilmore@firaxis.com">kgilmore@firaxis.com</a>&rdquo;</p>
-      "mailto:kgilmore@firaxis.com">kgilmore@firaxis.com</a>”</p>
+  </blockquote>
-    </blockquote>
+
-
+  <p>Boost.Python is used as the interface layer between the C++ game code
-    <p>Boost.Python is used as the interface layer between the C++ game code
+  and Python. Python is used for many purposes in the game, including map
-    and Python. Python is used for many purposes in the game, including map
+  generation, interface screens, game events, tools, tutorials, etc. Most
-    generation, interface screens, game events, tools, tutorials, etc. Most
+  high-level game operations have been exposed to Python in order to give
-    high-level game operations have been exposed to Python in order to give
+  modders the power they need to customize the game.</p>
-    modders the power they need to customize the game.</p>
+
-
+  <blockquote>
-    <blockquote>
+    -Mustafa Thamer, Civ4 Lead Programmer
-      -Mustafa Thamer, Civ4 Lead Programmer
+  </blockquote>
-    </blockquote>
+
-
+  <dl class="page-index">
-    <dl class="page-index">
+    <dt><b><a href="http://vegastrike.sourceforge.net">Vega
-      <dt><b><a href="http://vegastrike.sourceforge.net">Vega
+    Strike</a></b></dt>
-      Strike</a></b></dt>
+
-
+    <dd>
-      <dd>
+      <a href="http://vegastrike.sourceforge.net">Vega Strike</a> is the 3D
-        <a href="http://vegastrike.sourceforge.net">Vega Strike</a> is the 3D
+      Space Simulator that allows you to trade and bounty hunt in a vast
-        Space Simulator that allows you to trade and bounty hunt in a vast
+      universe. Players face dangers, decisions, piracy, and aliens.
-        universe. Players face dangers, decisions, piracy, and aliens. 
+
-
+      <p><a href="http://vegastrike.sourceforge.net">Vega Strike</a> has
-        <p><a href="http://vegastrike.sourceforge.net">Vega Strike</a> has
+      decided to base its scripting on python, using boost as the layer
-        decided to base its scripting on python, using boost as the layer
+      between the class hierarchy in python and the class hierarchy in C++.
-        between the class hierarchy in python and the class hierarchy in C++.
+      The result is a very flexible scripting system that treats units as
-        The result is a very flexible scripting system that treats units as
+      native python classes when designing missions or writing AI's.</p>
-        native python classes when designing missions or writing AI's.</p>
+
-
+      <p>A large economic and planetary simulation is currently being run in
-        <p>A large economic and planetary simulation is currently being run
+      the background in python and the results are returned back into C++ in
-        in the background in python and the results are returned back into
+      the form of various factions' spaceships appearing near worlds that
-        C++ in the form of various factions' spaceships appearing near worlds
+      they are simulated to be near in python if the player is in the general
-        that they are simulated to be near in python if the player is in the
+      neighborhood.</p>
-        general neighborhood.</p>
+    </dd>
-      </dd>
+  </dl>
-    </dl>
+
-
+  <h3>Graphics</h3>
-    <h3>Graphics</h3>
+
-
+  <dl class="page-index">
-    <dl class="page-index">
+    <dt><b><a href="http://sourceforge.net/projects/pyosg">OpenSceneGraph
-      <dt><b><a href="http://sourceforge.net/projects/pyosg">OpenSceneGraph
+    Bindings</a></b></dt>
-      Bindings</a></b></dt>
+
-
+    <dd><a href="mailto:gideon@computer.org">Gideon May</a> has created a set
-      <dd><a href="mailto:gideon@computer.org">Gideon May</a> has created a
+    of bindings for <a href=
-      set of bindings for <a href=
+    "http://www.openscenegraph.org">OpenSceneGraph</a>, a cross-platform
-      "http://www.openscenegraph.org">OpenSceneGraph</a>, a cross-platform
+    C++/OpenGL library for the real-time visualization.<br>
-      C++/OpenGL library for the real-time visualization.<br>
+    &nbsp;</dd>
-       &nbsp;</dd>
+
-
+    <dt><b><a href=
-      <dt><b><a href=
+    "http://www.slac.stanford.edu/grp/ek/hippodraw/index.html">HippoDraw</a></b></dt>
-      "http://www.slac.stanford.edu/grp/ek/hippodraw/index.html">HippoDraw</a></b></dt>
+
-
+    <dd>
-      <dd>
+      HippoDraw is a data analysis environment consisting of a canvas upon
-        HippoDraw is a data analysis environment consisting of a canvas upon
+      which graphs such as histograms, scattter plots, etc, are prsented. It
-        which graphs such as histograms, scattter plots, etc, are prsented.
+      has a highly interactive GUI interface, but some things you need to do
-        It has a highly interactive GUI interface, but some things you need
+      with scripts. HippoDraw can be run as Python extension module so that
-        to do with scripts. HippoDraw can be run as Python extension module
+      all the manipulation can be done from either Python or the GUI.
-        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>
-        <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
-        <blockquote>
+        <a href=
-          Don't have a web page for the project, but the organization's is <a
+        "http://www.slac.stanford.edu">http://www.slac.stanford.edu</a> (the
-          href=
+        first web server site in America, I installed it).
-          "http://www.slac.stanford.edu">http://www.slac.stanford.edu</a>
+      </blockquote>Which was just too cool a piece of trivia to omit.<br>
-          (the first web server site in America, I installed it).
+      &nbsp;
-        </blockquote>
+    </dd>
-        Which was just too cool a piece of trivia to omit.<br>
+
-         &nbsp;
+    <dt><a href="http://www.iplt.org"><b>IPLT</b></a></dt>
-      </dd>
+
-
+    <dd>
-      <dt><a href="http://www.iplt.org"><b>IPLT</b></a></dt>
+      <a href="mailto:ansgar.philippsen-at-unibas.ch">Ansgar Philippsen</a>
-
+      writes:
-      <dd>
+
-        <a href="mailto:ansgar.philippsen-at-unibas.ch">Ansgar Philippsen</a>
+      <blockquote>
-        writes: 
+        IPLT is an image processing library and toolbox for the structural
-
+        biology electron microscopy community. I would call it a
-        <blockquote>
+        budding/evolving project, since it is currently not in production
-          IPLT is an image processing library and toolbox for the structural
+        stage, but rather under heavy development. Python is used as the main
-          biology electron microscopy community. I would call it a
+        scripting/interaction level, but also for rapid prototyping, since
-          budding/evolving project, since it is currently not in production
+        the underlying C++ class library is pretty much fully exposed via
-          stage, but rather under heavy development. Python is used as the
+        boost.python (at least the high-level interface). The combined power
-          main scripting/interaction level, but also for rapid prototyping,
+        of C++ and Python for this project turned out to be just awesome.
-          since the underlying C++ class library is pretty much fully exposed
+      </blockquote><br>
-          via boost.python (at least the high-level interface). The combined
+      &nbsp;
-          power of C++ and Python for this project turned out to be just
+    </dd>
-          awesome.
+
-        </blockquote>
+    <dt><a href=
-        <br>
+    "http://www.procoders.net/pythonmagick"><b>PythonMagick</b></a></dt>
-         &nbsp;
+
-      </dd>
+    <dd>PythonMagick binds the <a href=
-
+    "http://www.graphicsmagick.org">GraphicsMagick</a> image manipulation
-      <dt><a href=
+    library to Python.<br>
-      "http://www.procoders.net/pythonmagick"><b>PythonMagick</b></a></dt>
+    &nbsp;</dd>
-
+
-      <dd>PythonMagick binds the <a href=
+    <dt><a href="http://www.vpython.org"><b>VPython</b></a></dt>
-      "http://www.graphicsmagick.org">GraphicsMagick</a> image manipulation
+
-      library to Python.<br>
+    <dd>
-       &nbsp;</dd>
+      <a href="mailto:Bruce_Sherwood-at-ncsu.edu">Bruce Sherwood</a> writes:
-    </dl>
+
-
+      <blockquote>
-    <h3>Scientific Computing</h3>
+        VPython is an extension for Python that makes it easy to create
-
+        navigable 3D animations, which are generated as a side effect of
-    <dl class="page index">
+        computational code. VPython is used in education for various
-      <dt><a href="http://camfr.sourceforge.net"><b>CAMFR</b></a></dt>
+        purposes, including teaching physics and programming, but it has also
-
+        been used by research scientists to visualize systems or data in 3D.
-      <dd>
+      </blockquote><br>
-        CAMFR is a photonics and electromagnetics modelling tool. Python is
+      &nbsp;
-        used for computational steering. 
+    </dd>
-
+  </dl>
-        <p><a href="mailto:Peter.Bienstman@rug.ac.be">Peter Bienstman</a>
+
-        writes:</p>
+  <h3>Scientific Computing</h3>
-
+
-        <blockquote>
+  <dl class="page index">
-          Thanks for providing such a great tool!
+    <dt><a href="http://camfr.sourceforge.net"><b>CAMFR</b></a></dt>
-        </blockquote>
+
-      </dd>
+    <dd>
-
+      CAMFR is a photonics and electromagnetics modelling tool. Python is
-      <dt><a href="http://cctbx.sourceforge.net"><b>cctbx - Computational
+      used for computational steering.
-      Crystallography Toolbox</b></a></dt>
+
-
+      <p><a href="mailto:Peter.Bienstman@rug.ac.be">Peter Bienstman</a>
-      <dd>
+      writes:</p>
-        Computational Crystallography is concerned with the derivation of
+
-        atomic models of crystal structures, given experimental X-ray
+      <blockquote>
-        diffraction data. The cctbx is an open-source library of fundamental
+        Thanks for providing such a great tool!
-        algorithms for crystallographic computations. The core algorithms are
+      </blockquote>
-        implemented in C++ and accessed through higher-level Python
+    </dd>
-        interfaces. 
+
-
+    <dt><a href="http://cctbx.sourceforge.net"><b>cctbx - Computational
-        <p>The cctbx grew together with Boost.Python and is designed from the
+    Crystallography Toolbox</b></a></dt>
-        ground up as a hybrid Python/C++ system. With one minor exception,
+
-        run-time polymorphism is completely handled by Python. C++
+    <dd>
-        compile-time polymorphism is used to implement performance critical
+      Computational Crystallography is concerned with the derivation of
-        algorithms. The Python and C++ layers are seamlessly integrated using
+      atomic models of crystal structures, given experimental X-ray
-        Boost.Python.</p>
+      diffraction data. The cctbx is an open-source library of fundamental
-
+      algorithms for crystallographic computations. The core algorithms are
-        <p>The SourceForge cctbx project is organized in modules to
+      implemented in C++ and accessed through higher-level Python interfaces.
-        facilitate use in non-crystallographic applications. The scitbx
+
-        module implements a general purpose array family for scientific
+      <p>The cctbx grew together with Boost.Python and is designed from the
-        applications and pure C++ ports of FFTPACK and the LBFGS conjugate
+      ground up as a hybrid Python/C++ system. With one minor exception,
-        gradient minimizer.</p>
+      run-time polymorphism is completely handled by Python. C++ compile-time
-      </dd>
+      polymorphism is used to implement performance critical algorithms. The
-
+      Python and C++ layers are seamlessly integrated using Boost.Python.</p>
-      <dt><a href="http://www.llnl.gov/CASC/emsolve"><b>EMSolve</b></a></dt>
+
-
+      <p>The SourceForge cctbx project is organized in modules to facilitate
-      <dd>EMSolve is a provably stable, charge conserving, and energy
+      use in non-crystallographic applications. The scitbx module implements
-      conserving solver for Maxwell's equations.<br>
+      a general purpose array family for scientific applications and pure C++
-       &nbsp;</dd>
+      ports of FFTPACK and the L-BFGS quasi-Newton minimizer.</p>
-
+    </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>
+    <dt><a href="http://www.llnl.gov/CASC/emsolve"><b>EMSolve</b></a></dt>
-
+
-      <dd>
+    <dd>EMSolve is a provably stable, charge conserving, and energy
-        Gaudi is a framework for particle physics collision data processing
+    conserving solver for Maxwell's equations.<br>
-        applications developed in the context of the LHCb and ATLAS
+    &nbsp;</dd>
-        experiments at CERN. 
+
-
+    <dt><b><a href="http://cern.ch/gaudi">Gaudi</a></b> and <b><a href=
-        <p><a href="mailto:Pere.Mato@cern.ch">Pere Mato Vila</a> writes:</p>
+    "http://cern.ch/Gaudi/RootPython/">RootPython</a></b></dt>
-
+
-        <blockquote>
+    <dd>
-          We are using Boost.Python to provide scripting/interactive
+      Gaudi is a framework for particle physics collision data processing
-          capability to our framework. We have a module called "GaudiPython"
+      applications developed in the context of the LHCb and ATLAS experiments
-          implemented using Boost.Python that allows the interaction with any
+      at CERN.
-          framework service or algorithm from python. RootPython also uses
+
-          Boost.Python to provide a generic "gateway" between the <a href=
+      <p><a href="mailto:Pere.Mato@cern.ch">Pere Mato Vila</a> writes:</p>
-          "http://root.cern.ch">ROOT</a> framework and python 
+
-
+      <blockquote>
-          <p>Boost.Python is great. We managed very quickly to interface our
+        We are using Boost.Python to provide scripting/interactive capability
-          framework to python, which is great language. We are trying to
+        to our framework. We have a module called "GaudiPython" implemented
-          facilitate to our physicists (end-users) a rapid analysis
+        using Boost.Python that allows the interaction with any framework
-          application development environment based on python. For that,
+        service or algorithm from python. RootPython also uses Boost.Python
-          Boost.Python plays and essential role.</p>
+        to provide a generic "gateway" between the <a href=
-        </blockquote>
+        "http://root.cern.ch">ROOT</a> framework and python
-      </dd>
+
-
+        <p>Boost.Python is great. We managed very quickly to interface our
-      <dt><b><a href="http://www.esss.com.br">ESSS</a></b></dt>
+        framework to python, which is great language. We are trying to
-
+        facilitate to our physicists (end-users) a rapid analysis application
-      <dd>
+        development environment based on python. For that, Boost.Python plays
-        ESSS (Engineering Simulation and Scientific Software) is a company
+        and essential role.</p>
-        that provides engineering solutions and acts in the brazilian and
+      </blockquote>
-        south-american market providing products and services related to
+    </dd>
-        Computational Fluid Dynamics and Image Analysis. 
+
-
+    <dt><b><a href="http://www.esss.com.br">ESSS</a></b></dt>
-        <p><a href="mailto:bruno@esss.com.br">Bruno da Silva de Oliveira</a>
+
-        writes:</p>
+    <dd>
-
+      ESSS (Engineering Simulation and Scientific Software) is a company that
-        <blockquote>
+      provides engineering solutions and acts in the brazilian and
-          Recently we moved our work from working exclusively with C++ to an
+      south-american market providing products and services related to
-          hybrid-language approach, using Python and C++, with Boost.Python
+      Computational Fluid Dynamics and Image Analysis.
-          providing the layer between the two. The results are great so far!
+
-        </blockquote>
+      <p><a href="mailto:bruno@esss.com.br">Bruno da Silva de Oliveira</a>
-
+      writes:</p>
-        <p>Two projects have been developed so far with this technology:</p>
+
-
+      <blockquote>
-        <p><b><a href="http://www.esss.com.br/index.php?pg=dev_projetos">Simba</a></b>
+        Recently we moved our work from working exclusively with C++ to an
-        provides 3D visualization of geological formations gattered from the
+        hybrid-language approach, using Python and C++, with Boost.Python
-        simulation of the evolution of oil systems, allowing the user to
+        providing the layer between the two. The results are great so far!
-        analyse various aspects of the simulation, like deformation, pressure
+      </blockquote>
-        and fluids, along the time of the simulation.</p>
+
-
+      <p>Two projects have been developed so far with this technology:</p>
-        <p><b><a href="http://www.esss.com.br/index.php?pg=dev_projetos">Aero</a></b>
+
-        aims to construct a CFD with brazilian technology, which involves
+      <p><b><a href=
-        various companies and universities. ESSS is responsible for various
+      "http://www.esss.com.br/index.php?pg=dev_projetos">Simba</a></b>
-        of the application modules, including GUI and post-processing of
+      provides 3D visualization of geological formations gattered from the
-        results.</p>
+      simulation of the evolution of oil systems, allowing the user to
-      </dd>
+      analyse various aspects of the simulation, like deformation, pressure
-
+      and fluids, along the time of the simulation.</p>
-      <dt><b><a href="http://www.rationaldiscovery.com">Rational Discovery
+
-      LLC</a></b></dt>
+      <p><b><a href=
-
+      "http://www.esss.com.br/index.php?pg=dev_projetos">Aero</a></b> aims to
-      <dd>
+      construct a CFD with brazilian technology, which involves various
-        Rational Discovery provides computational modeling, combinatorial
+      companies and universities. ESSS is responsible for various of the
-        library design and custom software development services to the
+      application modules, including GUI and post-processing of results.</p>
-        pharmaceutical, biotech and chemical industries. We do a substantial
+    </dd>
-        amount of internal research to develop new approaches for applying
+
-        machine-learning techniques to solve chemical problems. Because we're
+    <dt><b><a href="http://polybori.sourceforge.net/">PolyBoRi</a></b></dt>
-        a small organization and chemistry is a large and complex field, it
+
-        is essential that we be able to quickly and easily prototype and test
+    <dd>
-        new algorithms. 
+      <p><a href="mailto:brickenstein@mfo.de"
-
+        >Michael Brickenstein</a> writes:</p>
-        <p>For our internal software, we implement core data structures in C
+
-        and expose them to Python using Boost.Python. Algorithm development
+      <blockquote>
-        is done in Python and then translated to C if required (often it's
+        <p>The core of PolyBoRi is a C++ library, which provides
-        not). This hybrid development approach not only greatly increases our
+        high-level data types for Boolean polynomials and monomials,
-        productivity, but it also allows "non-developers" (people without C
+        exponent vectors, as well as for the underlying polynomial
-        experience) to take part in method development. Learning C is a
+        rings and subsets of the powerset of the Boolean variables. As
-        daunting task, but "Python fits your brain." (Thanks to Bruce Eckel
+        a unique approach, binary decision diagrams are used as
-        for the quote.)</p>
+        internal storage type for polynomial structures. On top of
-      </dd>
+        this C++-library we provide a Python interface. This allows
-    </dl>
+        parsing of complex polynomial systems, as well as sophisticated
-
+        and extendable strategies for Gr&ouml;bner basis computation.
-    <h3>Systems Libraries</h3>
+        Boost.Python has helped us to create this interface in a
-
+        very clean way.</p>
-    <dl>
+      </blockquote>
-      <dt><a href="http://itamarst.org/software"><b>Fusion</b></a></dt>
+    </dd>
-
+
-      <dd>
+    <dt><b><a href="http://www.rationaldiscovery.com">Rational Discovery
-        <p>Fusion is a library that supports implementing protocols in C++
+    LLC</a></b></dt>
-        for use with Twisted, allowing control over memory allocation
+
-        strategies, fast method calls internally, etc.. Fusion supports TCP,
+    <dd>
-        UDP and multicast, and is implemented using the Boost.Python python
+      Rational Discovery provides computational modeling, combinatorial
-        bindings.</p>
+      library design and custom software development services to the
-
+      pharmaceutical, biotech and chemical industries. We do a substantial
-        <p>Fusion is licensed under the MIT license, and available for
+      amount of internal research to develop new approaches for applying
-        download from <a href=
+      machine-learning techniques to solve chemical problems. Because we're a
-        "http://itamarst.org/software">http://itamarst.org/software</a>.</p>
+      small organization and chemistry is a large and complex field, it is
-      </dd>
+      essential that we be able to quickly and easily prototype and test new
-    </dl>
+      algorithms.
-
+
-    <h3>Tools</h3>
+      <p>For our internal software, we implement core data structures in C
-
+      and expose them to Python using Boost.Python. Algorithm development is
-    <dl>
+      done in Python and then translated to C if required (often it's not).
-      <dt><a href="http://www.jayacard.org"><b>Jayacard</b></a></dt>
+      This hybrid development approach not only greatly increases our
-
+      productivity, but it also allows "non-developers" (people without C
-      <dd>
+      experience) to take part in method development. Learning C is a
-        Jayacard aims at developing a secure portable open source operating
+      daunting task, but "Python fits your brain." (Thanks to Bruce Eckel for
-        system for contactless smart cards and a complete suite of high
+      the quote.)</p>
-        quality development tools to ease smart card OS and application
+    </dd>
-        development. 
+  </dl>
-
+
-        <p>The core of the smart card reader management is written in C++ but
+  <h3>Systems Libraries</h3>
-        all the development tools are written in the friendly Python
+
-        language. Boost plays the fundamental role of binding the tools to
+  <dl>
-        our core smart card reader library.</p>
+    <dt><a href="http://itamarst.org/software"><b>Fusion</b></a></dt>
-      </dd>
+
-    </dl>
+    <dd>
-    <hr>
+      <p>Fusion is a library that supports implementing protocols in C++ for
-
+      use with Twisted, allowing control over memory allocation strategies,
-    <p>Revised 
+      fast method calls internally, etc.. Fusion supports TCP, UDP and
-    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+      multicast, and is implemented using the Boost.Python python
-     15 July, 2003</p>
+      bindings.</p>
-
+
-    <p><i>&copy; Copyright <a href="../../../people/dave_abrahams.htm">Dave
+      <p>Fusion is licensed under the MIT license, and available for download
-    Abrahams</a> 2002-2003.</i></p>
+      from <a href=
-  </body>
+      "http://itamarst.org/software">http://itamarst.org/software</a>.</p>
+    </dd>
+  </dl>
+
+  <h3>Tools</h3>
+
+  <dl>
+    <dt><a href="http://www.jayacard.org"><b>Jayacard</b></a></dt>
+
+    <dd>
+      Jayacard aims at developing a secure portable open source operating
+      system for contactless smart cards and a complete suite of high quality
+      development tools to ease smart card OS and application development.
+
+      <p>The core of the smart card reader management is written in C++ but
+      all the development tools are written in the friendly Python language.
+      Boost plays the fundamental role of binding the tools to our core smart
+      card reader library.</p>
+    </dd>
+  </dl>
+  <hr>
+
+  <p>Revised
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+   29 May, 2008</p>
+
+  <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
+  Abrahams</a> 2002-2008.</i></p>
+</body>
 </html>
-

doc/support.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -64,7 +67,7 @@
      12 Sept, 2003 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
-    <p><i>&copy; Copyright <a href="../../../people/dave_abrahams.htm">Dave
+    <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
     Abrahams</a> 2003.</i></p>
   </body>
 </html>

doc/tutorial/doc/Jamfile.v2

@@ -1,12 +1,18 @@
+# Copyright Joel de Guzman 2006. Distributed under the Boost
+# Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 project boost/libs/python/doc/tutorial/doc ;
 
 import boostbook : boostbook ;
 using quickbook ;
 
+path-constant images : html ;
+
 boostbook tutorial
     :
         tutorial.qbk
     :
         <xsl:param>boost.root=../../../../../..
-        <xsl:param>boost.libraries=../../../../../../libs/libraries.htm
+        <format>pdf:<xsl:param>img.src.path=$(images)/
+        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/python/doc/tutorial/doc/html
     ;

doc/tutorial/doc/html/boostbook.css

@@ -1,430 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2004 Joel de Guzman
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to the Boost Software
-    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-    http://www.boost.org/LICENSE_1_0.txt)
-=============================================================================*/
-
-/*=============================================================================
-    Body defaults
-=============================================================================*/
-
-    body 
-    {
-        margin: 1em;
-        font-family: sans-serif;
-    }
-
-/*=============================================================================
-    Paragraphs
-=============================================================================*/
-
-    p 
-    {
-        text-align: justify;
-        font-size: 11pt; 
-        line-height: 1.2;
-    }
-
-/*=============================================================================
-    Program listings
-=============================================================================*/
-
-    tt.computeroutput
-    {
-        font-size: 10pt;
-    }
-
-    pre.synopsis
-    {
-        font-size: 10pt;
-        margin: 1pc 4% 0pc 4%;
-        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
-    }
-
-    .programlisting, 
-    .screen
-    {
-        font-size: 10pt;
-        display: block;
-        margin: 1pc 4% 0pc 4%;
-        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
-    }
-
-/*=============================================================================
-    Headings
-=============================================================================*/
-
-    h1, 
-    h2, 
-    h3, 
-    h4, 
-    h5, 
-    h6 
-    { 
-        text-align: left; 
-        margin-top: 2pc; 
-    }
-
-    h1 { font: 170% }
-    h2 { font: bold 140% }
-    h3 { font: bold 120% }
-    h4 { font: bold 100% }
-    h5 { font: italic 100% }
-    h6 { font: italic 100% }
-
-    /* Top page titles */
-    title, 
-    h1.title, 
-    h2.title
-    h3.title, 
-    h4.title, 
-    h5.title, 
-    h6.title, 
-    .refentrytitle
-    {
-        font-weight: bold;
-        margin-bottom: 1pc;
-    }
-
-    h1.title { font-size: 220% }
-    h2.title { font-size: 220% }
-    h3.title { font-size: 170% }
-    h4.title { font-size: 140% }
-    h5.title { font-size: 120% }
-    h6.title { font-size: 120% }
-
-/*=============================================================================
-    Lists
-=============================================================================*/
-
-    li
-    {
-        font-size: 11pt;
-        line-height: 1.3;
-    }
-    
-    /* Unordered lists */
-    ul 
-    {
-        text-align: justify;
-    }
-    
-    /* Ordered lists */
-    ol 
-    {
-        text-align: justify;
-    }
-
-/*=============================================================================
-    Links
-=============================================================================*/
-
-    a
-    {
-        text-decoration: none; /* no underline */
-    }
-    
-    a:hover
-    {
-        text-decoration: underline;
-    }
-
-/*=============================================================================
-    Spirit style navigation
-=============================================================================*/
-
-    .spirit-nav
-    {
-        text-align: right;
-    }
-    
-    .spirit-nav a
-    {
-        color: white;
-        padding-left: 0.5em;
-    }
-    
-    .spirit-nav img
-    {
-        border-width: 0px;
-    }
-
-/*=============================================================================
-    Table of contents
-=============================================================================*/
-
-    .toc
-    {
-       margin: 1pc 4% 0pc 4%;
-       padding: 0.5pc;
-       font-size: 11pt; 
-       line-height: 1.3;
-    }
-    
-    .boost-toc
-    {
-       float: right;
-       padding: 0.5pc;
-    }
-
-/*=============================================================================
-    Tables
-=============================================================================*/
-
-    .table-title, 
-    div.table p.title
-    {
-        margin-left: 4%;
-        padding-right: 0.5em; 
-        padding-left: 0.5em;
-        font-size: 120%;
-    }
-    
-    .informaltable table, 
-    .table table
-    {
-        width: 92%;
-        margin-left: 4%;
-        margin-right: 4%;
-    }
-    
-    div.informaltable table, 
-    div.table table
-    {
-        padding: 4px;
-    }
-    
-    /* Table Cells */
-    div.informaltable table tr td, 
-    div.table table tr td
-    {
-        padding: 0.5em;
-        text-align: justify;
-        font-size: 11pt;
-    }
-
-    div.informaltable table tr th, 
-    div.table table tr th
-    {
-        padding: 0.5em 0.5em 0.5em 0.5em;
-        border: 1pt solid white;
-    }
-
-/*=============================================================================
-    Blurbs
-=============================================================================*/
-
-    div.informaltable table tr td.blurb
-    {
-        font-size: 10pt; /* A little bit smaller than the main text */
-        line-height: 1.2;
-    }
-    
-    td.blurb img
-    {
-        padding: 1pt;
-    }
-
-/*=============================================================================
-    Misc
-=============================================================================*/
-
-    /* Tone down the title of Parameter lists */
-    div.variablelist p.title
-    {
-        font-weight: bold;
-        font-size: 100%;
-        text-align: left;
-    }
-    
-    /* Tabularize parameter lists */
-    div.variablelist dl dt
-    {
-        float: left;
-        clear: left;
-        display: block;
-        font-style: italic;
-    }
-    
-    div.variablelist dl dd
-    {
-        display: block;
-        clear:   right;
-        padding-left: 8pc;
-    }
-
-    /* Title of books and articles in bibliographies */
-    span.title
-    {
-        font-style: italic;
-    }
-
-    span.underline
-    {
-        text-decoration: underline;
-    }
-
-    span.strikethrough
-    {
-        text-decoration: line-through;
-    }
-
-    /* Copyright, Legal Notice */
-    div div.legalnotice p
-    {
-        text-align: left
-    }
-
-/*=============================================================================
-    Colors
-=============================================================================*/
-
-    @media screen
-    {
-    /* Links */
-        a
-        {
-            color: #005a9c;
-        }
-    
-        a:visited
-        {
-            color: #9c5a9c;
-        }
-    
-    /* Syntax Highlighting */
-        .keyword        { color: #0000AA; }
-        .identifier     { color: #000000; }
-        .special        { color: #707070; }
-        .preprocessor   { color: #402080; }
-        .char           { color: teal; }
-        .comment        { color: #800000; }
-        .string         { color: teal; }
-        .number         { color: teal; }
-        .white_bkd      { background-color: #FFFFFF; }
-        .dk_grey_bkd    { background-color: #999999; }
-    
-    /* Copyright, Legal Notice */
-        .copyright      
-        { 
-            color: #666666; 
-            font-size: small; 
-        }
-    
-        div div.legalnotice p
-        {
-            color: #666666;
-        }
-    
-    /* Program listing */
-        pre.synopsis
-        {
-            background-color: #F3F3F3;
-            border: 1pt solid #C0C0C0;
-        }
-    
-        .programlisting, 
-        .screen
-        {
-            background-color: #F3F3F3;
-            border: 1pt solid #C0C0C0;
-        }
-    
-    /* Blurbs */
-        div.informaltable table tr td.blurb
-        {
-            background-color: #FFFFF0;
-            border: 1pt solid #707070;
-        }
-    
-    /* Table of contents */
-        .toc
-        {
-            background-color: #F3F3F3;
-        }
-    
-    /* Tables */
-        div.informaltable table tr td, 
-        div.table table tr td
-        {
-            background-color: #F0F0F0;
-        }
-    
-        div.informaltable table tr th, 
-        div.table table tr th
-        {
-            background-color: #E4E4E4;
-        }
-    
-    /* Misc */
-        span.highlight
-        {
-            color: #00A000;
-        }
-    }
-    
-    @media print
-    {
-    /* Links */
-        a
-        {
-            color: black;
-        }
-    
-        a:visited
-        {
-            color: black;
-        }
-    
-        .spirit-nav
-        {
-            display: none;
-        }
-    
-    /* Program listing */
-        pre.synopsis
-        {
-            border: 1px solid gray;
-        }
-    
-        .programlisting, 
-        .screen
-        {
-            border: 1px solid gray;
-        }
-    
-    /* Table of contents */
-        .toc
-        {
-            border: 1px solid gray;
-        }
-    
-        .informaltable table, 
-        .table table
-        {
-            border: 1px solid gray;
-            border-collapse: collapse;
-        }
-    
-    /* Tables */
-        div.informaltable table tr td, 
-        div.table table tr td
-        {
-            border: 1px solid gray;
-        }
-    
-        div.informaltable table tr th, 
-        div.table table tr th
-        {
-            border: 1px solid gray;
-        }
-    
-    /* Misc */
-        span.highlight
-        {
-            font-weight: bold;
-        }
-    }

doc/tutorial/doc/html/index.html

@@ -1,37 +1,37 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Chapter 1. python 1.0</title>
+<title>Chapter&#160;1.&#160;python 2.0</title>
-<link rel="stylesheet" href="boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="start" href="index.html" title="Chapter 1. python 1.0">
+<link rel="home" href="index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="next" href="python/hello.html" title=" Building Hello World">
+<link rel="next" href="python/hello.html" title="Building Hello World">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../boost.png"></td>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
-</table>
+</tr></table>
 <hr>
-<div class="spirit-nav"><a accesskey="n" href="python/hello.html"><img src="images/next.png" alt="Next"></a></div>
+<div class="spirit-nav"><a accesskey="n" href="python/hello.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a></div>
-<div class="chapter" lang="en">
+<div class="chapter">
 <div class="titlepage"><div>
 <div><h2 class="title">
-<a name="python"></a>Chapter 1. python 1.0</h2></div>
+<a name="python"></a>Chapter&#160;1.&#160;python 2.0</h2></div>
 <div><div class="author"><h3 class="author">
 <span class="firstname">Joel</span> <span class="surname">de Guzman</span>
 </h3></div></div>
 <div><div class="author"><h3 class="author">
 <span class="firstname">David</span> <span class="surname">Abrahams</span>
 </h3></div></div>
-<div><p class="copyright">Copyright © 2002-2005 Joel
+<div><p class="copyright">Copyright &#169; 2002-2005 Joel
       de Guzman, David Abrahams</p></div>
 <div><div class="legalnotice">
-<a name="id427816"></a><p>
+<a name="id759709"></a><p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
         http://www.boost.org/LICENSE_1_0.txt </a>)
@@ -79,30 +79,29 @@
 </dl></dd>
 </dl>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="python.quickstart"></a>QuickStart</h2></div></div></div>
 <p>
-      QuickStartThe Boost Python Library is a framework for interfacing Python and
+      The Boost Python Library is a framework for interfacing Python and C++. It
-      C++. It allows you to quickly and seamlessly expose C++ classes functions and
+      allows you to quickly and seamlessly expose C++ classes functions and objects
-      objects to Python, and vice-versa, using no special tools -- just your C++
+      to Python, and vice-versa, using no special tools -- just your C++ compiler.
-      compiler. It is designed to wrap C++ interfaces non-intrusively, so that you
+      It is designed to wrap C++ interfaces non-intrusively, so that you should not
-      should not have to change the C++ code at all in order to wrap it, making Boost.Python
+      have to change the C++ code at all in order to wrap it, making Boost.Python
       ideal for exposing 3rd-party libraries to Python. The library's use of advanced
       metaprogramming techniques simplifies its syntax for users, so that wrapping
       code takes on the look of a kind of declarative interface definition language
       (IDL).
     </p>
-<a name="quickstart.hello_world"></a><h2>
+<a name="quickstart.hello_world"></a><h3>
-<a name="id372244"></a>
+<a name="id759740"></a>
       Hello World
-    </h2>
+    </h3>
 <p>
       Following C/C++ tradition, let's start with the "hello, world". A
       C++ Function:
     </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*</span> <span class="identifier">greet</span><span class="special">()</span>
-<span class="keyword">char</span> <span class="keyword">const</span><span class="special">*</span> <span class="identifier">greet</span><span class="special">()</span>
 <span class="special">{</span>
    <span class="keyword">return</span> <span class="string">"hello, world"</span><span class="special">;</span>
 <span class="special">}</span>
@@ -110,12 +109,11 @@
 <p>
       can be exposed to Python by writing a Boost.Python wrapper:
     </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
-<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
-<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">;</span>
 
-<span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">hello</span><span class="special">)</span>
+<span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">hello_ext</span><span class="special">)</span>
 <span class="special">{</span>
+    <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">def</span><span class="special">(</span><span class="string">"greet"</span><span class="special">,</span> <span class="identifier">greet</span><span class="special">);</span>
 <span class="special">}</span>
 </pre>
@@ -123,22 +121,25 @@
       That's it. We're done. We can now build this as a shared library. The resulting
       DLL is now visible to Python. Here's a sample Python session:
     </p>
-<p></p>
+<p>
-<pre class="programlisting">
+    </p>
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello_ext</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span>
+<span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">hello_ext</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span>
 <span class="identifier">hello</span><span class="special">,</span> <span class="identifier">world</span>
 </pre>
-<p></p>
+<p>
-<div class="blockquote"><blockquote class="blockquote"><p><span class="emphasis"><em><span class="bold"><b>Next stop... Building your Hello World module
+    </p>
-        from start to finish...</b></span></em></span></p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+        <span class="emphasis"><em><span class="bold"><strong>Next stop... Building your Hello World module
+        from start to finish...</strong></span></em></span>
+      </p></blockquote></div>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><small><p>Last revised: October 31, 2005 at 18:46:06 GMT</p></small></td>
+<td align="left"><p><small>Last revised: July 01, 2010 at 21:56:58 GMT</small></p></td>
-<td align="right"><small></small></td>
+<td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>
-<div class="spirit-nav"><a accesskey="n" href="python/hello.html"><img src="images/next.png" alt="Next"></a></div>
+<div class="spirit-nav"><a accesskey="n" href="python/hello.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a></div>
 </body>
 </html>

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

@@ -1,67 +1,66 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>Embedding</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="prev" href="object.html" title=" Object Interface">
+<link rel="prev" href="object.html" title="Object Interface">
 <link rel="next" href="iterators.html" title="Iterators">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
-</table>
+</tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="object.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="iterators.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="object.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="iterators.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="python.embedding"></a>Embedding</h2></div></div></div>
 <div class="toc"><dl><dt><span class="section"><a href="embedding.html#python.using_the_interpreter">Using the interpreter</a></span></dt></dl></div>
 <p>
-      EmbeddingBy now you should know how to use Boost.Python to call your C++ code
+      By now you should know how to use Boost.Python to call your C++ code from Python.
-      from Python. However, sometimes you may need to do the reverse: call Python
+      However, sometimes you may need to do the reverse: call Python code from the
-      code from the C++-side. This requires you to <span class="emphasis"><em>embed</em></span> the
+      C++-side. This requires you to <span class="emphasis"><em>embed</em></span> the Python interpreter
-      Python interpreter into your C++ program.
+      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" target="_top">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... <span class="inlinemediaobject"><img src="../images/smiley.png"></span></p>
+      Python/C API at all. So stay tuned... <span class="inlinemediaobject"><img src="../images/smiley.png" alt="smiley"></span>
-<a name="embedding.building_embedded_programs"></a><h2>
+    </p>
-<a name="id457321"></a>
+<a name="embedding.building_embedded_programs"></a><h3>
+<a name="id773307"></a>
       Building embedded programs
-    </h2>
+    </h3>
 <p>
-      To be able to use embedding in your programs, they have to be linked to both
+      To be able to embed python into your programs, you have to link to both Boost.Python's
-      Boost.Python's and Python's static link library.
+      as well as Python's own runtime library.
     </p>
 <p>
-      Boost.Python's static link library comes in two variants. Both are located
+      Boost.Python's library comes in two variants. Both are located in Boost's
-      in Boost's <tt class="literal">/libs/python/build/bin-stage</tt> subdirectory. On
+      <code class="literal">/libs/python/build/bin-stage</code> subdirectory. On Windows, the
-      Windows, the variants are called <tt class="literal">boost_python.lib</tt> (for release
+      variants are called <code class="literal">boost_python.lib</code> (for release builds)
-      builds) and <tt class="literal">boost_python_debug.lib</tt> (for debugging). If you
+      and <code class="literal">boost_python_debug.lib</code> (for debugging). If you can't
-      can't find the libraries, you probably haven't built Boost.Python yet. See
+      find the libraries, you probably haven't built Boost.Python yet. See <a href="../../../../building.html" target="_top">Building and Testing</a> on how to do this.
-      <a href="../../../../building.html" target="_top">Building and Testing</a> on how to
-      do this.
     </p>
 <p>
-      Python's static link library can be found in the <tt class="literal">/libs</tt> subdirectory
+      Python's library can be found in the <code class="literal">/libs</code> 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 class="literal">/include</tt> subdirectory has to be added
+      Additionally, Python's <code class="literal">/include</code> subdirectory has to be added
       to your include path.
     </p>
 <p>
@@ -82,298 +81,160 @@ exe embedded_program # name of the executable
     &lt;library-path&gt;$(PYTHON_LIB_PATH)
     &lt;find-library&gt;$(PYTHON_EMBEDDED_LIBRARY) ;
 </pre>
-<a name="embedding.getting_started"></a><h2>
+<a name="embedding.getting_started"></a><h3>
-<a name="id457409"></a>
+<a name="id773391"></a>
       Getting started
-    </h2>
+    </h3>
 <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>
-<div class="orderedlist"><ol type="1">
+<div class="orderedlist"><ol class="orderedlist" type="1">
-<li>
+<li class="listitem">
-        #include <tt class="literal">&lt;boost/python.hpp&gt;</tt><br><br>
+          #include <code class="literal">&lt;boost/python.hpp&gt;</code>
-</li>
+        </li>
-<li>
+<li class="listitem">
-        Call <a href="http://www.python.org/doc/current/api/initialization.html#l2h-652" target="_top">Py_Initialize</a>()
+          Call <a href="http://www.python.org/doc/current/api/initialization.html#l2h-652" target="_top">Py_Initialize</a>()
-        to start the interpreter and create the <tt class="literal"><span class="underline">_main</span>_</tt>
+          to start the interpreter and create the <code class="literal"><span class="underline">_main</span>_</code>
-        module.<br><br>
+          module.
-</li>
+        </li>
-<li>
+<li class="listitem">
-        Call other Python C API routines to use the interpreter.<br><br>
+          Call other Python C API routines to use the interpreter.
-</li>
+        </li>
-<li>
-        Call <a href="http://www.python.org/doc/current/api/initialization.html#l2h-656" target="_top">Py_Finalize</a>()
-        to stop the interpreter and release its resources.
-      </li>
 </ol></div>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+        <span class="bold"><strong>Note that at this time you must not call <a href="http://www.python.org/doc/current/api/initialization.html#l2h-656" target="_top">Py_Finalize</a>()
+        to stop the interpreter. This may be fixed in a future version of boost.python.</strong></span>
+      </p></td></tr>
+</table></div>
 <p>
       (Of course, there can be other C++ code between all of these steps.)
     </p>
-<div class="blockquote"><blockquote class="blockquote"><p><span class="emphasis"><em><span class="bold"><b>Now that we can embed the interpreter in
+<div class="blockquote"><blockquote class="blockquote"><p>
-        our programs, lets see how to put it to use...</b></span></em></span></p></blockquote></div>
+        <span class="emphasis"><em><span class="bold"><strong>Now that we can embed the interpreter in
-<div class="section" lang="en">
+        our programs, lets see how to put it to use...</strong></span></em></span>
+      </p></blockquote></div>
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.using_the_interpreter"></a>Using the interpreter</h3></div></div></div>
 <p>
-        Using the interpreterAs you probably already know, objects in Python are
+        As you probably already know, objects in Python are reference-counted. Naturally,
-        reference-counted. Naturally, the <tt class="literal">PyObject</tt>s of the Python/C
+        the <code class="literal">PyObject</code>s of the Python C API are also reference-counted.
-        API are also reference-counted. There is a difference however. While the
+        There is a difference however. While the reference-counting is fully automatic
-        reference-counting is fully automatic in Python, the Python/C API requires
+        in Python, the Python C API requires you to do it <a href="http://www.python.org/doc/current/c-api/refcounting.html" target="_top">by
-        you to do it <a href="http://www.python.org/doc/current/api/refcounts.html" target="_top">by
         hand</a>. This is messy and especially hard to get right in the presence
         of C++ exceptions. Fortunately Boost.Python provides the <a href="../../../../v2/handle.html" target="_top">handle</a>
         and <a href="../../../../v2/object.html" target="_top">object</a> class templates to
         automate the process.
       </p>
-<a name="using_the_interpreter.reference_counting_handles_and_objects"></a><h2>
+<a name="using_the_interpreter.running_python_code"></a><h3>
-<a name="id457544"></a>
+<a name="id773549"></a>
-        Reference-counting handles and objects
-      </h2>
-<p>
-        There are two ways in which a function in the Python/C API can return a
-        <tt class="literal">PyObject*</tt>: as a <span class="emphasis"><em>borrowed reference</em></span>
-        or as a <span class="emphasis"><em>new reference</em></span>. 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 <span class="emphasis"><em>borrowed reference</em></span> we'll
-        have to tell the <tt class="literal">handle</tt> that the <tt class="literal">PyObject*</tt>
-        is borrowed with the aptly named <a href="../../../../v2/handle.html#borrowed-spec" target="_top">borrowed</a>
-        function. Two functions returning borrowed references are <a href="http://www.python.org/doc/current/api/importing.html#l2h-125" target="_top">PyImport_AddModule</a>
-        and <a href="http://www.python.org/doc/current/api/moduleObjects.html#l2h-594" target="_top">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 class="literal"><span class="underline">_main</span>_</tt>
-        module:
-      </p>
-<pre class="programlisting">
-<span class="identifier">object</span> <span class="identifier">main_module</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><a href="http://www.python.org/doc/current/api/importing.html#l2h-125" target="_top">PyImport_AddModule</a><span class="special">(</span><span class="string">"__main__"</span><span class="special">)))));</span>
-
-<span class="identifier">object</span> <span class="identifier">main_namespace</span> <span class="special">=</span> <span class="identifier">main_module</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">);</span>
-</pre>
-<p>
-        For a function returning a <span class="emphasis"><em>new reference</em></span> we can just
-        create a <tt class="literal">handle</tt> out of the raw <tt class="literal">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" target="_top">PyRun_String</a>
-        which we'll discuss in the next section.
-      </p>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb">
-<span class="inlinemediaobject"><img src="../images/note.png"></span> <span class="bold"><b>Handle is a class <span class="emphasis"><em>template</em></span>, so why
-              haven't we been using any template parameters?</b></span><br><br><tt class="literal">handle</tt> has a single template parameter specifying
-              the type of the managed object. This type is <tt class="literal">PyObject</tt>
-              99% of the time, so the parameter was defaulted to <tt class="literal">PyObject</tt>
-              for convenience. Therefore we can use the shorthand <tt class="literal">handle&lt;&gt;</tt>
-              instead of the longer, but equivalent, <tt class="literal">handle&lt;PyObject&gt;</tt>.
-              </td></tr></tbody>
-</table></div>
-<a name="using_the_interpreter.running_python_code"></a><h2>
-<a name="id457863"></a>
         Running Python code
-      </h2>
+      </h3>
 <p>
-        To run Python code from C++ there is a family of functions in the API starting
+        Boost.python provides three related functions to run Python code from C++.
-        with the PyRun prefix. You can find the full list of these functions <a href="http://www.python.org/doc/current/api/veryhigh.html" target="_top">here</a>. They
-        all work similarly so we will look at only one of them, namely:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">eval</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">expression</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">globals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">(),</span> <span class="identifier">object</span> <span class="identifier">locals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">())</span>
-<span class="identifier">PyObject</span><span class="special">*</span> <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55" target="_top">PyRun_String</a><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>
+<span class="identifier">object</span> <span class="identifier">exec</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">code</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">globals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">(),</span> <span class="identifier">object</span> <span class="identifier">locals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">())</span>
+<span class="identifier">object</span> <span class="identifier">exec_file</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">filename</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">globals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">(),</span> <span class="identifier">object</span> <span class="identifier">locals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">())</span>
 </pre>
-<p><a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55" target="_top">PyRun_String</a>
+<p>
-        takes the code to execute as a null-terminated (C-style) string in its <tt class="literal">str</tt>
+        eval evaluates the given expression and returns the resulting value. exec
-        parameter. The function returns a new reference to a Python object. Which
+        executes the given code (typically a set of statements) returning the result,
-        object is returned depends on the <tt class="literal">start</tt> paramater.
+        and exec_file executes the code contained in the given file.
       </p>
 <p>
-        The <tt class="literal">start</tt> parameter is the start symbol from the Python
+        The <code class="literal">globals</code> and <code class="literal">locals</code> parameters are
-        grammar to use for interpreting the code. The possible values are:
+        Python dictionaries containing the globals and locals of the context in which
-      </p>
+        to run the code. For most intents and purposes you can use the namespace
-<div class="informaltable">
+        dictionary of the <code class="literal"><span class="underline">_main</span>_</code>
-<h4>
-<a name="id458033"></a><span class="table-title">Start symbols</span>
-</h4>
-<table class="table">
-<colgroup>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th><a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-58" target="_top">Py_eval_input</a></th>
-<th>for
-              interpreting isolated expressions</th>
-</tr></thead>
-<tbody>
-<tr>
-<td><a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-59" target="_top">Py_file_input</a></td>
-<td>for
-              interpreting sequences of statements</td>
-</tr>
-<tr>
-<td><a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-60" target="_top">Py_single_input</a></td>
-<td>for
-              interpreting a single statement</td>
-</tr>
-</tbody>
-</table>
-</div>
-<p>
-        When using <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-58" target="_top">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" target="_top">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" target="_top">Py_single_input</a>
-        works in the same way as <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-59" target="_top">Py_file_input</a>
-        but only accepts a single statement.
-      </p>
-<p>
-        Lastly, the <tt class="literal">globals</tt> and <tt class="literal">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 class="literal"><span class="underline">_main</span>_</tt>
         module for both parameters.
       </p>
 <p>
-        We have already seen how to get the <tt class="literal"><span class="underline">_main</span>_</tt>
+        Boost.python provides a function to import a module:
-        module's namespace so let's run some Python code in it:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">import</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">name</span><span class="special">)</span>
-<span class="identifier">object</span> <span class="identifier">main_module</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><a href="http://www.python.org/doc/current/api/importing.html#l2h-125" target="_top">PyImport_AddModule</a><span class="special">(</span><span class="string">"__main__"</span><span class="special">)))));</span>
-
-<span class="identifier">object</span> <span class="identifier">main_namespace</span> <span class="special">=</span> <span class="identifier">main_module</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">);</span>
-
-<span class="identifier">handle</span><span class="special">&lt;&gt;</span> <span class="identifier">ignored</span><span class="special">((</span><a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55" target="_top">PyRun_String</a><span class="special">(</span>
-
-    <span class="string">"hello = file('hello.txt', 'w')\n"</span>
-    <span class="string">"hello.write('Hello world!')\n"</span>
-    <span class="string">"hello.close()"</span>
-
-  <span class="special">,</span> <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-59" target="_top">Py_file_input</a>
-  <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="special">,</span> <span class="identifier">main_namespace</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">())</span>
-<span class="special">));</span>
 </pre>
 <p>
-        Because the Python/C API doesn't know anything about <tt class="literal">object</tt>s,
+        import imports a python module (potentially loading it into the running process
-        we used the object's <tt class="literal">ptr</tt> member function to retrieve the
+        first), and returns it.
-        <tt class="literal">PyObject*</tt>.
       </p>
+<p>
+        Let's import the <code class="literal"><span class="underline">_main</span>_</code>
+        module and run some Python code in its namespace:
+      </p>
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">main_module</span> <span class="special">=</span> <span class="identifier">import</span><span class="special">(</span><span class="string">"__main__"</span><span class="special">);</span>
+<span class="identifier">object</span> <span class="identifier">main_namespace</span> <span class="special">=</span> <span class="identifier">main_module</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">);</span>
+
+<span class="identifier">object</span> <span class="identifier">ignored</span> <span class="special">=</span> <span class="identifier">exec</span><span class="special">(</span><span class="string">"hello = file('hello.txt', 'w')\n"</span>
+                      <span class="string">"hello.write('Hello world!')\n"</span>
+                      <span class="string">"hello.close()"</span><span class="special">,</span>
+                      <span class="identifier">main_namespace</span><span class="special">);</span>
+</pre>
 <p>
         This should create a file called 'hello.txt' in the current directory containing
         a phrase that is well-known in programming circles.
       </p>
-<div class="informaltable"><table class="table">
+<a name="using_the_interpreter.manipulating_python_objects"></a><h3>
-<colgroup><col></colgroup>
+<a name="id774064"></a>
-<tbody><tr><td class="blurb">
+        Manipulating Python objects
-<span class="inlinemediaobject"><img src="../images/note.png"></span> <span class="bold"><b>Note</b></span> that we wrap the return value of <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55" target="_top">PyRun_String</a>
+      </h3>
-              in a (nameless) <tt class="literal">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 class="literal">PyObject*</tt>s in <tt class="literal">handle</tt>s.
-              </td></tr></tbody>
-</table></div>
-<a name="using_the_interpreter.beyond_handles"></a><h2>
-<a name="id458506"></a>
-        Beyond handles
-      </h2>
 <p>
-        It's nice that <tt class="literal">handle</tt> manages the reference counting details
+        Often we'd like to have a class to manipulate Python objects. But we have
-        for us, but other than that it doesn't do much. Often we'd like to have a
+        already seen such a class above, and in the <a href="object.html" target="_top">previous
-        more useful class to manipulate Python objects. But we have already seen
+        section</a>: the aptly named <code class="literal">object</code> class and its
-        such a class above, and in the <a href="object.html" target="_top">previous section</a>:
+        derivatives. We've already seen that they can be constructed from a <code class="literal">handle</code>.
-        the aptly named <tt class="literal">object</tt> class and it's derivatives. We've
-        already seen that they can be constructed from a <tt class="literal">handle</tt>.
         The following examples should further illustrate this fact:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">main_module</span> <span class="special">=</span> <span class="identifier">import</span><span class="special">(</span><span class="string">"__main__"</span><span class="special">);</span>
-<span class="identifier">object</span> <span class="identifier">main_module</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><a href="http://www.python.org/doc/current/api/importing.html#l2h-125" target="_top">PyImport_AddModule</a><span class="special">(</span><span class="string">"__main__"</span><span class="special">)))));</span>
-
 <span class="identifier">object</span> <span class="identifier">main_namespace</span> <span class="special">=</span> <span class="identifier">main_module</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">);</span>
-
+<span class="identifier">object</span> <span class="identifier">ignored</span> <span class="special">=</span> <span class="identifier">exec</span><span class="special">(</span><span class="string">"result = 5 ** 2"</span><span class="special">,</span> <span class="identifier">main_namespace</span><span class="special">);</span>
-<span class="identifier">handle</span><span class="special">&lt;&gt;</span> <span class="identifier">ignored</span><span class="special">((</span><a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55" target="_top">PyRun_String</a><span class="special">(</span>
-
-    <span class="string">"result = 5 ** 2"</span>
-
-    <span class="special">,</span> <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-59" target="_top">Py_file_input</a>
-    <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="special">,</span> <span class="identifier">main_namespace</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">())</span>
-<span class="special">));</span>
-
 <span class="keyword">int</span> <span class="identifier">five_squared</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">main_namespace</span><span class="special">[</span><span class="string">"result"</span><span class="special">]);</span>
 </pre>
 <p>
-        Here we create a dictionary object for the <tt class="literal"><span class="underline">_main</span>_</tt>
+        Here we create a dictionary object for the <code class="literal"><span class="underline">_main</span>_</code>
         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" target="_top">PyRun_String</a>
+        is to use eval instead, which returns the result directly:
-        return the result directly with <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-58" target="_top">Py_eval_input</a>:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">eval</span><span class="special">(</span><span class="string">"5 ** 2"</span><span class="special">);</span>
-<span class="identifier">object</span> <span class="identifier">result</span><span class="special">((</span><span class="identifier">handle</span><span class="special">&lt;&gt;(</span>
-    <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55" target="_top">PyRun_String</a><span class="special">(</span><span class="string">"5 ** 2"</span>
-        <span class="special">,</span> <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-58" target="_top">Py_eval_input</a>
-        <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="special">,</span> <span class="identifier">main_namespace</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">()))</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>
-<div class="informaltable"><table class="table">
+<a name="using_the_interpreter.exception_handling"></a><h3>
-<colgroup><col></colgroup>
+<a name="id774390"></a>
-<tbody><tr><td class="blurb">
-<span class="inlinemediaobject"><img src="../images/note.png"></span> <span class="bold"><b>Note</b></span> that <tt class="literal">object</tt>'s member
-              function to return the wrapped <tt class="literal">PyObject*</tt> is called
-              <tt class="literal">ptr</tt> instead of <tt class="literal">get</tt>. This makes
-              sense if you take into account the different functions that <tt class="literal">object</tt>
-              and <tt class="literal">handle</tt> perform. </td></tr></tbody>
-</table></div>
-<a name="using_the_interpreter.exception_handling"></a><h2>
-<a name="id459120"></a>
         Exception handling
-      </h2>
+      </h3>
 <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" target="_top">PyRun_String</a>
+        If an exception occurs in the evaluation of the python expression, <a href="../../../../v2/errors.html#error_already_set-spec" target="_top">error_already_set</a>
-        function returns a null pointer. Constructing a <tt class="literal">handle</tt>
+        is thrown:
-        out of this null pointer throws <a href="../../../../v2/errors.html#error_already_set-spec" target="_top">error_already_set</a>,
-        so basically, the Python exception is automatically translated into a C++
-        exception when using <tt class="literal">handle</tt>:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">try</span>
-<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><a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55" target="_top">PyRun_String</a><span class="special">(</span>
+    <span class="identifier">object</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">eval</span><span class="special">(</span><span class="string">"5/0"</span><span class="special">);</span>
-        <span class="string">"5/0"</span>
-      <span class="special">,</span> <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-58" target="_top">Py_eval_input</a>
-      <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="special">,</span> <span class="identifier">main_namespace</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">()))</span>
-    <span class="special">));</span>
-
     <span class="comment">// execution will never get here:
 </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="special">}</span>
-<span class="keyword">catch</span><span class="special">(</span><span class="identifier">error_already_set</span><span class="special">)</span>
+<span class="keyword">catch</span><span class="special">(</span><span class="identifier">error_already_set</span> <span class="keyword">const</span> <span class="special">&amp;)</span>
 <span class="special">{</span>
     <span class="comment">// handle the exception in some way
 </span><span class="special">}</span>
 </pre>
 <p>
-        The <tt class="literal">error_already_set</tt> exception class doesn't carry any
+        The <code class="literal">error_already_set</code> exception class doesn't carry any
         information in itself. To find out more about the Python exception that occurred,
         you need to use the <a href="http://www.python.org/doc/api/exceptionHandling.html" target="_top">exception
-        handling functions</a> of the Python/C API in your catch-statement. This
+        handling functions</a> of the Python C API in your catch-statement. This
         can be as simple as calling <a href="http://www.python.org/doc/api/exceptionHandling.html#l2h-70" target="_top">PyErr_Print()</a>
         to print the exception's traceback to the console, or comparing the type
         of the exception with those of the <a href="http://www.python.org/doc/api/standardExceptions.html" target="_top">standard
         exceptions</a>:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">catch</span><span class="special">(</span><span class="identifier">error_already_set</span> <span class="keyword">const</span> <span class="special">&amp;)</span>
-<span class="keyword">catch</span><span class="special">(</span><span class="identifier">error_already_set</span><span class="special">)</span>
 <span class="special">{</span>
     <span class="keyword">if</span> <span class="special">(</span><span class="identifier">PyErr_ExceptionMatches</span><span class="special">(</span><span class="identifier">PyExc_ZeroDivisionError</span><span class="special">))</span>
     <span class="special">{</span>
@@ -390,33 +251,21 @@ exe embedded_program # name of the executable
         (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" target="_top">here</a>.)
       </p>
-<p>
-        If you'd rather not have <tt class="literal">handle</tt> throw a C++ exception
-        when it is constructed, you can use the <a href="../../../../v2/handle.html#allow_null-spec" target="_top">allow_null</a>
-        function in the same way you'd use borrowed:
-      </p>
-<pre class="programlisting">
-<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><a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55" target="_top">PyRun_String</a><span class="special">(</span>
-    <span class="string">"5/0"</span>
-   <span class="special">,</span> <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-58" target="_top">Py_eval_input</a>
-   <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="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="comment">// Python exception occurred
-</span><span class="keyword">else</span>
-    <span class="comment">// everything went okay, it's safe to use the result
-</span></pre>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><small>Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
-      de Guzman, David Abrahams</small></td>
+      de Guzman, David Abrahams<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
+        http://www.boost.org/LICENSE_1_0.txt </a>)
+      </p>
+</div></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="object.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="iterators.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="object.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="iterators.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

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

@@ -1,44 +1,41 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title> Exception Translation</title>
+<title>Exception Translation</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
 <link rel="prev" href="iterators.html" title="Iterators">
-<link rel="next" href="techniques.html" title=" General Techniques">
+<link rel="next" href="techniques.html" title="General Techniques">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
-</table>
+</tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="iterators.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="techniques.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="iterators.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="techniques.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="python.exception"></a> Exception Translation</h2></div></div></div>
 <p>
-      Exception TranslationAll C++ exceptions must be caught at the boundary with
+      All C++ exceptions must be caught at the boundary with Python code. This boundary
-      Python code. This boundary is the point where C++ meets Python. Boost.Python
+      is the point where C++ meets Python. Boost.Python provides a default exception
-      provides a default exception handler that translates selected standard exceptions,
+      handler that translates selected standard exceptions, then gives up:
-      then gives up:
     </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">raise</span> <span class="identifier">RuntimeError</span><span class="special">,</span> <span class="string">'unidentifiable C++ Exception'</span>
-<span class="keyword">raise</span> <span class="identifier">RuntimeError</span><span class="special">,</span> <span class="string">'unidentifiable C++ Exception'</span>
 </pre>
 <p>
       Users may provide custom translation. Here's an example:
     </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">struct</span> <span class="identifier">PodBayDoorException</span><span class="special">;</span>
-<span class="identifier">struct</span> <span class="identifier">PodBayDoorException</span><span class="special">;</span>
 <span class="identifier">void</span> <span class="identifier">translator</span><span class="special">(</span><span class="identifier">PodBayDoorException</span> <span class="identifier">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">{</span>
     <span class="identifier">PyErr_SetString</span><span class="special">(</span><span class="identifier">PyExc_UserWarning</span><span class="special">,</span> <span class="string">"I'm sorry Dave..."</span><span class="special">);</span>
 <span class="special">}</span>
@@ -50,12 +47,17 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><small>Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
-      de Guzman, David Abrahams</small></td>
+      de Guzman, David Abrahams<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
+        http://www.boost.org/LICENSE_1_0.txt </a>)
+      </p>
+</div></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="iterators.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="techniques.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="iterators.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="techniques.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

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

@@ -1,28 +1,28 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title> Exposing Classes</title>
+<title>Exposing Classes</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="prev" href="hello.html" title=" Building Hello World">
+<link rel="prev" href="hello.html" title="Building Hello World">
 <link rel="next" href="functions.html" title="Functions">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
-</table>
+</tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="hello.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="functions.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="hello.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="functions.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="python.exposing"></a> Exposing Classes</h2></div></div></div>
 <div class="toc"><dl>
@@ -35,13 +35,12 @@
 <dt><span class="section"><a href="exposing.html#python.class_operators_special_functions">Class Operators/Special Functions</a></span></dt>
 </dl></div>
 <p>
-      Exposing ClassesNow let's expose a C++ class to Python.
+      Now let's expose a C++ class to Python.
     </p>
 <p>
       Consider a C++ class/struct that we want to expose to Python:
     </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">World</span>
-<span class="keyword">struct</span> <span class="identifier">World</span>
 <span class="special">{</span>
     <span class="keyword">void</span> <span class="identifier">set</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">msg</span><span class="special">)</span> <span class="special">{</span> <span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">msg</span> <span class="special">=</span> <span class="identifier">msg</span><span class="special">;</span> <span class="special">}</span>
     <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">greet</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">msg</span><span class="special">;</span> <span class="special">}</span>
@@ -51,8 +50,7 @@
 <p>
       We can expose this to Python by writing a corresponding Boost.Python C++ Wrapper:
     </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
-<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">;</span>
 
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">hello</span><span class="special">)</span>
@@ -64,38 +62,37 @@
 <span class="special">}</span>
 </pre>
 <p>
-      Here, we wrote a C++ class wrapper that exposes the member functions <tt class="literal">greet</tt>
+      Here, we wrote a C++ class wrapper that exposes the member functions <code class="literal">greet</code>
-      and <tt class="literal">set</tt>. Now, after building our module as a shared library,
+      and <code class="literal">set</code>. Now, after building our module as a shared library,
-      we may use our class <tt class="literal">World</tt> in Python. Here's a sample Python
+      we may use our class <code class="literal">World</code> in Python. Here's a sample Python
       session:
     </p>
-<p></p>
+<p>
-<pre class="programlisting">
+    </p>
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">planet</span> <span class="special">=</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">World</span><span class="special">()</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">planet</span><span class="special">.</span><span class="identifier">set</span><span class="special">(</span><span class="string">'howdy'</span><span class="special">)</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">planet</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span>
 <span class="string">'howdy'</span>
 </pre>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.constructors"></a>Constructors</h3></div></div></div>
 <p>
-        ConstructorsOur previous example didn't have any explicit constructors. Since
+        Our previous example didn't have any explicit constructors. Since <code class="literal">World</code>
-        <tt class="literal">World</tt> is declared as a plain struct, it has an implicit
+        is declared as a plain struct, it has an implicit default constructor. Boost.Python
-        default constructor. Boost.Python exposes the default constructor by default,
+        exposes the default constructor by default, which is why we were able to
-        which is why we were able to write
+        write
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">planet</span> <span class="special">=</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">World</span><span class="special">()</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">planet</span> <span class="special">=</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">World</span><span class="special">()</span>
 </pre>
 <p>
         We may wish to wrap a class with a non-default constructor. Let us build
         on our previous example:
       </p>
-<p></p>
+<p>
-<pre class="programlisting">
+      </p>
-<span class="keyword">struct</span> <span class="identifier">World</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">World</span>
 <span class="special">{</span>
     <span class="identifier">World</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">msg</span><span class="special">):</span> <span class="identifier">msg</span><span class="special">(</span><span class="identifier">msg</span><span class="special">)</span> <span class="special">{}</span> <span class="comment">// added constructor
 </span>    <span class="keyword">void</span> <span class="identifier">set</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">msg</span><span class="special">)</span> <span class="special">{</span> <span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">msg</span> <span class="special">=</span> <span class="identifier">msg</span><span class="special">;</span> <span class="special">}</span>
@@ -104,13 +101,12 @@
 <span class="special">};</span>
 </pre>
 <p>
-        This time <tt class="literal">World</tt> has no default constructor; our previous
+        This time <code class="literal">World</code> has no default constructor; our previous
         wrapping code would fail to compile when the library tried to expose it.
-        We have to tell <tt class="literal">class_&lt;World&gt;</tt> about the constructor
+        We have to tell <code class="literal">class_&lt;World&gt;</code> about the constructor
         we want to expose instead.
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
-<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">;</span>
 
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">hello</span><span class="special">)</span>
@@ -121,17 +117,17 @@
     <span class="special">;</span>
 <span class="special">}</span>
 </pre>
-<p><tt class="literal">init&lt;std::string&gt;()</tt> exposes the constructor taking
+<p>
-        in a <tt class="literal">std::string</tt> (in Python, constructors are spelled
+        <code class="literal">init&lt;std::string&gt;()</code> exposes the constructor taking
-        "<tt class="literal">"<span class="underline">_init</span>_"</tt>").
+        in a <code class="literal">std::string</code> (in Python, constructors are spelled
+        "<code class="literal">"<span class="underline">_init</span>_"</code>").
       </p>
 <p>
-        We can expose additional constructors by passing more <tt class="literal">init&lt;...&gt;</tt>s
+        We can expose additional constructors by passing more <code class="literal">init&lt;...&gt;</code>s
-        to the <tt class="literal">def()</tt> member function. Say for example we have
+        to the <code class="literal">def()</code> member function. Say for example we have
         another World constructor taking in two doubles:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">World</span><span class="special">&gt;(</span><span class="string">"World"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span>
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">World</span><span class="special">&gt;(</span><span class="string">"World"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span>
     <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">init</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;())</span>
     <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"greet"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">World</span><span class="special">::</span><span class="identifier">greet</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"set"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">World</span><span class="special">::</span><span class="identifier">set</span><span class="special">)</span>
@@ -139,27 +135,25 @@
 </pre>
 <p>
         On the other hand, if we do not wish to expose any constructors at all, we
-        may use <tt class="literal">no_init</tt> instead:
+        may use <code class="literal">no_init</code> instead:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Abstract</span><span class="special">&gt;(</span><span class="string">"Abstract"</span><span class="special">,</span> <span class="identifier">no_init</span><span class="special">)</span>
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Abstract</span><span class="special">&gt;(</span><span class="string">"Abstract"</span><span class="special">,</span> <span class="identifier">no_init</span><span class="special">)</span>
 </pre>
 <p>
-        This actually adds an <tt class="literal"><span class="underline">_init</span>_</tt>
+        This actually adds an <code class="literal"><span class="underline">_init</span>_</code>
         method which always raises a Python RuntimeError exception.
       </p>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.class_data_members"></a>Class Data Members</h3></div></div></div>
 <p>
-        Class Data MembersData members may also be exposed to Python so that they
+        Data members may also be exposed to Python so that they can be accessed as
-        can be accessed as attributes of the corresponding Python class. Each data
+        attributes of the corresponding Python class. Each data member that we wish
-        member that we wish to be exposed may be regarded as <span class="bold"><b>read-only</b></span>
+        to be exposed may be regarded as <span class="bold"><strong>read-only</strong></span>
-        or <span class="bold"><b>read-write</b></span>. Consider this class <tt class="literal">Var</tt>:
+        or <span class="bold"><strong>read-write</strong></span>. Consider this class <code class="literal">Var</code>:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Var</span>
-<span class="keyword">struct</span> <span class="identifier">Var</span>
 <span class="special">{</span>
     <span class="identifier">Var</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">name</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">name</span><span class="special">(</span><span class="identifier">name</span><span class="special">),</span> <span class="identifier">value</span><span class="special">()</span> <span class="special">{}</span>
     <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="keyword">const</span> <span class="identifier">name</span><span class="special">;</span>
@@ -167,11 +161,10 @@
 <span class="special">};</span>
 </pre>
 <p>
-        Our C++ <tt class="literal">Var</tt> class and its data members can be exposed
+        Our C++ <code class="literal">Var</code> class and its data members can be exposed
         to Python:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Var</span><span class="special">&gt;(</span><span class="string">"Var"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span>
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Var</span><span class="special">&gt;(</span><span class="string">"Var"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span>
     <span class="special">.</span><span class="identifier">def_readonly</span><span class="special">(</span><span class="string">"name"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Var</span><span class="special">::</span><span class="identifier">name</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">def_readwrite</span><span class="special">(</span><span class="string">"value"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Var</span><span class="special">::</span><span class="identifier">value</span><span class="special">);</span>
 </pre>
@@ -179,37 +172,35 @@
         Then, in Python, assuming we have placed our Var class inside the namespace
         hello as we did before:
       </p>
-<p></p>
+<p>
-<pre class="programlisting">
+      </p>
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">Var</span><span class="special">(</span><span class="string">'pi'</span><span class="special">)</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">Var</span><span class="special">(</span><span class="string">'pi'</span><span class="special">)</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">value</span> <span class="special">=</span> <span class="number">3.14</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">name</span><span class="special">,</span> <span class="string">'is around'</span><span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">value</span>
 <span class="identifier">pi</span> <span class="keyword">is</span> <span class="identifier">around</span> <span class="number">3.14</span>
 </pre>
 <p>
-        Note that <tt class="literal">name</tt> is exposed as <span class="bold"><b>read-only</b></span>
+        Note that <code class="literal">name</code> is exposed as <span class="bold"><strong>read-only</strong></span>
-        while <tt class="literal">value</tt> is exposed as <span class="bold"><b>read-write</b></span>.
+        while <code class="literal">value</code> is exposed as <span class="bold"><strong>read-write</strong></span>.
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">name</span> <span class="special">=</span> <span class="string">'e'</span> <span class="comment"># can't change name
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">name</span> <span class="special">=</span> <span class="string">'e'</span> <span class="comment"># can't change name
 </span><span class="identifier">Traceback</span> <span class="special">(</span><span class="identifier">most</span> <span class="identifier">recent</span> <span class="identifier">call</span> <span class="identifier">last</span><span class="special">):</span>
-  <span class="identifier">File</span> <span class="string">"&lt;stdin&gt;"</span><span class="special">,</span> <span class="identifier">line</span> <span class="number">1</span><span class="special">,</span> <span class="keyword">in</span> #
+  <span class="identifier">File</span> <span class="string">"&lt;stdin&gt;"</span><span class="special">,</span> <span class="identifier">line</span> <span class="number">1</span><span class="special">,</span> <span class="keyword">in</span> <span class="error">?</span>
-<span class="identifier">AttributeError</span><span class="special">:</span> <span class="identifier">can</span>#<span class="identifier">t</span> <span class="identifier">set</span> <span class="identifier">attribute</span>
+<span class="identifier">AttributeError</span><span class="special">:</span> <span class="identifier">can</span><span class="error">'</span><span class="identifier">t</span> <span class="identifier">set</span> <span class="identifier">attribute</span>
 </pre>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.class_properties"></a>Class Properties</h3></div></div></div>
 <p>
-        Class PropertiesIn C++, classes with public data members are usually frowned
+        In C++, classes with public data members are usually frowned upon. Well designed
-        upon. Well designed classes that take advantage of encapsulation hide the
+        classes that take advantage of encapsulation hide the class' data members.
-        class' data members. The only way to access the class' data is through access
+        The only way to access the class' data is through access (getter/setter)
-        (getter/setter) functions. Access functions expose class properties. Here's
+        functions. Access functions expose class properties. Here's an example:
-        an example:
       </p>
-<p></p>
+<p>
-<pre class="programlisting">
+      </p>
-<span class="keyword">struct</span> <span class="identifier">Num</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Num</span>
 <span class="special">{</span>
     <span class="identifier">Num</span><span class="special">();</span>
     <span class="keyword">float</span> <span class="identifier">get</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
@@ -220,40 +211,39 @@
 <p>
         However, in Python attribute access is fine; it doesn't neccessarily break
         encapsulation to let users handle attributes directly, because the attributes
-        can just be a different syntax for a method call. Wrapping our <tt class="literal">Num</tt>
+        can just be a different syntax for a method call. Wrapping our <code class="literal">Num</code>
         class using Boost.Python:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Num</span><span class="special">&gt;(</span><span class="string">"Num"</span><span class="special">)</span>
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Num</span><span class="special">&gt;(</span><span class="string">"Num"</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">add_property</span><span class="special">(</span><span class="string">"rovalue"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">get</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">add_property</span><span class="special">(</span><span class="string">"value"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">get</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">set</span><span class="special">);</span>
 </pre>
 <p>
         And at last, in Python:
       </p>
-<p></p>
+<p>
-<pre class="programlisting">
+      </p>
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">Num</span><span class="special">()</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">Num</span><span class="special">()</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">value</span> <span class="special">=</span> <span class="number">3.14</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">value</span><span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">rovalue</span>
 <span class="special">(</span><span class="number">3.14</span><span class="special">,</span> <span class="number">3.14</span><span class="special">)</span>
 <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="comment"># error!
 </span></pre>
 <p>
-        Take note that the class property <tt class="literal">rovalue</tt> is exposed as
+        Take note that the class property <code class="literal">rovalue</code> is exposed as
-        <span class="bold"><b>read-only</b></span> since the <tt class="literal">rovalue</tt>
+        <span class="bold"><strong>read-only</strong></span> since the <code class="literal">rovalue</code>
         setter member function is not passed in:
       </p>
-<p></p>
+<p>
-<pre class="programlisting">
+      </p>
-<span class="special">.</span><span class="identifier">add_property</span><span class="special">(</span><span class="string">"rovalue"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">get</span><span class="special">)</span>
+<pre class="programlisting"><span class="special">.</span><span class="identifier">add_property</span><span class="special">(</span><span class="string">"rovalue"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">get</span><span class="special">)</span>
 </pre>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.inheritance"></a>Inheritance</h3></div></div></div>
 <p>
-        InheritanceIn the previous examples, we dealt with classes that are not polymorphic.
+        In the previous examples, we dealt with classes that are not polymorphic.
         This is not often the case. Much of the time, we will be wrapping polymorphic
         classes and class hierarchies related by inheritance. We will often have
         to write Boost.Python wrappers for classes that are derived from abstract
@@ -262,85 +252,78 @@
 <p>
         Consider this trivial inheritance structure:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Base</span> <span class="special">{</span> <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">Base</span><span class="special">();</span> <span class="special">};</span>
-<span class="keyword">struct</span> <span class="identifier">Base</span> <span class="special">{</span> <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">Base</span><span class="special">();</span> <span class="special">};</span>
 <span class="keyword">struct</span> <span class="identifier">Derived</span> <span class="special">:</span> <span class="identifier">Base</span> <span class="special">{};</span>
 </pre>
 <p>
-        And a set of C++ functions operating on <tt class="literal">Base</tt> and <tt class="literal">Derived</tt>
+        And a set of C++ functions operating on <code class="literal">Base</code> and <code class="literal">Derived</code>
         object instances:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">b</span><span class="special">(</span><span class="identifier">Base</span><span class="special">*);</span>
-<span class="keyword">void</span> <span class="identifier">b</span><span class="special">(</span><span class="identifier">Base</span><span class="special">*);</span>
 <span class="keyword">void</span> <span class="identifier">d</span><span class="special">(</span><span class="identifier">Derived</span><span class="special">*);</span>
 <span class="identifier">Base</span><span class="special">*</span> <span class="identifier">factory</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="keyword">new</span> <span class="identifier">Derived</span><span class="special">;</span> <span class="special">}</span>
 </pre>
 <p>
-        We've seen how we can wrap the base class <tt class="literal">Base</tt>:
+        We've seen how we can wrap the base class <code class="literal">Base</code>:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
     <span class="comment">/*...*/</span>
     <span class="special">;</span>
 </pre>
 <p>
-        Now we can inform Boost.Python of the inheritance relationship between <tt class="literal">Derived</tt>
+        Now we can inform Boost.Python of the inheritance relationship between <code class="literal">Derived</code>
-        and its base class <tt class="literal">Base</tt>. Thus:
+        and its base class <code class="literal">Base</code>. Thus:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Derived</span><span class="special">,</span> <span class="identifier">bases</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span> <span class="special">&gt;(</span><span class="string">"Derived"</span><span class="special">)</span>
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Derived</span><span class="special">,</span> <span class="identifier">bases</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span> <span class="special">&gt;(</span><span class="string">"Derived"</span><span class="special">)</span>
     <span class="comment">/*...*/</span>
     <span class="special">;</span>
 </pre>
 <p>
         Doing so, we get some things for free:
       </p>
-<div class="orderedlist"><ol type="1">
+<div class="orderedlist"><ol class="orderedlist" type="1">
-<li>
+<li class="listitem">
-          Derived automatically inherits all of Base's Python methods (wrapped C++
+            Derived automatically inherits all of Base's Python methods (wrapped
-          member functions)
+            C++ member functions)
-        </li>
+          </li>
-<li>
+<li class="listitem">
-<span class="bold"><b>If</b></span> Base is polymorphic, <tt class="literal">Derived</tt>
+            <span class="bold"><strong>If</strong></span> Base is polymorphic, <code class="literal">Derived</code>
-          objects which have been passed to Python via a pointer or reference to
+            objects which have been passed to Python via a pointer or reference to
-          <tt class="literal">Base</tt> can be passed where a pointer or reference to
+            <code class="literal">Base</code> can be passed where a pointer or reference to
-          <tt class="literal">Derived</tt> is expected.
+            <code class="literal">Derived</code> is expected.
-        </li>
+          </li>
 </ol></div>
 <p>
-        Now, we shall expose the C++ free functions <tt class="literal">b</tt> and <tt class="literal">d</tt>
+        Now, we will expose the C++ free functions <code class="literal">b</code> and <code class="literal">d</code>
-        and <tt class="literal">factory</tt>:
+        and <code class="literal">factory</code>:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"b"</span><span class="special">,</span> <span class="identifier">b</span><span class="special">);</span>
-<span class="identifier">def</span><span class="special">(</span><span class="string">"b"</span><span class="special">,</span> <span class="identifier">b</span><span class="special">);</span>
 <span class="identifier">def</span><span class="special">(</span><span class="string">"d"</span><span class="special">,</span> <span class="identifier">d</span><span class="special">);</span>
 <span class="identifier">def</span><span class="special">(</span><span class="string">"factory"</span><span class="special">,</span> <span class="identifier">factory</span><span class="special">);</span>
 </pre>
 <p>
-        Note that free function <tt class="literal">factory</tt> is being used to generate
+        Note that free function <code class="literal">factory</code> is being used to generate
-        new instances of class <tt class="literal">Derived</tt>. In such cases, we use
+        new instances of class <code class="literal">Derived</code>. In such cases, we use
-        <tt class="literal">return_value_policy&lt;manage_new_object&gt;</tt> to instruct
+        <code class="literal">return_value_policy&lt;manage_new_object&gt;</code> to instruct
-        Python to adopt the pointer to <tt class="literal">Base</tt> and hold the instance
+        Python to adopt the pointer to <code class="literal">Base</code> and hold the instance
-        in a new Python <tt class="literal">Base</tt> object until the the Python object
+        in a new Python <code class="literal">Base</code> object until the the Python object
-        is destroyed. We shall see more of Boost.Python <a href="functions.html#python.call_policies" title="Call Policies">call
+        is destroyed. We will see more of Boost.Python <a class="link" href="functions.html#python.call_policies" title="Call Policies">call
         policies</a> later.
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="comment">// Tell Python to take ownership of factory's result
-<span class="comment">// Tell Python to take ownership of factory's result
 </span><span class="identifier">def</span><span class="special">(</span><span class="string">"factory"</span><span class="special">,</span> <span class="identifier">factory</span><span class="special">,</span>
     <span class="identifier">return_value_policy</span><span class="special">&lt;</span><span class="identifier">manage_new_object</span><span class="special">&gt;());</span>
 </pre>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.class_virtual_functions"></a>Class Virtual Functions</h3></div></div></div>
 <p>
-        Class Virtual FunctionsIn this section, we shall learn how to make functions
+        In this section, we will learn how to make functions behave polymorphically
-        behave polymorphically through virtual functions. Continuing our example,
+        through virtual functions. Continuing our example, let us add a virtual function
-        let us add a virtual function to our <tt class="literal">Base</tt> class:
+        to our <code class="literal">Base</code> class:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Base</span>
-<span class="keyword">struct</span> <span class="identifier">Base</span>
 <span class="special">{</span>
     <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">Base</span><span class="special">()</span> <span class="special">{}</span>
     <span class="keyword">virtual</span> <span class="keyword">int</span> <span class="identifier">f</span><span class="special">()</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
@@ -350,16 +333,15 @@
         One of the goals of Boost.Python is to be minimally intrusive on an existing
         C++ design. In principle, it should be possible to expose the interface for
         a 3rd party library without changing it. It is not ideal to add anything
-        to our class <tt class="computeroutput"><span class="identifier">Base</span></tt>. Yet, when
+        to our class <code class="computeroutput"><span class="identifier">Base</span></code>. Yet, when
         you have a virtual function that's going to be overridden in Python and called
-        polymorphically <span class="bold"><b>from C++</b></span>, we'll need to
+        polymorphically <span class="bold"><strong>from C++</strong></span>, we'll need to
         add some scaffoldings to make things work properly. What we'll do is write
-        a class wrapper that derives from <tt class="computeroutput"><span class="identifier">Base</span></tt>
+        a class wrapper that derives from <code class="computeroutput"><span class="identifier">Base</span></code>
         that will unintrusively hook into the virtual functions so that a Python
         override may be called:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">BaseWrap</span> <span class="special">:</span> <span class="identifier">Base</span><span class="special">,</span> <span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">BaseWrap</span> <span class="special">:</span> <span class="identifier">Base</span><span class="special">,</span> <span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span>
 <span class="special">{</span>
     <span class="keyword">int</span> <span class="identifier">f</span><span class="special">()</span>
     <span class="special">{</span>
@@ -368,70 +350,79 @@
 <span class="special">};</span>
 </pre>
 <p>
-        Notice too that in addition to inheriting from <tt class="computeroutput"><span class="identifier">Base</span></tt>,
+        Notice too that in addition to inheriting from <code class="computeroutput"><span class="identifier">Base</span></code>,
-        we also multiply- inherited <tt class="computeroutput"><span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span></tt> (See <a href="../../../../v2/wrapper.html" target="_top">Wrapper</a>).
+        we also multiply- inherited <code class="computeroutput"><span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span></code> (See <a href="../../../../v2/wrapper.html" target="_top">Wrapper</a>).
-        The <tt class="computeroutput"><span class="identifier">wrapper</span></tt> template makes
+        The <code class="computeroutput"><span class="identifier">wrapper</span></code> template makes
         the job of wrapping classes that are meant to overridden in Python, easier.
       </p>
-<div class="informaltable"><table class="table">
+<div class="sidebar">
-<colgroup><col></colgroup>
+<p class="title"><b></b></p>
-<tbody><tr><td class="blurb">
-<span class="inlinemediaobject"><img src="../images/alert.png"></span> <span class="bold"><b>MSVC6/7 Workaround</b></span><br><br> If you are using
-              Microsoft Visual C++ 6 or 7, you have to write <tt class="computeroutput"><span class="identifier">f</span></tt>
-              as:<br><br><tt class="computeroutput"><span class="keyword">return</span> <span class="identifier">call</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get_override</span><span class="special">(</span><span class="string">"f"</span><span class="special">).</span><span class="identifier">ptr</span><span class="special">());</span></tt>.</td></tr></tbody>
-</table></div>
 <p>
-        BaseWrap's overridden virtual member function <tt class="computeroutput"><span class="identifier">f</span></tt>
+        <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><strong>MSVC6/7 Workaround</strong></span>
-        in effect calls the corresponding method of the Python object through <tt class="computeroutput"><span class="identifier">get_override</span></tt>.
       </p>
 <p>
-        Finally, exposing <tt class="computeroutput"><span class="identifier">Base</span></tt>:
+        If you are using Microsoft Visual C++ 6 or 7, you have to write <code class="computeroutput"><span class="identifier">f</span></code> as:
       </p>
-<pre class="programlisting">
+<p>
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">BaseWrap</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
+        <code class="computeroutput"><span class="keyword">return</span> <span class="identifier">call</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get_override</span><span class="special">(</span><span class="string">"f"</span><span class="special">).</span><span class="identifier">ptr</span><span class="special">());</span></code>.
+      </p>
+</div>
+<p>
+        BaseWrap's overridden virtual member function <code class="computeroutput"><span class="identifier">f</span></code>
+        in effect calls the corresponding method of the Python object through <code class="computeroutput"><span class="identifier">get_override</span></code>.
+      </p>
+<p>
+        Finally, exposing <code class="computeroutput"><span class="identifier">Base</span></code>:
+      </p>
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">BaseWrap</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">pure_virtual</span><span class="special">(&amp;</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">))</span>
     <span class="special">;</span>
 </pre>
-<p><tt class="computeroutput"><span class="identifier">pure_virtual</span></tt> signals Boost.Python
+<p>
-        that the function <tt class="computeroutput"><span class="identifier">f</span></tt> is a
+        <code class="computeroutput"><span class="identifier">pure_virtual</span></code> signals Boost.Python
+        that the function <code class="computeroutput"><span class="identifier">f</span></code> is a
         pure virtual function.
       </p>
-<div class="informaltable"><table class="table">
+<div class="note"><table border="0" summary="Note">
-<colgroup><col></colgroup>
+<tr>
-<tbody><tr><td class="blurb">
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
-<span class="inlinemediaobject"><img src="../images/note.png"></span> <span class="bold"><b>member function and methods</b></span><br><br> Python,
+<th align="left">Note</th>
-              like many object oriented languages uses the term <span class="bold"><b>methods</b></span>.
+</tr>
-              Methods correspond roughly to C++'s <span class="bold"><b>member functions</b></span>
+<tr><td align="left" valign="top">
-</td></tr></tbody>
+<p>
+          <span class="bold"><strong>member function and methods</strong></span>
+        </p>
+<p>
+          Python, like many object oriented languages uses the term <span class="bold"><strong>methods</strong></span>.
+          Methods correspond roughly to C++'s <span class="bold"><strong>member functions</strong></span>
+        </p>
+</td></tr>
 </table></div>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.virtual_functions_with_default_implementations"></a>Virtual Functions with Default Implementations</h3></div></div></div>
 <p>
-        Virtual Functions with Default ImplementationsWe've seen in the previous
+        We've seen in the previous section how classes with pure virtual functions
-        section how classes with pure virtual functions are wrapped using Boost.Python's
+        are wrapped using Boost.Python's <a href="../../../../v2/wrapper.html" target="_top">class
-        <a href="../../../../v2/wrapper.html" target="_top">class wrapper</a> facilities. If
+        wrapper</a> facilities. If we wish to wrap <span class="bold"><strong>non</strong></span>-pure-virtual
-        we wish to wrap <span class="bold"><b>non</b></span>-pure-virtual functions
+        functions instead, the mechanism is a bit different.
-        instead, the mechanism is a bit different.
       </p>
 <p>
-        Recall that in the <a href="exposing.html#python.class_virtual_functions" title="Class Virtual Functions">previous
+        Recall that in the <a class="link" href="exposing.html#python.class_virtual_functions" title="Class Virtual Functions">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>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Base</span>
-<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>
 </pre>
 <p>
-        had a pure virtual function <tt class="literal">f</tt>. If, however, its member
+        had a pure virtual function <code class="literal">f</code>. If, however, its member
-        function <tt class="literal">f</tt> was not declared as pure virtual:
+        function <code class="literal">f</code> was not declared as pure virtual:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Base</span>
-<span class="keyword">struct</span> <span class="identifier">Base</span>
 <span class="special">{</span>
     <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">Base</span><span class="special">()</span> <span class="special">{}</span>
     <span class="keyword">virtual</span> <span class="keyword">int</span> <span class="identifier">f</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> <span class="special">}</span>
@@ -440,8 +431,7 @@
 <p>
         We wrap it this way:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">BaseWrap</span> <span class="special">:</span> <span class="identifier">Base</span><span class="special">,</span> <span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">BaseWrap</span> <span class="special">:</span> <span class="identifier">Base</span><span class="special">,</span> <span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span>
 <span class="special">{</span>
     <span class="keyword">int</span> <span class="identifier">f</span><span class="special">()</span>
     <span class="special">{</span>
@@ -454,37 +444,42 @@
 <span class="special">};</span>
 </pre>
 <p>
-        Notice how we implemented <tt class="computeroutput"><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">f</span></tt>. Now,
+        Notice how we implemented <code class="computeroutput"><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">f</span></code>. Now,
-        we have to check if there is an override for <tt class="computeroutput"><span class="identifier">f</span></tt>.
+        we have to check if there is an override for <code class="computeroutput"><span class="identifier">f</span></code>.
-        If none, then we call <tt class="computeroutput"><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">()</span></tt>.
+        If none, then we call <code class="computeroutput"><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">()</span></code>.
       </p>
-<div class="informaltable"><table class="table">
+<div class="sidebar">
-<colgroup><col></colgroup>
+<p class="title"><b></b></p>
-<tbody><tr><td class="blurb">
+<p>
-<span class="inlinemediaobject"><img src="../images/alert.png"></span> <span class="bold"><b>MSVC6/7 Workaround</b></span><br><br> If you are using
+        <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><strong>MSVC6/7 Workaround</strong></span>
-              Microsoft Visual C++ 6 or 7, you have to rewrite the line with the
+      </p>
-              <tt class="computeroutput"><span class="special">*</span><span class="identifier">note</span><span class="special">*</span></tt> as:<br><br><tt class="computeroutput"><span class="keyword">return</span> <span class="identifier">call</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*&gt;(</span><span class="identifier">f</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">());</span></tt>.</td></tr></tbody>
+<p>
-</table></div>
+        If you are using Microsoft Visual C++ 6 or 7, you have to rewrite the line
+        with the <code class="computeroutput"><span class="special">*</span><span class="identifier">note</span><span class="special">*</span></code> as:
+      </p>
+<p>
+        <code class="computeroutput"><span class="keyword">return</span> <span class="identifier">call</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*&gt;(</span><span class="identifier">f</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">());</span></code>.
+      </p>
+</div>
 <p>
         Finally, exposing:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">BaseWrap</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">BaseWrap</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">default_f</span><span class="special">)</span>
     <span class="special">;</span>
 </pre>
 <p>
-        Take note that we expose both <tt class="computeroutput"><span class="special">&amp;</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span></tt> and <tt class="computeroutput"><span class="special">&amp;</span><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">default_f</span></tt>. Boost.Python needs to keep track
+        Take note that we expose both <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span></code> and <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">default_f</span></code>. Boost.Python needs to keep track
-        of 1) the dispatch function <tt class="literal">f</tt> and 2) the forwarding function
+        of 1) the dispatch function <code class="literal">f</code> and 2) the forwarding function
-        to its default implementation <tt class="literal">default_f</tt>. There's a special
+        to its default implementation <code class="literal">default_f</code>. There's a special
-        <tt class="literal">def</tt> function for this purpose.
+        <code class="literal">def</code> function for this purpose.
       </p>
 <p>
         In Python, the results would be as expected:
       </p>
-<p></p>
+<p>
-<pre class="programlisting">
+      </p>
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">base</span> <span class="special">=</span> <span class="identifier">Base</span><span class="special">()</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">base</span> <span class="special">=</span> <span class="identifier">Base</span><span class="special">()</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="keyword">class</span> <span class="identifier">Derived</span><span class="special">(</span><span class="identifier">Base</span><span class="special">):</span>
 <span class="special">...</span>     <span class="keyword">def</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span>
 <span class="special">...</span>         <span class="keyword">return</span> <span class="number">42</span>
@@ -492,39 +487,37 @@
 <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>
 <p>
-        Calling <tt class="literal">base.f()</tt>:
+        Calling <code class="literal">base.f()</code>:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">base</span><span class="special">.</span><span class="identifier">f</span><span class="special">()</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">base</span><span class="special">.</span><span class="identifier">f</span><span class="special">()</span>
 <span class="number">0</span>
 </pre>
 <p>
-        Calling <tt class="literal">derived.f()</tt>:
+        Calling <code class="literal">derived.f()</code>:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">derived</span><span class="special">.</span><span class="identifier">f</span><span class="special">()</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">derived</span><span class="special">.</span><span class="identifier">f</span><span class="special">()</span>
 <span class="number">42</span>
 </pre>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.class_operators_special_functions"></a>Class Operators/Special Functions</h3></div></div></div>
-<a name="class_operators_special_functions.class_operators_special_functionspython_operators"></a><h2>
+<a name="class_operators_special_functions.python_operators"></a><h3>
-<a name="id447955"></a>
+<a name="id764956"></a>
-        Class Operators/Special FunctionsPython Operators
+        Python Operators
-      </h2>
+      </h3>
 <p>
         C is well known for the abundance of operators. C++ extends this to the extremes
         by allowing operator overloading. Boost.Python takes advantage of this and
         makes it easy to wrap C++ operator-powered classes.
       </p>
 <p>
-        Consider a file position class <tt class="literal">FilePos</tt> and a set of operators
+        Consider a file position class <code class="literal">FilePos</code> and a set of operators
         that take on FilePos instances:
       </p>
-<p></p>
+<p>
-<pre class="programlisting">
+      </p>
-<span class="keyword">class</span> <span class="identifier">FilePos</span> <span class="special">{</span> <span class="comment">/*...*/</span> <span class="special">};</span>
+<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">FilePos</span> <span class="special">{</span> <span class="comment">/*...*/</span> <span class="special">};</span>
 
 <span class="identifier">FilePos</span>     <span class="keyword">operator</span><span class="special">+(</span><span class="identifier">FilePos</span><span class="special">,</span> <span class="keyword">int</span><span class="special">);</span>
 <span class="identifier">FilePos</span>     <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">FilePos</span><span class="special">);</span>
@@ -538,8 +531,7 @@
         The class and the various operators can be mapped to Python rather easily
         and intuitively:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">FilePos</span><span class="special">&gt;(</span><span class="string">"FilePos"</span><span class="special">)</span>
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">FilePos</span><span class="special">&gt;(</span><span class="string">"FilePos"</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">+</span> <span class="keyword">int</span><span class="special">())</span>          <span class="comment">// __add__
 </span>    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="keyword">int</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">self</span><span class="special">)</span>          <span class="comment">// __radd__
 </span>    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">-</span> <span class="identifier">self</span><span class="special">)</span>           <span class="comment">// __sub__
@@ -551,16 +543,16 @@
 <p>
         The code snippet above is very clear and needs almost no explanation at all.
         It is virtually the same as the operators' signatures. Just take note that
-        <tt class="literal">self</tt> refers to FilePos object. Also, not every class
+        <code class="literal">self</code> refers to FilePos object. Also, not every class
-        <tt class="literal">T</tt> that you might need to interact with in an operator
+        <code class="literal">T</code> that you might need to interact with in an operator
-        expression is (cheaply) default-constructible. You can use <tt class="literal">other&lt;T&gt;()</tt>
+        expression is (cheaply) default-constructible. You can use <code class="literal">other&lt;T&gt;()</code>
-        in place of an actual <tt class="literal">T</tt> instance when writing "self
+        in place of an actual <code class="literal">T</code> instance when writing "self
         expressions".
       </p>
-<a name="class_operators_special_functions.special_methods"></a><h2>
+<a name="class_operators_special_functions.special_methods"></a><h3>
-<a name="id448698"></a>
+<a name="id765570"></a>
         Special Methods
-      </h2>
+      </h3>
 <p>
         Python has a few more <span class="emphasis"><em>Special Methods</em></span>. Boost.Python
         supports all of the standard special method names supported by real Python
@@ -568,8 +560,7 @@
         wrap C++ functions that correspond to these Python <span class="emphasis"><em>special functions</em></span>.
         Example:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">Rational</span>
-<span class="keyword">class</span> <span class="identifier">Rational</span>
 <span class="special">{</span> <span class="keyword">public</span><span class="special">:</span> <span class="keyword">operator</span> <span class="keyword">double</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span> <span class="special">};</span>
 
 <span class="identifier">Rational</span> <span class="identifier">pow</span><span class="special">(</span><span class="identifier">Rational</span><span class="special">,</span> <span class="identifier">Rational</span><span class="special">);</span>
@@ -586,23 +577,31 @@
 <p>
         Need we say more?
       </p>
-<div class="informaltable"><table class="table">
+<div class="note"><table border="0" summary="Note">
-<colgroup><col></colgroup>
+<tr>
-<tbody><tr><td class="blurb">
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
-<span class="inlinemediaobject"><img src="../images/note.png"></span>
+<th align="left">Note</th>
-              What is the business of <tt class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></tt>? Well, the method <tt class="computeroutput"><span class="identifier">str</span></tt> requires the <tt class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></tt> to do its work (i.e. <tt class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></tt>
+</tr>
-              is used by the method defined by <tt class="computeroutput"><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></tt>.</td></tr></tbody>
+<tr><td align="left" valign="top"><p>
+          What is the business of <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code>? Well, the method <code class="computeroutput"><span class="identifier">str</span></code> requires the <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code> to do its work (i.e. <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code>
+          is used by the method defined by <code class="computeroutput"><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></code>.
+        </p></td></tr>
 </table></div>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><small>Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
-      de Guzman, David Abrahams</small></td>
+      de Guzman, David Abrahams<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
+        http://www.boost.org/LICENSE_1_0.txt </a>)
+      </p>
+</div></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="hello.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="functions.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="hello.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="functions.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

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

@@ -1,28 +1,28 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>Functions</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="prev" href="exposing.html" title=" Exposing Classes">
+<link rel="prev" href="exposing.html" title="Exposing Classes">
-<link rel="next" href="object.html" title=" Object Interface">
+<link rel="next" href="object.html" title="Object Interface">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
-</table>
+</tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="exposing.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="object.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="exposing.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="object.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="python.functions"></a>Functions</h2></div></div></div>
 <div class="toc"><dl>
@@ -32,16 +32,18 @@
 <dt><span class="section"><a href="functions.html#python.auto_overloading">Auto-Overloading</a></span></dt>
 </dl></div>
 <p>
-      FunctionsIn this chapter, we'll look at Boost.Python powered functions in closer
+      In this chapter, we'll look at Boost.Python powered functions in closer detail.
-      detail. We shall see some facilities to make exposing C++ functions to Python
+      We will see some facilities to make exposing C++ functions to Python safe from
-      safe from potential pifalls such as dangling pointers and references. We shall
+      potential pifalls such as dangling pointers and references. We will also see
-      also see facilities that will make it even easier for us to expose C++ functions
+      facilities that will make it even easier for us to expose C++ functions that
-      that take advantage of C++ features such as overloading and default arguments.
+      take advantage of C++ features such as overloading and default arguments.
     </p>
-<div class="blockquote"><blockquote class="blockquote"><p><span class="emphasis"><em>Read on...</em></span></p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+        <span class="emphasis"><em>Read on...</em></span>
+      </p></blockquote></div>
 <p>
       But before you do, you might want to fire up Python 2.2 or later and type
-      <tt class="literal">&gt;&gt;&gt; import this</tt>.
+      <code class="literal">&gt;&gt;&gt; import this</code>.
     </p>
 <pre class="programlisting">&gt;&gt;&gt; import this
 The Zen of Python, by Tim Peters
@@ -60,37 +62,35 @@ In the face of ambiguity, refuse the temptation to guess.
 There should be one-- and preferably only one --obvious way to do it
 Although that way may not be obvious at first unless you're Dutch.
 Now is better than never.
-Although never is often better than <span class="bold"><b>right</b></span> now.
+Although never is often better than <span class="bold"><strong>right</strong></span> now.
 If the implementation is hard to explain, it's a bad idea.
 If the implementation is easy to explain, it may be a good idea.
 Namespaces are one honking great idea -- let's do more of those!
 </pre>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.call_policies"></a>Call Policies</h3></div></div></div>
 <p>
-        Call PoliciesIn C++, we often deal with arguments and return types such as
+        In C++, we often deal with arguments and return types such as pointers and
-        pointers and references. Such primitive types are rather, ummmm, low level
+        references. Such primitive types are rather, ummmm, low level and they really
-        and they really don't tell us much. At the very least, we don't know the
+        don't tell us much. At the very least, we don't know the owner of the pointer
-        owner of the pointer or the referenced object. No wonder languages such as
+        or the referenced object. No wonder languages such as Java and Python never
-        Java and Python never deal with such low level entities. In C++, it's usually
+        deal with such low level entities. In C++, it's usually considered a good
-        considered a good practice to use smart pointers which exactly describe ownership
+        practice to use smart pointers which exactly describe ownership semantics.
-        semantics. Still, even good C++ interfaces use raw references and pointers
+        Still, even good C++ interfaces use raw references and pointers sometimes,
-        sometimes, so Boost.Python must deal with them. To do this, it may need your
+        so Boost.Python must deal with them. To do this, it may need your help. Consider
-        help. Consider the following C++ function:
+        the following C++ function:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">);</span>
-<span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">);</span>
 </pre>
 <p>
         How should the library wrap this function? A naive approach builds a Python
         X object around result reference. This strategy might or might not work out.
         Here's an example where it didn't
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="preprocessor"># x</span> <span class="identifier">refers</span> <span class="identifier">to</span> <span class="identifier">some</span> <span class="identifier">C</span><span class="special">++</span> <span class="identifier">X</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">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="preprocessor"># CRASH</span><span class="special">!</span>
 </pre>
 <p>
         What's the problem?
@@ -98,8 +98,7 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         Well, what if f() was implemented as shown below:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">)</span>
-<span class="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>
@@ -116,28 +115,30 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         Here's what's happening:
       </p>
-<div class="orderedlist"><ol type="1">
+<div class="orderedlist"><ol class="orderedlist" type="1">
-<li>
+<li class="listitem">
-<tt class="literal">f</tt> is called passing in a reference to <tt class="literal">y</tt>
+            <code class="literal">f</code> is called passing in a reference to <code class="literal">y</code>
-          and a pointer to <tt class="literal">z</tt>
+            and a pointer to <code class="literal">z</code>
-</li>
+          </li>
-<li>
+<li class="listitem">
-          A reference to <tt class="literal">y.x</tt> is returned
+            A reference to <code class="literal">y.x</code> is returned
-        </li>
+          </li>
-<li>
+<li class="listitem">
-<tt class="literal">y</tt> is deleted. <tt class="literal">x</tt> is a dangling reference
+            <code class="literal">y</code> is deleted. <code class="literal">x</code> is a dangling reference
-        </li>
+          </li>
-<li>
+<li class="listitem">
-<tt class="literal">x.some_method()</tt> is called
+            <code class="literal">x.some_method()</code> is called
-        </li>
+          </li>
-<li><span class="bold"><b>BOOM!</b></span></li>
+<li class="listitem">
+            <span class="bold"><strong>BOOM!</strong></span>
+          </li>
 </ol></div>
 <p>
         We could copy result into a new object:
       </p>
-<p></p>
+<p>
-<pre class="programlisting">
+      </p>
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">).</span><span class="identifier">set</span><span class="special">(</span><span class="number">42</span><span class="special">)</span> <span class="comment"># Result disappears
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">).</span><span class="identifier">set</span><span class="special">(</span><span class="number">42</span><span class="special">)</span> <span class="comment"># Result disappears
 </span><span class="special">&gt;&gt;&gt;</span> <span class="identifier">y</span><span class="special">.</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span>       <span class="comment"># No crash, but still bad
 </span><span class="number">3.14</span>
 </pre>
@@ -149,28 +150,26 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         Our problems do not end there. Suppose Y is implemented as follows:
       </p>
-<p></p>
+<p>
-<pre class="programlisting">
+      </p>
-<span class="keyword">struct</span> <span class="identifier">Y</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Y</span>
 <span class="special">{</span>
     <span class="identifier">X</span> <span class="identifier">x</span><span class="special">;</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">;</span>
     <span class="keyword">int</span> <span class="identifier">z_value</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">z</span><span class="special">-&gt;</span><span class="identifier">value</span><span class="special">();</span> <span class="special">}</span>
 <span class="special">};</span>
 </pre>
 <p>
-        Notice that the data member <tt class="literal">z</tt> is held by class Y using
+        Notice that the data member <code class="literal">z</code> is held by class Y using
         a raw pointer. Now we have a potential dangling pointer problem inside Y:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="preprocessor"># y</span> <span class="identifier">refers</span> <span class="identifier">to</span> <span class="identifier">z</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">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="preprocessor"># Kill</span> <span class="identifier">the</span> <span class="identifier">z</span> <span class="identifier">object</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">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="preprocessor"># CRASH</span><span class="special">!</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>
 <p>
-        For reference, here's the implementation of <tt class="literal">f</tt> again:
+        For reference, here's the implementation of <code class="literal">f</code> again:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">)</span>
-<span class="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>
@@ -179,71 +178,70 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         Here's what's happening:
       </p>
-<div class="orderedlist"><ol type="1">
+<div class="orderedlist"><ol class="orderedlist" type="1">
-<li>
+<li class="listitem">
-<tt class="literal">f</tt> is called passing in a reference to <tt class="literal">y</tt>
+            <code class="literal">f</code> is called passing in a reference to <code class="literal">y</code>
-          and a pointer to <tt class="literal">z</tt>
+            and a pointer to <code class="literal">z</code>
-</li>
+          </li>
-<li>
+<li class="listitem">
-          A pointer to <tt class="literal">z</tt> is held by <tt class="literal">y</tt>
+            A pointer to <code class="literal">z</code> is held by <code class="literal">y</code>
-</li>
+          </li>
-<li>
+<li class="listitem">
-          A reference to <tt class="literal">y.x</tt> is returned
+            A reference to <code class="literal">y.x</code> is returned
-        </li>
+          </li>
-<li>
+<li class="listitem">
-<tt class="literal">z</tt> is deleted. <tt class="literal">y.z</tt> is a dangling pointer
+            <code class="literal">z</code> is deleted. <code class="literal">y.z</code> is a dangling
-        </li>
+            pointer
-<li>
+          </li>
-<tt class="literal">y.z_value()</tt> is called
+<li class="listitem">
-        </li>
+            <code class="literal">y.z_value()</code> is called
-<li>
+          </li>
-<tt class="literal">z-&gt;value()</tt> is called
+<li class="listitem">
-        </li>
+            <code class="literal">z-&gt;value()</code> is called
-<li><span class="bold"><b>BOOM!</b></span></li>
+          </li>
+<li class="listitem">
+            <span class="bold"><strong>BOOM!</strong></span>
+          </li>
 </ol></div>
-<a name="call_policies.call_policies"></a><h2>
+<a name="call_policies.call_policies"></a><h3>
-<a name="id450599"></a>
+<a name="id767074"></a>
         Call Policies
-      </h2>
+      </h3>
 <p>
         Call Policies may be used in situations such as the example detailed above.
-        In our example, <tt class="literal">return_internal_reference</tt> and <tt class="literal">with_custodian_and_ward</tt>
+        In our example, <code class="literal">return_internal_reference</code> and <code class="literal">with_custodian_and_ward</code>
         are our friends:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">,</span>
-<span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">,</span>
     <span class="identifier">return_internal_reference</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span>
         <span class="identifier">with_custodian_and_ward</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">&gt;</span> <span class="special">&gt;());</span>
 </pre>
 <p>
-        What are the <tt class="literal">1</tt> and <tt class="literal">2</tt> parameters, you
+        What are the <code class="literal">1</code> and <code class="literal">2</code> parameters, you
         ask?
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">return_internal_reference</span><span class="special">&lt;</span><span class="number">1</span>
-<span class="identifier">return_internal_reference</span><span class="special">&lt;</span><span class="number">1</span>
 </pre>
 <p>
-        Informs Boost.Python that the first argument, in our case <tt class="literal">Y&amp;
+        Informs Boost.Python that the first argument, in our case <code class="literal">Y&amp;
-        y</tt>, is the owner of the returned reference: <tt class="literal">X&amp;</tt>.
+        y</code>, is the owner of the returned reference: <code class="literal">X&amp;</code>.
-        The "<tt class="literal">1</tt>" simply specifies the first argument.
+        The "<code class="literal">1</code>" simply specifies the first argument.
-        In short: "return an internal reference <tt class="literal">X&amp;</tt> owned
+        In short: "return an internal reference <code class="literal">X&amp;</code> owned
-        by the 1st argument <tt class="literal">Y&amp; y</tt>".
+        by the 1st argument <code class="literal">Y&amp; y</code>".
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">with_custodian_and_ward</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">&gt;</span>
-<span class="identifier">with_custodian_and_ward</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">&gt;</span>
 </pre>
 <p>
         Informs Boost.Python that the lifetime of the argument indicated by ward
-        (i.e. the 2nd argument: <tt class="literal">Z* z</tt>) is dependent on the lifetime
+        (i.e. the 2nd argument: <code class="literal">Z* z</code>) is dependent on the lifetime
-        of the argument indicated by custodian (i.e. the 1st argument: <tt class="literal">Y&amp;
+        of the argument indicated by custodian (i.e. the 1st argument: <code class="literal">Y&amp;
-        y</tt>).
+        y</code>).
       </p>
 <p>
         It is also important to note that we have defined two policies above. Two
         or more policies can be composed by chaining. Here's the general syntax:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">policy1</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...,</span>
-<span class="identifier">policy1</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...,</span>
     <span class="identifier">policy2</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...,</span>
         <span class="identifier">policy3</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...&gt;</span> <span class="special">&gt;</span> <span class="special">&gt;</span>
 </pre>
@@ -251,60 +249,65 @@ Namespaces are one honking great idea -- let's do more of those!
         Here is the list of predefined call policies. A complete reference detailing
         these can be found <a href="../../../../v2/reference.html#models_of_call_policies" target="_top">here</a>.
       </p>
-<div class="itemizedlist"><ul type="disc">
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li>
+<li class="listitem">
-<span class="bold"><b>with_custodian_and_ward</b></span><br> Ties lifetimes
+            <span class="bold"><strong>with_custodian_and_ward</strong></span>: Ties lifetimes
-          of the arguments
+            of the arguments
-        </li>
+          </li>
-<li>
+<li class="listitem">
-<span class="bold"><b>with_custodian_and_ward_postcall</b></span><br>
+            <span class="bold"><strong>with_custodian_and_ward_postcall</strong></span>: Ties
-          Ties lifetimes of the arguments and results
+            lifetimes of the arguments and results
-        </li>
+          </li>
-<li>
+<li class="listitem">
-<span class="bold"><b>return_internal_reference</b></span><br> Ties lifetime
+            <span class="bold"><strong>return_internal_reference</strong></span>: Ties lifetime
-          of one argument to that of result
+            of one argument to that of result
-        </li>
+          </li>
-<li>
+<li class="listitem">
-<span class="bold"><b>return_value_policy&lt;T&gt; with T one of:</b></span><br>
+            <span class="bold"><strong>return_value_policy&lt;T&gt; with T one of:</strong></span>
-</li>
+            <div class="itemizedlist"><ul class="itemizedlist" type="circle">
-<li>
+<li class="listitem">
-<span class="bold"><b>reference_existing_object</b></span><br> naive
+                  <span class="bold"><strong>reference_existing_object</strong></span>: naive
-          (dangerous) approach
+                  (dangerous) approach
-        </li>
+                </li>
-<li>
+<li class="listitem">
-<span class="bold"><b>copy_const_reference</b></span><br> Boost.Python
+                  <span class="bold"><strong>copy_const_reference</strong></span>: Boost.Python
-          v1 approach
+                  v1 approach
-        </li>
+                </li>
-<li>
+<li class="listitem">
-<span class="bold"><b>copy_non_const_reference</b></span><br>
+                  <span class="bold"><strong>copy_non_const_reference</strong></span>:
-</li>
+                </li>
-<li>
+<li class="listitem">
-<span class="bold"><b>manage_new_object</b></span><br> Adopt a pointer
+                  <span class="bold"><strong>manage_new_object</strong></span>: Adopt a pointer
-          and hold the instance
+                  and hold the instance
-        </li>
+                </li>
 </ul></div>
-<div class="informaltable"><table class="table">
+          </li>
-<colgroup><col></colgroup>
+</ul></div>
-<tbody><tr><td class="blurb">
+<div class="sidebar">
-<span class="inlinemediaobject"><img src="../images/smiley.png"></span> <span class="bold"><b>Remember the Zen, Luke:</b></span><br><br> "Explicit
+<p class="title"><b></b></p>
-              is better than implicit"<br> "In the face of ambiguity,
+<p>
-              refuse the temptation to guess"<br>
+        <span class="inlinemediaobject"><img src="../images/smiley.png" alt="smiley"></span> <span class="bold"><strong>Remember the Zen, Luke:</strong></span>
-</td></tr></tbody>
+      </p>
-</table></div>
+<p>
+        "Explicit is better than implicit"
+      </p>
+<p>
+        "In the face of ambiguity, refuse the temptation to guess"
+      </p>
 </div>
-<div class="section" lang="en">
+</div>
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.overloading"></a>Overloading</h3></div></div></div>
 <p>
-        OverloadingThe following illustrates a scheme for manually wrapping an overloaded
+        The following illustrates a scheme for manually wrapping an overloaded member
-        member functions. Of course, the same technique can be applied to wrapping
+        functions. Of course, the same technique can be applied to wrapping overloaded
-        overloaded non-member functions.
+        non-member functions.
       </p>
 <p>
         We have here our C++ class:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">X</span>
-<span class="keyword">struct</span> <span class="identifier">X</span>
 <span class="special">{</span>
     <span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">)</span>
     <span class="special">{</span>
@@ -328,11 +331,10 @@ Namespaces are one honking great idea -- let's do more of those!
 <span class="special">};</span>
 </pre>
 <p>
-        Class X has 4 overloaded functions. We shall start by introducing some member
+        Class X has 4 overloaded functions. We will start by introducing some member
         function pointer variables:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx1</span><span class="special">)(</span><span class="keyword">int</span><span class="special">)</span>              <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
-<span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx1</span><span class="special">)(</span><span class="keyword">int</span><span class="special">)</span>              <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
 <span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx2</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">)</span>      <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
 <span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx3</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">char</span><span class="special">)=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
 <span class="keyword">int</span>     <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx4</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)</span>    <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
@@ -340,45 +342,40 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         With these in hand, we can proceed to define and wrap this for Python:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx1</span><span class="special">)</span>
-<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx1</span><span class="special">)</span>
 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx2</span><span class="special">)</span>
 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx3</span><span class="special">)</span>
 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx4</span><span class="special">)</span>
 </pre>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.default_arguments"></a>Default Arguments</h3></div></div></div>
 <p>
-        Default ArgumentsBoost.Python wraps (member) function pointers. Unfortunately,
+        Boost.Python wraps (member) function pointers. Unfortunately, C++ function
-        C++ function pointers carry no default argument info. Take a function <tt class="literal">f</tt>
+        pointers carry no default argument info. Take a function <code class="literal">f</code>
         with default arguments:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span> <span class="special">=</span> <span class="number">3.14</span><span class="special">,</span> <span class="keyword">char</span> <span class="keyword">const</span><span class="special">*</span> <span class="special">=</span> <span class="string">"hello"</span><span class="special">);</span>
-<span class="keyword">int</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span> <span class="special">=</span> <span class="number">3.14</span><span class="special">,</span> <span class="keyword">char</span> <span class="keyword">const</span><span class="special">*</span> <span class="special">=</span> <span class="string">"hello"</span><span class="special">);</span>
 </pre>
 <p>
-        But the type of a pointer to the function <tt class="literal">f</tt> has no information
+        But the type of a pointer to the function <code class="literal">f</code> has no information
         about its default arguments:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">int</span><span class="special">(*</span><span class="identifier">g</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span><span class="keyword">double</span><span class="special">,</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*)</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">;</span>    <span class="comment">// defaults lost!
-<span class="keyword">int</span><span class="special">(*</span><span class="identifier">g</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span><span class="keyword">double</span><span class="special">,</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*)</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">;</span>    <span class="comment">// defaults lost!
 </span></pre>
 <p>
-        When we pass this function pointer to the <tt class="literal">def</tt> function,
+        When we pass this function pointer to the <code class="literal">def</code> function,
         there is no way to retrieve the default arguments:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">);</span>                            <span class="comment">// defaults lost!
-<span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">);</span>                            <span class="comment">// defaults lost!
 </span></pre>
 <p>
         Because of this, when wrapping C++ code, we had to resort to manual wrapping
-        as outlined in the <a href="functions.html#python.overloading" title="Overloading">previous section</a>,
+        as outlined in the <a class="link" href="functions.html#python.overloading" title="Overloading">previous section</a>,
         or writing thin wrappers:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="comment">// write "thin wrappers"
-<span class="comment">// write "thin wrappers"
 </span><span class="keyword">int</span> <span class="identifier">f1</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">{</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span> <span class="special">}</span>
 <span class="keyword">int</span> <span class="identifier">f2</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">)</span> <span class="special">{</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">);</span> <span class="special">}</span>
 
@@ -392,23 +389,22 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         When you want to wrap functions (or member functions) that either:
       </p>
-<div class="itemizedlist"><ul type="disc">
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li>
+<li class="listitem">
-          have default arguments, or
+            have default arguments, or
-        </li>
+          </li>
-<li>
+<li class="listitem">
-          are overloaded with a common sequence of initial arguments
+            are overloaded with a common sequence of initial arguments
-        </li>
+          </li>
 </ul></div>
-<a name="default_arguments.boost_python_function_overloads"></a><h2>
+<a name="default_arguments.boost_python_function_overloads"></a><h3>
-<a name="id452559"></a>
+<a name="id769042"></a>
         BOOST_PYTHON_FUNCTION_OVERLOADS
-      </h2>
+      </h3>
 <p>
         Boost.Python now has a way to make it easier. For instance, given a function:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">char</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">c</span> <span class="special">=</span> <span class="number">2</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="number">3</span><span class="special">)</span>
-<span class="keyword">int</span> <span class="identifier">foo</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">char</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">c</span> <span class="special">=</span> <span class="number">2</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="number">3</span><span class="special">)</span>
 <span class="special">{</span>
     <span class="comment">/*...*/</span>
 <span class="special">}</span>
@@ -416,24 +412,22 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         The macro invocation:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">BOOST_PYTHON_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">foo_overloads</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">4</span><span class="special">)</span>
-<span class="identifier">BOOST_PYTHON_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">foo_overloads</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">4</span><span class="special">)</span>
 </pre>
 <p>
         will automatically create the thin wrappers for us. This macro will create
-        a class <tt class="literal">foo_overloads</tt> that can be passed on to <tt class="literal">def(...)</tt>.
+        a class <code class="literal">foo_overloads</code> that can be passed on to <code class="literal">def(...)</code>.
         The third and fourth macro argument are the minimum arguments and maximum
-        arguments, respectively. In our <tt class="literal">foo</tt> function the minimum
+        arguments, respectively. In our <code class="literal">foo</code> function the minimum
-        number of arguments is 1 and the maximum number of arguments is 4. The <tt class="literal">def(...)</tt>
+        number of arguments is 1 and the maximum number of arguments is 4. The <code class="literal">def(...)</code>
         function will automatically add all the foo variants for us:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
-<span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
 </pre>
-<a name="default_arguments.boost_python_member_function_overloads"></a><h2>
+<a name="default_arguments.boost_python_member_function_overloads"></a><h3>
-<a name="id452863"></a>
+<a name="id769301"></a>
         BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS
-      </h2>
+      </h3>
 <p>
         Objects here, objects there, objects here there everywhere. More frequently
         than anything else, we need to expose member functions of our classes to
@@ -442,12 +436,11 @@ Namespaces are one honking great idea -- let's do more of those!
         play. Another macro is provided to make this a breeze.
       </p>
 <p>
-        Like <tt class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</tt>, <tt class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt>
+        Like <code class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</code>, <code class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</code>
         may be used to automatically create the thin wrappers for wrapping member
         functions. Let's have an example:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">george</span>
-<span class="keyword">struct</span> <span class="identifier">george</span>
 <span class="special">{</span>
     <span class="keyword">void</span>
     <span class="identifier">wack_em</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span> <span class="keyword">char</span> <span class="identifier">c</span> <span class="special">=</span> <span class="char">'x'</span><span class="special">)</span>
@@ -459,34 +452,31 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         The macro invocation:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">george_overloads</span><span class="special">,</span> <span class="identifier">wack_em</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">3</span><span class="special">)</span>
-<span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">george_overloads</span><span class="special">,</span> <span class="identifier">wack_em</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">3</span><span class="special">)</span>
 </pre>
 <p>
-        will generate a set of thin wrappers for george's <tt class="literal">wack_em</tt>
+        will generate a set of thin wrappers for george's <code class="literal">wack_em</code>
         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 class="literal">george_overloads</tt> that can then be used
+        in a class named <code class="literal">george_overloads</code> that can then be used
-        as an argument to <tt class="literal">def(...)</tt>:
+        as an argument to <code class="literal">def(...)</code>:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"wack_em"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">george</span><span class="special">::</span><span class="identifier">wack_em</span><span class="special">,</span> <span class="identifier">george_overloads</span><span class="special">());</span>
-<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"wack_em"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">george</span><span class="special">::</span><span class="identifier">wack_em</span><span class="special">,</span> <span class="identifier">george_overloads</span><span class="special">());</span>
 </pre>
 <p>
         See the <a href="../../../../v2/overloads.html#BOOST_PYTHON_FUNCTION_OVERLOADS-spec" target="_top">overloads
         reference</a> for details.
       </p>
-<a name="default_arguments.init_and_optional"></a><h2>
+<a name="default_arguments.init_and_optional"></a><h3>
-<a name="id453212"></a>
+<a name="id769596"></a>
         init and optional
-      </h2>
+      </h3>
 <p>
         A similar facility is provided for class constructors, again, with default
-        arguments or a sequence of overloads. Remember <tt class="literal">init&lt;...&gt;</tt>?
+        arguments or a sequence of overloads. Remember <code class="literal">init&lt;...&gt;</code>?
         For example, given a class X with a constructor:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">X</span>
-<span class="keyword">struct</span> <span class="identifier">X</span>
 <span class="special">{</span>
     <span class="identifier">X</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">char</span> <span class="identifier">b</span> <span class="special">=</span> <span class="char">'D'</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">c</span> <span class="special">=</span> <span class="string">"constructor"</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">);</span>
     <span class="comment">/*...*/</span>
@@ -495,25 +485,23 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         You can easily add this constructor to Boost.Python in one shot:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">init</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;</span> <span class="special">&gt;())</span>
-<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">init</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;</span> <span class="special">&gt;())</span>
 </pre>
 <p>
-        Notice the use of <tt class="literal">init&lt;...&gt;</tt> and <tt class="literal">optional&lt;...&gt;</tt>
+        Notice the use of <code class="literal">init&lt;...&gt;</code> and <code class="literal">optional&lt;...&gt;</code>
         to signify the default (optional arguments).
       </p>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.auto_overloading"></a>Auto-Overloading</h3></div></div></div>
 <p>
-        Auto-OverloadingIt was mentioned in passing in the previous section that
+        It was mentioned in passing in the previous section that <code class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</code>
-        <tt class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</tt> and <tt class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt>
+        and <code class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</code> can also be
-        can also be used for overloaded functions and member functions with a common
+        used for overloaded functions and member functions with a common sequence
-        sequence of initial arguments. Here is an example:
+        of initial arguments. Here is an example:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><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="special">{</span>
    <span class="comment">/*...*/</span>
 <span class="special">}</span>
@@ -537,66 +525,66 @@ Namespaces are one honking great idea -- let's do more of those!
         Like in the previous section, we can generate thin wrappers for these overloaded
         functions in one-shot:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">BOOST_PYTHON_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">foo_overloads</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">3</span><span class="special">)</span>
-<span class="identifier">BOOST_PYTHON_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">foo_overloads</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">3</span><span class="special">)</span>
 </pre>
 <p>
         Then...
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="special">(</span><span class="keyword">void</span><span class="special">(*)(</span><span class="keyword">bool</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">))</span><span class="number">0</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
-<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
 </pre>
 <p>
         Notice though that we have a situation now where we have a minimum of zero
         (0) arguments and a maximum of 3 arguments.
       </p>
-<a name="auto_overloading.manual_wrapping"></a><h2>
+<a name="auto_overloading.manual_wrapping"></a><h3>
-<a name="id453917"></a>
+<a name="id770226"></a>
         Manual Wrapping
-      </h2>
+      </h3>
 <p>
-        It is important to emphasize however that <span class="bold"><b>the overloaded
+        It is important to emphasize however that <span class="bold"><strong>the overloaded
-        functions must have a common sequence of initial arguments</b></span>. Otherwise,
+        functions must have a common sequence of initial arguments</strong></span>. Otherwise,
         our scheme above will not work. If this is not the case, we have to wrap
-        our functions <a href="functions.html#python.overloading" title="Overloading">manually</a>.
+        our functions <a class="link" href="functions.html#python.overloading" title="Overloading">manually</a>.
       </p>
 <p>
         Actually, we can mix and match manual wrapping of overloaded functions and
-        automatic wrapping through <tt class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt>
+        automatic wrapping through <code class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</code>
-        and its sister, <tt class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</tt>. Following
+        and its sister, <code class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</code>. Following
-        up on our example presented in the section <a href="functions.html#python.overloading" title="Overloading">on
+        up on our example presented in the section <a class="link" href="functions.html#python.overloading" title="Overloading">on
         overloading</a>, since the first 4 overload functins have a common sequence
-        of initial arguments, we can use <tt class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt>
+        of initial arguments, we can use <code class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</code>
-        to automatically wrap the first three of the <tt class="literal">def</tt>s and
+        to automatically wrap the first three of the <code class="literal">def</code>s and
         manually wrap just the last. Here's how we'll do this:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">xf_overloads</span><span class="special">,</span> <span class="identifier">f</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">4</span><span class="special">)</span>
-<span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">xf_overloads</span><span class="special">,</span> <span class="identifier">f</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">4</span><span class="special">)</span>
 </pre>
 <p>
         Create a member function pointers as above for both X::f overloads:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx1</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">char</span><span class="special">)</span>    <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
-<span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx1</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">char</span><span class="special">)</span>    <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
 <span class="keyword">int</span>     <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx2</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)</span>        <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
 </pre>
 <p>
         Then...
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx1</span><span class="special">,</span> <span class="identifier">xf_overloads</span><span class="special">());</span>
-<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx1</span><span class="special">,</span> <span class="identifier">xf_overloads</span><span class="special">());</span>
 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx2</span><span class="special">)</span>
 </pre>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><small>Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
-      de Guzman, David Abrahams</small></td>
+      de Guzman, David Abrahams<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
+        http://www.boost.org/LICENSE_1_0.txt </a>)
+      </p>
+</div></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="exposing.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="object.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="exposing.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="object.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

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

@@ -1,282 +1,195 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title> Building Hello World</title>
+<title>Building Hello World</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="prev" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="prev" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="next" href="exposing.html" title=" Exposing Classes">
+<link rel="next" href="exposing.html" title="Exposing Classes">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
-</table>
+</tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="../index.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="exposing.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="../index.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="exposing.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="python.hello"></a> Building Hello World</h2></div></div></div>
-<a name="hello._building_hello_worldfrom_start_to_finish"></a><h2>
+<a name="hello.from_start_to_finish"></a><h3>
-<a name="id442456"></a>
+<a name="id760024"></a>
-      Building Hello WorldFrom Start To Finish
+      From Start To Finish
-    </h2>
+    </h3>
 <p>
       Now the first thing you'd want to do is to build the Hello World module and
-      try it for yourself in Python. In this section, we shall outline the steps
+      try it for yourself in Python. In this section, we will outline the steps necessary
-      necessary to achieve that. We shall use the build tool that comes bundled with
+      to achieve that. We will use the build tool that comes bundled with every boost
-      every boost distribution: <span class="bold"><b>bjam</b></span>.
+      distribution: <span class="bold"><strong>bjam</strong></span>.
     </p>
-<div class="informaltable"><table class="table">
+<div class="note"><table border="0" summary="Note">
-<colgroup><col></colgroup>
+<tr>
-<tbody><tr><td class="blurb">
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
-<span class="inlinemediaobject"><img src="../images/note.png"></span> <span class="bold"><b>Building without bjam</b></span><br><br> Besides bjam,
+<th align="left">Note</th>
-            there are of course other ways to get your module built. What's written
+</tr>
-            here should not be taken as "the one and only way". There are
+<tr><td align="left" valign="top">
-            of course other build tools apart from <tt class="literal">bjam</tt>.<br><br> Take note however that the preferred build tool for Boost.Python
+<p>
-            is bjam. There are so many ways to set up the build incorrectly. Experience
+        <span class="bold"><strong>Building without bjam</strong></span>
-            shows that 90% of the "I can't build Boost.Python" problems
+      </p>
-            come from people who had to use a different tool. </td></tr></tbody>
+<p>
+        Besides bjam, there are of course other ways to get your module built. What's
+        written here should not be taken as "the one and only way". There
+        are of course other build tools apart from <code class="literal">bjam</code>.
+      </p>
+<p>
+        Take note however that the preferred build tool for Boost.Python is bjam.
+        There are so many ways to set up the build incorrectly. Experience shows
+        that 90% of the "I can't build Boost.Python" problems come from
+        people who had to use a different tool.
+      </p>
+</td></tr>
 </table></div>
 <p>
-      We shall skip over the details. Our objective will be to simply create the
+      We will skip over the details. Our objective will be to simply create the hello
-      hello world module and run it in Python. For a complete reference to building
+      world module and run it in Python. For a complete reference to building Boost.Python,
-      Boost.Python, check out: <a href="../../../../building.html" target="_top">building.html</a>.
+      check out: <a href="../../../../building.html" target="_top">building.html</a>. After
-      After this brief <span class="emphasis"><em>bjam</em></span> tutorial, we should have built two
+      this brief <span class="emphasis"><em>bjam</em></span> tutorial, we should have built the DLLs
-      DLLs:
+      and run a python program using the extension.
-    </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
-        boost_python.dll
-      </li>
-<li>
-        hello.pyd
-      </li>
-</ul></div>
-<p>
-      if you are on Windows, and
-    </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
-        libboost_python.so
-      </li>
-<li>
-        hello.so
-      </li>
-</ul></div>
-<p>
-      if you are on Unix.
     </p>
 <p>
-      The tutorial example can be found in the directory: <tt class="literal">libs/python/example/tutorial</tt>.
+      The tutorial example can be found in the directory: <code class="literal">libs/python/example/tutorial</code>.
       There, you can find:
     </p>
-<div class="itemizedlist"><ul type="disc">
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li>
+<li class="listitem">
-        hello.cpp
+          hello.cpp
-      </li>
+        </li>
-<li>
+<li class="listitem">
-        Jamfile
+          hello.py
-      </li>
+        </li>
+<li class="listitem">
+          Jamroot
+        </li>
 </ul></div>
 <p>
-      The <tt class="literal">hello.cpp</tt> file is our C++ hello world example. The
+      The <code class="literal">hello.cpp</code> file is our C++ hello world example. The
-      <tt class="literal">Jamfile</tt> is a minimalist <span class="emphasis"><em>bjam</em></span> script
+      <code class="literal">Jamroot</code> is a minimalist <span class="emphasis"><em>bjam</em></span> script
-      that builds the DLLs for us.
+      that builds the DLLs for us. Finally, <code class="literal">hello.py</code> is our Python
+      program that uses the extension in <code class="literal">hello.cpp</code>.
     </p>
 <p>
       Before anything else, you should have the bjam executable in your boost directory
-      or somewhere in your path such that <tt class="literal">bjam</tt> can be executed
+      or somewhere in your path such that <code class="literal">bjam</code> can be executed
       in the command line. Pre-built Boost.Jam executables are available for most
       platforms. The complete list of Bjam executables can be found <a href="http://sourceforge.net/project/showfiles.php?group_id=7586" target="_top">here</a>.
     </p>
-<a name="hello.let_s_jam_"></a><h2>
+<a name="hello.let_s_jam_"></a><h3>
-<a name="id373799"></a>
+<a name="id760177"></a>
       Let's Jam!
-    </h2>
+    </h3>
-<p><span class="inlinemediaobject"><img src="../images/jam.png"></span></p>
 <p>
-      Here is our minimalist Jamfile:
+      <span class="inlinemediaobject"><img src="../images/jam.png" alt="jam"></span>
-    </p>
-<pre class="programlisting"># This is the top of our own project tree
-project-root ;
-
-import python ;
-
-extension hello                     # Declare a Python extension called hello
-:   hello.cpp                       # source
-    # requirements and dependencies for Boost.Python extensions
-    &lt;template&gt;@boost/libs/python/build/extension
-    ;
-</pre>
-<p>
-      First, we need to specify our location. You may place your project anywhere.
-      <tt class="literal">project-root</tt> allows you to do that.
-    </p>
-<pre class="programlisting">project-root ;
-</pre>
-<p>
-      By doing so, you'll need a Jamrules file. Simply copy the one in the <a href="../../../../../example/tutorial/Jamrules" target="_top">example/tutorial directory</a>
-      and tweak the <tt class="literal">path-global BOOST_ROOT</tt> to where your boost
-      root directory is. The file has <a href="../../../../../example/tutorial/Jamrules" target="_top">detailed
-      instructions</a> you can follow.
     </p>
 <p>
-      Then we will import the definitions needed by Python modules:
+      <a href="../../../../../example/tutorial/Jamroot" target="_top">Here</a> is our minimalist
+      Jamroot file. Simply copy the file and tweak <code class="literal">use-project boost</code>
+      to where your boost root directory is and your OK.
     </p>
-<pre class="programlisting">import python ;
-</pre>
 <p>
-      Finally we declare our <tt class="literal">hello</tt> extension:
+      The comments contained in the Jamrules file above should be sufficient to get
+      you going.
     </p>
-<pre class="programlisting">extension hello                     # Declare a Python extension called hello
+<a name="hello.running_bjam"></a><h3>
-:   hello.cpp                       # source
+<a name="id760225"></a>
-
-    # requirements and dependencies for Boost.Python extensions
-    &lt;template&gt;@boost/libs/python/build/extension
-    ;
-</pre>
-<p>
-      The last part tells BJam that we are depending on the Boost Python Library.
-    </p>
-<a name="hello.running_bjam"></a><h2>
-<a name="id373910"></a>
       Running bjam
-    </h2>
+    </h3>
-<p><span class="emphasis"><em>bjam</em></span> is run using your operating system's command line
+<p>
+      <span class="emphasis"><em>bjam</em></span> is run using your operating system's command line
       interpreter.
     </p>
 <div class="blockquote"><blockquote class="blockquote"><p>
         Start it up.
       </p></blockquote></div>
 <p>
-      Make sure that the environment is set so that we can invoke the C++ compiler.
+      A file called user-config.jam in your home directory is used to configure your
-      With MSVC, that would mean running the <tt class="literal">Vcvars32.bat</tt> batch
+      tools. In Windows, your home directory can be found by typing:
-      file. For instance:
     </p>
-<pre class="programlisting">C:\Program Files\Microsoft Visual Studio .NET 2003\Common7\Tools\vsvars32.bat
+<pre class="programlisting">ECHO %HOMEDRIVE%%HOMEPATH%
 </pre>
 <p>
-      Some environment variables will have to be setup for proper building of our
+      into a command prompt window. Your file should at least have the rules for
-      Python modules. Example:
+      your compiler and your python installation. A specific example of this on Windows
+      would be:
     </p>
-<pre class="programlisting">set PYTHON_ROOT=c:/dev/tools/python
+<pre class="programlisting">#  MSVC configuration
-set PYTHON_VERSION=2.2
+using msvc : 8.0 ;
+
+#  Python configuration
+using python : 2.4 : C:/dev/tools<span class="emphasis"><em>Python</em></span> ;
 </pre>
 <p>
-      The above assumes that the Python installation is in <tt class="literal">c:/dev/tools/python</tt>
+      The first rule tells Bjam to use the MSVC 8.0 compiler and associated tools.
-      and that we are using Python version 2.2. You'll have to tweak these appropriately.
+      The second rule provides information on Python, its version and where it is
-    </p>
+      located. The above assumes that the Python installation is in <code class="literal">C:/dev/tools/Python/</code>.
-<div class="informaltable"><table class="table">
+      If you have one fairly "standard" python installation for your platform,
-<colgroup><col></colgroup>
+      you might not need to do this.
-<tbody><tr><td class="blurb">
-<span class="inlinemediaobject"><img src="../images/tip.png"></span>
-            Be sure not to include a third number, e.g. <span class="bold"><b>not</b></span>
-            "2.2.1", even if that's the version you have.</td></tr></tbody>
-</table></div>
-<p>
-      Take note that you may also do that through the Jamrules file we put in our
-      project as detailed above. The file has <a href="../../../../../example/tutorial/Jamrules" target="_top">detailed
-      instructions</a> you can follow.
     </p>
 <p>
-      Now we are ready... Be sure to <tt class="literal">cd</tt> to <tt class="literal">libs/python/example/tutorial</tt>
+      Now we are ready... Be sure to <code class="literal">cd</code> to <code class="literal">libs/python/example/tutorial</code>
-      where the tutorial <tt class="literal">"hello.cpp"</tt> and the <tt class="literal">"Jamfile"</tt>
+      where the tutorial <code class="literal">"hello.cpp"</code> and the <code class="literal">"Jamroot"</code>
       is situated.
     </p>
 <p>
       Finally:
     </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">bjam</span>
-<span class="identifier">bjam</span> <span class="special">-</span><span class="identifier">sTOOLS</span><span class="special">=</span><span class="identifier">vc</span><span class="special">-</span><span class="number">7</span><span class="identifier">_1</span>
 </pre>
-<p>
-      We are again assuming that we are using Microsoft Visual C++ version 7.1. If
-      not, then you will have to specify the appropriate tool. See <a href="../../../../../../../tools/build/index.html" target="_top">Building
-      Boost Libraries</a> for further details.
-    </p>
 <p>
       It should be building now:
     </p>
 <pre class="programlisting">cd C:\dev\boost\libs\python\example\tutorial
-bjam -sTOOLS=msvc
+bjam
 ...patience...
-...found 1703 targets...
+...found 1101 targets...
-...updating 40 targets...
+...updating 35 targets...
 </pre>
 <p>
       And so on... Finally:
     </p>
-<pre class="programlisting">Creating library bin\boost\libs\python\build\boost_python.dll\vc-7_1\debug\th
+<pre class="programlisting">Creating library <span class="emphasis"><em>path-to-boost_python.dll</em></span>
-reading-multi\boost_python.lib and object bin\boost\libs\python\build\boost_pyth
+   Creating library <span class="emphasis"><em>path-to-'''hello_ext'''.exp</em></span>
-on.dll\vc-7_1\debug\threading-multi\boost_python.exp
+**passed** ... hello.test
-vc-C++ bin\tutorial\hello.pyd\vc-7_1\debug\threading-multi\hello.obj
+...updated 35 targets...
-hello.cpp
-vc-Link bin\tutorial\hello.pyd\vc-7_1\debug\threading-multi\hello.pyd bin\tutori
-al\hello.pyd\vc-7_1\debug\threading-multi\hello.lib
-   Creating library bin\tutorial\hello.pyd\vc-7_1\debug\threading-multi\hello.li
-b and object bin\tutorial\hello.pyd\vc-7_1\debug\threading-multi\hello.exp
-...updated 31 targets...
 </pre>
 <p>
-      If all is well, you should now have:
+      Or something similar. If all is well, you should now have built the DLLs and
+      run the Python program.
     </p>
-<div class="itemizedlist"><ul type="disc">
+<div class="blockquote"><blockquote class="blockquote"><p>
-<li>
+        <span class="bold"><strong>There you go... Have fun!</strong></span>
-        boost_python.dll
+      </p></blockquote></div>
-      </li>
-<li>
-        hello.pyd
-      </li>
-</ul></div>
-<p>
-      if you are on Windows, and
-    </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
-        libboost_python.so
-      </li>
-<li>
-        hello.so
-      </li>
-</ul></div>
-<p>
-      if you are on Unix.
-    </p>
-<p><tt class="literal">boost_python.dll</tt> and <tt class="literal">hello.pyd</tt> can be
-      found somewhere in your project's <tt class="literal">bin</tt> directory. After a
-      successful build, you can just link in these DLLs with the Python interpreter.
-      In Windows for example, you can simply put these libraries inside the directory
-      where the Python executable is.
-    </p>
-<p>
-      You may now fire up Python and run our hello module:
-    </p>
-<p></p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span>
-<span class="identifier">hello</span><span class="special">,</span> <span class="identifier">world</span>
-</pre>
-<p></p>
-<div class="blockquote"><blockquote class="blockquote"><p><span class="bold"><b>There you go... Have fun!</b></span></p></blockquote></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><small>Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
-      de Guzman, David Abrahams</small></td>
+      de Guzman, David Abrahams<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
+        http://www.boost.org/LICENSE_1_0.txt </a>)
+      </p>
+</div></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="../index.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="exposing.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="../index.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="exposing.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

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

@@ -1,66 +1,70 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>Iterators</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
 <link rel="prev" href="embedding.html" title="Embedding">
-<link rel="next" href="exception.html" title=" Exception Translation">
+<link rel="next" href="exception.html" title="Exception Translation">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
-</table>
+</tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="embedding.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="exception.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="embedding.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="exception.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="python.iterators"></a>Iterators</h2></div></div></div>
 <p>
-      IteratorsIn C++, and STL in particular, we see iterators everywhere. Python
+      In C++, and STL in particular, we see iterators everywhere. Python also has
-      also has iterators, but these are two very different beasts.
+      iterators, but these are two very different beasts.
     </p>
-<p><span class="bold"><b>C++ iterators:</b></span></p>
+<p>
-<div class="itemizedlist"><ul type="disc">
+      <span class="bold"><strong>C++ iterators:</strong></span>
-<li>
+    </p>
-        C++ has 5 type categories (random-access, bidirectional, forward, input,
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-        output)
+<li class="listitem">
-      </li>
+          C++ has 5 type categories (random-access, bidirectional, forward, input,
-<li>
+          output)
-        There are 2 Operation categories: reposition, access
+        </li>
-      </li>
+<li class="listitem">
-<li>
+          There are 2 Operation categories: reposition, access
-        A pair of iterators is needed to represent a (first/last) range.
+        </li>
-      </li>
+<li class="listitem">
-</ul></div>
+          A pair of iterators is needed to represent a (first/last) range.
-<p><span class="bold"><b>Python Iterators:</b></span></p>
+        </li>
-<div class="itemizedlist"><ul type="disc">
-<li>
-        1 category (forward)
-      </li>
-<li>
-        1 operation category (next())
-      </li>
-<li>
-        Raises StopIteration exception at end
-      </li>
 </ul></div>
 <p>
-      The typical Python iteration protocol: <tt class="literal"><span class="bold"><b>for y
+      <span class="bold"><strong>Python Iterators:</strong></span>
-      in x...</b></span></tt> is as follows:
     </p>
-<p></p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<pre class="programlisting">
+<li class="listitem">
-<span class="identifier">iter</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">__iter__</span><span class="special">()</span>         <span class="comment"># get iterator
+          1 category (forward)
+        </li>
+<li class="listitem">
+          1 operation category (next())
+        </li>
+<li class="listitem">
+          Raises StopIteration exception at end
+        </li>
+</ul></div>
+<p>
+      The typical Python iteration protocol: <code class="literal"><span class="bold"><strong>for y
+      in x...</strong></span></code> is as follows:
+    </p>
+<p>
+    </p>
+<pre class="programlisting"><span class="identifier">iter</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">__iter__</span><span class="special">()</span>         <span class="comment"># get iterator
 </span><span class="keyword">try</span><span class="special">:</span>
     <span class="keyword">while</span> <span class="number">1</span><span class="special">:</span>
     <span class="identifier">y</span> <span class="special">=</span> <span class="identifier">iter</span><span class="special">.</span><span class="identifier">next</span><span class="special">()</span>         <span class="comment"># get each item
@@ -69,62 +73,65 @@
 </span></pre>
 <p>
       Boost.Python provides some mechanisms to make C++ iterators play along nicely
-      as Python iterators. What we need to do is to produce appropriate <tt class="computeroutput"><span class="identifier">__iter__</span></tt> function from C++ iterators that
+      as Python iterators. What we need to do is to produce appropriate <code class="computeroutput"><span class="identifier">__iter__</span></code> function from C++ iterators that
       is compatible with the Python iteration protocol. For example:
     </p>
-<p></p>
+<p>
-<pre class="programlisting">
+    </p>
-<span class="identifier">object</span> <span class="identifier">get_iterator</span> <span class="special">=</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;();</span>
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">get_iterator</span> <span class="special">=</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;();</span>
 <span class="identifier">object</span> <span class="identifier">iter</span> <span class="special">=</span> <span class="identifier">get_iterator</span><span class="special">(</span><span class="identifier">v</span><span class="special">);</span>
 <span class="identifier">object</span> <span class="identifier">first</span> <span class="special">=</span> <span class="identifier">iter</span><span class="special">.</span><span class="identifier">next</span><span class="special">();</span>
 </pre>
 <p>
       Or for use in class_&lt;&gt;:
     </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"__iter__"</span><span class="special">,</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;())</span>
-<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"__iter__"</span><span class="special">,</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;())</span>
 </pre>
-<p><span class="bold"><b>range</b></span></p>
+<p>
+      <span class="bold"><strong>range</strong></span>
+    </p>
 <p>
       We can create a Python savvy iterator using the range function:
     </p>
-<div class="itemizedlist"><ul type="disc">
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li>
+<li class="listitem">
-        range(start, finish)
+          range(start, finish)
-      </li>
+        </li>
-<li>
+<li class="listitem">
-        range&lt;Policies,Target&gt;(start, finish)
+          range&lt;Policies,Target&gt;(start, finish)
-      </li>
+        </li>
 </ul></div>
 <p>
       Here, start/finish may be one of:
     </p>
-<div class="itemizedlist"><ul type="disc">
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li>
+<li class="listitem">
-        member data pointers
+          member data pointers
-      </li>
+        </li>
-<li>
+<li class="listitem">
-        member function pointers
+          member function pointers
-      </li>
+        </li>
-<li>
+<li class="listitem">
-        adaptable function object (use Target parameter)
+          adaptable function object (use Target parameter)
-      </li>
+        </li>
 </ul></div>
-<p><span class="bold"><b>iterator</b></span></p>
-<div class="itemizedlist"><ul type="disc"><li>
-        iterator&lt;T, Policies&gt;()
-      </li></ul></div>
 <p>
-      Given a container <tt class="literal">T</tt>, iterator is a shortcut that simply
+      <span class="bold"><strong>iterator</strong></span>
-      calls <tt class="literal">range</tt> with &amp;T::begin, &amp;T::end.
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+          iterator&lt;T, Policies&gt;()
+        </li></ul></div>
+<p>
+      Given a container <code class="literal">T</code>, iterator is a shortcut that simply
+      calls <code class="literal">range</code> with &amp;T::begin, &amp;T::end.
     </p>
 <p>
       Let's put this into action... Here's an example from some hypothetical bogon
       Particle accelerator code:
     </p>
-<p></p>
+<p>
-<pre class="programlisting">
+    </p>
-<span class="identifier">f</span> <span class="special">=</span> <span class="identifier">Field</span><span class="special">()</span>
+<pre class="programlisting"><span class="identifier">f</span> <span class="special">=</span> <span class="identifier">Field</span><span class="special">()</span>
 <span class="keyword">for</span> <span class="identifier">x</span> <span class="keyword">in</span> <span class="identifier">f</span><span class="special">.</span><span class="identifier">pions</span><span class="special">:</span>
     <span class="identifier">smash</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span>
 <span class="keyword">for</span> <span class="identifier">y</span> <span class="keyword">in</span> <span class="identifier">f</span><span class="special">.</span><span class="identifier">bogons</span><span class="special">:</span>
@@ -133,23 +140,25 @@
 <p>
       Now, our C++ Wrapper:
     </p>
-<p></p>
+<p>
-<pre class="programlisting">
+    </p>
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">&gt;(</span><span class="string">"Field"</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">&gt;(</span><span class="string">"Field"</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">property</span><span class="special">(</span><span class="string">"pions"</span><span class="special">,</span> <span class="identifier">range</span><span class="special">(&amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">p_begin</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">p_end</span><span class="special">))</span>
     <span class="special">.</span><span class="identifier">property</span><span class="special">(</span><span class="string">"bogons"</span><span class="special">,</span> <span class="identifier">range</span><span class="special">(&amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">b_begin</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">b_end</span><span class="special">));</span>
 </pre>
-<p><span class="bold"><b>stl_input_iterator</b></span></p>
+<p>
+      <span class="bold"><strong>stl_input_iterator</strong></span>
+    </p>
 <p>
       So far, we have seen how to expose C++ iterators and ranges to Python. Sometimes
       we wish to go the other way, though: we'd like to pass a Python sequence to
       an STL algorithm or use it to initialize an STL container. We need to make
-      a Python iterator look like an STL iterator. For that, we use <tt class="computeroutput"><span class="identifier">stl_input_iterator</span><span class="special">&lt;&gt;</span></tt>.
+      a Python iterator look like an STL iterator. For that, we use <code class="computeroutput"><span class="identifier">stl_input_iterator</span><span class="special">&lt;&gt;</span></code>.
-      Consider how we might implement a function that exposes <tt class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">assign</span><span class="special">()</span></tt> to Python:
+      Consider how we might implement a function that exposes <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">assign</span><span class="special">()</span></code> to Python:
     </p>
-<p></p>
+<p>
-<pre class="programlisting">
+    </p>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">void</span> <span class="identifier">list_assign</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">l</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">o</span><span class="special">)</span> <span class="special">{</span>
     <span class="comment">// Turn a Python sequence into an STL input range
 </span>    <span class="identifier">stl_input_iterator</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">begin</span><span class="special">(</span><span class="identifier">o</span><span class="special">),</span> <span class="identifier">end</span><span class="special">;</span>
@@ -163,23 +172,28 @@
 </span>    <span class="special">;</span>
 </pre>
 <p>
-      Now in Python, we can assign any integer sequence to <tt class="computeroutput"><span class="identifier">list_int</span></tt>
+      Now in Python, we can assign any integer sequence to <code class="computeroutput"><span class="identifier">list_int</span></code>
       objects:
     </p>
-<p></p>
+<p>
-<pre class="programlisting">
+    </p>
-<span class="identifier">x</span> <span class="special">=</span> <span class="identifier">list_int</span><span class="special">();</span>
+<pre class="programlisting"><span class="identifier">x</span> <span class="special">=</span> <span class="identifier">list_int</span><span class="special">();</span>
 <span class="identifier">x</span><span class="special">.</span><span class="identifier">assign</span><span class="special">([</span><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span><span class="special">])</span>
 </pre>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><small>Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
-      de Guzman, David Abrahams</small></td>
+      de Guzman, David Abrahams<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
+        http://www.boost.org/LICENSE_1_0.txt </a>)
+      </p>
+</div></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="embedding.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="exception.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="embedding.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="exception.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

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

@@ -1,28 +1,28 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title> Object Interface</title>
+<title>Object Interface</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
 <link rel="prev" href="functions.html" title="Functions">
 <link rel="next" href="embedding.html" title="Embedding">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
-</table>
+</tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="functions.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="embedding.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="embedding.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="python.object"></a> Object Interface</h2></div></div></div>
 <div class="toc"><dl>
@@ -32,35 +32,37 @@
 <dt><span class="section"><a href="object.html#python.enums">Enums</a></span></dt>
 </dl></div>
 <p>
-      Object InterfacePython is dynamically typed, unlike C++ which is statically
+      Python is dynamically typed, unlike C++ which is statically typed. Python variables
-      typed. Python variables may hold an integer, a float, list, dict, tuple, str,
+      may hold an integer, a float, list, dict, tuple, str, long etc., among other
-      long etc., among other things. In the viewpoint of Boost.Python and C++, these
+      things. In the viewpoint of Boost.Python and C++, these Pythonic variables
-      Pythonic variables are just instances of class <tt class="literal">object</tt>. We
+      are just instances of class <code class="literal">object</code>. We will see in this
-      shall see in this chapter how to deal with Python objects.
+      chapter how to deal with Python objects.
     </p>
 <p>
       As mentioned, one of the goals of Boost.Python is to provide a bidirectional
       mapping between C++ and Python while maintaining the Python feel. Boost.Python
-      C++ <tt class="literal">object</tt>s are as close as possible to Python. This should
+      C++ <code class="literal">object</code>s are as close as possible to Python. This should
       minimize the learning curve significantly.
     </p>
-<p><span class="inlinemediaobject"><img src="../images/python.png"></span></p>
+<p>
-<div class="section" lang="en">
+      <span class="inlinemediaobject"><img src="../images/python.png" alt="python"></span>
+    </p>
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.basic_interface"></a>Basic Interface</h3></div></div></div>
 <p>
-        Basic InterfaceClass <tt class="literal">object</tt> wraps <tt class="literal">PyObject*</tt>.
+        Class <code class="literal">object</code> wraps <code class="literal">PyObject*</code>. All the
-        All the intricacies of dealing with <tt class="literal">PyObject</tt>s such as
+        intricacies of dealing with <code class="literal">PyObject</code>s such as managing
-        managing reference counting are handled by the <tt class="literal">object</tt>
+        reference counting are handled by the <code class="literal">object</code> class. C++
-        class. C++ object interoperability is seamless. Boost.Python C++ <tt class="literal">object</tt>s
+        object interoperability is seamless. Boost.Python C++ <code class="literal">object</code>s
         can in fact be explicitly constructed from any C++ object.
       </p>
 <p>
         To illustrate, this Python code snippet:
       </p>
-<p></p>
+<p>
-<pre class="programlisting">
+      </p>
-<span class="keyword">def</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">y</span><span class="special">):</span>
+<pre class="programlisting"><span class="keyword">def</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">y</span><span class="special">):</span>
      <span class="keyword">if</span> <span class="special">(</span><span class="identifier">y</span> <span class="special">==</span> <span class="string">'foo'</span><span class="special">):</span>
          <span class="identifier">x</span><span class="special">[</span><span class="number">3</span><span class="special">:</span><span class="number">7</span><span class="special">]</span> <span class="special">=</span> <span class="string">'bar'</span>
      <span class="keyword">else</span><span class="special">:</span>
@@ -73,9 +75,9 @@
 <p>
         Can be rewritten in C++ using Boost.Python facilities this way:
       </p>
-<p></p>
+<p>
-<pre class="programlisting">
+      </p>
-<span class="identifier">object</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">object</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">y</span><span class="special">)</span> <span class="special">{</span>
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">object</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">y</span><span class="special">)</span> <span class="special">{</span>
      <span class="keyword">if</span> <span class="special">(</span><span class="identifier">y</span> <span class="special">==</span> <span class="string">"foo"</span><span class="special">)</span>
          <span class="identifier">x</span><span class="special">.</span><span class="identifier">slice</span><span class="special">(</span><span class="number">3</span><span class="special">,</span><span class="number">7</span><span class="special">)</span> <span class="special">=</span> <span class="string">"bar"</span><span class="special">;</span>
      <span class="keyword">else</span>
@@ -91,62 +93,59 @@
         in C++, the look and feel should be immediately apparent to the Python coder.
       </p>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.derived_object_types"></a>Derived Object types</h3></div></div></div>
 <p>
-        Derived Object typesBoost.Python comes with a set of derived <tt class="literal">object</tt>
+        Boost.Python comes with a set of derived <code class="literal">object</code> types
-        types corresponding to that of Python's:
+        corresponding to that of Python's:
       </p>
-<div class="itemizedlist"><ul type="disc">
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li>
+<li class="listitem">
-          list
+            list
-        </li>
+          </li>
-<li>
+<li class="listitem">
-          dict
+            dict
-        </li>
+          </li>
-<li>
+<li class="listitem">
-          tuple
+            tuple
-        </li>
+          </li>
-<li>
+<li class="listitem">
-          str
+            str
-        </li>
+          </li>
-<li>
+<li class="listitem">
-          long_
+            long_
-        </li>
+          </li>
-<li>
+<li class="listitem">
-          enum
+            enum
-        </li>
+          </li>
 </ul></div>
 <p>
-        These derived <tt class="literal">object</tt> types act like real Python types.
+        These derived <code class="literal">object</code> types act like real Python types.
         For instance:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">str</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">==&gt;</span> <span class="string">"1"</span>
-<span class="identifier">str</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">==&gt;</span> <span class="string">"1"</span>
 </pre>
 <p>
-        Wherever appropriate, a particular derived <tt class="literal">object</tt> has
+        Wherever appropriate, a particular derived <code class="literal">object</code> has
-        corresponding Python type's methods. For instance, <tt class="literal">dict</tt>
+        corresponding Python type's methods. For instance, <code class="literal">dict</code>
-        has a <tt class="literal">keys()</tt> method:
+        has a <code class="literal">keys()</code> method:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">d</span><span class="special">.</span><span class="identifier">keys</span><span class="special">()</span>
-<span class="identifier">d</span><span class="special">.</span><span class="identifier">keys</span><span class="special">()</span>
 </pre>
-<p><tt class="literal">make_tuple</tt> is provided for declaring <span class="emphasis"><em>tuple literals</em></span>.
+<p>
+        <code class="literal">make_tuple</code> is provided for declaring <span class="emphasis"><em>tuple literals</em></span>.
         Example:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">make_tuple</span><span class="special">(</span><span class="number">123</span><span class="special">,</span> <span class="char">'D'</span><span class="special">,</span> <span class="string">"Hello, World"</span><span class="special">,</span> <span class="number">0.0</span><span class="special">);</span>
-<span class="identifier">make_tuple</span><span class="special">(</span><span class="number">123</span><span class="special">,</span> <span class="char">'D'</span><span class="special">,</span> <span class="string">"Hello, World"</span><span class="special">,</span> <span class="number">0.0</span><span class="special">);</span>
 </pre>
 <p>
-        In C++, when Boost.Python <tt class="literal">object</tt>s are used as arguments
+        In C++, when Boost.Python <code class="literal">object</code>s are used as arguments
         to functions, subtype matching is required. For example, when a function
-        <tt class="literal">f</tt>, as declared below, is wrapped, it will only accept
+        <code class="literal">f</code>, as declared below, is wrapped, it will only accept
-        instances of Python's <tt class="literal">str</tt> type and subtypes.
+        instances of Python's <code class="literal">str</code> type and subtypes.
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">name</span><span class="special">)</span>
-<span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">name</span><span class="special">)</span>
 <span class="special">{</span>
     <span class="identifier">object</span> <span class="identifier">n2</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"upper"</span><span class="special">)();</span>   <span class="comment">// NAME = name.upper()
 </span>    <span class="identifier">str</span> <span class="identifier">NAME</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">.</span><span class="identifier">upper</span><span class="special">();</span>            <span class="comment">// better
@@ -156,56 +155,52 @@
 <p>
         In finer detail:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">str</span> <span class="identifier">NAME</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">.</span><span class="identifier">upper</span><span class="special">();</span>
-<span class="identifier">str</span> <span class="identifier">NAME</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">.</span><span class="identifier">upper</span><span class="special">();</span>
 </pre>
 <p>
         Illustrates that we provide versions of the str type's methods as C++ member
         functions.
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">msg</span> <span class="special">=</span> <span class="string">"%s is bigger than %s"</span> <span class="special">%</span> <span class="identifier">make_tuple</span><span class="special">(</span><span class="identifier">NAME</span><span class="special">,</span><span class="identifier">name</span><span class="special">);</span>
-<span class="identifier">object</span> <span class="identifier">msg</span> <span class="special">=</span> <span class="string">"%s is bigger than %s"</span> <span class="special">%</span> <span class="identifier">make_tuple</span><span class="special">(</span><span class="identifier">NAME</span><span class="special">,</span><span class="identifier">name</span><span class="special">);</span>
 </pre>
 <p>
-        Demonstrates that you can write the C++ equivalent of <tt class="literal">"format"
+        Demonstrates that you can write the C++ equivalent of <code class="literal">"format"
-        % x,y,z</tt> in Python, which is useful since there's no easy way to
+        % x,y,z</code> in Python, which is useful since there's no easy way to
         do that in std C++.
       </p>
-<div class="informaltable"><table class="table">
+<div class="sidebar">
-<colgroup><col></colgroup>
+<p class="title"><b></b></p>
-<tbody><tr><td class="blurb">
+<p>
-<span class="inlinemediaobject"><img src="../images/alert.png"></span> <span class="bold"><b>Beware</b></span> the common pitfall of forgetting that
+        <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><strong>Beware</strong></span> the common pitfall
-              the constructors of most of Python's mutable types make copies, just
+        of forgetting that the constructors of most of Python's mutable types make
-              as in Python. </td></tr></tbody>
+        copies, just as in Python.
-</table></div>
+      </p>
+</div>
 <p>
         Python:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">dict</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">__dict__</span><span class="special">)</span>     <span class="comment"># copies x.__dict__
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">dict</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">__dict__</span><span class="special">)</span>     <span class="comment"># copies x.__dict__
 </span><span class="special">&gt;&gt;&gt;</span> <span class="identifier">d</span><span class="special">[</span><span class="string">'whatever'</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span>        <span class="comment"># modifies the copy
 </span></pre>
 <p>
         C++:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">dict</span> <span class="identifier">d</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span>  <span class="comment">// copies x.__dict__
-<span class="identifier">dict</span> <span class="identifier">d</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span>  <span class="comment">// copies x.__dict__
 </span><span class="identifier">d</span><span class="special">[</span><span class="char">'whatever'</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>           <span class="comment">// modifies the copy
 </span></pre>
-<a name="derived_object_types.class__lt_t_gt__as_objects"></a><h2>
+<a name="derived_object_types.class__lt_t_gt__as_objects"></a><h3>
-<a name="id455806"></a>
+<a name="id771905"></a>
         class_&lt;T&gt; as objects
-      </h2>
+      </h3>
 <p>
-        Due to the dynamic nature of Boost.Python objects, any <tt class="literal">class_&lt;T&gt;</tt>
+        Due to the dynamic nature of Boost.Python objects, any <code class="literal">class_&lt;T&gt;</code>
         may also be one of these types! The following code snippet wraps the class
         (type) object.
       </p>
 <p>
         We can use this to create wrapped instances. Example:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">vec345</span> <span class="special">=</span> <span class="special">(</span>
-<span class="identifier">object</span> <span class="identifier">vec345</span> <span class="special">=</span> <span class="special">(</span>
     <span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Vec2</span><span class="special">&gt;(</span><span class="string">"Vec2"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;())</span>
         <span class="special">.</span><span class="identifier">def_readonly</span><span class="special">(</span><span class="string">"length"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Point</span><span class="special">::</span><span class="identifier">length</span><span class="special">)</span>
         <span class="special">.</span><span class="identifier">def_readonly</span><span class="special">(</span><span class="string">"angle"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Point</span><span class="special">::</span><span class="identifier">angle</span><span class="special">)</span>
@@ -214,106 +209,108 @@
 <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">"length"</span><span class="special">)</span> <span class="special">==</span> <span class="number">5.0</span><span class="special">);</span>
 </pre>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.extracting_c___objects"></a>Extracting C++ objects</h3></div></div></div>
 <p>
-        Extracting C++ objectsAt some point, we will need to get C++ values out of
+        At some point, we will need to get C++ values out of object instances. This
-        object instances. This can be achieved with the <tt class="literal">extract&lt;T&gt;</tt>
+        can be achieved with the <code class="literal">extract&lt;T&gt;</code> function. Consider
-        function. Consider the following:
+        the following:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">o</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">);</span> <span class="comment">// compile error
-<span class="keyword">double</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">o</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">);</span> <span class="comment">// compile error
 </span></pre>
 <p>
-        In the code above, we got a compiler error because Boost.Python <tt class="literal">object</tt>
+        In the code above, we got a compiler error because Boost.Python <code class="literal">object</code>
-        can't be implicitly converted to <tt class="literal">double</tt>s. Instead, what
+        can't be implicitly converted to <code class="literal">double</code>s. Instead, what
         we wanted to do above can be achieved by writing:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">l</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;(</span><span class="identifier">o</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">));</span>
-<span class="keyword">double</span> <span class="identifier">l</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;(</span><span class="identifier">o</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">));</span>
 <span class="identifier">Vec2</span><span class="special">&amp;</span> <span class="identifier">v</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">Vec2</span><span class="special">&amp;&gt;(</span><span class="identifier">o</span><span class="special">);</span>
 <span class="identifier">assert</span><span class="special">(</span><span class="identifier">l</span> <span class="special">==</span> <span class="identifier">v</span><span class="special">.</span><span class="identifier">length</span><span class="special">());</span>
 </pre>
 <p>
         The first line attempts to extract the "length" attribute of the
-        Boost.Python <tt class="literal">object</tt>. The second line attempts to <span class="emphasis"><em>extract</em></span>
+        Boost.Python <code class="literal">object</code>. The second line attempts to <span class="emphasis"><em>extract</em></span>
-        the <tt class="literal">Vec2</tt> object from held by the Boost.Python <tt class="literal">object</tt>.
+        the <code class="literal">Vec2</code> object from held by the Boost.Python <code class="literal">object</code>.
       </p>
 <p>
         Take note that we said "attempt to" above. What if the Boost.Python
-        <tt class="literal">object</tt> does not really hold a <tt class="literal">Vec2</tt>
+        <code class="literal">object</code> does not really hold a <code class="literal">Vec2</code>
         type? This is certainly a possibility considering the dynamic nature of Python
-        <tt class="literal">object</tt>s. To be on the safe side, if the C++ type can't
+        <code class="literal">object</code>s. To be on the safe side, if the C++ type can't
         be extracted, an appropriate exception is thrown. To avoid an exception,
         we need to test for extractibility:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">Vec2</span><span class="special">&amp;&gt;</span> <span class="identifier">x</span><span class="special">(</span><span class="identifier">o</span><span class="special">);</span>
-<span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">Vec2</span><span class="special">&amp;&gt;</span> <span class="identifier">x</span><span class="special">(</span><span class="identifier">o</span><span class="special">);</span>
 <span class="keyword">if</span> <span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">check</span><span class="special">())</span> <span class="special">{</span>
     <span class="identifier">Vec2</span><span class="special">&amp;</span> <span class="identifier">v</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">();</span> <span class="special">...</span>
 </pre>
-<p><span class="inlinemediaobject"><img src="../images/tip.png"></span>
+<p>
-        The astute reader might have noticed that the <tt class="literal">extract&lt;T&gt;</tt>
+        <span class="inlinemediaobject"><img src="../images/tip.png" alt="tip"></span> The astute reader might have noticed that the <code class="literal">extract&lt;T&gt;</code>
         facility in fact solves the mutable copying problem:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">dict</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">dict</span><span class="special">&gt;(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span>
-<span class="identifier">dict</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">dict</span><span class="special">&gt;(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span>
 <span class="identifier">d</span><span class="special">[</span><span class="string">"whatever"</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>          <span class="comment">// modifies x.__dict__ !
 </span></pre>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.enums"></a>Enums</h3></div></div></div>
 <p>
-        EnumsBoost.Python has a nifty facility to capture and wrap C++ enums. While
+        Boost.Python has a nifty facility to capture and wrap C++ enums. While Python
-        Python has no <tt class="literal">enum</tt> type, we'll often want to expose our
+        has no <code class="literal">enum</code> type, we'll often want to expose our C++ enums
-        C++ enums to Python as an <tt class="literal">int</tt>. Boost.Python's enum facility
+        to Python as an <code class="literal">int</code>. Boost.Python's enum facility makes
-        makes this easy while taking care of the proper conversions from Python's
+        this easy while taking care of the proper conversions from Python's dynamic
-        dynamic typing to C++'s strong static typing (in C++, ints cannot be implicitly
+        typing to C++'s strong static typing (in C++, ints cannot be implicitly converted
-        converted to enums). To illustrate, given a C++ enum:
+        to enums). To illustrate, given a C++ enum:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">enum</span> <span class="identifier">choice</span> <span class="special">{</span> <span class="identifier">red</span><span class="special">,</span> <span class="identifier">blue</span> <span class="special">};</span>
-<span class="keyword">enum</span> <span class="identifier">choice</span> <span class="special">{</span> <span class="identifier">red</span><span class="special">,</span> <span class="identifier">blue</span> <span class="special">};</span>
 </pre>
 <p>
         the construct:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">enum_</span><span class="special">&lt;</span><span class="identifier">choice</span><span class="special">&gt;(</span><span class="string">"choice"</span><span class="special">)</span>
-<span class="identifier">enum_</span><span class="special">&lt;</span><span class="identifier">choice</span><span class="special">&gt;(</span><span class="string">"choice"</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">value</span><span class="special">(</span><span class="string">"red"</span><span class="special">,</span> <span class="identifier">red</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">value</span><span class="special">(</span><span class="string">"blue"</span><span class="special">,</span> <span class="identifier">blue</span><span class="special">)</span>
     <span class="special">;</span>
 </pre>
 <p>
         can be used to expose to Python. The new enum type is created in the current
-        <tt class="literal">scope()</tt>, which is usually the current module. The snippet
+        <code class="literal">scope()</code>, which is usually the current module. The snippet
-        above creates a Python class derived from Python's <tt class="literal">int</tt>
+        above creates a Python class derived from Python's <code class="literal">int</code>
         type which is associated with the C++ type passed as its first parameter.
       </p>
-<div class="informaltable"><table class="table">
+<div class="note"><table border="0" summary="Note">
-<colgroup><col></colgroup>
+<tr>
-<tbody><tr><td class="blurb">
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
-<span class="inlinemediaobject"><img src="../images/note.png"></span> <span class="bold"><b>what is a scope?</b></span><br><br> The scope is a
+<th align="left">Note</th>
-              class that has an associated global Python object which controls the
+</tr>
-              Python namespace in which new extension classes and wrapped functions
+<tr><td align="left" valign="top">
-              will be defined as attributes. Details can be found <a href="../../../../v2/scope.html" target="_top">here</a>.</td></tr></tbody>
+<p>
+          <span class="bold"><strong>what is a scope?</strong></span>
+        </p>
+<p>
+          The scope is a class that has an associated global Python object which
+          controls the Python namespace in which new extension classes and wrapped
+          functions will be defined as attributes. Details can be found <a href="../../../../v2/scope.html" target="_top">here</a>.
+        </p>
+</td></tr>
 </table></div>
 <p>
         You can access those values in Python as
       </p>
-<p></p>
+<p>
-<pre class="programlisting">
+      </p>
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">my_module</span><span class="special">.</span><span class="identifier">choice</span><span class="special">.</span><span class="identifier">red</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">my_module</span><span class="special">.</span><span class="identifier">choice</span><span class="special">.</span><span class="identifier">red</span>
 <span class="identifier">my_module</span><span class="special">.</span><span class="identifier">choice</span><span class="special">.</span><span class="identifier">red</span>
 </pre>
 <p>
         where my_module is the module where the enum is declared. You can also create
         a new scope around a class:
       </p>
-<p></p>
+<p>
-<pre class="programlisting">
+      </p>
-<span class="identifier">scope</span> <span class="identifier">in_X</span> <span class="special">=</span> <span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;(</span><span class="string">"X"</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">scope</span> <span class="identifier">in_X</span> <span class="special">=</span> <span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;(</span><span class="string">"X"</span><span class="special">)</span>
                 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span> <span class="special">...</span> <span class="special">)</span>
                 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span> <span class="special">...</span> <span class="special">)</span>
             <span class="special">;</span>
@@ -328,12 +325,17 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><small>Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
-      de Guzman, David Abrahams</small></td>
+      de Guzman, David Abrahams<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
+        http://www.boost.org/LICENSE_1_0.txt </a>)
+      </p>
+</div></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="functions.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="embedding.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="embedding.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

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

@@ -1,27 +1,27 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title> General Techniques</title>
+<title>General Techniques</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
-<link rel="prev" href="exception.html" title=" Exception Translation">
+<link rel="prev" href="exception.html" title="Exception Translation">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
-</table>
+</tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="exception.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a>
+<a accesskey="p" href="exception.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="python.techniques"></a> General Techniques</h2></div></div></div>
 <div class="toc"><dl>
@@ -30,16 +30,16 @@
 <dt><span class="section"><a href="techniques.html#python.reducing_compiling_time">Reducing Compiling Time</a></span></dt>
 </dl></div>
 <p>
-      General TechniquesHere are presented some useful techniques that you can use
+      Here are presented some useful techniques that you can use while wrapping code
-      while wrapping code with Boost.Python.
+      with Boost.Python.
     </p>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.creating_packages"></a>Creating Packages</h3></div></div></div>
 <p>
-        Creating PackagesA Python package is a collection of modules that provide
+        A Python package is a collection of modules that provide to the user a certain
-        to the user a certain functionality. If you're not familiar on how to create
+        functionality. If you're not familiar on how to create packages, a good introduction
-        packages, a good introduction to them is provided in the <a href="http://www.python.org/doc/current/tut/node8.html" target="_top">Python
+        to them is provided in the <a href="http://www.python.org/doc/current/tut/node8.html" target="_top">Python
         Tutorial</a>.
       </p>
 <p>
@@ -50,11 +50,10 @@
 <p>
         We have a C++ library that works with sounds: reading and writing various
         formats, applying filters to the sound data, etc. It is named (conveniently)
-        <tt class="literal">sounds</tt>. Our library already has a neat C++ namespace hierarchy,
+        <code class="literal">sounds</code>. Our library already has a neat C++ namespace hierarchy,
         like so:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">sounds</span><span class="special">::</span><span class="identifier">core</span>
-<span class="identifier">sounds</span><span class="special">::</span><span class="identifier">core</span>
 <span class="identifier">sounds</span><span class="special">::</span><span class="identifier">io</span>
 <span class="identifier">sounds</span><span class="special">::</span><span class="identifier">filters</span>
 </pre>
@@ -62,16 +61,14 @@
         We would like to present this same hierarchy to the Python user, allowing
         him to write code like this:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
-<span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
 <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo</span><span class="special">(...)</span> <span class="comment"># echo is a C++ function
 </span></pre>
 <p>
         The first step is to write the wrapping code. We have to export each module
         separately with Boost.Python, like this:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="special">/*</span> <span class="identifier">file</span> <span class="identifier">core</span><span class="special">.</span><span class="identifier">cpp</span> <span class="special">*/</span>
-<span class="special">/*</span> <span class="identifier">file</span> <span class="identifier">core</span><span class="special">.</span><span class="identifier">cpp</span> <span class="special">*/</span>
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">core</span><span class="special">)</span>
 <span class="special">{</span>
     <span class="special">/*</span> <span class="identifier">export</span> <span class="identifier">everything</span> <span class="keyword">in</span> <span class="identifier">the</span> <span class="identifier">sounds</span><span class="special">::</span><span class="identifier">core</span> <span class="identifier">namespace</span> <span class="special">*/</span>
@@ -93,17 +90,20 @@
 <span class="special">}</span>
 </pre>
 <p>
-        Compiling these files will generate the following Python extensions: <tt class="literal">core.pyd</tt>,
+        Compiling these files will generate the following Python extensions: <code class="literal">core.pyd</code>,
-        <tt class="literal">io.pyd</tt> and <tt class="literal">filters.pyd</tt>.
+        <code class="literal">io.pyd</code> and <code class="literal">filters.pyd</code>.
       </p>
-<div class="informaltable"><table class="table">
+<div class="note"><table border="0" summary="Note">
-<colgroup><col></colgroup>
+<tr>
-<tbody><tr><td class="blurb">
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
-<span class="inlinemediaobject"><img src="../images/note.png"></span>
+<th align="left">Note</th>
-              The extension <tt class="literal">.pyd</tt> is used for python extension
+</tr>
-              modules, which are just shared libraries. Using the default for your
+<tr><td align="left" valign="top"><p>
-              system, like <tt class="literal">.so</tt> for Unix and <tt class="literal">.dll</tt>
+          The extension <code class="literal">.pyd</code> is used for python extension modules,
-              for Windows, works just as well.</td></tr></tbody>
+          which are just shared libraries. Using the default for your system, like
+          <code class="literal">.so</code> for Unix and <code class="literal">.dll</code> for Windows,
+          works just as well.
+        </p></td></tr>
 </table></div>
 <p>
         Now, we create this directory structure for our Python package:
@@ -115,18 +115,18 @@
     io.pyd
 </pre>
 <p>
-        The file <tt class="literal">__init__.py</tt> is what tells Python that the directory
+        The file <code class="literal">__init__.py</code> is what tells Python that the directory
-        <tt class="literal">sounds/</tt> is actually a Python package. It can be a empty
+        <code class="literal">sounds/</code> is actually a Python package. It can be a empty
         file, but can also perform some magic, that will be shown later.
       </p>
 <p>
-        Now our package is ready. All the user has to do is put <tt class="literal">sounds</tt>
+        Now our package is ready. All the user has to do is put <code class="literal">sounds</code>
         into his <a href="http://www.python.org/doc/current/tut/node8.html#SECTION008110000000000000000" target="_top">PYTHONPATH</a>
         and fire up the interpreter:
       </p>
-<p></p>
+<p>
-<pre class="programlisting">
+      </p>
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">io</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">io</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">sound</span> <span class="special">=</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">io</span><span class="special">.</span><span class="identifier">open</span><span class="special">(</span><span class="string">'file.mp3'</span><span class="special">)</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">new_sound</span> <span class="special">=</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo</span><span class="special">(</span><span class="identifier">sound</span><span class="special">,</span> <span class="number">1.0</span><span class="special">)</span>
@@ -146,9 +146,9 @@
         If we want this flexibility, we will have to complicate our package hierarchy
         a little. First, we will have to change the name of the extension modules:
       </p>
-<p></p>
+<p>
-<pre class="programlisting">
+      </p>
-<span class="comment">/* file core.cpp */</span>
+<pre class="programlisting"><span class="comment">/* file core.cpp */</span>
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">_core</span><span class="special">)</span>
 <span class="special">{</span>
     <span class="special">...</span>
@@ -157,7 +157,7 @@
 </pre>
 <p>
         Note that we added an underscore to the module name. The filename will have
-        to be changed to <tt class="literal">_core.pyd</tt> as well, and we do the same
+        to be changed to <code class="literal">_core.pyd</code> as well, and we do the same
         to the other extension modules. Now, we change our package hierarchy like
         so:
       </p>
@@ -165,12 +165,12 @@
     __init__.py
     core/
         __init__.py
-        _core.pyd
+        <span class="underline">core.pyd
     filters/
-        __init__.py
+        \</span>_init__.py
-        _filters.pyd
+        <span class="underline">filters.pyd
     io/
-        __init__.py
+        \</span>_init__.py
         _io.pyd
 </pre>
 <p>
@@ -178,70 +178,64 @@
         to each one. But if we leave it that way, the user will have to access the
         functions in the core module with this syntax:
       </p>
-<p></p>
+<p>
-<pre class="programlisting">
+      </p>
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">_core</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">_core</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">_core</span><span class="special">.</span><span class="identifier">foo</span><span class="special">(...)</span>
 </pre>
 <p>
-        which is not what we want. But here enters the <tt class="literal">__init__.py</tt>
+        which is not what we want. But here enters the <code class="literal">__init__.py</code>
-        magic: everything that is brought to the <tt class="literal">__init__.py</tt> namespace
+        magic: everything that is brought to the <code class="literal">__init__.py</code> namespace
         can be accessed directly by the user. So, all we have to do is bring the
-        entire namespace from <tt class="literal">_core.pyd</tt> to <tt class="literal">core/__init__.py</tt>.
+        entire namespace from <code class="literal">_core.pyd</code> to <code class="literal">core/__init__.py</code>.
-        So add this line of code to <tt class="literal">sounds<span class="emphasis"><em>core</em></span>__init__.py</tt>:
+        So add this line of code to <code class="literal">sounds<span class="emphasis"><em>core</em></span>__init__.py</code>:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">from</span> <span class="identifier">_core</span> <span class="keyword">import</span> <span class="special">*</span>
-<span class="keyword">from</span> <span class="identifier">_core</span> <span class="keyword">import</span> <span class="special">*</span>
 </pre>
 <p>
         We do the same for the other packages. Now the user accesses the functions
         and classes in the extension modules like before:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo</span><span class="special">(...)</span>
 </pre>
 <p>
         with the additional benefit that we can easily add pure Python functions
         to any module, in a way that the user can't tell the difference between a
         C++ function and a Python function. Let's add a <span class="emphasis"><em>pure</em></span>
-        Python function, <tt class="literal">echo_noise</tt>, to the <tt class="literal">filters</tt>
+        Python function, <code class="literal">echo_noise</code>, to the <code class="literal">filters</code>
-        package. This function applies both the <tt class="literal">echo</tt> and <tt class="literal">noise</tt>
+        package. This function applies both the <code class="literal">echo</code> and <code class="literal">noise</code>
-        filters in sequence in the given <tt class="literal">sound</tt> object. We create
+        filters in sequence in the given <code class="literal">sound</code> object. We create
-        a file named <tt class="literal">sounds/filters/echo_noise.py</tt> and code our
+        a file named <code class="literal">sounds/filters/echo_noise.py</code> and code our
         function:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">import</span> <span class="identifier">_filters</span>
-<span class="keyword">import</span> <span class="identifier">_filters</span>
 <span class="keyword">def</span> <span class="identifier">echo_noise</span><span class="special">(</span><span class="identifier">sound</span><span class="special">):</span>
     <span class="identifier">s</span> <span class="special">=</span> <span class="identifier">_filters</span><span class="special">.</span><span class="identifier">echo</span><span class="special">(</span><span class="identifier">sound</span><span class="special">)</span>
     <span class="identifier">s</span> <span class="special">=</span> <span class="identifier">_filters</span><span class="special">.</span><span class="identifier">noise</span><span class="special">(</span><span class="identifier">sound</span><span class="special">)</span>
     <span class="keyword">return</span> <span class="identifier">s</span>
 </pre>
 <p>
-        Next, we add this line to <tt class="literal">sounds<span class="emphasis"><em>filters</em></span>__init__.py</tt>:
+        Next, we add this line to <code class="literal">sounds<span class="emphasis"><em>filters</em></span>__init__.py</code>:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">from</span> <span class="identifier">echo_noise</span> <span class="keyword">import</span> <span class="identifier">echo_noise</span>
-<span class="keyword">from</span> <span class="identifier">echo_noise</span> <span class="keyword">import</span> <span class="identifier">echo_noise</span>
 </pre>
 <p>
         And that's it. The user now accesses this function like any other function
-        from the <tt class="literal">filters</tt> package:
+        from the <code class="literal">filters</code> package:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo_noise</span><span class="special">(...)</span>
 </pre>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.extending_wrapped_objects_in_python"></a>Extending Wrapped Objects in Python</h3></div></div></div>
 <p>
-        Extending Wrapped Objects in PythonThanks to Python's flexibility, you can
+        Thanks to Python's flexibility, you can easily add new methods to a class,
-        easily add new methods to a class, even after it was already created:
+        even after it was already created:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">class</span> <span class="identifier">C</span><span class="special">(</span><span class="identifier">object</span><span class="special">):</span> <span class="keyword">pass</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">class</span> <span class="identifier">C</span><span class="special">(</span><span class="identifier">object</span><span class="special">):</span> <span class="keyword">pass</span>
 <span class="special">&gt;&gt;&gt;</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="comment"># a regular function
 </span><span class="special">&gt;&gt;&gt;</span> <span class="keyword">def</span> <span class="identifier">C_str</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span> <span class="keyword">return</span> <span class="string">'A C instance!'</span>
@@ -256,14 +250,15 @@
 <span class="identifier">A</span> <span class="identifier">C</span> <span class="identifier">instance</span><span class="special">!</span>
 </pre>
 <p>
-        Yes, Python rox. <span class="inlinemediaobject"><img src="../images/smiley.png"></span></p>
+        Yes, Python rox. <span class="inlinemediaobject"><img src="../images/smiley.png" alt="smiley"></span>
+      </p>
 <p>
         We can do the same with classes that were wrapped with Boost.Python. Suppose
-        we have a class <tt class="literal">point</tt> in C++:
+        we have a class <code class="literal">point</code> in C++:
       </p>
-<p></p>
+<p>
-<pre class="programlisting">
+      </p>
-<span class="keyword">class</span> <span class="identifier">point</span> <span class="special">{...};</span>
+<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">point</span> <span class="special">{...};</span>
 
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">_geom</span><span class="special">)</span>
 <span class="special">{</span>
@@ -271,12 +266,12 @@
 <span class="special">}</span>
 </pre>
 <p>
-        If we are using the technique from the previous session, <a href="techniques.html#python.creating_packages" title="Creating Packages">Creating
+        If we are using the technique from the previous session, <a class="link" href="techniques.html#python.creating_packages" title="Creating Packages">Creating
-        Packages</a>, we can code directly into <tt class="literal">geom/__init__.py</tt>:
+        Packages</a>, we can code directly into <code class="literal">geom/__init__.py</code>:
       </p>
-<p></p>
+<p>
-<pre class="programlisting">
+      </p>
-<span class="keyword">from</span> <span class="identifier">_geom</span> <span class="keyword">import</span> <span class="special">*</span>
+<pre class="programlisting"><span class="keyword">from</span> <span class="identifier">_geom</span> <span class="keyword">import</span> <span class="special">*</span>
 
 <span class="comment"># a regular function
 </span><span class="keyword">def</span> <span class="identifier">point_str</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span>
@@ -285,30 +280,30 @@
 <span class="comment"># now we turn it into a member function
 </span><span class="identifier">point</span><span class="special">.</span><span class="identifier">__str__</span> <span class="special">=</span> <span class="identifier">point_str</span>
 </pre>
-<p><span class="bold"><b>All</b></span> point instances created from C++ will
+<p>
+        <span class="bold"><strong>All</strong></span> point instances created from C++ will
         also have this member function! This technique has several advantages:
       </p>
-<div class="itemizedlist"><ul type="disc">
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li>
+<li class="listitem">
-          Cut down compile times to zero for these additional functions
+            Cut down compile times to zero for these additional functions
-        </li>
+          </li>
-<li>
+<li class="listitem">
-          Reduce the memory footprint to virtually zero
+            Reduce the memory footprint to virtually zero
-        </li>
+          </li>
-<li>
+<li class="listitem">
-          Minimize the need to recompile
+            Minimize the need to recompile
-        </li>
+          </li>
-<li>
+<li class="listitem">
-          Rapid prototyping (you can move the code to C++ if required without changing
+            Rapid prototyping (you can move the code to C++ if required without changing
-          the interface)
+            the interface)
-        </li>
+          </li>
 </ul></div>
 <p>
         You can even add a little syntactic sugar with the use of metaclasses. Let's
         create a special metaclass that "injects" methods in other classes.
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="comment"># The one Boost.Python uses for all wrapped classes.
-<span class="comment"># The one Boost.Python uses for all wrapped classes.
 </span><span class="comment"># You can use here any class exported by Boost instead of "point"
 </span><span class="identifier">BoostPythonMetaclass</span> <span class="special">=</span> <span class="identifier">point</span><span class="special">.</span><span class="identifier">__class__</span>
 
@@ -331,8 +326,7 @@
 <p>
         Now let's see how it got:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">point</span><span class="special">()</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">point</span><span class="special">()</span>
 <span class="identifier">Point</span><span class="special">(</span><span class="identifier">x</span><span class="special">=</span><span class="number">10</span><span class="special">,</span> <span class="identifier">y</span><span class="special">=</span><span class="number">10</span><span class="special">)</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">point</span><span class="special">().</span><span class="identifier">foo</span><span class="special">()</span>
 <span class="identifier">foo</span><span class="special">!</span>
@@ -340,8 +334,7 @@
 <p>
         Another useful idea is to replace constructors with factory functions:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="identifier">_point</span> <span class="special">=</span> <span class="identifier">point</span>
-<span class="identifier">_point</span> <span class="special">=</span> <span class="identifier">point</span>
 
 <span class="keyword">def</span> <span class="identifier">point</span><span class="special">(</span><span class="identifier">x</span><span class="special">=</span><span class="number">0</span><span class="special">,</span> <span class="identifier">y</span><span class="special">=</span><span class="number">0</span><span class="special">):</span>
     <span class="keyword">return</span> <span class="identifier">_point</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">y</span><span class="special">)</span>
@@ -353,18 +346,18 @@
         support.
       </p>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.reducing_compiling_time"></a>Reducing Compiling Time</h3></div></div></div>
 <p>
-        Reducing Compiling TimeIf you have ever exported a lot of classes, you know
+        If you have ever exported a lot of classes, you know that it takes quite
-        that it takes quite a good time to compile the Boost.Python wrappers. Plus
+        a good time to compile the Boost.Python wrappers. Plus the memory consumption
-        the memory consumption can easily become too high. If this is causing you
+        can easily become too high. If this is causing you problems, you can split
-        problems, you can split the class_ definitions in multiple files:
+        the class_ definitions in multiple files:
       </p>
-<p></p>
+<p>
-<pre class="programlisting">
+      </p>
-<span class="comment">/* file point.cpp */</span>
+<pre class="programlisting"><span class="comment">/* file point.cpp */</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">point</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
@@ -383,11 +376,10 @@
 <span class="special">}</span>
 </pre>
 <p>
-        Now you create a file <tt class="literal">main.cpp</tt>, which contains the <tt class="literal">BOOST_PYTHON_MODULE</tt>
+        Now you create a file <code class="literal">main.cpp</code>, which contains the <code class="literal">BOOST_PYTHON_MODULE</code>
         macro, and call the various export functions inside it.
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">export_point</span><span class="special">();</span>
-<span class="keyword">void</span> <span class="identifier">export_point</span><span class="special">();</span>
 <span class="keyword">void</span> <span class="identifier">export_triangle</span><span class="special">();</span>
 
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">_geom</span><span class="special">)</span>
@@ -400,8 +392,7 @@
         Compiling and linking together all this files produces the same result as
         the usual approach:
       </p>
-<pre class="programlisting">
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
-<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">point</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">triangle</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span>
 
@@ -419,32 +410,43 @@
         exporting it to Python at the same time: changes in a class will only demand
         the compilation of a single cpp, instead of the entire wrapper code.
       </p>
-<div class="informaltable"><table class="table">
+<div class="note"><table border="0" summary="Note">
-<colgroup><col></colgroup>
+<tr>
-<tbody><tr><td class="blurb">
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
-<span class="inlinemediaobject"><img src="../images/note.png"></span>
+<th align="left">Note</th>
-              If you're exporting your classes with <a href="../../../../../pyste/index.html" target="_top">Pyste</a>,
+</tr>
-              take a look at the <tt class="literal">--multiple</tt> option, that generates
+<tr><td align="left" valign="top"><p>
-              the wrappers in various files as demonstrated here.</td></tr></tbody>
+          If you're exporting your classes with <a href="../../../../../pyste/index.html" target="_top">Pyste</a>,
+          take a look at the <code class="literal">--multiple</code> option, that generates
+          the wrappers in various files as demonstrated here.
+        </p></td></tr>
 </table></div>
-<div class="informaltable"><table class="table">
+<div class="note"><table border="0" summary="Note">
-<colgroup><col></colgroup>
+<tr>
-<tbody><tr><td class="blurb">
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
-<span class="inlinemediaobject"><img src="../images/note.png"></span>
+<th align="left">Note</th>
-              This method is useful too if you are getting the error message <span class="emphasis"><em>"fatal
+</tr>
-              error C1204:Compiler limit:internal structure overflow"</em></span>
+<tr><td align="left" valign="top"><p>
-              when compiling a large source file, as explained in the <a href="../../../../v2/faq.html#c1204" target="_top">FAQ</a>.</td></tr></tbody>
+          This method is useful too if you are getting the error message <span class="emphasis"><em>"fatal
+          error C1204:Compiler limit:internal structure overflow"</em></span>
+          when compiling a large source file, as explained in the <a href="../../../../v2/faq.html#c1204" target="_top">FAQ</a>.
+        </p></td></tr>
 </table></div>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><small>Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
-      de Guzman, David Abrahams</small></td>
+      de Guzman, David Abrahams<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
+        http://www.boost.org/LICENSE_1_0.txt </a>)
+      </p>
+</div></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="exception.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a>
+<a accesskey="p" href="exception.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a>
 </div>
 </body>
 </html>

doc/tutorial/doc/tutorial.qbk

@@ -1,5 +1,5 @@
 [library python
-    [version 1.0]
+    [version 2.0]
     [authors [de Guzman, Joel], [Abrahams, David]]
     [copyright 2002 2003 2004 2005 Joel de Guzman, David Abrahams]
     [category inter-language support]
@@ -49,10 +49,10 @@ Function:
 can be exposed to Python by writing a Boost.Python wrapper:
 
     #include <boost/python.hpp>
-    using namespace boost::python;
 
-    BOOST_PYTHON_MODULE(hello)
+    BOOST_PYTHON_MODULE(hello_ext)
     {
+        using namespace boost::python;
         def("greet", greet);
     }
 
@@ -61,8 +61,8 @@ resulting DLL is now visible to Python. Here's a sample Python session:
 
 [python]
 
-    >>> import hello
+    >>> import hello_ext
-    >>> print hello.greet()
+    >>> print hello_ext.greet()
     hello, world
 
 [c++]
@@ -75,43 +75,39 @@ resulting DLL is now visible to Python. Here's a sample Python session:
 [h2 From Start To Finish]
 
 Now the first thing you'd want to do is to build the Hello World module and
-try it for yourself in Python. In this section, we shall outline the steps
+try it for yourself in Python. In this section, we will outline the steps
-necessary to achieve that. We shall use the build tool that comes bundled
+necessary to achieve that. We will use the build tool that comes bundled
 with every boost distribution: [*bjam].
 
-[blurb __note__ [*Building without bjam]\n\n
+[note [*Building without bjam]
-    Besides bjam, there are of course other ways to get your module built.
+
-    What's written here should not be taken as "the one and only way".
+Besides bjam, there are of course other ways to get your module built.
-    There are of course other build tools apart from [^bjam].\n\n
+What's written here should not be taken as "the one and only way".
-    Take note however that the preferred build tool for Boost.Python is bjam.
+There are of course other build tools apart from [^bjam].
-    There are so many ways to set up the build incorrectly. Experience shows
+
-    that 90% of the "I can't build Boost.Python" problems come from people
+Take note however that the preferred build tool for Boost.Python is bjam.
-    who had to use a different tool.
+There are so many ways to set up the build incorrectly. Experience shows
+that 90% of the "I can't build Boost.Python" problems come from people
+who had to use a different tool.
 ]
 
-We shall skip over the details. Our objective will be to simply create the
+We will skip over the details. Our objective will be to simply create
-hello world module and run it in Python. For a complete reference to
+the hello world module and run it in Python. For a complete reference to
-building Boost.Python, check out: [@../../../building.html building.html].
+building Boost.Python, check out: [@../../../building.html
-After this brief ['bjam] tutorial, we should have built two DLLs:
+building.html]. After this brief ['bjam] tutorial, we should have built
-
+the DLLs and run a python program using the extension.
-* boost_python.dll
-* hello.pyd
-
-if you are on Windows, and
-
-* libboost_python.so
-* hello.so
-
-if you are on Unix.
 
 The tutorial example can be found in the directory:
 [^libs/python/example/tutorial]. There, you can find:
 
 * hello.cpp
-* Jamfile
+* hello.py
+* Jamroot
 
-The [^hello.cpp] file is our C++ hello world example. The [^Jamfile] is a
+The [^hello.cpp] file is our C++ hello world example. The [^Jamroot] is
-minimalist ['bjam] script that builds the DLLs for us.
+a minimalist ['bjam] script that builds the DLLs for us. Finally,
+[^hello.py] is our Python program that uses the extension in
+[^hello.cpp].
 
 Before anything else, you should have the bjam executable in your boost
 directory or somewhere in your path such that [^bjam] can be executed in
@@ -122,51 +118,12 @@ platforms. The complete list of Bjam executables can be found
 [h2 Let's Jam!]
 __jam__
 
-Here is our minimalist Jamfile:
+[@../../../../example/tutorial/Jamroot Here] is our minimalist Jamroot
+file. Simply copy the file and tweak [^use-project boost] to where your
+boost root directory is and your OK.
 
-[pre
+The comments contained in the Jamrules file above should be sufficient
-# This is the top of our own project tree
+to get you going.
-project-root ;
-
-import python ;
-
-extension hello                     # Declare a Python extension called hello
-:   hello.cpp                       # source
-    # requirements and dependencies for Boost.Python extensions
-    <template>@boost/libs/python/build/extension
-    ;
-]
-
-First, we need to specify our location. You may place your project anywhere.
-[^project-root] allows you to do that.
-
-[pre
-project-root ;
-]
-
-By doing so, you'll need a Jamrules file. Simply copy the one in the 
-[@../../../../example/tutorial/Jamrules example/tutorial directory] and tweak 
-the [^path-global BOOST_ROOT] to where your boost root directory is. The file
-has [@../../../../example/tutorial/Jamrules detailed instructions] you can follow.
-
-Then we will import the definitions needed by Python modules:
-
-[pre
-import python ;
-]
-
-Finally we declare our [^hello] extension:
-
-[pre
-extension hello                     # Declare a Python extension called hello
-:   hello.cpp                       # source
-
-    # requirements and dependencies for Boost.Python extensions
-    <template>@boost/libs/python/build/extension
-    ;
-]
-
-The last part tells BJam that we are depending on the Boost Python Library.
 
 [h2 Running bjam]
 
@@ -174,97 +131,60 @@ The last part tells BJam that we are depending on the Boost Python Library.
 
 [:Start it up.]
 
-Make sure that the environment is set so that we can invoke the C++
+A file called user-config.jam in your home directory is used to
-compiler. With MSVC, that would mean running the [^Vcvars32.bat] batch
+configure your tools. In Windows, your home directory can be found by
-file. For instance:
+typing:
 
 [pre
-C:\Program Files\Microsoft Visual Studio .NET 2003\Common7\Tools\vsvars32.bat
+ECHO %HOMEDRIVE%%HOMEPATH%
 ]
 
-Some environment variables will have to be setup for proper building of our
+into a command prompt window. Your file should at least have the rules
-Python modules. Example:
+for your compiler and your python installation. A specific example of
+this on Windows would be:
 
 [pre
-set PYTHON_ROOT=c:/dev/tools/python
+#  MSVC configuration
-set PYTHON_VERSION=2.2
+using msvc : 8.0 ;
+
+#  Python configuration
+using python : 2.4 : C:/dev/tools/Python/ ;
 ]
 
-The above assumes that the Python installation is in [^c:/dev/tools/python]
+The first rule tells Bjam to use the MSVC 8.0 compiler and associated
-and that we are using Python version 2.2. You'll have to tweak these
+tools. The second rule provides information on Python, its version and
-appropriately.
+where it is located. The above assumes that the Python installation is
-
+in [^C:/dev/tools\/Python/]. If you have one fairly "standard" python
-[blurb __tip__ Be sure not to include a third number, e.g. [*not]  "2.2.1",
+installation for your platform, you might not need to do this.
-even if that's the version you have.]
-
-Take note that you may also do that through the Jamrules file we put in
-our project as detailed above. The file
-has [@../../../../example/tutorial/Jamrules detailed instructions] you 
-can follow.
 
 Now we are ready... Be sure to [^cd] to [^libs/python/example/tutorial]
-where the tutorial [^"hello.cpp"] and the [^"Jamfile"] is situated.
+where the tutorial [^"hello.cpp"] and the [^"Jamroot"] is situated.
 
 Finally:
 
-    bjam -sTOOLS=vc-7_1
+    bjam
-
-We are again assuming that we are using Microsoft Visual C++ version 7.1. If
-not, then you will have to specify the appropriate tool. See
-[@../../../../../../tools/build/index.html Building Boost Libraries] for
-further details.
 
 It should be building now:
 
 [pre
 cd C:\dev\boost\libs\python\example\tutorial
-bjam -sTOOLS=msvc
+bjam
 ...patience...
-...found 1703 targets...
+...found 1101 targets...
-...updating 40 targets...
+...updating 35 targets...
 ]
 
 And so on... Finally:
 
 [pre
-Creating library bin\boost\libs\python\build\boost_python.dll\vc-7_1\debug\th
+   Creating library /path-to-boost_python.dll/
-reading-multi\boost_python.lib and object bin\boost\libs\python\build\boost_pyth
+   Creating library /path-to-'''hello_ext'''.exp/
-on.dll\vc-7_1\debug\threading-multi\boost_python.exp
+'''**passed**''' ... hello.test
-vc-C++ bin\tutorial\hello.pyd\vc-7_1\debug\threading-multi\hello.obj
+...updated 35 targets...
-hello.cpp
-vc-Link bin\tutorial\hello.pyd\vc-7_1\debug\threading-multi\hello.pyd bin\tutori
-al\hello.pyd\vc-7_1\debug\threading-multi\hello.lib
-   Creating library bin\tutorial\hello.pyd\vc-7_1\debug\threading-multi\hello.li
-b and object bin\tutorial\hello.pyd\vc-7_1\debug\threading-multi\hello.exp
-...updated 31 targets...
 ]
 
-If all is well, you should now have:
+Or something similar. If all is well, you should now have built the DLLs and
-
+run the Python program.
-* boost_python.dll
-* hello.pyd
-
-if you are on Windows, and
-
-* libboost_python.so
-* hello.so
-
-if you are on Unix.
-
-[^boost_python.dll] and [^hello.pyd] can be found somewhere in your project's
-[^bin] directory. After a successful build, you can just link in these DLLs with 
-the Python interpreter. In Windows for example, you can simply put these libraries 
-inside the directory where the Python executable is.
-
-You may now fire up Python and run our hello module:
-
-[python]
-
-    >>> import hello
-    >>> print hello.greet()
-    hello, world
-
-[c++]
 
 [:[*There you go... Have fun!]]
 
@@ -494,7 +414,7 @@ Doing so, we get some things for free:
   Python via a pointer or reference to [^Base] can be passed where a pointer
   or reference to [^Derived] is expected.
 
-Now, we shall expose the C++ free functions [^b] and [^d] and [^factory]:
+Now, we will expose the C++ free functions [^b] and [^d] and [^factory]:
 
     def("b", b);
     def("d", d);
@@ -504,7 +424,7 @@ Note that free function [^factory] is being used to generate new
 instances of class [^Derived]. In such cases, we use
 [^return_value_policy<manage_new_object>] to instruct Python to adopt
 the pointer to [^Base] and hold the instance in a new Python [^Base]
-object until the the Python object is destroyed. We shall see more of
+object until the the Python object is destroyed. We will see more of
 Boost.Python [link python.call_policies call policies] later.
 
     // Tell Python to take ownership of factory's result
@@ -515,7 +435,7 @@ Boost.Python [link python.call_policies call policies] later.
 
 [section Class Virtual Functions]
 
-In this section, we shall learn how to make functions behave polymorphically
+In this section, we will learn how to make functions behave polymorphically
 through virtual functions. Continuing our example, let us add a virtual function
 to our [^Base] class:
 
@@ -525,13 +445,13 @@ to our [^Base] class:
         virtual int f() = 0;
     };
 
-One of the goals of Boost.Python is to be minimally intrusive on an existing C++ 
+One of the goals of Boost.Python is to be minimally intrusive on an existing C++
-design. In principle, it should be possible to expose the interface for a 3rd 
+design. In principle, it should be possible to expose the interface for a 3rd
-party library without changing it. It is not ideal to add anything to our class 
+party library without changing it. It is not ideal to add anything to our class
-`Base`. Yet, when you have a virtual function that's going to be overridden in 
+`Base`. Yet, when you have a virtual function that's going to be overridden in
-Python and called polymorphically *from C++*, we'll need to add some 
+Python and called polymorphically *from C++*, we'll need to add some
-scaffoldings to make things work properly. What we'll do is write a class 
+scaffoldings to make things work properly. What we'll do is write a class
-wrapper that derives from `Base` that will unintrusively hook into the virtual 
+wrapper that derives from `Base` that will unintrusively hook into the virtual
 functions so that a Python override may be called:
 
     struct BaseWrap : Base, wrapper<Base>
@@ -547,8 +467,10 @@ inherited `wrapper<Base>` (See [@../../../v2/wrapper.html Wrapper]). The
 `wrapper` template makes the job of wrapping classes that are meant to
 overridden in Python, easier.
 
-[blurb __alert__ [*MSVC6/7 Workaround]\n\n 
+[blurb __alert__ [*MSVC6/7 Workaround]
-If you are using Microsoft Visual C++ 6 or 7, you have to write `f` as:\n\n
+
+If you are using Microsoft Visual C++ 6 or 7, you have to write `f` as:
+
 `return call<int>(this->get_override("f").ptr());`.]
 
 BaseWrap's overridden virtual member function `f` in effect calls the
@@ -560,24 +482,25 @@ Finally, exposing `Base`:
         .def("f", pure_virtual(&Base::f))
         ;
 
-`pure_virtual` signals Boost.Python that the function `f` is a pure virtual 
+`pure_virtual` signals Boost.Python that the function `f` is a pure virtual
 function.
 
-[blurb __note__ [*member function and methods]\n\n Python, like
+[note [*member function and methods]
-many object oriented languages uses the term [*methods].  Methods
+
-correspond roughly to C++'s [*member functions]]
+Python, like many object oriented languages uses the term [*methods].
+Methods correspond roughly to C++'s [*member functions]]
 
 [endsect]
 
 [section Virtual Functions with Default Implementations]
 
-We've seen in the previous section how classes with pure virtual functions are 
+We've seen in the previous section how classes with pure virtual functions are
 wrapped using Boost.Python's [@../../../v2/wrapper.html class wrapper]
-facilities. If we wish to wrap [*non]-pure-virtual functions instead, the 
+facilities. If we wish to wrap [*non]-pure-virtual functions instead, the
 mechanism is a bit different.
 
-Recall that in the [link python.class_virtual_functions previous section], we 
+Recall that in the [link python.class_virtual_functions previous section], we
-wrapped a class with a pure virtual function that we then implemented in C++, or 
+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
@@ -595,7 +518,7 @@ not declared as pure virtual:
     };
 
 We wrap it this way:
-    
+
     struct BaseWrap : Base, wrapper<Base>
     {
         int f()
@@ -607,24 +530,26 @@ We wrap it this way:
 
         int default_f() { return this->Base::f(); }
     };
-    
+
-Notice how we implemented `BaseWrap::f`. Now, we have to check if there is an 
+Notice how we implemented `BaseWrap::f`. Now, we have to check if there is an
 override for `f`. If none, then we call `Base::f()`.
 
-[blurb __alert__ [*MSVC6/7 Workaround]\n\n 
+[blurb __alert__ [*MSVC6/7 Workaround]
+
 If you are using Microsoft Visual C++ 6 or 7, you have to rewrite the line
-with the `*note*` as:\n\n
+with the `*note*` as:
+
 `return call<char const*>(f.ptr());`.]
 
 Finally, exposing:
-    
+
     class_<BaseWrap, boost::noncopyable>("Base")
         .def("f", &Base::f, &BaseWrap::default_f)
         ;
 
-Take note that we expose both `&Base::f` and `&BaseWrap::default_f`. 
+Take note that we expose both `&Base::f` and `&BaseWrap::default_f`.
-Boost.Python needs to keep track of 1) the dispatch function [^f] and 2) the 
+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 
+forwarding function to its default implementation [^default_f]. There's a
 special [^def] function for this purpose.
 
 In Python, the results would be as expected:
@@ -714,7 +639,7 @@ that correspond to these Python ['special functions]. Example:
 
 Need we say more?
 
-[blurb __note__ What is the business of `operator<<`?
+[note What is the business of `operator<<`?
 Well, the method `str` requires the `operator<<` to do its work (i.e.
 `operator<<` is used by the method defined by `def(str(self))`.]
 
@@ -724,9 +649,9 @@ Well, the method `str` requires the `operator<<` to do its work (i.e.
 [section Functions]
 
 In this chapter, we'll look at Boost.Python powered functions in closer
-detail. We shall see some facilities to make exposing C++ functions to
+detail. We will see some facilities to make exposing C++ functions to
 Python safe from potential pifalls such as dangling pointers and
-references. We shall also see facilities that will make it even easier for
+references. We will also see facilities that will make it even easier for
 us to expose C++ functions that take advantage of C++ features such as
 overloading and default arguments.
 
@@ -889,18 +814,21 @@ or more policies can be composed by chaining. Here's the general syntax:
 Here is the list of predefined call policies. A complete reference detailing
 these can be found [@../../../v2/reference.html#models_of_call_policies here].
 
-* [*with_custodian_and_ward]\n Ties lifetimes of the arguments
+* [*with_custodian_and_ward]:  Ties lifetimes of the arguments
-* [*with_custodian_and_ward_postcall]\n Ties lifetimes of the arguments and results
+* [*with_custodian_and_ward_postcall]:  Ties lifetimes of the arguments and results
-* [*return_internal_reference]\n Ties lifetime of one argument to that of result
+* [*return_internal_reference]:  Ties lifetime of one argument to that of result
-* [*return_value_policy<T> with T one of:]\n
+* [*return_value_policy<T> with T one of:]
-* [*reference_existing_object]\nnaive (dangerous) approach
+    * [*reference_existing_object]: naive (dangerous) approach
-* [*copy_const_reference]\nBoost.Python v1 approach
+    * [*copy_const_reference]: Boost.Python v1 approach
-* [*copy_non_const_reference]\n
+    * [*copy_non_const_reference]:
-* [*manage_new_object]\n Adopt a pointer and hold the instance
+    * [*manage_new_object]: Adopt a pointer and hold the instance
 
-[blurb :-) [*Remember the Zen, Luke:]\n\n
+[blurb :-) [*Remember the Zen, Luke:]
-"Explicit is better than implicit"\n
+
-"In the face of ambiguity, refuse the temptation to guess"\n]
+"Explicit is better than implicit"
+
+"In the face of ambiguity, refuse the temptation to guess"
+]
 
 [endsect]
 [section Overloading]
@@ -934,7 +862,7 @@ We have here our C++ class:
         };
     };
 
-Class X has 4 overloaded functions. We shall start by introducing some
+Class X has 4 overloaded functions. We will start by introducing some
 member function pointer variables:
 
     bool    (X::*fx1)(int)              = &X::f;
@@ -1099,7 +1027,7 @@ overloaded functions in one-shot:
 
 Then...
 
-    .def("foo", foo, foo_overloads());
+    .def("foo", (void(*)(bool, int, char))0, 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.
@@ -1140,7 +1068,7 @@ Then...
 Python is dynamically typed, unlike C++ which is statically typed. Python
 variables may hold an integer, a float, list, dict, tuple, str, long etc.,
 among other things. In the viewpoint of Boost.Python and C++, these
-Pythonic variables are just instances of class [^object]. We shall see in
+Pythonic variables are just instances of class [^object]. We will see in
 this chapter how to deal with Python objects.
 
 As mentioned, one of the goals of Boost.Python is to provide a
@@ -1289,14 +1217,14 @@ we wanted to do above can be achieved by writing:
     Vec2& v = extract<Vec2&>(o);
     assert(l == v.length());
 
-The first line attempts to extract the "length" attribute of the Boost.Python 
+The first line attempts to extract the "length" attribute of the Boost.Python
-[^object]. The second line attempts to ['extract] the [^Vec2] object from held 
+[^object]. The second line attempts to ['extract] the [^Vec2] object from held
 by the Boost.Python [^object].
 
-Take note that we said "attempt to" above. What if the Boost.Python [^object] 
+Take note that we said "attempt to" above. What if the Boost.Python [^object]
-does not really hold a [^Vec2] type? This is certainly a possibility considering 
+does not really hold a [^Vec2] type? This is certainly a possibility considering
-the dynamic nature of Python [^object]s. To be on the safe side, if the C++ type 
+the dynamic nature of Python [^object]s. To be on the safe side, if the C++ type
-can't be extracted, an appropriate exception is thrown. To avoid an exception, 
+can't be extracted, an appropriate exception is thrown. To avoid an exception,
 we need to test for extractibility:
 
     extract<Vec2&> x(o);
@@ -1334,10 +1262,12 @@ current [^scope()], which is usually the current module. The snippet above
 creates a Python class derived from Python's [^int] type which is
 associated with the C++ type passed as its first parameter.
 
-[blurb __note__ [*what is a scope?]\n\n The scope is a class that has an
+[note [*what is a scope?]
-associated global Python object which controls the Python namespace in
+
-which new extension classes and wrapped functions will be defined as
+The scope is a class that has an associated global Python object which
-attributes. Details can be found [@../../../v2/scope.html here].]
+controls the Python namespace in which new extension classes and wrapped
+functions will be defined as attributes. Details can be found
+[@../../../v2/scope.html here].]
 
 You can access those values in Python as
 
@@ -1364,11 +1294,6 @@ create a new scope around a class:
 
 [def Py_Initialize          [@http://www.python.org/doc/current/api/initialization.html#l2h-652  Py_Initialize]]
 [def Py_Finalize            [@http://www.python.org/doc/current/api/initialization.html#l2h-656  Py_Finalize]]
-[def PyRun_String           [@http://www.python.org/doc/current/api/veryhigh.html#l2h-55         PyRun_String]]
-[def PyRun_File             [@http://www.python.org/doc/current/api/veryhigh.html#l2h-56         PyRun_File]]
-[def Py_eval_input          [@http://www.python.org/doc/current/api/veryhigh.html#l2h-58         Py_eval_input]]
-[def Py_file_input          [@http://www.python.org/doc/current/api/veryhigh.html#l2h-59         Py_file_input]]
-[def Py_single_input        [@http://www.python.org/doc/current/api/veryhigh.html#l2h-60         Py_single_input]]
 [def Py_XINCREF             [@http://www.python.org/doc/current/api/countingRefs.html#l2h-65     Py_XINCREF]]
 [def Py_XDECREF             [@http://www.python.org/doc/current/api/countingRefs.html#l2h-67     Py_XDECREF]]
 [def PyImport_AppendInittab [@http://www.python.org/doc/current/api/importing.html#l2h-137       PyImport_AppendInittab]]
@@ -1395,17 +1320,17 @@ all. So stay tuned... :-)
 
 [h2 Building embedded programs]
 
-To be able to use embedding in your programs, they have to be linked to
+To be able to embed python into your programs, you have to link to
-both Boost.Python's and Python's static link library.
+both Boost.Python's as well as Python's own runtime library.
 
-Boost.Python's static link library comes in two variants. Both are located
+Boost.Python's library comes in two variants. Both are located
 in Boost's [^/libs/python/build/bin-stage] subdirectory. On Windows, the
 variants are called [^boost_python.lib] (for release builds) and
 [^boost_python_debug.lib] (for debugging). If you can't find the libraries,
 you probably haven't built Boost.Python yet. See
 [@../../../building.html Building and Testing] on how to do this.
 
-Python's static link library can be found in the [^/libs] subdirectory of
+Python's library can be found in the [^/libs] subdirectory of
 your Python directory. On Windows it is called pythonXY.lib where X.Y is
 your major Python version number.
 
@@ -1437,13 +1362,17 @@ 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:
 
-# '''#include''' [^<boost/python.hpp>]\n\n
+# '''#include''' [^<boost/python.hpp>]
 
-# Call Py_Initialize() to start the interpreter and create the [^__main__] module.\n\n
+# Call Py_Initialize() to start the interpreter and create the [^__main__] module.
 
-# Call other Python C API routines to use the interpreter.\n\n
+# Call other Python C API routines to use the interpreter.
 
-# Call Py_Finalize() to stop the interpreter and release its resources.
+[/ # Call Py_Finalize() to stop the interpreter and release its resources.]
+
+[note [*Note that at this time you must not call Py_Finalize() to stop the
+interpreter. This may be fixed in a future version of boost.python.]
+]
 
 (Of course, there can be other C++ code between all of these steps.)
 
@@ -1452,179 +1381,84 @@ steps:
 [section Using the interpreter]
 
 As you probably already know, objects in Python are reference-counted.
-Naturally, the [^PyObject]s of the Python/C API are also reference-counted.
+Naturally, the [^PyObject]s of the Python C API are also reference-counted.
 There is a difference however. While the reference-counting is fully
-automatic in Python, the Python/C API requires you to do it
+automatic in Python, the Python C API requires you to do it
-[@http://www.python.org/doc/current/api/refcounts.html by hand]. This is
+[@http://www.python.org/doc/current/c-api/refcounting.html by hand]. This is
 messy and especially hard to get right in the presence of C++ exceptions.
 Fortunately Boost.Python provides the [@../../../v2/handle.html handle] and
 [@../../../v2/object.html object] class templates to automate the process.
 
-[h2 Reference-counting handles and objects]
-
-There are two ways in which a function in the Python/C API can return a
-[^PyObject*]: as a ['borrowed reference] or as a ['new reference]. 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.
-
-For a function returning a ['borrowed reference] we'll have to tell the
-[^handle] that the [^PyObject*] is borrowed with the aptly named
-[@../../../v2/handle.html#borrowed-spec borrowed] function. Two functions
-returning borrowed references are PyImport_AddModule and PyModule_GetDict.
-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 [^__main__] module:
-
-    object main_module((
-        handle<>(borrowed(PyImport_AddModule("__main__")))));
-
-    object main_namespace = main_module.attr("__dict__");
-
-For a function returning a ['new reference] we can just create a [^handle]
-out of the raw [^PyObject*] without wrapping it in a call to borrowed. One
-such function that returns a new reference is PyRun_String which we'll
-discuss in the next section.
-
-[blurb __note__ [*Handle is a class ['template], so why haven't we been using any template parameters?]\n
-\n
-[^handle] has a single template parameter specifying the type of the managed object. This type is [^PyObject] 99% of the time, so the parameter was defaulted to [^PyObject] for convenience. Therefore we can use the shorthand [^handle<>] instead of the longer, but equivalent, [^handle<PyObject>].
-]
-
 [h2 Running Python code]
 
-To run Python code from C++ there is a family of functions in the API
+Boost.python provides three related functions to run Python code from C++.
-starting with the PyRun prefix. You can find the full list of these
-functions [@http://www.python.org/doc/current/api/veryhigh.html here]. They
-all work similarly so we will look at only one of them, namely:
 
-    PyObject* PyRun_String(char *str, int start, PyObject *globals, PyObject *locals)
+    object eval(str expression, object globals = object(), object locals = object())
+    object exec(str code, object globals = object(), object locals = object())
+    object exec_file(str filename, object globals = object(), object locals = object())
 
-PyRun_String takes the code to execute as a null-terminated (C-style)
+eval evaluates the given expression and returns the resulting value.
-string in its [^str] parameter. The function returns a new reference to a
+exec executes the given code (typically a set of statements) returning the result,
-Python object. Which object is returned depends on the [^start] paramater.
+and exec_file executes the code contained in the given file.
 
-The [^start] parameter is the start symbol from the Python grammar to use
+The [^globals] and [^locals] parameters are Python dictionaries
-for interpreting the code. The possible values are:
-
-[table Start symbols
-
-    [[Py_eval_input]   [for interpreting isolated expressions]]
-    [[Py_file_input]   [for interpreting sequences of statements]]
-    [[Py_single_input] [for interpreting a single statement]]
-]
-
-When using Py_eval_input, the input string must contain a single expression
-and its result is returned. When using Py_file_input, the string can
-contain an abitrary number of statements and None is returned.
-Py_single_input works in the same way as Py_file_input but only accepts a
-single statement.
-
-Lastly, the [^globals] and [^locals] 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
 [^__main__] module for both parameters.
 
-We have already seen how to get the [^__main__] module's namespace so let's
+Boost.python provides a function to import a module:
-run some Python code in it:
 
-    object main_module((
+    object import(str name)
-        handle<>(borrowed(PyImport_AddModule("__main__")))));
 
+import imports a python module (potentially loading it into the running process
+first), and returns it.
+
+Let's import the [^__main__] module and run some Python code in its namespace:
+
+    object main_module = import("__main__");
     object main_namespace = main_module.attr("__dict__");
 
-    handle<> ignored((PyRun_String(
+    object ignored = exec("hello = file('hello.txt', 'w')\n"
-
+                          "hello.write('Hello world!')\n"
-        "hello = file('hello.txt', 'w')\n"
+                          "hello.close()",
-        "hello.write('Hello world!')\n"
+                          main_namespace);
-        "hello.close()"
-
-      , Py_file_input
-      , main_namespace.ptr()
-      , main_namespace.ptr())
-    ));
-
-Because the Python/C API doesn't know anything about [^object]s, we used
-the object's [^ptr] member function to retrieve the [^PyObject*].
 
 This should create a file called 'hello.txt' in the current directory
 containing a phrase that is well-known in programming circles.
 
-[blurb
+[h2 Manipulating Python objects]
-    __note__ [*Note] that we wrap the return value of PyRun_String in a
-    (nameless) [^handle] 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 [^PyObject*]s in [^handle]s.
-]
 
-[h2 Beyond handles]
+Often we'd like to have a class to manipulate Python objects.
-
+But we have already seen such a class above, and in the
-It's nice that [^handle] manages the reference counting details for us, but
+[@python/object.html previous section]: the aptly named [^object] class
-other than that it doesn't do much. Often we'd like to have a more useful
+and its derivatives. We've already seen that they can be constructed from
-class to manipulate Python objects. But we have already seen such a class
+a [^handle]. The following examples should further illustrate this fact:
-above, and in the [@python/object.html previous section]: the aptly
-named [^object] class and it's derivatives. We've already seen that they
-can be constructed from a [^handle]. The following examples should further
-illustrate this fact:
-
-    object main_module((
-         handle<>(borrowed(PyImport_AddModule("__main__")))));
 
+    object main_module = import("__main__");
     object main_namespace = main_module.attr("__dict__");
-
+    object ignored = exec("result = 5 ** 2", main_namespace);
-    handle<> ignored((PyRun_String(
-
-        "result = 5 ** 2"
-
-        , Py_file_input
-        , main_namespace.ptr()
-        , main_namespace.ptr())
-    ));
-
     int five_squared = extract<int>(main_namespace["result"]);
 
 Here we create a dictionary object for the [^__main__] 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
+the dictionary. Another way to achieve the same result is to use eval instead,
-PyRun_String return the result directly with Py_eval_input:
+which returns the result directly:
-
-    object result((handle<>(
-        PyRun_String("5 ** 2"
-            , Py_eval_input
-            , main_namespace.ptr()
-            , main_namespace.ptr()))
-    ));
 
+    object result = eval("5 ** 2");
     int five_squared = extract<int>(result);
 
-[blurb
-    __note__ [*Note] that [^object]'s member function to return the wrapped
-    [^PyObject*] is called [^ptr] instead of [^get]. This makes sense if you
-    take into account the different functions that [^object] and [^handle]
-    perform.
-]
-
 [h2 Exception handling]
 
-If an exception occurs in the execution of some Python code, the PyRun_String
+If an exception occurs in the evaluation of the python expression,
-function returns a null pointer. Constructing a [^handle] out of this null
+[@../../../v2/errors.html#error_already_set-spec error_already_set] is thrown:
-pointer throws [@../../../v2/errors.html#error_already_set-spec error_already_set],
-so basically, the Python exception is automatically translated into a
-C++ exception when using [^handle]:
 
     try
     {
-        object result((handle<>(PyRun_String(
+        object result = eval("5/0");
-            "5/0"
-          , Py_eval_input
-          , main_namespace.ptr()
-          , main_namespace.ptr()))
-        ));
-
         // execution will never get here:
         int five_divided_by_zero = extract<int>(result);
     }
-    catch(error_already_set)
+    catch(error_already_set const &)
     {
         // handle the exception in some way
     }
@@ -1632,13 +1466,13 @@ C++ exception when using [^handle]:
 The [^error_already_set] exception class doesn't carry any information in itself.
 To find out more about the Python exception that occurred, you need to use the
 [@http://www.python.org/doc/api/exceptionHandling.html exception handling functions]
-of the Python/C API in your catch-statement. This can be as simple as calling
+of the Python C API in your catch-statement. This can be as simple as calling
 [@http://www.python.org/doc/api/exceptionHandling.html#l2h-70 PyErr_Print()] to
 print the exception's traceback to the console, or comparing the type of the
 exception with those of the [@http://www.python.org/doc/api/standardExceptions.html
 standard exceptions]:
 
-    catch(error_already_set)
+    catch(error_already_set const &)
     {
         if (PyErr_ExceptionMatches(PyExc_ZeroDivisionError))
         {
@@ -1654,21 +1488,6 @@ standard exceptions]:
 (To retrieve even more information from the exception you can use some of the other
 exception handling functions listed [@http://www.python.org/doc/api/exceptionHandling.html here].)
 
-If you'd rather not have [^handle] throw a C++ exception when it is constructed, you
-can use the [@../../../v2/handle.html#allow_null-spec allow_null] function in the same
-way you'd use borrowed:
-
-    handle<> result((allow_null(PyRun_String(
-        "5/0"
-       , Py_eval_input
-       , main_namespace.ptr()
-       , main_namespace.ptr()))));
-
-    if (!result)
-        // Python exception occurred
-    else
-        // everything went okay, it's safe to use the result
-
 [endsect]
 [endsect] [/ Embedding]
 
@@ -1760,7 +1579,7 @@ So far, we have seen how to expose C++ iterators and ranges to Python.
 Sometimes we wish to go the other way, though: we'd like to pass a
 Python sequence to an STL algorithm or use it to initialize an STL
 container. We need to make a Python iterator look like an STL iterator.
-For that, we use `stl_input_iterator<>`. Consider how we might 
+For that, we use `stl_input_iterator<>`. Consider how we might
 implement a function that exposes `std::list<int>::assign()` to
 Python:
 
@@ -1864,7 +1683,7 @@ separately with Boost.Python, like this:
 Compiling these files will generate the following Python extensions:
 [^core.pyd], [^io.pyd] and [^filters.pyd].
 
-[blurb __note__ The extension [^.pyd] is used for python extension modules, which
+[note The extension [^.pyd] is used for python extension modules, which
 are just shared libraries.  Using the default for your system, like [^.so] for
 Unix and [^.dll] for Windows, works just as well.]
 
@@ -2135,11 +1954,11 @@ This method is recommended too if you are developing the C++ library and
 exporting it to Python at the same time: changes in a class will only demand
 the compilation of a single cpp, instead of the entire wrapper code.
 
-[blurb __note__ If you're exporting your classes with [@../../../../pyste/index.html Pyste],
+[note If you're exporting your classes with [@../../../../pyste/index.html Pyste],
 take a look at the [^--multiple] option, that generates the wrappers in
 various files as demonstrated here.]
 
-[blurb __note__ This method is useful too if you are getting the error message
+[note This method is useful too if you are getting the error message
 ['"fatal error C1204:Compiler limit:internal structure overflow"] when compiling
 a large source file, as explained in the [@../../../v2/faq.html#c1204 FAQ].]
 

doc/tutorial/index.html

@@ -1,10 +1,18 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta http-equiv="refresh" content="0; URL=doc/html/index.html">
   </head>
   <body>
     Automatic redirection failed, click this 
-    <a href="doc/html/index.html">link</a>
+    <a href="doc/html/index.html">link</a> &nbsp;<hr>
+    <p>© Copyright Beman Dawes, 2001</p>
+    <p>Distributed under the Boost Software License, Version 1.0. (See 
+    accompanying file <a href="../../../../LICENSE_1_0.txt">
+    LICENSE_1_0.txt</a> or copy at
+    <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
   </body>
 </html>

doc/v2/Apr2002.html

@@ -1,3 +1,6 @@
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
@@ -157,7 +160,7 @@ documentation).
   13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+<p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 
   2002. </i></p>
 </body>
 </html>

doc/v2/CallPolicies.html

@@ -1,11 +1,14 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <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>
+    <link rel="stylesheet" type="text/css" href="../../../../boost.css">
 
     <title>Boost.Python - CallPolicies Concept</title>
   </head>
@@ -57,6 +60,7 @@
 
       <li><code>postcall</code> - Python argument tuple and result management
       after the wrapped object is invoked</li>
+      <li><code>extract_return_type</code> - metafunction for extracting the return type from a given signature type sequence</li>
     </ol>
 
     <h2><a name="composition"></a>CallPolicies Composition</h2>
@@ -129,7 +133,16 @@
         reference count must be decremented; if another existing object is
         returned, its reference count must be incremented.</td>
       </tr>
-    </table>
+      <tr>
+        <td valign="top"><code>P::extract_return_type</code></td>
+
+        <td>A model of <a href=
+          "../../../mpl/doc/refmanual/metafunction.html">Metafunction</a>.</td>
+
+        <td>An MPL unary <a href=
+          "../../../mpl/doc/refmanual/metafunction.html">Metafunction</a> used extract the return type from a given signature. By default it is derived from mpl::front.</td>
+      </tr>
+  </table>
     Models of CallPolicies are required to be <a href=
     "../../../utility/CopyConstructible.html">CopyConstructible</a>. 
     <hr>
@@ -141,7 +154,7 @@
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
 
     <p>Permission to copy, use, modify, sell and distribute this software is
     granted provided this copyright notice appears in all copies. This

doc/v2/Dereferenceable.html

@@ -1,7 +1,10 @@
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <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">
@@ -60,7 +63,7 @@ type <code>T</code>.  In addition, all pointers are Dereferenceable.
   18 December, 2003
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
     Abrahams</a> 2002-2003. </i>
 
 <p>Permission to copy, use, modify, sell

doc/v2/Extractor.html

@@ -1,7 +1,10 @@
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <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">
@@ -82,7 +85,7 @@ are layout-compatible with PyObject.
   13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
     Abrahams</a> 2002. </i>
 
 <p>Permission to copy, use, modify, sell

doc/v2/HolderGenerator.html

@@ -1,7 +1,10 @@
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <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">
@@ -60,7 +63,7 @@ type.
   13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
     Abrahams</a> 2002. </i>
 
 <p>Permission to copy, use, modify, sell

doc/v2/Jun2002.html

@@ -1,3 +1,6 @@
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
@@ -220,7 +223,7 @@ you'll just have to wait till next month (hopefully the beginning).
   13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+<p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 
   2002. </i></p>
 </body>
 </html>

doc/v2/Mar2002.html

@@ -1,3 +1,6 @@
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
@@ -228,7 +231,7 @@ worth doing anything about it.
   13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+<p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 
   2002. </i></p>
 </body>
 </html>

doc/v2/May2002.html

@@ -1,3 +1,6 @@
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
@@ -302,7 +305,7 @@ to these issues will probably have to be formalized before long.
   13 November, 2002
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+<p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 
   2002. </i></p>
 </body>
 </html>

doc/v2/ObjectWrapper.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -144,7 +147,7 @@ instances of the associated Python type will be considered a match.
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/ResultConverter.html

@@ -1,7 +1,12 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <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">
@@ -21,10 +26,12 @@
 <dl class="page-index"> 
   <dt><a href="#introduction">Introduction</a></dt>
   <dt><a href="#concept-requirements">Concept Requirements</a></dt>
-  <dl class="page-index"> 
+  <dd>
-    <dt><a href="#ResultConverter-concept">ResultConverter Concept</a></dt>
+    <dl class="page-index"> 
-    <dt><a href="#ResultConverterGenerator-concept">ResultConverterGenerator Concept</a></dt>
+      <dt><a href="#ResultConverter-concept">ResultConverter Concept</a></dt>
-  </dl>
+      <dt><a href="#ResultConverterGenerator-concept">ResultConverterGenerator Concept</a></dt>
+    </dl>
+  </dd>
 </dl>
 
 <h2><a name="introduction"></a>Introduction</h2>
@@ -76,6 +83,13 @@ denotes an object of type <code><b>R</b></code>.
     href="http://www.python.org/doc/current/api/exceptionHandling.html#l2h-71">PyErr_Occurred</a>
     should return non-zero.</td>
   </tr>
+  <tr> 
+    <td valign="top"><code>c.get_pytype()</code></td>
+    <td><code>PyTypeObject const*</code></td>
+    <td>A pointer to a Python Type object corresponding to result of the conversion,
+    or <code>0</code>. Used for documentation generation. If <code>0</code> is returned
+    the generated type in the documentation will be <b>object</b> .</td>
+  </tr>
 </table>
 
 <h3><a name="ResultConverterGenerator-concept"></a>ResultConverterGenerator Concept</h3>
@@ -99,7 +113,7 @@ C++ function return type.
   09 May, 2002    <!--Luann's birthday! -->
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
     Abrahams</a> 2002. </i>
 
 <p>Permission to copy, use, modify, sell

doc/v2/acknowledgments.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -28,7 +31,7 @@
     </table>
     <hr>
 
-    <p><a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> is
+    <p><a href="http://www.boost.org/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>
@@ -44,7 +47,7 @@
     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.
+    <p><a href="http://www.boost.org/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
@@ -56,15 +59,15 @@
     C++ and Python for solving the problems of large-scale software
     construction.</p>
 
-    <p><a href="../../../../people/aleksey_gurtovoy.htm">Aleksey Gurtovoy</a>
+    <p><a href="http://www.boost.org/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>,
+    <p><a href="http://www.boost.org/people/paul_mensonides.htm">Paul Mensonides</a>,
-    building on the work <a href="../../../../people/vesa_karvonen.htm">Vesa
+    building on the work <a href="http://www.boost.org/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
@@ -126,7 +129,7 @@
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/args.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -98,7 +101,7 @@ namespace boost { namespace python
         struct arg 
         {
           template &lt;class T&gt;
-                  arg &amp;perator = (T const &amp;value);
+                  arg &amp;operator = (T const &amp;value);
           explicit arg (char const *name){elements[0].name = name;}
         };
 
@@ -190,7 +193,7 @@ BOOST_PYTHON_MODULE(xxx)
     <p>Revised 01 August, 2003</p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002-2003.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002-2003.</i></p>
   </body>
 </html>
 

doc/v2/call.html

@@ -1,3 +1,6 @@
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
@@ -76,7 +79,7 @@ double apply2(PyObject* func, double x, double y)
   9 May, 2002 <!-- Luann's birthday! -->
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
-<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+<p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 
   2002. </i></p>
 </body>
 </html>

doc/v2/call_method.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -152,7 +155,7 @@ BOOST_PYTHON_MODULE(my_module)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/callbacks.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -245,7 +248,7 @@ void apply(PyObject* callable, X&amp; x)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/callbacks.txt

@@ -1,3 +1,7 @@
+.. Copyright David Abrahams 2006. Distributed under the Boost
+.. Software License, Version 1.0. (See accompanying
+.. file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
 Here's the plan:
 
 I aim to provide an interface similar to that of Boost.Python v1's

doc/v2/class.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
   <meta name="generator" content=
@@ -781,7 +784,7 @@ class_&lt;Derived, bases&lt;Base&gt; &gt;("Derived");
 <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
    1 November, 2005 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 
-  <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+  <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
   Abrahams</a> 2002.</i></p>
 </body>
 </html>

doc/v2/configuration.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -103,6 +106,33 @@
         function from being treated as an exported symbol on platforms which
         support that distinction in-code</td>
       </tr>
+
+      <tr>
+        <td valign="top"><code>BOOST_PYTHON_ENABLE_CDECL</code></td>
+
+        <td valign="top" align="center"><i>not&nbsp;defined</i></td>
+
+        <td valign="top">If defined, allows functions using the <code>__cdecl
+        </code> calling convention to be wrapped.</td>
+      </tr>
+
+      <tr>
+        <td valign="top"><code>BOOST_PYTHON_ENABLE_STDCALL</code></td>
+
+        <td valign="top" align="center"><i>not&nbsp;defined</i></td>
+
+        <td valign="top">If defined, allows functions using the <code>__stdcall
+        </code> calling convention to be wrapped.</td>
+      </tr>
+
+      <tr>
+        <td valign="top"><code>BOOST_PYTHON_ENABLE_FASTCALL</code></td>
+
+        <td valign="top" align="center"><i>not&nbsp;defined</i></td>
+
+        <td valign="top">If defined, allows functions using the <code>__fastcall
+        </code> calling convention to be wrapped.</td>
+      </tr>
     </table>
 
     <h2><a name="lib-defined-impl"></a>Library Defined Implementation
@@ -136,6 +166,41 @@
         compares <code>typeid(T).name()</code> instead of using and comparing
         the <code>std::type_info</code> objects directly.</td>
       </tr>
+      <tr>
+        <td valign="top"><code>BOOST_PYTHON_NO_PY_SIGNATURES</code></td>
+
+        <td valign="top" align="center"><i>not&nbsp;defined</i></td>
+
+        <td valign="top">If defined for a module no pythonic signatures are generated 
+        for the docstrings of the module functions, and no python type is associated with any
+        of the converters registered by the module. This also reduces the binary size of the 
+        module by about 14% (gcc compiled).<br>
+        If defined for the boost_python runtime library, the default for the 
+        <code>docstring_options.enable_py_signatures()</code> is set to <code>false</code>.
+        </td>
+
+      </tr>
+      <tr>
+        <td valign="top"><code>BOOST_PYTHON_SUPPORTS_PY_SIGNATURES</code></td>
+
+        <td valign="top" align="center"><i>defined if <code>BOOST_PYTHON_NO_PY_SIGNATURES</code> is undefined</i></td>
+
+        <td valign="top">This macro is defined to enable a smooth transition from older Boost.Python versions
+        which do not support pythonic signatures. For example usage see 
+        <a href="pytype_function.html#examples">here</a>.
+        </td>
+
+      </tr>
+      <tr>
+        <td valign="top"><code>BOOST_PYTHON_PY_SIGNATURES_PROPER_INIT_SELF_TYPE</code></td>
+
+        <td valign="top" align="center"><i>not&nbsp;defined</i></td>
+
+        <td valign="top">If defined the python type of <code>__init__</code> method "self" parameters
+        is properly generated, otherwise <code><b>object</b></code> is used. It is undefined
+        by default because it increases the binary size of the module by about 14% (gcc compiled).</td>
+
+      </tr>
     </table>
     <hr>
 
@@ -146,7 +211,7 @@
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/copy_const_reference.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -140,7 +143,7 @@ BOOST_PYTHON_MODULE(my_module)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/copy_non_const_reference.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -140,7 +143,7 @@ BOOST_PYTHON_MODULE(my_module)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/data_members.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -220,7 +223,7 @@ BOOST_PYTHON_MODULE_INIT(data_members_example)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/def.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -182,7 +185,7 @@ BOOST_PYTHON_MODULE(def_test)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/def_visitor.html

@@ -132,4 +132,6 @@ BOOST_PYTHON_MODULE(my_ext)
   </p>
 
 
-    <p><i>&copy; Copyright Joel de Guzman 2003. </i>
+    <p><i>&copy; Copyright Joel de Guzman 2003. </i> Distributed under the Boost
+   Software License, Version 1.0. (See accompanying
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 

doc/v2/default_call_policies.html

@@ -82,6 +82,7 @@ namespace boost { namespace python
         static PyObject* postcall(PyObject*, PyObject* result);
         typedef <a href=
 "#default_result_converter-spec">default_result_converter</a> result_converter;
+        template &lt;class Sig&gt; struct extract_return_type : mpl::front&lt;Sig&gt;{};
     };
 }}
 </pre>
@@ -161,10 +162,12 @@ struct return_value_policy : Base
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  13 November, 2002
+  11 June, 2007
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 
 
-    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+  <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002. </i>
+  Abrahams</a> 2002.</i> Distributed under the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt)</p>
 

doc/v2/definitions.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -93,7 +96,7 @@
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/dict.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -143,7 +146,7 @@ dict swap_object_dict(object target, dict d)
     <p>Revised 30 September, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/docstring_options.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
   <meta name="generator" content=
@@ -100,6 +103,8 @@ namespace boost { namespace python {
 
           docstring_options(bool show_user_defined, bool show_signatures);
 
+          docstring_options(bool show_user_defined, bool show_py_signatures, bool show_cpp_signatures);
+
           ~docstring_options();
 
           void
@@ -114,6 +119,18 @@ namespace boost { namespace python {
           void
           enable_signatures();
 
+          void
+          disable_py_signatures();
+
+          void
+          enable_py_signatures();
+
+          void
+          disable_cpp_signatures();
+
+          void
+          enable_cpp_signatures();
+
           void
           disable_all();
 
@@ -136,7 +153,7 @@ docstring_options(bool show_all=true);
     object which controls the appearance of function and
     member-function docstrings defined in the code that follows. If
     <code>show_all</code> is <code>true</code>, both the
-    user-defined docstrings and the automatically generated C++
+    user-defined docstrings and the automatically generated Python and C++
     signatures are shown. If <code>show_all</code> is
     <code>false</code> the <code>__doc__</code> attributes are
     <code>None</code>.</dt>
@@ -151,12 +168,29 @@ docstring_options(bool show_user_defined, bool show_signatures);
     member-function docstrings defined in the code that follows.
     Iff <code>show_user_defined</code> is <code>true</code>, the
     user-defined docstrings are shown. Iff
-    <code>show_signatures</code> is <code>true</code>, C++
+    <code>show_signatures</code> is <code>true</code>, Python and C++
     signatures are automatically added. If both
     <code>show_user_defined</code> and <code>show_signatures</code>
     are <code>false</code>, the <code>__doc__</code> attributes are
     <code>None</code>.</dt>
   </dl>
+  <pre>
+docstring_options(bool show_user_defined, bool show_py_signatures, bool show_cpp_signatures);
+</pre>
+
+  <dl class="function-semantics">
+    <dt><b>Effects:</b> Constructs a <code>docstring_options</code>
+    object which controls the appearance of function and
+    member-function docstrings defined in the code that follows.
+    Iff <code>show_user_defined</code> is <code>true</code>, the
+    user-defined docstrings are shown. Iff
+    <code>show_py_signatures</code> is <code>true</code>, Python 
+    signatures are automatically added. Iff 
+    <code>show_cpp_signatures</code> is <code>true</code>, C++ 
+    signatures are automatically added. If all parameters are
+    <code>false</code>, the <code>__doc__</code> attributes are
+    <code>None</code>.</dt>
+  </dl>
 
   <h4><a name="docstring_options-spec-dtors" id=
   "docstring_options-spec-dtors"></a>Class
@@ -183,6 +217,10 @@ void disable_user_defined();
 void enable_user_defined();
 void disable_signatures();
 void enable_signatures();
+void disable_py_signatures();
+void enable_py_signatures();
+void disable_cpp_signatures();
+void enable_cpp_signatures();
 void disable_all();
 void enable_all();
 </pre>
@@ -193,7 +231,7 @@ void enable_all();
     <code>*_user_defined()</code> and <code>*_signatures()</code>
     member functions are provided for fine-grained control. The
     <code>*_all()</code> member functions are convenient shortcuts
-    to manipulate both settings simultaneously.</dt>
+    to manipulate all settings simultaneously.</dt>
   </dl>
 
   <h2><a name="examples" id="examples"></a>Examples</h2>
@@ -216,7 +254,7 @@ BOOST_PYTHON_MODULE(demo)
   <pre>
 &gt;&gt;&gt; import demo
 &gt;&gt;&gt; print demo.foo.__doc__
-foo doc
+foo() -&gt; None : foo doc
 C++ signature:
     foo(void) -&gt; void
 </pre>If compiled with
@@ -250,21 +288,33 @@ BOOST_PYTHON_MODULE(demo)
     def("foo3", foo3, arg("f"), "foo3 doc");
     doc_options.enable_user_defined();
     def("foo4", foo4, arg("d"), "foo4 doc");
+    doc_options.enable_py_signatures();
+    def("foo5", foo4, arg("d"), "foo5 doc");
+    doc_options.disable_py_signatures();
+    doc_options.enable_cpp_signatures();
+    def("foo6", foo4, arg("d"), "foo6 doc");
 }
 </pre>Python code:
   <pre>
 &gt;&gt;&gt; import demo
 &gt;&gt;&gt; print demo.foo1.__doc__
-foo1 doc
+foo1( (int)i) -&gt; int : foo1 doc
 C++ signature:
     foo1(int i) -&gt; int
 &gt;&gt;&gt; print demo.foo2.__doc__
+foo2( (int)l) -&gt; int : 
 C++ signature:
     foo2(long l) -&gt; int
 &gt;&gt;&gt; print demo.foo3.__doc__
 None
 &gt;&gt;&gt; print demo.foo4.__doc__
 foo4 doc
+&gt;&gt;&gt; print demo.foo5.__doc__
+foo5( (float)d) -&gt; int : foo5 doc
+&gt;&gt;&gt; print demo.foo6.__doc__
+foo6 doc
+C++ signature:
+    foo6(double d) -&gt; int
 </pre>
 
   <h4>Wrapping from multiple C++ scopes</h4>
@@ -330,7 +380,7 @@ bar2 doc
   <!--webbot bot="Timestamp" endspan i-checksum="39359" --></p>
 
   <p><i>&copy; Copyright <a href=
-  "../../../../people/ralf_w_grosse_kunstleve.htm">Ralf W.
+  "http://www.boost.org/people/ralf_w_grosse_kunstleve.htm">Ralf W.
   Grosse-Kunstleve</a> 2006.</i></p>
 </body>
 </html>

doc/v2/enum.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -86,7 +89,7 @@ namespace boost { namespace python
   template &lt;class T&gt;
   class enum_ : public <a href="object.html#object-spec">object</a>
   {
-    enum_(char const* name);
+    enum_(char const* name, char const* doc = 0);
     enum_&lt;T&gt;&amp; value(char const* name, T);
     enum_&lt;T&gt;&amp; export_values();
   };
@@ -96,7 +99,7 @@ namespace boost { namespace python
     <h4><a name="enum_-spec-ctors"></a>Class template <code>enum_</code>
     constructors</h4>
 <pre>
-enum_(char const* name);
+enum_(char const* name, char const* doc=0);
 </pre>
 
     <dl class="function-semantics">
@@ -128,7 +131,7 @@ inline enum_&lt;T&gt;&amp; value(char const* name, T x);
 
       <dt><b>Effects:</b> adds an instance of the wrapped enumeration
       type with value <code>x</code> to the type's dictionary as the
-      <code>name</code>d attribute</dt>.
+      <code>name</code>d attribute.</dt>
 
       <dt><b>Returns:</b> <code>*this</code></dt>
 
@@ -143,7 +146,7 @@ inline enum_&lt;T&gt;&amp; export_values();
       <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>.
+        by calling <code>value()</code>.</dt>
 
       <dt><b>Returns:</b> <code>*this</code></dt>
 
@@ -225,7 +228,7 @@ TypeError: bad argument type for built-in operation
      
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/errors.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -280,7 +283,7 @@ same_name2(PyObject* args, PyObject* keywords)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/exception_translator.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -141,7 +144,7 @@ BOOST_PYTHON_MODULE(exception_translator_ext)
     <p>Revised 03 October, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/exec.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
@@ -35,6 +38,7 @@
 
       <dd>
         <dl class="page-index">
+          <dt><a href="#eval-spec"><code>eval</code></a></dt>
           <dt><a href="#exec-spec"><code>exec</code></a></dt>
           <dt><a href="#exec_file-spec"><code>exec_file</code></a></dt>
         </dl>
@@ -49,6 +53,23 @@
 
     <h2><a name="functions"></a>Functions</h2>
 
+    <h3><a name="eval-spec"></a><code>eval</code></h3>
+    <pre>
+object eval(str expression,
+            object globals = object(),
+            object locals = object());
+    </pre>
+    <dl class="function-semantics">
+      <dt><b>Effects:</b>
+        Evaluate Python expression from <code>expression</code> in the context 
+        specified by the dictionaries <code>globals</code> and <code>locals</code>.
+      </dt>
+      <dt><b>Returns:</b>
+        An instance of <a href="object.html#object-spec">object</a> 
+        which holds the value of the expression.
+      </dt>
+    </dl>
+
     <h3><a name="exec-spec"></a><code>exec</code></h3>
     <pre>
 object exec(str code,
@@ -106,7 +127,7 @@ void greet()
 
   // Define greet function in Python.
   object result = exec(
-    "def greet(self):               \n"
+    "def greet():                   \n"
     "   return 'Hello from Python!' \n",
     global, global);
 
@@ -123,7 +144,7 @@ void greet()
       we could also store it in an a file...</para>
 
 <pre>
-def greet(self):
+def greet():
    return 'Hello from Python!'
 </pre>
     <para>... and execute that instead.</para>

doc/v2/extract.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -223,7 +226,7 @@ BOOST_PYTHON_MODULE(extract_ext)
     <p>Revised 15 November, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/faq.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -67,8 +70,6 @@
       >error C2064: term does not evaluate to a function taking 2 arguments</a>
       </dt>
 
-      <dt><a href="#voidptr">How do I handle <tt>void *</tt> conversion?</a></dt>
-
       <dt><a href="#custom_string"
       >How can I automatically convert my custom string type to
        and from a Python string?</a></dt>
@@ -568,7 +569,7 @@ handle&lt;&gt; f_wrap()
 ...
 
 def("f", f_wrap());
-class_&lt;X,X_wrap&gt;("X", init&lt;int&gt;())
+class_&lt;X,X_wrap,boost::noncopyable&gt;("X", init&lt;int&gt;())
    ...
    ;
 </pre>
@@ -693,29 +694,6 @@ void Export_FXThread()
         .def("setAutoDelete", (bool (FXThread::*)(bool)) &amp;FXThread::setAutoDelete)</pre>
     <p>(The bug has been reported to Microsoft.)</p>
 
-    <hr>
-    <h2><a name="voidptr"></a>How do I handle <tt>void *</tt> conversion?</h2>
-    <font size="-1"><i>Niall Douglas provides these notes:</i></font><p>
-    For several reasons Boost.Python does not support <tt>void *</tt> as
-    an argument or as a return value. However, it is possible to wrap
-    functions with <tt>void *</tt> arguments or return values using
-    thin wrappers and the <i>opaque pointer</i> facility. E.g.:
-    <pre>// Declare the following in each translation unit
-struct void_ {};
-BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID(void_);
-
-void *foo(int par1, void *par2);
-
-void_ *foo_wrapper(int par1, void_ *par2)
-{
-    return (void_ *) foo(par1, par2);
-}
-...
-BOOST_PYTHON_MODULE(bar)
-{
-    def("foo", &amp;foo_wrapper);
-}</pre>
-
     <hr>
     <h2><a name="custom_string"></a>How can I automatically
     convert my custom string type to and from a Python string?</h2>
@@ -873,11 +851,11 @@ BOOST_PYTHON_MODULE(custom_string)
 
     <p>Revised
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     28 January, 2004
+     12 March, 2006
     <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002-2003.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002-2006.</i></p>
   </body>
 </html>

doc/v2/feb2002.html

@@ -360,7 +360,8 @@
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 
 
-    <p class="c3">&copy; Copyright <a href= 
+  <p class="c3">&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a>
+  "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002. Distributed
-    2002. 
+  under the Boost Software License, Version 1.0. (See accompanying file
+  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)</p>
 

doc/v2/function_doc_signature.html

@@ -0,0 +1,216 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<!-- Copyright Nikolay Mladenov	 2007. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
+<html>
+<head>
+  <meta http-equiv="Content-Type" content=
+  "text/html; charset=us-ascii">
+  <link rel="stylesheet" type="text/css" href="../boost.css">
+
+  <title>Boost.Python -
+  &lt;boost/python/doobject/function_doc_signature.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="../../../../boost.png" 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/object/function_doc_signature.hpp&gt;</h2>
+      </td>
+    </tr>
+  </table>
+  <hr>
+
+  <h2>Contents</h2>
+
+  <dl class="page-index">
+    <dt><a href="#introduction">Introduction</a></dt>
+
+    <dt><a href="#classes">Classes</a></dt>
+
+    <dd>
+      <dl class="page-index">
+        <dt><a href="#function_doc_signature_generator-spec">Class
+        <code>function_doc_signature_generator</code></a></dt>
+
+        <dd>
+          <dl class="page-index">
+            <dt><a href="#function_doc_signature_generator-spec-synopsis">Class
+            <code>function_doc_signature_generator</code> synopsis</a></dt>
+
+          </dl>
+        </dd>
+      </dl>
+    </dd>
+
+    <dt><a href="#examples">Examples</a></dt>
+  </dl>
+  <hr>
+
+  <h2><a name="introduction" id=
+  "introduction"></a>Introduction</h2>
+
+  <p>Boost.Python supports docstrings with automatic
+  appending of Pythonic and C++ signatures. This feature is implemented 
+  by <code>class function_doc_signature_generator</code>
+  The class uses all of the overloads, supplied arg names and default values, as well as 
+  the user-defined docstrings, to generate documentation for a given function.</p>
+
+  <h2><a name="classes" id="classes"></a>Classes</h2>
+
+  <h3><a name="function_doc_signature_generator-spec" id=
+  "function_doc_signature_generator-spec"></a>Class
+  <code>function_doc_signature_generator</code></h3>
+
+  <p>
+   The class has only one public function which returns a list of strings documenting the
+   overloads of a function.
+  </p>
+
+  <h4><a name="function_doc_signature_generator-spec-synopsis" id=
+  "function_doc_signature_generator-spec-synopsis"></a>Class
+  <code>function_doc_signature_generator</code> synopsis</h4>
+  <pre>
+namespace boost { namespace python { namespace objects {
+
+    class function_doc_signature_generator 
+    {
+      public:
+          static list function_doc_signatures(function const *f);
+    };
+
+}}}
+</pre>
+
+
+  <h2><a name="examples" id="examples"></a>Examples</h2>
+
+  <h4>Docstrings generated with <code>function_doc_signature_generator</code></h4>
+  <pre>
+#include &lt;boost/python/module.hpp&gt;
+#include &lt;boost/python/def.hpp&gt;
+#include &lt;boost/python/args.hpp&gt;
+#include &lt;boost/python/tuple.hpp&gt;
+#include &lt;boost/python/class.hpp&gt;
+#include &lt;boost/python/overloads.hpp&gt;
+#include &lt;boost/python/raw_function.hpp&gt;
+
+using namespace boost::python;
+
+tuple f(int x = 1, double y = 4.25, char const* z = "wow")
+{
+    return make_tuple(x, y, z);
+}
+
+BOOST_PYTHON_FUNCTION_OVERLOADS(f_overloads, f, 0, 3)
+
+
+struct X
+{
+    tuple f(int x = 1, double y = 4.25, char const* z = "wow")
+    {
+        return make_tuple(x, y, z);
+    }
+};
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(X_f_overloads, X::f, 0, 3)
+
+tuple raw_func(tuple args, dict kw)
+{
+    return make_tuple(args, kw);
+}
+
+BOOST_PYTHON_MODULE(args_ext)
+{
+    def("f", f, (arg("x")=1, arg("y")=4.25, arg("z")="wow")
+        , "This is f's docstring"
+        );
+
+    def("raw", raw_function(raw_func));
+
+    def("f1", f, f_overloads("f1's docstring", args("x", "y", "z")));
+
+
+    class_&lt;X&gt;("X", "This is X's docstring", init&lt;&gt;(args("self")))
+        .def("f", &amp;X::f
+             , "This is X.f's docstring"
+             , args("self","x", "y", "z"))
+
+        ;
+
+}
+
+</pre>
+Python code:
+  <pre>
+&gt;&gt;&gt; import args_ext
+&gt;&gt;&gt; help(args_ext)
+Help on module args_ext:
+
+NAME
+    args_ext
+
+FILE
+    args_ext.pyd
+
+CLASSES
+    Boost.Python.instance(__builtin__.object)
+        X
+
+    class X(Boost.Python.instance)
+     |  This is X's docstring
+     |
+     |  Method resolution order:
+     |      X
+     |      Boost.Python.instance
+     |      __builtin__.object
+     |
+     |  Methods defined here:
+     |
+     |  __init__(...)
+     |      __init__( (object)self) -> None :
+     |       C++ signature:
+     |           void __init__(struct _object *)
+     |
+     |  f(...)
+     |      f( (X)self, (int)x, (float)y, (str)z) -> tuple : This is X.f's docstring
+     |      C++ signature:
+     |          class boost::python::tuple f(struct X {lvalue},int,double,char const *)
+     |
+     |    .................
+     |
+FUNCTIONS
+    f(...)
+        f([ (int)x=1 [, (float)y=4.25 [, (str)z='wow']]]) -> tuple : This is f's docstring
+        C++ signature:
+            class boost::python::tuple f([ int=1 [,double=4.25 [,char const *='wow']]])
+
+    f1(...)
+        f1([ (int)x [, (float)y [, (str)z]]]) -> tuple : f1's docstring
+        C++ signature:
+            class boost::python::tuple f1([ int [,double [,char const *]]])
+
+    raw(...)
+        object raw(tuple args, dict kwds) :
+        C++ signature:
+            object raw(tuple args, dict kwds)
+
+
+</pre>
+
+  <p><i>&copy; Copyright <a href="mailto:nickm at sitius dot com">Nikolay Mladenov</a> 2007.</i></p>
+</body>
+</html>

doc/v2/handle.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -326,7 +329,7 @@ null_ok&lt;T&gt;* allow_null(T* p)
     </p>
 
     <p class="c4">&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002
 .</p>
   </body>
 </html>

doc/v2/has_back_reference.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -215,7 +218,7 @@ BOOST_PYTHON_MODULE(back_references)
     </p>
 
     <p class="c3">&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002
 .</p>
   </body>
 </html>

doc/v2/implicit.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -154,7 +157,7 @@ BOOST_PYTHON_MODULE(implicit_ext)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/import.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">

doc/v2/index.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=

doc/v2/indexing.html

@@ -1,4 +1,7 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=

doc/v2/init.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -242,7 +245,7 @@ class_&lt;X&gt;("X", "This is X's docstring.",
      
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/instance_holder.html

@@ -1,6 +1,9 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content="HTML Tidy, see www.w3.org">
@@ -210,7 +213,7 @@ struct pointer_holder : instance_holder
 
 
     <p class="c4">&copy; Copyright <a href= 
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. 
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002. 
 
   </body>
 </html>

doc/v2/iterator.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -389,7 +392,7 @@ BOOST_PYTHON_MODULE(demo)
         </p>
 
         <p><i>&copy; Copyright <a href=
-        "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+        "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/list.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -133,7 +136,7 @@ long zeroes(list l)
     <p>Revised 1 October, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/long.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -110,7 +113,7 @@ python::long_ fact(long n)
     <p>Revised 1 October, 2002</p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/lvalue_from_pytype.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -292,7 +295,7 @@ BOOST_PYTHON_MODULE(noddy_cache)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/make_function.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -201,7 +204,7 @@ BOOST_PYTHON_MODULE(make_function_test)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/manage_new_object.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -136,7 +139,7 @@ BOOST_PYTHON_MODULE(my_module)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/module.html

@@ -103,6 +103,8 @@ RuntimeError: Unidentifiable C++ Exception
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 
 
-    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002. </i>
+    Abrahams</a> 2002. </i> Distributed
+  under the Boost Software License, Version 1.0. (See accompanying file
+  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)</p>
 

doc/v2/numeric.html

@@ -1,102 +1,105 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 
 <html>
-  <head>
+<head>
-    <meta name="generator" content=
+  <meta name="generator" content=
-    "HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
+  "HTML Tidy for Linux/x86 (vers 1 September 2005), see www.w3.org">
-    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
-    <link rel="stylesheet" type="text/css" href="../boost.css">
+  <link rel="stylesheet" type="text/css" href="../boost.css">
 
-    <title>Boost.Python - &lt;boost/python/numeric.hpp&gt;</title>
+  <title>Boost.Python - &lt;boost/python/numeric.hpp&gt;</title>
-  </head>
+</head>
 
-  <body>
+<body>
-    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+  <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
-    "header">
+  "header">
-      <tr>
+    <tr>
-        <td valign="top" width="300">
+      <td valign="top" width="300">
-          <h3><a href="../../../../index.htm"><img height="86" width="277"
+        <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
-          alt="C++ Boost" src="../../../../boost.png" border="0"></a></h3>
+        "C++ Boost" src="../../../../boost.png" border="0"></a></h3>
-        </td>
+      </td>
 
-        <td valign="top">
+      <td valign="top">
-          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
+        <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
 
-          <h2 align="center">Header &lt;boost/python/numeric.hpp&gt;</h2>
+        <h2 align="center">Header &lt;boost/python/numeric.hpp&gt;</h2>
-        </td>
+      </td>
-      </tr>
+    </tr>
-    </table>
+  </table>
-    <hr>
+  <hr>
 
-    <h2>Contents</h2>
+  <h2>Contents</h2>
 
-    <dl class="page-index">
+  <dl class="page-index">
-      <dt><a href="#introduction">Introduction</a></dt>
+    <dt><a href="#introduction">Introduction</a></dt>
 
-      <dt><a href="#classes">Classes</a></dt>
+    <dt><a href="#classes">Classes</a></dt>
 
-      <dd>
+    <dd>
-        <dl class="page-index">
+      <dl class="page-index">
-          <dt><a href="#array-spec">Class <code>array</code></a></dt>
+        <dt><a href="#array-spec">Class <code>array</code></a></dt>
 
-          <dd>
+        <dd>
-            <dl class="page-index">
+          <dl class="page-index">
-              <dt><a href="#array-spec-synopsis">Class <code>array</code>
+            <dt><a href="#array-spec-synopsis">Class <code>array</code>
-              synopsis</a></dt>
+            synopsis</a></dt>
 
-              <dt><a href="#array-spec-observers">Class <code>array</code>
+            <dt><a href="#array-spec-observers">Class <code>array</code>
-              observer functions</a></dt>
+            observer functions</a></dt>
 
-              <dt><a href="#array-spec-statics">Class <code>array</code>
+            <dt><a href="#array-spec-statics">Class <code>array</code> static
-              static functions</a></dt>
+            functions</a></dt>
-            </dl>
+          </dl>
-          </dd>
+        </dd>
-        </dl>
+      </dl>
-      </dd>
+    </dd>
 
-      <dt><a href="#examples">Example(s)</a></dt>
+    <dt><a href="#examples">Example(s)</a></dt>
-    </dl>
+  </dl>
-    <hr>
+  <hr>
 
-    <h2><a name="introduction"></a>Introduction</h2>
+  <h2><a name="introduction" id="introduction"></a>Introduction</h2>
 
-    <p>Exposes a <a href=
+  <p>Exposes a <a href=
-    "ObjectWrapper.html#TypeWrapper-concept">TypeWrapper</a> for the Python
+  "ObjectWrapper.html#TypeWrapper-concept">TypeWrapper</a> for the Python
-    <a href=
+  <a href=
-    "http://www.python.org/dev/doc/devel/lib/typesmapping.html">array</a>
+  "http://www.python.org/dev/doc/devel/lib/typesmapping.html">array</a>
-    type.</p>
+  type.</p>
 
-    <h2><a name="classes"></a>Classes</h2>
+  <h2><a name="classes" id="classes"></a>Classes</h2>
 
-    <h3><a name="array-spec"></a>Class <code>array</code></h3>
+  <h3><a name="array-spec" id="array-spec"></a>Class <code>array</code></h3>
 
-    <p>Provides access to the array types of <a href=
+  <p>Provides access to the array types of <a href=
-    "http://www.pfdubois.com/numpy/">Numerical Python</a>'s <a href=
+  "http://www.pfdubois.com/numpy/">Numerical Python</a>'s <a href=
-    "http://www.pfdubois.com/numpy/#Numeric">Numeric</a> and <a href=
+  "http://www.pfdubois.com/numpy/#Numeric">Numeric</a> and <a href=
-    "http://stsdas.stsci.edu/numarray/index.html">NumArray</a> modules. With
+  "http://stsdas.stsci.edu/numarray/index.html">NumArray</a> modules. With
-    the exception of the functions documented <a href=
+  the exception of the functions documented <a href=
-    "#array-spec-observers">below</a>, the semantics of the constructors and
+  "#array-spec-observers">below</a>, the semantics of the constructors and
-    member functions defined below can be fully understood by reading the <a
+  member functions defined below can be fully understood by reading the
-    href="ObjectWrapper.html#TypeWrapper-concept">TypeWrapper</a> concept
+  <a href="ObjectWrapper.html#TypeWrapper-concept">TypeWrapper</a> concept
-    definition. Since <code>array</code> is publicly derived from <code><a
+  definition. Since <code>array</code> is publicly derived from
-    href="object.html#object-spec">object</a></code>, the public object
+  <code><a href="object.html#object-spec">object</a></code>, the public
-    interface applies to <code>array</code> instances as well.</p>
+  object interface applies to <code>array</code> instances as well.</p>
 
-    <p><a name="default_search"></a>The default behavior is to use
+  <p><a name="default_search" id="default_search"></a>The default behavior is
-    <code>numarray.NDArray</code> as the associated Python type if the
+  to use <code>numarray.NDArray</code> as the associated Python type if the
-    <code>numarray</code> module is installed in the default location.
+  <code>numarray</code> module is installed in the default location.
-    Otherwise it falls back to use <code>Numeric.ArrayType</code>. If neither
+  Otherwise it falls back to use <code>Numeric.ArrayType</code>. If neither
-    extension module is installed, conversions to arguments of type
+  extension module is installed, overloads of wrapped C++ functions with
-    <code>numeric::array</code> will cause overload resolution to reject the
+  <code>numeric::array</code> parameters will never be matched, and other
-    overload, and other attempted uses of <code>numeric::array</code> will <a
+  attempted uses of <code>numeric::array</code> will <a href=
-    href="definitions.html#raise">raise</a> an appropriate Python exception.
+  "definitions.html#raise">raise</a> an appropriate Python exception. The
-    The associated Python type can be set manually using the <code><a href=
+  associated Python type can be set manually using the <code><a href=
-    "#array-spec-statics">set_module_and_type</a>(...)</code> static
+  "#array-spec-statics">set_module_and_type</a>(...)</code> static
-    function.</p>
+  function.</p>
 
-    <h4><a name="array-spec-synopsis"></a>Class <code>array</code>
+  <h4><a name="array-spec-synopsis" id="array-spec-synopsis"></a>Class
-    synopsis</h4>
+  <code>array</code> synopsis</h4>
-<pre>
+  <pre>
 namespace boost { namespace python { namespace numeric
 {
    class array : public object
@@ -107,7 +110,7 @@ namespace boost { namespace python { namespace numeric
       object astype(Type const&amp; type_);
 
       template &lt;class Type&gt;
-      object new_(Type const&amp; type_) const;
+      array new_(Type const&amp; type_) const;
 
       template &lt;class Sequence&gt; 
       void resize(Sequence const&amp; x);
@@ -133,14 +136,14 @@ namespace boost { namespace python { namespace numeric
       void tofile(File const&amp; f) const;
 
       object factory();
-      template &lt;class Buffer&gt;
+      template &lt;class Sequence&gt;
-      object factory(Buffer const&amp;);
+      object factory(Sequence const&amp;);
-      template &lt;class Buffer, class Type&gt;
+      template &lt;class Sequence, class Typecode&gt;
-      object factory(Buffer const&amp;, Type const&amp;);
+      object factory(Sequence const&amp;, Typecode const&amp;, bool copy = true, bool savespace = false);
-      template &lt;class Buffer, class Type, class Shape&gt;
+      template &lt;class Sequence, class Typecode, class Type&gt;
-      object factory(Buffer const&amp;, Type const&amp;, Shape const&amp;, bool copy = true, bool savespace = false);
+      object factory(Sequence const&amp;, Typecode const&amp;, bool copy, bool savespace, Type const&amp;);
-      template &lt;class Buffer, class Type, class Shape&gt;
+      template &lt;class Sequence, class Typecode, class Type, class Shape&gt;
-      object factory(Buffer const&amp;, Type const&amp;, Shape const&amp;, bool copy, bool savespace, char typecode);
+      object factory(Sequence const&amp;, Typecode const&amp;, bool copy, bool savespace, Type const&amp;, Shape const&amp;);
 
       template &lt;class T1&gt;
       explicit array(T1 const&amp; x1);
@@ -152,6 +155,7 @@ namespace boost { namespace python { namespace numeric
 
       static void set_module_and_type();
       static void set_module_and_type(char const* package_path = 0, char const* type_name = 0);
+      static void get_module_name();
 
       object argmax(long axis=-1);
 
@@ -200,54 +204,60 @@ namespace boost { namespace python { namespace numeric
 }}}
 </pre>
 
-    <h4><a name="array-spec-observers"></a>Class <code>array</code> observer
+  <h4><a name="array-spec-observers" id="array-spec-observers"></a>Class
-    functions</h4>
+  <code>array</code> observer functions</h4>
-<pre>
+  <pre>
 object factory();
-template &lt;class Buffer&gt;
+template &lt;class Sequence&gt;
-object factory(Buffer const&amp;);
+object factory(Sequence const&amp;);
-template &lt;class Buffer, class Type&gt;
+template &lt;class Sequence, class Typecode&gt;
-object factory(Buffer const&amp;, Type const&amp;);
+object factory(Sequence const&amp;, Typecode const&amp;, bool copy = true, bool savespace = false);
-template &lt;class Buffer, class Type, class Shape&gt;
+template &lt;class Sequence, class Typecode, class Type&gt;
-object factory(Buffer const&amp;, Type const&amp;, Shape const&amp;, bool copy = true, bool savespace = false);
+object factory(Sequence const&amp;, Typecode const&amp;, bool copy, bool savespace, Type const&amp;);
-template &lt;class Buffer, class Type, class Shape&gt;
+template &lt;class Sequence, class Typecode, class Type, class Shape&gt;
-object factory(Buffer const&amp;, Type const&amp;, Shape const&amp;, bool copy, bool savespace, char typecode);
+object factory(Sequence const&amp;, Typecode const&amp;, bool copy, bool savespace, Type const&amp;, Shape const&amp;);
-</pre>
+</pre>These functions map to the underlying array type's <code>array()</code>
-    These functions map to the underlying array type's <code>array()</code>
+function family. They are not called "<code>array</code>" because of the C++
-    function family. They are not called "<code>array</code>" because of the
+limitation that you can't define a member function with the same name as its
-    C++ limitation that you can't define a member function with the same name
+enclosing class.
-    as its enclosing class. 
+  <pre>
-<pre>
 template &lt;class Type&gt;
-object new_(Type const&amp;) const;
+array new_(Type const&amp;) const;
-</pre>
+</pre>This function maps to the underlying array type's <code>new()</code>
-    This function maps to the underlying array type's <code>new()</code>
+function. It is not called "<code>new</code>" because that is a keyword in
-    function. It is not called "<code>new</code>" because that is a keyword
+C++.
-    in C++. 
 
-    <h4><a name="array-spec-statics"></a>Class <code>array</code> static
+  <h4><a name="array-spec-statics" id="array-spec-statics"></a>Class
-    functions</h4>
+  <code>array</code> static functions</h4>
-<pre>
+  <pre>
 static void set_module_and_type(char const* package_path, char const* type_name);
 static void set_module_and_type();
 </pre>
 
-    <dl class="function-semantics">
+  <dl class="function-semantics">
-      <dt><b>Requires:</b> <code>package_path</code> and
+    <dt><b>Requires:</b> <code>package_path</code> and
-      <code>type_name</code>, if supplied, is an <a href=
+    <code>type_name</code>, if supplied, is an <a href=
-      "definitions.html#ntbs">ntbs</a>.</dt>
+    "definitions.html#ntbs">ntbs</a>.</dt>
 
-      <dt><b>Effects:</b> The first form sets the package path of the module
+    <dt><b>Effects:</b> The first form sets the package path of the module
-      which supplies the type named by <code>type_name</code> to
+    that supplies the type named by <code>type_name</code> to
-      <code>package_path</code>. The second form restores the <a href=
+    <code>package_path</code>. The second form restores the <a href=
-      "#default_search">default search behavior</a>. The associated Python
+    "#default_search">default search behavior</a>. The associated Python type
-      type will be searched for only the first time it is needed, and
+    will be searched for only the first time it is needed, and thereafter the
-      thereafter the first time it is needed after an invocation of
+    first time it is needed after an invocation of
-      <code>set_module_and_type</code>.</dt>
+    <code>set_module_and_type</code>.</dt>
-    </dl>
+  </dl>
+  <pre>
+static std::string get_module_name()
+</pre>
 
-    <h2><a name="examples"></a>Example</h2>
+  <dl class="function-semantics">
-<pre>
+    <dt><b>Effects:</b> Returns the name of the module containing the class
+    that will be held by new <code>numeric::array</code> instances.</dt>
+  </dl>
+
+  <h2><a name="examples" id="examples"></a>Example</h2>
+  <pre>
 #include &lt;boost/python/numeric.hpp&gt;
 #include &lt;boost/python/tuple.hpp&gt;
 
@@ -258,10 +268,9 @@ void set_first_element(numeric::array&amp; y, double value)
 }
 </pre>
 
-    <p>Revised 03 October, 2002</p>
+  <p>Revised 07 October, 2006</p>
 
-    <p><i>&copy; Copyright <a href=
+  <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+  Abrahams</a> 2002-2006.</i></p>
-  </body>
+</body>
 </html>
-

doc/v2/object.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -71,6 +74,32 @@
             </dl>
           </dd>
 
+          <dt><a href="#const_objattribute_policies-spec">Class
+          <code>const_objattribute_policies</code></a></dt>
+
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#const_objattribute_policies-spec-synopsis">Class
+              <code>const_objattribute_policies</code> synopsis</a></dt>
+
+              <dt><a href="#const_objattribute_policies-spec-statics">Class
+              <code>const_objattribute_policies</code> static functions</a></dt>
+            </dl>
+          </dd>
+
+          <dt><a href="#objattribute_policies-spec">Class
+          <code>objattribute_policies</code></a></dt>
+
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#objattribute_policies-spec-synopsis">Class
+              <code>objattribute_policies</code> synopsis</a></dt>
+
+              <dt><a href="#objattribute_policies-spec-statics">Class
+              <code>objattribute_policies</code> static functions</a></dt>
+            </dl>
+          </dd>
+
           <dt><a href="#const_item_policies-spec">Class
           <code>const_item_policies</code></a></dt>
 
@@ -325,6 +354,102 @@ static void del(object const&amp;target, char const* key);
     <!-- end -->
     <!-- begin -->
 
+    <h3><a name="const_objattribute_policies-spec"></a>Class
+    <code>const_objattribute_policies</code></h3>
+
+    <p>The policies which are used for proxies representing an attribute
+    access to a <code>const&nbsp;object</code> when the attribute name is
+    given as a <code>const&nbsp;object</code>.</p>
+
+    <h4><a name="const_objattribute_policies-spec-synopsis"></a>Class
+    <code>const_objattribute_policies</code> synopsis</h4>
+<pre>
+namespace boost { namespace python { namespace api
+{
+  struct const_objattribute_policies
+  {
+      typedef object const& key_type;
+      static object get(object const&amp; target, object const& key);
+  };
+}}}
+</pre>
+
+    <h4><a name="const_objattribute_policies-spec-statics"></a>Class
+    <code>const_objattribute_policies</code> static functions</h4>
+<pre>
+static object get(object const&amp; target, object const& key);
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> <code>key</code> is an <code>object</code>
+      holding a string.</dt>
+
+      <dt><b>Effects:</b> accesses the attribute of <code>target</code> named
+      by <code>key</code>.</dt>
+
+      <dt><b>Returns:</b> An <code>object</code> managing the result of the
+      attribute access.</dt>
+
+      <dt><b>Throws:</b> <code><a href=
+      "errors.html#error_already_set-spec">error_already_set</a></code> if a
+      Python exception is raised.</dt>
+    </dl>
+
+    <h3><a name="objattribute_policies-spec"></a>Class
+    <code>objattribute_policies</code></h3>
+
+    <p>The policies which are used for proxies representing an attribute
+    access to a mutable <code>object</code> when the attribute name is
+    given as a <code>const&nbsp;object</code>.</p>
+
+    <h4><a name="objattribute_policies-spec-synopsis"></a>Class
+    <code>objattribute_policies</code> synopsis</h4>
+<pre>
+namespace boost { namespace python { namespace api
+{
+  struct objattribute_policies : const_objattribute_policies
+  {
+      static object const&amp; set(object const&amp; target, object const& key, object const&amp; value);
+      static void del(object const&amp;target, object const& key);
+  };
+}}}
+</pre>
+
+    <h4><a name="objattribute_policies-spec-statics"></a>Class
+    <code>objattribute_policies</code> static functions</h4>
+<pre>
+static object const&amp; set(object const&amp; target, object const& key, object const&amp; value);
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> <code>key</code> is an <code>object</code>
+      holding a string.</dt>
+
+      <dt><b>Effects:</b> sets the attribute of <code>target</code> named by
+      <code>key</code> to <code>value</code>.</dt>
+
+      <dt><b>Throws:</b> <code><a href=
+      "errors.html#error_already_set-spec">error_already_set</a></code> if a
+      Python exception is raised.</dt>
+    </dl>
+<pre>
+static void del(object const&amp;target, object const& key);
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> <code>key</code> is an <code>object</code>
+      holding a string.</dt>
+
+      <dt><b>Effects:</b> deletes the attribute of <code>target</code> named
+      by <code>key</code>.</dt>
+
+      <dt><b>Throws:</b> <code><a href=
+      "errors.html#error_already_set-spec">error_already_set</a></code> if a
+      Python exception is raised.</dt>
+    </dl>
+    <!-- end -->
+    <!-- begin -->
+
     <h3><a name="const_item_policies-spec"></a>Class
     <code>const_item_policies</code></h3>
 
@@ -530,6 +655,11 @@ namespace boost { namespace python { namespace api
       template &lt;class A0, class A1,...class An&gt;
       object operator()(A0 const&amp;, A1 const&amp;,...An const&amp;) const;
 
+      detail::args_proxy operator* () const; 
+      object operator()(detail::args_proxy const &amp;args) const; 
+      object operator()(detail::args_proxy const &amp;args, 
+                        detail::kwds_proxy const &amp;kwds) const; 
+
       // truth value testing
       //
       typedef unspecified bool_type;
@@ -539,6 +669,8 @@ namespace boost { namespace python { namespace api
       //
       proxy&lt;const_object_attribute&gt; attr(char const*) const;
       proxy&lt;object_attribute&gt; attr(char const*);
+      proxy&lt;const_object_objattribute&gt; attr(object const&) const;
+      proxy&lt;object_objattribute&gt; attr(object const&);
 
       // item access
       //
@@ -577,6 +709,25 @@ object operator()(A0 const&amp; a1, A1 const&amp; a2,...An const&amp; aN) const;
       call&lt;object&gt;(object(*static_cast&lt;U*&gt;(this)).ptr(), a1,
       a2,...aN)</dt>
     </dl>
+
+<pre>
+object operator()(detail::args_proxy const &amp;args) const; 
+</pre>
+<dl class="function-semantics">
+  <dt><b>Effects:</b>
+  call object with arguments given by the tuple <varname>args</varname></dt>
+</dl>
+<pre>
+object operator()(detail::args_proxy const &amp;args, 
+                  detail::kwds_proxy const &amp;kwds) const; 
+</pre>
+<dl class="function-semantics">
+  <dt><b>Effects:</b>
+  call object with arguments given by the tuple <varname>args</varname>, and named
+  arguments given by the dictionary <varname>kwds</varname></dt>
+</dl>
+
+
 <pre>
 operator bool_type() const;
 </pre>
@@ -605,6 +756,21 @@ proxy&lt;object_attribute&gt; attr(char const* name);
       <code>name</code> as its key.</dt>
     </dl>
 <pre>
+proxy&lt;const_object_objattribute&gt; attr(const object& name) const;
+proxy&lt;object_objattribute&gt; attr(const object& name);
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> name is a <code>object</code> holding a string.</dt>
+
+      <dt><b>Effects:</b> accesses the named attribute of
+      <code>*this</code>.</dt>
+
+      <dt><b>Returns:</b> a proxy object which binds
+      <code>object(*static_cast&lt;U*&gt;(this))</code> as its target, and
+      <code>name</code> as its key.</dt>
+    </dl>
+<pre>
 template &lt;class T&gt;
 proxy&lt;const_object_item&gt; operator[](T const&amp; key) const;
 template &lt;class T&gt;
@@ -669,6 +835,8 @@ namespace boost { namespace python { namespace api
       object&amp; operator=(object const&amp;); 
 
       PyObject* ptr() const;
+
+      bool is_none() const;
   };
 }}}
 </pre>
@@ -729,6 +897,14 @@ PyObject* ptr() const;
       <dt><b>Returns:</b> a pointer to the internally-held Python
       object.</dt>
     </dl>
+
+<pre>
+bool is_none() const;
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Returns:</b> result of (ptr() == Py_None)</dt>
+    </dl>
     <!-- -->
 
     <h3><a name="proxy-spec"></a>Class template <code>proxy</code></h3>
@@ -851,12 +1027,12 @@ void del(proxy&lt;T&gt; const&amp; x);
     </dl>
 <pre>
 <a name="comparisons-spec"></a>
-template&lt;class L,class R&gt; bool operator&gt;(L const&amp;l,R const&amp;r);
+template&lt;class L,class R&gt; object operator&gt;(L const&amp;l,R const&amp;r);
-template&lt;class L,class R&gt; bool operator&gt;=(L const&amp;l,R const&amp;r);
+template&lt;class L,class R&gt; object operator&gt;=(L const&amp;l,R const&amp;r);
-template&lt;class L,class R&gt; bool operator&lt;(L const&amp;l,R const&amp;r);
+template&lt;class L,class R&gt; object operator&lt;(L const&amp;l,R const&amp;r);
-template&lt;class L,class R&gt; bool operator&lt;=(L const&amp;l,R const&amp;r);
+template&lt;class L,class R&gt; object operator&lt;=(L const&amp;l,R const&amp;r);
-template&lt;class L,class R&gt; bool operator==(L const&amp;l,R const&amp;r);
+template&lt;class L,class R&gt; object operator==(L const&amp;l,R const&amp;r);
-template&lt;class L,class R&gt; bool operator!=(L const&amp;l,R const&amp;r);
+template&lt;class L,class R&gt; object operator!=(L const&amp;l,R const&amp;r);
 </pre>
 
     <dl class="function-semantics">
@@ -935,11 +1111,11 @@ object sum_items(object seq)
 </pre>
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  13 January, 2006
+  15 March, 2010
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2006.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2008.</i></p>
   </body>
 </html>

doc/v2/opaque.html

@@ -0,0 +1,138 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<!-- Copyright 2003..2006 Haufe Mediengruppe. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
+
+<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="../../../../boost.png" 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-spec">Class template
+          <code>opaque&lt;Pointee&gt;</code></a></dt>
+
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#opaque-spec-synopsis">Class template
+              <code>opaque</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="#see-also">See Also</a></dt>
+    </dl>
+    <hr>
+
+    <h2><a name="classes"></a>Classes</h2>
+
+    <h3><a name="opaque-spec"></a>Class template
+    <code>opaque&lt;P&gt;</code></h3>
+
+    <p><code>opaque&lt;&gt;</code> registers itself as a converter from
+      Python objects to pointers to undefined types and vice versa.</p>
+
+    <h4><a name="opaque-spec-synopsis"></a>Class template
+    <code>opaque</code> synopsis</h4>
+<pre>
+namespace boost { namespace python
+{
+    template&lt;class Pointee&gt;
+    struct opaque
+    {
+        opaque();
+    };
+}}
+</pre>
+
+    <h4><a name="opaque-spec-constructor"></a>Class template
+    <code>opaque</code> constructor</h4>
+<pre>
+opaque();
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Effects:</b>
+    <ul>
+        <li>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 Python Objects created are named after the type pointed to
+          by the opaque pointer being wrapped.</p></li>
+        <li>Registers the instance as a 
+          <a href="to_python_converter.html#to_python_converter-spec"> <code>to_python_converter</code></a>
+        from opaque pointers to Python objects.</p></li>
+    </ul>
+    <p>If there is already an instance registered by another module, this
+      instance doesn't try to register again in order to avoid warnings
+      about multiple registrations.</p>
+
+    <h4>Note</h4>
+    <p>Normally only a single instance of this class is created for every
+      Pointee.</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>The macro must be invoked in every translation unit which uses the
+      opaque converter.</p>
+
+    <h2><a name="see-also"></a>See Also</h2>
+        <p>
+          <a href="return_opaque_pointer.html">return_opaque_pointer</a>
+        </p>
+
+    <p>Revised 
+  10 September, 2006
+    </p>
+
+    <p><i>&copy; Copyright 2003..2006 Haufe Mediengruppe. All Rights
+    Reserved.</i></p>
+  </body>
+</html>
+

doc/v2/opaque_pointer_converter.html

@@ -1,142 +0,0 @@
-<!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="../../../../boost.png" 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#examples">
-          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

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -211,6 +214,9 @@ namespace boost { namespace python { namespace self_ns {
    <a href=
 "#operator_-spec">operator_</a>&lt;<i>unspecified</i>&gt; str(self_t);
 
+   <a href=
+"#operator_-spec">operator_</a>&lt;<i>unspecified</i>&gt; repr(self_t);
+
 }}};
 </pre>
     The tables below describe the methods generated when the results of the
@@ -762,6 +768,15 @@ namespace boost { namespace python { namespace self_ns {
         <td><code><a href=
         "../../../conversion/lexical_cast.htm#lexical_cast">lexical_cast</a>&lt;std::string&gt;(x)</code></td>
       </tr>
+
+      <tr>
+        <td><code>repr</code></td>
+
+        <td><code>__repr__</code></td>
+
+        <td><code><a href=
+        "../../../conversion/lexical_cast.htm#lexical_cast">lexical_cast</a>&lt;std::string&gt;(x)</code></td>
+      </tr>
     </table>
 
     <h3><a name="other-spec"></a>Class Template <code>other</code></h3>
@@ -900,7 +915,7 @@ BOOST_PYTHON_MODULE(demo)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>
 

doc/v2/overloads.html

@@ -1,5 +1,8 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
+<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
+<!-- Software License, Version 1.0. (See accompanying -->
+<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -220,7 +223,7 @@ BOOST_PYTHON_MODULE(args_ext)
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2002.</i></p>
   </body>
 </html>