Escape some slashes which were confusing quickbook.

[SVN r43286]
Some more fixes for an over-enthusiastic search and replace.
2026-01-19 16:32:16 +00:00 · 2008-02-17 12:24:17 +00:00 · 2008-02-16 11:07:24 +00:00 · 2008-02-16 11:00:33 +00:00 · 2008-02-07 23:08:19 +00:00 · 2008-02-07 22:27:50 +00:00
182 changed files with 1602 additions and 1685 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,72 +0,0 @@
-#
-# Copyright Troy D. Straszheim
-#
-# Distributed under the Boost Software License, Version 1.0.
-# See http://www.boost.org/LICENSE_1_0.txt
-#
-if (PYTHON_LIBRARIES)
-  include_directories(${PYTHON_INCLUDE_PATH})
-
-  # Determine extra libraries we need to link against to build Python
-  # extension modules.
-  if(CMAKE_SYSTEM_NAME STREQUAL "SunOS")
-    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "dl")
-    if(CMAKE_COMPILER_IS_GNUCXX)
-      set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "rt")
-    endif(CMAKE_COMPILER_IS_GNUCXX)
-  elseif(CMAKE_SYSTEM_NAME MATCHES ".*BSD")
-    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "pthread")
-  elseif(CMAKE_SYSTEM_NAME STREQUAL "DragonFly")
-    # DragonFly is a variant of FreeBSD
-    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "pthread")
-  elseif(CMAKE_SYSTEM_NAME STREQUAL "OSF")
-    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "pthread" "dl")
-    if(CMAKE_COMPILER_IS_GNUCXX)
-      set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "rt")
-    endif(CMAKE_COMPILER_IS_GNUCXX)    
-  elseif(CMAKE_SYSTEM_NAME STREQUAL "QNX")
-    # No options necessary for QNX
-  elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
-    # No options necessary for Mac OS X
-  elseif(CMAKE_SYSTEM_NAME STREQUAL "HP-UX")
-    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "rt")
-  elseif(UNIX)
-    # Assume -pthread and -ldl on all other variants
-    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "pthread" "dl")
-    if(CMAKE_COMPILER_IS_GNUCXX)
-      set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "util")
-    endif(CMAKE_COMPILER_IS_GNUCXX)    
-  endif(CMAKE_SYSTEM_NAME STREQUAL "SunOS")
-
-################################################################################
-#-- Macro for building Boost.Python extension modules
-  macro(boost_python_extension MODULE_NAME)
-    parse_arguments(BPL_EXT 
-      "" 
-      "" 
-      ${ARGN})
-      
-    boost_add_single_library(
-      ${MODULE_NAME}
-      ${BPL_EXT_DEFAULT_ARGS}
-      MODULE
-      LINK_LIBS ${PYTHON_LIBRARIES}
-      DEPENDS boost_python
-      SHARED
-    )
-       
-  endmacro(boost_python_extension)
-#--
-################################################################################
-
-
-  boost_library_project(
-    Python
-    SRCDIRS src
-    TESTDIRS test
-    HEADERS python.hpp python
-    MODULARIZED
-    DESCRIPTION "A framework for interfacing Python and C++. It allows you to quickly and seamlessly expose C++ classes functions and objects to Python, and vice-versa, using no special tools -- just your C++ compiler."
-    AUTHORS "David Abrahams <dave -at- boostpro.com>"
-    )
-endif (PYTHON_LIBRARIES)
--- a/build/VisualStudio/boost_python.dsp
+++ b/build/VisualStudio/boost_python.dsp
@@ -0,0 +1,902 @@
+# Microsoft Developer Studio Project File - Name="boost_python" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=BOOST_PYTHON - WIN32 RELEASE
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "boost_python.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "boost_python.mak" CFG="BOOST_PYTHON - WIN32 RELEASE"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "boost_python - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "boost_python - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "boost_python - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "../bin-stage"
+# PROP Intermediate_Dir "release-obj"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+F90=df.exe
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "BPL_EXPORTS" /YX /FD /Zm800 /Zm800 /Zm800 /c
+# ADD CPP /nologo /MD /W3 /GR /GX /O2 /I "../../../../" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "BOOST_PYTHON_DYNAMIC_LIB" /D "BOOST_PYTHON_SOURCE" /FD /Zm800 /Zm800 /Zm800 /Zm800 /c
+# SUBTRACT CPP /YX
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x1409 /d "NDEBUG"
+# ADD RSC /l 0x1409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
+# ADD LINK32 kernel32.lib user32.lib /nologo /dll /machine:I386
+
+!ELSEIF  "$(CFG)" == "boost_python - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "../bin-stage"
+# PROP Intermediate_Dir "debug-obj"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+F90=df.exe
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "BPL_EXPORTS" /YX /FD /Zm800 /Zm800 /Zm800 /GZ /c
+# ADD CPP /nologo /MDd /W3 /GR /GX /Zi /Od /I "../../../../" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "BOOST_PYTHON_DYNAMIC_LIB" /D "BOOST_PYTHON_SOURCE" /FD /Zm800 /Zm800 /Zm800 /Zm800 /Zm800 /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x1409 /d "_DEBUG"
+# ADD RSC /l 0x1409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib /nologo /dll /incremental:no /debug /machine:I386 /out:"../bin-stage/boost_python_debug.dll" /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "boost_python - Win32 Release"
+# Name "boost_python - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=..\..\src\converter\arg_to_python_base.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\converter\builtin_converters.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\object\class.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\dict.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\object\enum.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\errors.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\converter\from_python.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\object\function.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\object\inheritance.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\object\iterator.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\object\life_support.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\list.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\long.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\module.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\numeric.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\object_operators.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\object_protocol.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\object\pickle_support.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\converter\registry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\slice.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\object\stl_iterator.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\str.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\tuple.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\converter\type_id.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\wrapper.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\import.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\exec.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Group "detail"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\api_placeholder.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\arg_tuple_size.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\borrowed_ptr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\call_object.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\caller.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\char_array.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\config.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\construct.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\convertible.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\cv_category.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\decorated_type_id.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\def_helper.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\defaults_def.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\defaults_gen.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\dependent.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\destroy.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\exception_handler.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\force_instantiate.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\if_else.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\indirect_traits.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\make_keyword_range_fn.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\make_tuple.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\map_entry.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\member_function_cast.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\module_base.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\module_init.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\msvc_typeinfo.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\none.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\not_specified.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\operator_id.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\overloads_fwd.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\pointee.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\preprocessor.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\python22_fixed.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\raw_pyobject.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\referent_storage.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\result.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\returning.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\scope.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\string_literal.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\target.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\translate_exception.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\type_list.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\type_list_impl.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\type_list_impl_no_pts.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\type_list_utils.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\unwind_type.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\void_ptr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\void_return.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\detail\wrap_python.hpp
+# End Source File
+# End Group
+# Begin Group "converter"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\arg_from_python.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\arg_to_python.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\arg_to_python_base.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\builtin_converters.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\constructor_function.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\convertible_function.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\from_python.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\implicit.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\obj_mgr_arg_from_python.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\object_manager.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\pointer_type_id.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\pyobject_traits.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\pyobject_type.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\pytype_arg_from_python.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\pytype_object_mgr_traits.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\registered.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\registered_pointee.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\registrations.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\registry.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\return_from_python.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\rvalue_from_python_data.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\converter\to_python_function_type.hpp
+# End Source File
+# End Group
+# Begin Group "object"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\add_to_namespace.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\class.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\class_converters.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\class_detail.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\class_wrapper.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\construct.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\enum_base.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\find_instance.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\forward.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\function.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\function_handle.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\function_object.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\inheritance.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\instance.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\iterator.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\iterator_core.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\life_support.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\make_holder.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\make_instance.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\pickle_support.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\pointer_holder.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\py_function.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\select_holder.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\stl_iterator_core.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\value_holder.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object\value_holder_fwd.hpp
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\arg_from_python.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\args.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\args_fwd.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\back_reference.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\base_type_traits.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\bases.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\borrowed.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\call.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\call_method.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\cast.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\class.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\class_fwd.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\copy_const_reference.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\copy_non_const_reference.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\data_members.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\def.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\default_call_policies.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\dict.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\enum.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\errors.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\exception_translator.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\extract.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\handle.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\handle_fwd.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\has_back_reference.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\implicit.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\init.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\instance_holder.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\iterator.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\list.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\long.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\lvalue_from_pytype.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\make_function.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\manage_new_object.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\module.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\module_init.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\numeric.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object_attributes.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object_call.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object_core.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object_fwd.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object_items.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object_operators.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object_protocol.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object_protocol_core.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\object_slices.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\operators.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\operators2.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\other.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\overloads.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\pointee.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\proxy.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\ptr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\refcount.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\reference_existing_object.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\return_internal_reference.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\return_value_policy.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\scope.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\self.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\signature.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\slice_nil.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\stl_iterator.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\str.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\tag.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\to_python_converter.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\to_python_indirect.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\to_python_value.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\tuple.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\type_id.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\boost\python\with_custodian_and_ward.hpp
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project
--- a/build/VisualStudio/boost_python.dsw
+++ b/build/VisualStudio/boost_python.dsw
@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "boost_python"=".\boost_python.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
--- a/doc/PyConDC_2003/bpl.html
+++ b/doc/PyConDC_2003/bpl.html
--- a/doc/PyConDC_2003/bpl.pdf
+++ b/doc/PyConDC_2003/bpl.pdf
--- a/doc/PyConDC_2003/python_cpp_mix.jpg
+++ b/doc/PyConDC_2003/python_cpp_mix.jpg
--- a/doc/PyConDC_2003/python_cpp_mix.png
+++ b/doc/PyConDC_2003/python_cpp_mix.png
--- a/doc/building.html
+++ b/doc/building.html
@@ -9,7 +9,7 @@
 </head>
 <body>
 <div class="document" id="logo-boost-python-build-and-test-howto">
-<h1 class="title"><a class="reference external" href="../index.html"><img alt="Boost C++ Libraries:" class="boost-logo" src="../../../boost.png" /></a> Boost.Python Build and Test HOWTO</h1>
+<h1 class="title"><a class="reference external" href="../index.htm"><img alt="Boost C++ Libraries:" class="boost-logo" src="../../../boost.png" /></a> Boost.Python Build and Test HOWTO</h1>

 <!-- Copyright David Abrahams 2006. Distributed under the Boost -->
 <!-- Software License, Version 1.0. (See accompanying -->
--- a/doc/building.rst
+++ b/doc/building.rst
@@ -11,7 +11,7 @@
   :alt: Boost C++ Libraries:
   :class: boost-logo

-__ ../index.html
+__ ../index.htm


 .. section-numbering::
--- a/doc/internals.html
+++ b/doc/internals.html
--- a/doc/internals.rst
+++ b/doc/internals.rst
--- a/doc/projects.html
+++ b/doc/projects.html
@@ -375,27 +375,6 @@
      application modules, including GUI and post-processing of results.</p>
    </dd>

-    <dt><b><a href="http://polybori.sourceforge.net/">PolyBoRi</a></b></dt>
-
-    <dd>
-      <p><a href="mailto:brickenstein@mfo.de"
-        >Michael Brickenstein</a> writes:</p>
-
-      <blockquote>
-        <p>The core of PolyBoRi is a C++ library, which provides
-        high-level data types for Boolean polynomials and monomials,
-        exponent vectors, as well as for the underlying polynomial
-        rings and subsets of the powerset of the Boolean variables. As
-        a unique approach, binary decision diagrams are used as
-        internal storage type for polynomial structures. On top of
-        this C++-library we provide a Python interface. This allows
-        parsing of complex polynomial systems, as well as sophisticated
-        and extendable strategies for Gr&ouml;bner basis computation.
-        Boost.Python has helped us to create this interface in a
-        very clean way.</p>
-      </blockquote>
-    </dd>
-
    <dt><b><a href="http://www.rationaldiscovery.com">Rational Discovery
    LLC</a></b></dt>

@@ -456,11 +435,11 @@
  </dl>
  <hr>

-  <p>Revised
+  <p>Revised 
  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-   29 May, 2008</p>
+   15 July, 2003</p>

  <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
-  Abrahams</a> 2002-2008.</i></p>
+  Abrahams</a> 2002-2003.</i></p>
 </body>
 </html>
--- a/doc/tutorial/doc/Jamfile.v2
+++ b/doc/tutorial/doc/Jamfile.v2
@@ -6,8 +6,6 @@ project boost/libs/python/doc/tutorial/doc ;
 import boostbook : boostbook ;
 using quickbook ;

-path-constant images : html ;
-
 boostbook tutorial
    :
        tutorial.qbk
@@ -15,6 +13,4 @@ boostbook tutorial
        <xsl:param>boost.root=../../../../../..
        <xsl:param>boost.libraries=../../../../../../libs/libraries.htm
        <xsl:param>html.stylesheet=../../../../../../doc/html/boostbook.css
-        <format>pdf:<xsl:param>img.src.path=$(images)/
-        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/python/doc/tutorial/doc/html
    ;
--- a/doc/tutorial/doc/html/images/alert.png
+++ b/doc/tutorial/doc/html/images/alert.png
--- a/doc/tutorial/doc/html/images/home.png
+++ b/doc/tutorial/doc/html/images/home.png
--- a/doc/tutorial/doc/html/images/next.png
+++ b/doc/tutorial/doc/html/images/next.png
--- a/doc/tutorial/doc/html/images/note.png
+++ b/doc/tutorial/doc/html/images/note.png
--- a/doc/tutorial/doc/html/images/prev.png
+++ b/doc/tutorial/doc/html/images/prev.png
--- a/doc/tutorial/doc/html/images/tip.png
+++ b/doc/tutorial/doc/html/images/tip.png
--- a/doc/tutorial/doc/html/images/up.png
+++ b/doc/tutorial/doc/html/images/up.png
--- a/doc/tutorial/doc/html/index.html
+++ b/doc/tutorial/doc/html/index.html
@@ -1,7 +1,7 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Chapter 1. python 2.0</title>
+<title>Chapter 1. python 1.0</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
 <meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
 <link rel="start" href="index.html" title="Chapter 1. python 1.0">
@@ -10,10 +10,10 @@
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../index.htm">Home</a></td>
 <td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="../../../../../../more/faq.htm">FAQ</a></td>
 <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
@@ -31,7 +31,7 @@
 <div><p class="copyright">Copyright © 2002-2005 Joel
      de Guzman, David Abrahams</p></div>
 <div><div class="legalnotice">
-<a name="id457106"></a><p>
+<a name="id455917"></a><p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
        http://www.boost.org/LICENSE_1_0.txt </a>)
@@ -94,14 +94,15 @@
      (IDL).
    </p>
 <a name="quickstart.hello_world"></a><h2>
-<a name="id386707"></a>
+<a name="id385257"></a>
      Hello World
    </h2>
 <p>
      Following C/C++ tradition, let's start with the "hello, world". A
      C++ Function:
    </p>
-<pre class="programlisting"><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*</span> <span class="identifier">greet</span><span class="special">()</span>
+<pre class="programlisting">
+<span class="keyword">char</span> <span class="keyword">const</span><span class="special">*</span> <span class="identifier">greet</span><span class="special">()</span>
 <span class="special">{</span>
   <span class="keyword">return</span> <span class="string">"hello, world"</span><span class="special">;</span>
 <span class="special">}</span>
@@ -109,7 +110,8 @@
 <p>
      can be exposed to Python by writing a Boost.Python wrapper:
    </p>
-<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<pre class="programlisting">
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">hello_ext</span><span class="special">)</span>
 <span class="special">{</span>
@@ -123,7 +125,8 @@
    </p>
 <p>
    </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello_ext</span>
+<pre class="programlisting">
+<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello_ext</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span>
 <span class="identifier">hello</span><span class="special">,</span> <span class="identifier">world</span>
 </pre>
@@ -142,7 +145,7 @@
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: November 22, 2008 at 03:24:11 GMT</small></p></td>
+<td align="left"><p><small>Last revised: November 07, 2007 at 03:34:24 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>
--- a/doc/tutorial/doc/html/python/embedding.html
+++ b/doc/tutorial/doc/html/python/embedding.html
@@ -12,10 +12,10 @@
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
@@ -40,7 +40,7 @@
      Python/C API at all. So stay tuned... <span class="inlinemediaobject"><img src="../images/smiley.png" alt="smiley"></span>
    </p>
 <a name="embedding.building_embedded_programs"></a><h2>
-<a name="id472330"></a>
+<a name="id471171"></a>
      Building embedded programs
    </h2>
 <p>
@@ -82,7 +82,7 @@ exe embedded_program # name of the executable
    &lt;find-library&gt;$(PYTHON_EMBEDDED_LIBRARY) ;
 </pre>
 <a name="embedding.getting_started"></a><h2>
-<a name="id472435"></a>
+<a name="id471276"></a>
      Getting started
    </h2>
 <p>
@@ -130,22 +130,23 @@ exe embedded_program # name of the executable
 <a name="python.using_the_interpreter"></a>Using the interpreter</h3></div></div></div>
 <p>
        As you probably already know, objects in Python are reference-counted. Naturally,
-        the <tt class="literal">PyObject</tt>s of the Python C API are also reference-counted.
+        the <tt class="literal">PyObject</tt>s of the Python/C API are also reference-counted.
        There is a difference however. While the reference-counting is fully automatic
-        in Python, the Python C API requires you to do it <a href="http://www.python.org/doc/current/c-api/refcounting.html" target="_top">by
-        hand</a>. This is messy and especially hard to get right in the presence
+        in Python, the Python<span class="emphasis"><em>C API requires you to do it [@http:</em></span>/www.python.org/doc/current/api/refcounts.html
+        by hand]. This is messy and especially hard to get right in the presence
        of C++ exceptions. Fortunately Boost.Python provides the <a href="../../../../v2/handle.html" target="_top">handle</a>
        and <a href="../../../../v2/object.html" target="_top">object</a> class templates to
        automate the process.
      </p>
 <a name="using_the_interpreter.running_python_code"></a><h2>
-<a name="id472601"></a>
+<a name="id471439"></a>
        Running Python code
      </h2>
 <p>
        Boost.python provides three related functions to run Python code from C++.
      </p>
-<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">eval</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">expression</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">globals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">(),</span> <span class="identifier">object</span> <span class="identifier">locals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">())</span>
+<pre class="programlisting">
+<span class="identifier">object</span> <span class="identifier">eval</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">expression</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">globals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">(),</span> <span class="identifier">object</span> <span class="identifier">locals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">())</span>
 <span class="identifier">object</span> <span class="identifier">exec</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">code</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">globals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">(),</span> <span class="identifier">object</span> <span class="identifier">locals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">())</span>
 <span class="identifier">object</span> <span class="identifier">exec_file</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">filename</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">globals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">(),</span> <span class="identifier">object</span> <span class="identifier">locals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">())</span>
 </pre>
@@ -164,7 +165,8 @@ exe embedded_program # name of the executable
 <p>
        Boost.python provides a function to import a module:
      </p>
-<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">import</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">name</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="identifier">object</span> <span class="identifier">import</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">name</span><span class="special">)</span>
 </pre>
 <p>
        import imports a python module (potentially loading it into the running process
@@ -174,7 +176,8 @@ exe embedded_program # name of the executable
        Let's import the <tt class="literal"><span class="underline">_main</span>_</tt>
        module and run some Python code in its namespace:
      </p>
-<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">main_module</span> <span class="special">=</span> <span class="identifier">import</span><span class="special">(</span><span class="string">"__main__"</span><span class="special">);</span>
+<pre class="programlisting">
+<span class="identifier">object</span> <span class="identifier">main_module</span> <span class="special">=</span> <span class="identifier">import</span><span class="special">(</span><span class="string">"__main__"</span><span class="special">);</span>
 <span class="identifier">object</span> <span class="identifier">main_namespace</span> <span class="special">=</span> <span class="identifier">main_module</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">);</span>

 <span class="identifier">object</span> <span class="identifier">ignored</span> <span class="special">=</span> <span class="identifier">exec</span><span class="special">(</span><span class="string">"hello = file('hello.txt', 'w')\n"</span>
@@ -187,7 +190,7 @@ exe embedded_program # name of the executable
        a phrase that is well-known in programming circles.
      </p>
 <a name="using_the_interpreter.manipulating_python_objects"></a><h2>
-<a name="id473185"></a>
+<a name="id472027"></a>
        Manipulating Python objects
      </h2>
 <p>
@@ -197,7 +200,8 @@ exe embedded_program # name of the executable
        derivatives. We've already seen that they can be constructed from a <tt class="literal">handle</tt>.
        The following examples should further illustrate this fact:
      </p>
-<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">main_module</span> <span class="special">=</span> <span class="identifier">import</span><span class="special">(</span><span class="string">"__main__"</span><span class="special">);</span>
+<pre class="programlisting">
+<span class="identifier">object</span> <span class="identifier">main_module</span> <span class="special">=</span> <span class="identifier">import</span><span class="special">(</span><span class="string">"__main__"</span><span class="special">);</span>
 <span class="identifier">object</span> <span class="identifier">main_namespace</span> <span class="special">=</span> <span class="identifier">main_module</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">);</span>
 <span class="identifier">object</span> <span class="identifier">ignored</span> <span class="special">=</span> <span class="identifier">exec</span><span class="special">(</span><span class="string">"result = 5 ** 2"</span><span class="special">,</span> <span class="identifier">main_namespace</span><span class="special">);</span>
 <span class="keyword">int</span> <span class="identifier">five_squared</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">main_namespace</span><span class="special">[</span><span class="string">"result"</span><span class="special">]);</span>
@@ -208,18 +212,20 @@ exe embedded_program # name of the executable
        this variable from the dictionary. Another way to achieve the same result
        is to use eval instead, which returns the result directly:
      </p>
-<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">eval</span><span class="special">(</span><span class="string">"5 ** 2"</span><span class="special">);</span>
+<pre class="programlisting">
+<span class="identifier">object</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">eval</span><span class="special">(</span><span class="string">"5 ** 2"</span><span class="special">);</span>
 <span class="keyword">int</span> <span class="identifier">five_squared</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">result</span><span class="special">);</span>
 </pre>
 <a name="using_the_interpreter.exception_handling"></a><h2>
-<a name="id473554"></a>
+<a name="id472399"></a>
        Exception handling
      </h2>
 <p>
        If an exception occurs in the evaluation of the python expression, <a href="../../../../v2/errors.html#error_already_set-spec" target="_top">error_already_set</a>
        is thrown:
      </p>
-<pre class="programlisting"><span class="keyword">try</span>
+<pre class="programlisting">
+<span class="keyword">try</span>
 <span class="special">{</span>
    <span class="identifier">object</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">eval</span><span class="special">(</span><span class="string">"5/0"</span><span class="special">);</span>
    <span class="comment">// execution will never get here:
@@ -234,13 +240,14 @@ exe embedded_program # name of the executable
        The <tt class="literal">error_already_set</tt> exception class doesn't carry any
        information in itself. To find out more about the Python exception that occurred,
        you need to use the <a href="http://www.python.org/doc/api/exceptionHandling.html" target="_top">exception
-        handling functions</a> of the Python 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
+        handling functions</a> of the Python<span class="emphasis"><em>C API in your catch-statement.
+        This can be as simple as calling [@http:</em></span>/www.python.org/doc/api/exceptionHandling.html#l2h-70
+        PyErr_Print()] to print the exception's traceback to the console, or comparing
+        the type of the exception with those of the <a href="http://www.python.org/doc/api/standardExceptions.html" target="_top">standard
        exceptions</a>:
      </p>
-<pre class="programlisting"><span class="keyword">catch</span><span class="special">(</span><span class="identifier">error_already_set</span> <span class="keyword">const</span> <span class="special">&amp;)</span>
+<pre class="programlisting">
+<span class="keyword">catch</span><span class="special">(</span><span class="identifier">error_already_set</span> <span class="keyword">const</span> <span class="special">&amp;)</span>
 <span class="special">{</span>
    <span class="keyword">if</span> <span class="special">(</span><span class="identifier">PyErr_ExceptionMatches</span><span class="special">(</span><span class="identifier">PyExc_ZeroDivisionError</span><span class="special">))</span>
    <span class="special">{</span>
--- a/doc/tutorial/doc/html/python/exception.html
+++ b/doc/tutorial/doc/html/python/exception.html
@@ -12,10 +12,10 @@
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
@@ -30,12 +30,14 @@
      is the point where C++ meets Python. Boost.Python provides a default exception
      handler that translates selected standard exceptions, then gives up:
    </p>
-<pre class="programlisting"><span class="keyword">raise</span> <span class="identifier">RuntimeError</span><span class="special">,</span> <span class="string">'unidentifiable C++ Exception'</span>
+<pre class="programlisting">
+<span class="keyword">raise</span> <span class="identifier">RuntimeError</span><span class="special">,</span> <span class="string">'unidentifiable C++ Exception'</span>
 </pre>
 <p>
      Users may provide custom translation. Here's an example:
    </p>
-<pre class="programlisting"><span class="identifier">struct</span> <span class="identifier">PodBayDoorException</span><span class="special">;</span>
+<pre class="programlisting">
+<span class="identifier">struct</span> <span class="identifier">PodBayDoorException</span><span class="special">;</span>
 <span class="identifier">void</span> <span class="identifier">translator</span><span class="special">(</span><span class="identifier">PodBayDoorException</span> <span class="identifier">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">{</span>
    <span class="identifier">PyErr_SetString</span><span class="special">(</span><span class="identifier">PyExc_UserWarning</span><span class="special">,</span> <span class="string">"I'm sorry Dave..."</span><span class="special">);</span>
 <span class="special">}</span>
--- a/doc/tutorial/doc/html/python/exposing.html
+++ b/doc/tutorial/doc/html/python/exposing.html
@@ -12,10 +12,10 @@
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
@@ -40,7 +40,8 @@
 <p>
      Consider a C++ class/struct that we want to expose to Python:
    </p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">World</span>
+<pre class="programlisting">
+<span class="keyword">struct</span> <span class="identifier">World</span>
 <span class="special">{</span>
    <span class="keyword">void</span> <span class="identifier">set</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">msg</span><span class="special">)</span> <span class="special">{</span> <span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">msg</span> <span class="special">=</span> <span class="identifier">msg</span><span class="special">;</span> <span class="special">}</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">greet</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">msg</span><span class="special">;</span> <span class="special">}</span>
@@ -50,7 +51,8 @@
 <p>
      We can expose this to Python by writing a corresponding Boost.Python C++ Wrapper:
    </p>
-<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<pre class="programlisting">
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">;</span>

 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">hello</span><span class="special">)</span>
@@ -69,7 +71,8 @@
    </p>
 <p>
    </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello</span>
+<pre class="programlisting">
+<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">planet</span> <span class="special">=</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">World</span><span class="special">()</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">planet</span><span class="special">.</span><span class="identifier">set</span><span class="special">(</span><span class="string">'howdy'</span><span class="special">)</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">planet</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span>
@@ -84,7 +87,8 @@
        exposes the default constructor by default, which is why we were able to
        write
      </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">planet</span> <span class="special">=</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">World</span><span class="special">()</span>
+<pre class="programlisting">
+<span class="special">&gt;&gt;&gt;</span> <span class="identifier">planet</span> <span class="special">=</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">World</span><span class="special">()</span>
 </pre>
 <p>
        We may wish to wrap a class with a non-default constructor. Let us build
@@ -92,7 +96,8 @@
      </p>
 <p>
      </p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">World</span>
+<pre class="programlisting">
+<span class="keyword">struct</span> <span class="identifier">World</span>
 <span class="special">{</span>
    <span class="identifier">World</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">msg</span><span class="special">):</span> <span class="identifier">msg</span><span class="special">(</span><span class="identifier">msg</span><span class="special">)</span> <span class="special">{}</span> <span class="comment">// added constructor
 </span>    <span class="keyword">void</span> <span class="identifier">set</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">msg</span><span class="special">)</span> <span class="special">{</span> <span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">msg</span> <span class="special">=</span> <span class="identifier">msg</span><span class="special">;</span> <span class="special">}</span>
@@ -106,7 +111,8 @@
        We have to tell <tt class="literal">class_&lt;World&gt;</tt> about the constructor
        we want to expose instead.
      </p>
-<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<pre class="programlisting">
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">;</span>

 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">hello</span><span class="special">)</span>
@@ -127,7 +133,8 @@
        to the <tt class="literal">def()</tt> member function. Say for example we have
        another World constructor taking in two doubles:
      </p>
-<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">World</span><span class="special">&gt;(</span><span class="string">"World"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span>
+<pre class="programlisting">
+<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">World</span><span class="special">&gt;(</span><span class="string">"World"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span>
    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">init</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;())</span>
    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"greet"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">World</span><span class="special">::</span><span class="identifier">greet</span><span class="special">)</span>
    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"set"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">World</span><span class="special">::</span><span class="identifier">set</span><span class="special">)</span>
@@ -137,7 +144,8 @@
        On the other hand, if we do not wish to expose any constructors at all, we
        may use <tt class="literal">no_init</tt> instead:
      </p>
-<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Abstract</span><span class="special">&gt;(</span><span class="string">"Abstract"</span><span class="special">,</span> <span class="identifier">no_init</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Abstract</span><span class="special">&gt;(</span><span class="string">"Abstract"</span><span class="special">,</span> <span class="identifier">no_init</span><span class="special">)</span>
 </pre>
 <p>
        This actually adds an <tt class="literal"><span class="underline">_init</span>_</tt>
@@ -153,7 +161,8 @@
        to be exposed may be regarded as <span class="bold"><b>read-only</b></span>
        or <span class="bold"><b>read-write</b></span>. Consider this class <tt class="literal">Var</tt>:
      </p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Var</span>
+<pre class="programlisting">
+<span class="keyword">struct</span> <span class="identifier">Var</span>
 <span class="special">{</span>
    <span class="identifier">Var</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">name</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">name</span><span class="special">(</span><span class="identifier">name</span><span class="special">),</span> <span class="identifier">value</span><span class="special">()</span> <span class="special">{}</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="keyword">const</span> <span class="identifier">name</span><span class="special">;</span>
@@ -164,7 +173,8 @@
        Our C++ <tt class="literal">Var</tt> class and its data members can be exposed
        to Python:
      </p>
-<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Var</span><span class="special">&gt;(</span><span class="string">"Var"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span>
+<pre class="programlisting">
+<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Var</span><span class="special">&gt;(</span><span class="string">"Var"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span>
    <span class="special">.</span><span class="identifier">def_readonly</span><span class="special">(</span><span class="string">"name"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Var</span><span class="special">::</span><span class="identifier">name</span><span class="special">)</span>
    <span class="special">.</span><span class="identifier">def_readwrite</span><span class="special">(</span><span class="string">"value"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Var</span><span class="special">::</span><span class="identifier">value</span><span class="special">);</span>
 </pre>
@@ -174,7 +184,8 @@
      </p>
 <p>
      </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">Var</span><span class="special">(</span><span class="string">'pi'</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">Var</span><span class="special">(</span><span class="string">'pi'</span><span class="special">)</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">value</span> <span class="special">=</span> <span class="number">3.14</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">name</span><span class="special">,</span> <span class="string">'is around'</span><span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">value</span>
 <span class="identifier">pi</span> <span class="keyword">is</span> <span class="identifier">around</span> <span class="number">3.14</span>
@@ -183,7 +194,8 @@
        Note that <tt class="literal">name</tt> is exposed as <span class="bold"><b>read-only</b></span>
        while <tt class="literal">value</tt> is exposed as <span class="bold"><b>read-write</b></span>.
      </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">name</span> <span class="special">=</span> <span class="string">'e'</span> <span class="comment"># can't change name
+<pre class="programlisting">
+<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">name</span> <span class="special">=</span> <span class="string">'e'</span> <span class="comment"># can't change name
 </span><span class="identifier">Traceback</span> <span class="special">(</span><span class="identifier">most</span> <span class="identifier">recent</span> <span class="identifier">call</span> <span class="identifier">last</span><span class="special">):</span>
  <span class="identifier">File</span> <span class="string">"&lt;stdin&gt;"</span><span class="special">,</span> <span class="identifier">line</span> <span class="number">1</span><span class="special">,</span> <span class="keyword">in</span> #
 <span class="identifier">AttributeError</span><span class="special">:</span> <span class="identifier">can</span>#<span class="identifier">t</span> <span class="identifier">set</span> <span class="identifier">attribute</span>
@@ -200,7 +212,8 @@
      </p>
 <p>
      </p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Num</span>
+<pre class="programlisting">
+<span class="keyword">struct</span> <span class="identifier">Num</span>
 <span class="special">{</span>
    <span class="identifier">Num</span><span class="special">();</span>
    <span class="keyword">float</span> <span class="identifier">get</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
@@ -214,7 +227,8 @@
        can just be a different syntax for a method call. Wrapping our <tt class="literal">Num</tt>
        class using Boost.Python:
      </p>
-<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Num</span><span class="special">&gt;(</span><span class="string">"Num"</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Num</span><span class="special">&gt;(</span><span class="string">"Num"</span><span class="special">)</span>
    <span class="special">.</span><span class="identifier">add_property</span><span class="special">(</span><span class="string">"rovalue"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">get</span><span class="special">)</span>
    <span class="special">.</span><span class="identifier">add_property</span><span class="special">(</span><span class="string">"value"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">get</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">set</span><span class="special">);</span>
 </pre>
@@ -223,7 +237,8 @@
      </p>
 <p>
      </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">Num</span><span class="special">()</span>
+<pre class="programlisting">
+<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">Num</span><span class="special">()</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">value</span> <span class="special">=</span> <span class="number">3.14</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">value</span><span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">rovalue</span>
 <span class="special">(</span><span class="number">3.14</span><span class="special">,</span> <span class="number">3.14</span><span class="special">)</span>
@@ -236,7 +251,8 @@
      </p>
 <p>
      </p>
-<pre class="programlisting"><span class="special">.</span><span class="identifier">add_property</span><span class="special">(</span><span class="string">"rovalue"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">get</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="special">.</span><span class="identifier">add_property</span><span class="special">(</span><span class="string">"rovalue"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">get</span><span class="special">)</span>
 </pre>
 </div>
 <div class="section" lang="en">
@@ -252,21 +268,24 @@
 <p>
        Consider this trivial inheritance structure:
      </p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Base</span> <span class="special">{</span> <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">Base</span><span class="special">();</span> <span class="special">};</span>
+<pre class="programlisting">
+<span class="keyword">struct</span> <span class="identifier">Base</span> <span class="special">{</span> <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">Base</span><span class="special">();</span> <span class="special">};</span>
 <span class="keyword">struct</span> <span class="identifier">Derived</span> <span class="special">:</span> <span class="identifier">Base</span> <span class="special">{};</span>
 </pre>
 <p>
        And a set of C++ functions operating on <tt class="literal">Base</tt> and <tt class="literal">Derived</tt>
        object instances:
      </p>
-<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">b</span><span class="special">(</span><span class="identifier">Base</span><span class="special">*);</span>
+<pre class="programlisting">
+<span class="keyword">void</span> <span class="identifier">b</span><span class="special">(</span><span class="identifier">Base</span><span class="special">*);</span>
 <span class="keyword">void</span> <span class="identifier">d</span><span class="special">(</span><span class="identifier">Derived</span><span class="special">*);</span>
 <span class="identifier">Base</span><span class="special">*</span> <span class="identifier">factory</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="keyword">new</span> <span class="identifier">Derived</span><span class="special">;</span> <span class="special">}</span>
 </pre>
 <p>
        We've seen how we can wrap the base class <tt class="literal">Base</tt>:
      </p>
-<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
    <span class="comment">/*...*/</span>
    <span class="special">;</span>
 </pre>
@@ -274,7 +293,8 @@
        Now we can inform Boost.Python of the inheritance relationship between <tt class="literal">Derived</tt>
        and its base class <tt class="literal">Base</tt>. Thus:
      </p>
-<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Derived</span><span class="special">,</span> <span class="identifier">bases</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span> <span class="special">&gt;(</span><span class="string">"Derived"</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Derived</span><span class="special">,</span> <span class="identifier">bases</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span> <span class="special">&gt;(</span><span class="string">"Derived"</span><span class="special">)</span>
    <span class="comment">/*...*/</span>
    <span class="special">;</span>
 </pre>
@@ -297,7 +317,8 @@
        Now, we will expose the C++ free functions <tt class="literal">b</tt> and <tt class="literal">d</tt>
        and <tt class="literal">factory</tt>:
      </p>
-<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"b"</span><span class="special">,</span> <span class="identifier">b</span><span class="special">);</span>
+<pre class="programlisting">
+<span class="identifier">def</span><span class="special">(</span><span class="string">"b"</span><span class="special">,</span> <span class="identifier">b</span><span class="special">);</span>
 <span class="identifier">def</span><span class="special">(</span><span class="string">"d"</span><span class="special">,</span> <span class="identifier">d</span><span class="special">);</span>
 <span class="identifier">def</span><span class="special">(</span><span class="string">"factory"</span><span class="special">,</span> <span class="identifier">factory</span><span class="special">);</span>
 </pre>
@@ -310,7 +331,8 @@
        is destroyed. We will see more of Boost.Python <a href="functions.html#python.call_policies" title="Call Policies">call
        policies</a> later.
      </p>
-<pre class="programlisting"><span class="comment">// Tell Python to take ownership of factory's result
+<pre class="programlisting">
+<span class="comment">// Tell Python to take ownership of factory's result
 </span><span class="identifier">def</span><span class="special">(</span><span class="string">"factory"</span><span class="special">,</span> <span class="identifier">factory</span><span class="special">,</span>
    <span class="identifier">return_value_policy</span><span class="special">&lt;</span><span class="identifier">manage_new_object</span><span class="special">&gt;());</span>
 </pre>
@@ -323,7 +345,8 @@
        through virtual functions. Continuing our example, let us add a virtual function
        to our <tt class="literal">Base</tt> class:
      </p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Base</span>
+<pre class="programlisting">
+<span class="keyword">struct</span> <span class="identifier">Base</span>
 <span class="special">{</span>
    <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">Base</span><span class="special">()</span> <span class="special">{}</span>
    <span class="keyword">virtual</span> <span class="keyword">int</span> <span class="identifier">f</span><span class="special">()</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
@@ -341,7 +364,8 @@
        that will unintrusively hook into the virtual functions so that a Python
        override may be called:
      </p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">BaseWrap</span> <span class="special">:</span> <span class="identifier">Base</span><span class="special">,</span> <span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span>
+<pre class="programlisting">
+<span class="keyword">struct</span> <span class="identifier">BaseWrap</span> <span class="special">:</span> <span class="identifier">Base</span><span class="special">,</span> <span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span>
 <span class="special">{</span>
    <span class="keyword">int</span> <span class="identifier">f</span><span class="special">()</span>
    <span class="special">{</span>
@@ -373,7 +397,8 @@
 <p>
        Finally, exposing <tt class="computeroutput"><span class="identifier">Base</span></tt>:
      </p>
-<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">BaseWrap</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">BaseWrap</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">pure_virtual</span><span class="special">(&amp;</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">))</span>
    <span class="special">;</span>
 </pre>
@@ -412,7 +437,8 @@
        section</a>, we wrapped a class with a pure virtual function that we then
        implemented in C++, or Python classes derived from it. Our base class:
      </p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Base</span>
+<pre class="programlisting">
+<span class="keyword">struct</span> <span class="identifier">Base</span>
 <span class="special">{</span>
    <span class="keyword">virtual</span> <span class="keyword">int</span> <span class="identifier">f</span><span class="special">()</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">};</span>
@@ -421,7 +447,8 @@
        had a pure virtual function <tt class="literal">f</tt>. If, however, its member
        function <tt class="literal">f</tt> was not declared as pure virtual:
      </p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Base</span>
+<pre class="programlisting">
+<span class="keyword">struct</span> <span class="identifier">Base</span>
 <span class="special">{</span>
    <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">Base</span><span class="special">()</span> <span class="special">{}</span>
    <span class="keyword">virtual</span> <span class="keyword">int</span> <span class="identifier">f</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> <span class="special">}</span>
@@ -430,7 +457,8 @@
 <p>
        We wrap it this way:
      </p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">BaseWrap</span> <span class="special">:</span> <span class="identifier">Base</span><span class="special">,</span> <span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span>
+<pre class="programlisting">
+<span class="keyword">struct</span> <span class="identifier">BaseWrap</span> <span class="special">:</span> <span class="identifier">Base</span><span class="special">,</span> <span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span>
 <span class="special">{</span>
    <span class="keyword">int</span> <span class="identifier">f</span><span class="special">()</span>
    <span class="special">{</span>
@@ -462,7 +490,8 @@
 <p>
        Finally, exposing:
      </p>
-<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">BaseWrap</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">BaseWrap</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">default_f</span><span class="special">)</span>
    <span class="special">;</span>
 </pre>
@@ -477,7 +506,8 @@
      </p>
 <p>
      </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">base</span> <span class="special">=</span> <span class="identifier">Base</span><span class="special">()</span>
+<pre class="programlisting">
+<span class="special">&gt;&gt;&gt;</span> <span class="identifier">base</span> <span class="special">=</span> <span class="identifier">Base</span><span class="special">()</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="keyword">class</span> <span class="identifier">Derived</span><span class="special">(</span><span class="identifier">Base</span><span class="special">):</span>
 <span class="special">...</span>     <span class="keyword">def</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span>
 <span class="special">...</span>         <span class="keyword">return</span> <span class="number">42</span>
@@ -487,13 +517,15 @@
 <p>
        Calling <tt class="literal">base.f()</tt>:
      </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">base</span><span class="special">.</span><span class="identifier">f</span><span class="special">()</span>
+<pre class="programlisting">
+<span class="special">&gt;&gt;&gt;</span> <span class="identifier">base</span><span class="special">.</span><span class="identifier">f</span><span class="special">()</span>
 <span class="number">0</span>
 </pre>
 <p>
        Calling <tt class="literal">derived.f()</tt>:
      </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">derived</span><span class="special">.</span><span class="identifier">f</span><span class="special">()</span>
+<pre class="programlisting">
+<span class="special">&gt;&gt;&gt;</span> <span class="identifier">derived</span><span class="special">.</span><span class="identifier">f</span><span class="special">()</span>
 <span class="number">42</span>
 </pre>
 </div>
@@ -501,7 +533,7 @@
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.class_operators_special_functions"></a>Class Operators/Special Functions</h3></div></div></div>
 <a name="class_operators_special_functions.python_operators"></a><h2>
-<a name="id462548"></a>
+<a name="id461460"></a>
        Python Operators
      </h2>
 <p>
@@ -515,7 +547,8 @@
      </p>
 <p>
      </p>
-<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">FilePos</span> <span class="special">{</span> <span class="comment">/*...*/</span> <span class="special">};</span>
+<pre class="programlisting">
+<span class="keyword">class</span> <span class="identifier">FilePos</span> <span class="special">{</span> <span class="comment">/*...*/</span> <span class="special">};</span>

 <span class="identifier">FilePos</span>     <span class="keyword">operator</span><span class="special">+(</span><span class="identifier">FilePos</span><span class="special">,</span> <span class="keyword">int</span><span class="special">);</span>
 <span class="identifier">FilePos</span>     <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">FilePos</span><span class="special">);</span>
@@ -529,7 +562,8 @@
        The class and the various operators can be mapped to Python rather easily
        and intuitively:
      </p>
-<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">FilePos</span><span class="special">&gt;(</span><span class="string">"FilePos"</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">FilePos</span><span class="special">&gt;(</span><span class="string">"FilePos"</span><span class="special">)</span>
    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">+</span> <span class="keyword">int</span><span class="special">())</span>          <span class="comment">// __add__
 </span>    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="keyword">int</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">self</span><span class="special">)</span>          <span class="comment">// __radd__
 </span>    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">-</span> <span class="identifier">self</span><span class="special">)</span>           <span class="comment">// __sub__
@@ -548,7 +582,7 @@
        expressions".
      </p>
 <a name="class_operators_special_functions.special_methods"></a><h2>
-<a name="id463302"></a>
+<a name="id462216"></a>
        Special Methods
      </h2>
 <p>
@@ -558,7 +592,8 @@
        wrap C++ functions that correspond to these Python <span class="emphasis"><em>special functions</em></span>.
        Example:
      </p>
-<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">Rational</span>
+<pre class="programlisting">
+<span class="keyword">class</span> <span class="identifier">Rational</span>
 <span class="special">{</span> <span class="keyword">public</span><span class="special">:</span> <span class="keyword">operator</span> <span class="keyword">double</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span> <span class="special">};</span>

 <span class="identifier">Rational</span> <span class="identifier">pow</span><span class="special">(</span><span class="identifier">Rational</span><span class="special">,</span> <span class="identifier">Rational</span><span class="special">);</span>
--- a/doc/tutorial/doc/html/python/functions.html
+++ b/doc/tutorial/doc/html/python/functions.html
@@ -12,10 +12,10 @@
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
@@ -87,14 +87,16 @@ Namespaces are one honking great idea -- let's do more of those!
        so Boost.Python must deal with them. To do this, it may need your help. Consider
        the following C++ function:
      </p>
-<pre class="programlisting"><span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">);</span>
+<pre class="programlisting">
+<span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">);</span>
 </pre>
 <p>
        How should the library wrap this function? A naive approach builds a Python
        X object around result reference. This strategy might or might not work out.
        Here's an example where it didn't
      </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="preprocessor"># x</span> <span class="identifier">refers</span> <span class="identifier">to</span> <span class="identifier">some</span> <span class="identifier">C</span><span class="special">++</span> <span class="identifier">X</span>
+<pre class="programlisting">
+<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="preprocessor"># x</span> <span class="identifier">refers</span> <span class="identifier">to</span> <span class="identifier">some</span> <span class="identifier">C</span><span class="special">++</span> <span class="identifier">X</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">del</span> <span class="identifier">y</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">some_method</span><span class="special">()</span> <span class="preprocessor"># CRASH</span><span class="special">!</span>
 </pre>
@@ -104,7 +106,8 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
        Well, what if f() was implemented as shown below:
      </p>
-<pre class="programlisting"><span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">)</span>
 <span class="special">{</span>
    <span class="identifier">y</span><span class="special">.</span><span class="identifier">z</span> <span class="special">=</span> <span class="identifier">z</span><span class="special">;</span>
    <span class="keyword">return</span> <span class="identifier">y</span><span class="special">.</span><span class="identifier">x</span><span class="special">;</span>
@@ -142,7 +145,8 @@ Namespaces are one honking great idea -- let's do more of those!
      </p>
 <p>
      </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">).</span><span class="identifier">set</span><span class="special">(</span><span class="number">42</span><span class="special">)</span> <span class="comment"># Result disappears
+<pre class="programlisting">
+<span class="special">&gt;&gt;&gt;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">).</span><span class="identifier">set</span><span class="special">(</span><span class="number">42</span><span class="special">)</span> <span class="comment"># Result disappears
 </span><span class="special">&gt;&gt;&gt;</span> <span class="identifier">y</span><span class="special">.</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span>       <span class="comment"># No crash, but still bad
 </span><span class="number">3.14</span>
 </pre>
@@ -156,7 +160,8 @@ Namespaces are one honking great idea -- let's do more of those!
      </p>
 <p>
      </p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Y</span>
+<pre class="programlisting">
+<span class="keyword">struct</span> <span class="identifier">Y</span>
 <span class="special">{</span>
    <span class="identifier">X</span> <span class="identifier">x</span><span class="special">;</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">;</span>
    <span class="keyword">int</span> <span class="identifier">z_value</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">z</span><span class="special">-&gt;</span><span class="identifier">value</span><span class="special">();</span> <span class="special">}</span>
@@ -166,14 +171,16 @@ Namespaces are one honking great idea -- let's do more of those!
        Notice that the data member <tt class="literal">z</tt> is held by class Y using
        a raw pointer. Now we have a potential dangling pointer problem inside Y:
      </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="preprocessor"># y</span> <span class="identifier">refers</span> <span class="identifier">to</span> <span class="identifier">z</span>
+<pre class="programlisting">
+<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="preprocessor"># y</span> <span class="identifier">refers</span> <span class="identifier">to</span> <span class="identifier">z</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">del</span> <span class="identifier">z</span>       <span class="preprocessor"># Kill</span> <span class="identifier">the</span> <span class="identifier">z</span> <span class="identifier">object</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">y</span><span class="special">.</span><span class="identifier">z_value</span><span class="special">()</span> <span class="preprocessor"># CRASH</span><span class="special">!</span>
 </pre>
 <p>
        For reference, here's the implementation of <tt class="literal">f</tt> again:
      </p>
-<pre class="programlisting"><span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">)</span>
 <span class="special">{</span>
    <span class="identifier">y</span><span class="special">.</span><span class="identifier">z</span> <span class="special">=</span> <span class="identifier">z</span><span class="special">;</span>
    <span class="keyword">return</span> <span class="identifier">y</span><span class="special">.</span><span class="identifier">x</span><span class="special">;</span>
@@ -205,7 +212,7 @@ Namespaces are one honking great idea -- let's do more of those!
 <li><span class="bold"><b>BOOM!</b></span></li>
 </ol></div>
 <a name="call_policies.call_policies"></a><h2>
-<a name="id465291"></a>
+<a name="id464076"></a>
        Call Policies
      </h2>
 <p>
@@ -213,7 +220,8 @@ Namespaces are one honking great idea -- let's do more of those!
        In our example, <tt class="literal">return_internal_reference</tt> and <tt class="literal">with_custodian_and_ward</tt>
        are our friends:
      </p>
-<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">,</span>
+<pre class="programlisting">
+<span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">,</span>
    <span class="identifier">return_internal_reference</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span>
        <span class="identifier">with_custodian_and_ward</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">&gt;</span> <span class="special">&gt;());</span>
 </pre>
@@ -221,7 +229,8 @@ Namespaces are one honking great idea -- let's do more of those!
        What are the <tt class="literal">1</tt> and <tt class="literal">2</tt> parameters, you
        ask?
      </p>
-<pre class="programlisting"><span class="identifier">return_internal_reference</span><span class="special">&lt;</span><span class="number">1</span>
+<pre class="programlisting">
+<span class="identifier">return_internal_reference</span><span class="special">&lt;</span><span class="number">1</span>
 </pre>
 <p>
        Informs Boost.Python that the first argument, in our case <tt class="literal">Y&amp;
@@ -230,7 +239,8 @@ Namespaces are one honking great idea -- let's do more of those!
        In short: "return an internal reference <tt class="literal">X&amp;</tt> owned
        by the 1st argument <tt class="literal">Y&amp; y</tt>".
      </p>
-<pre class="programlisting"><span class="identifier">with_custodian_and_ward</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">&gt;</span>
+<pre class="programlisting">
+<span class="identifier">with_custodian_and_ward</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">&gt;</span>
 </pre>
 <p>
        Informs Boost.Python that the lifetime of the argument indicated by ward
@@ -242,7 +252,8 @@ Namespaces are one honking great idea -- let's do more of those!
        It is also important to note that we have defined two policies above. Two
        or more policies can be composed by chaining. Here's the general syntax:
      </p>
-<pre class="programlisting"><span class="identifier">policy1</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...,</span>
+<pre class="programlisting">
+<span class="identifier">policy1</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...,</span>
    <span class="identifier">policy2</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...,</span>
        <span class="identifier">policy3</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...&gt;</span> <span class="special">&gt;</span> <span class="special">&gt;</span>
 </pre>
@@ -306,7 +317,8 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
        We have here our C++ class:
      </p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">X</span>
+<pre class="programlisting">
+<span class="keyword">struct</span> <span class="identifier">X</span>
 <span class="special">{</span>
    <span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">)</span>
    <span class="special">{</span>
@@ -333,7 +345,8 @@ Namespaces are one honking great idea -- let's do more of those!
        Class X has 4 overloaded functions. We will start by introducing some member
        function pointer variables:
      </p>
-<pre class="programlisting"><span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx1</span><span class="special">)(</span><span class="keyword">int</span><span class="special">)</span>              <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
+<pre class="programlisting">
+<span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx1</span><span class="special">)(</span><span class="keyword">int</span><span class="special">)</span>              <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
 <span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx2</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">)</span>      <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
 <span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx3</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">char</span><span class="special">)=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
 <span class="keyword">int</span>     <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx4</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)</span>    <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
@@ -341,7 +354,8 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
        With these in hand, we can proceed to define and wrap this for Python:
      </p>
-<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx1</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx1</span><span class="special">)</span>
 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx2</span><span class="special">)</span>
 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx3</span><span class="special">)</span>
 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx4</span><span class="special">)</span>
@@ -355,26 +369,30 @@ Namespaces are one honking great idea -- let's do more of those!
        pointers carry no default argument info. Take a function <tt class="literal">f</tt>
        with default arguments:
      </p>
-<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span> <span class="special">=</span> <span class="number">3.14</span><span class="special">,</span> <span class="keyword">char</span> <span class="keyword">const</span><span class="special">*</span> <span class="special">=</span> <span class="string">"hello"</span><span class="special">);</span>
+<pre class="programlisting">
+<span class="keyword">int</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span> <span class="special">=</span> <span class="number">3.14</span><span class="special">,</span> <span class="keyword">char</span> <span class="keyword">const</span><span class="special">*</span> <span class="special">=</span> <span class="string">"hello"</span><span class="special">);</span>
 </pre>
 <p>
        But the type of a pointer to the function <tt class="literal">f</tt> has no information
        about its default arguments:
      </p>
-<pre class="programlisting"><span class="keyword">int</span><span class="special">(*</span><span class="identifier">g</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span><span class="keyword">double</span><span class="special">,</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*)</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">;</span>    <span class="comment">// defaults lost!
+<pre class="programlisting">
+<span class="keyword">int</span><span class="special">(*</span><span class="identifier">g</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span><span class="keyword">double</span><span class="special">,</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*)</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">;</span>    <span class="comment">// defaults lost!
 </span></pre>
 <p>
        When we pass this function pointer to the <tt class="literal">def</tt> function,
        there is no way to retrieve the default arguments:
      </p>
-<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">);</span>                            <span class="comment">// defaults lost!
+<pre class="programlisting">
+<span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">);</span>                            <span class="comment">// defaults lost!
 </span></pre>
 <p>
        Because of this, when wrapping C++ code, we had to resort to manual wrapping
        as outlined in the <a href="functions.html#python.overloading" title="Overloading">previous section</a>,
        or writing thin wrappers:
      </p>
-<pre class="programlisting"><span class="comment">// write "thin wrappers"
+<pre class="programlisting">
+<span class="comment">// write "thin wrappers"
 </span><span class="keyword">int</span> <span class="identifier">f1</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">{</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span> <span class="special">}</span>
 <span class="keyword">int</span> <span class="identifier">f2</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">)</span> <span class="special">{</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">);</span> <span class="special">}</span>

@@ -397,13 +415,14 @@ Namespaces are one honking great idea -- let's do more of those!
        </li>
 </ul></div>
 <a name="default_arguments.boost_python_function_overloads"></a><h2>
-<a name="id467317"></a>
+<a name="id466117"></a>
        BOOST_PYTHON_FUNCTION_OVERLOADS
      </h2>
 <p>
        Boost.Python now has a way to make it easier. For instance, given a function:
      </p>
-<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">char</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">c</span> <span class="special">=</span> <span class="number">2</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="number">3</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="keyword">int</span> <span class="identifier">foo</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">char</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">c</span> <span class="special">=</span> <span class="number">2</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="number">3</span><span class="special">)</span>
 <span class="special">{</span>
    <span class="comment">/*...*/</span>
 <span class="special">}</span>
@@ -411,7 +430,8 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
        The macro invocation:
      </p>
-<pre class="programlisting"><span class="identifier">BOOST_PYTHON_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">foo_overloads</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">4</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="identifier">BOOST_PYTHON_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">foo_overloads</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">4</span><span class="special">)</span>
 </pre>
 <p>
        will automatically create the thin wrappers for us. This macro will create
@@ -421,10 +441,11 @@ Namespaces are one honking great idea -- let's do more of those!
        number of arguments is 1 and the maximum number of arguments is 4. The <tt class="literal">def(...)</tt>
        function will automatically add all the foo variants for us:
      </p>
-<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
+<pre class="programlisting">
+<span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
 </pre>
 <a name="default_arguments.boost_python_member_function_overloads"></a><h2>
-<a name="id467632"></a>
+<a name="id466436"></a>
        BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS
      </h2>
 <p>
@@ -439,7 +460,8 @@ Namespaces are one honking great idea -- let's do more of those!
        may be used to automatically create the thin wrappers for wrapping member
        functions. Let's have an example:
      </p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">george</span>
+<pre class="programlisting">
+<span class="keyword">struct</span> <span class="identifier">george</span>
 <span class="special">{</span>
    <span class="keyword">void</span>
    <span class="identifier">wack_em</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span> <span class="keyword">char</span> <span class="identifier">c</span> <span class="special">=</span> <span class="char">'x'</span><span class="special">)</span>
@@ -451,7 +473,8 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
        The macro invocation:
      </p>
-<pre class="programlisting"><span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">george_overloads</span><span class="special">,</span> <span class="identifier">wack_em</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">3</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">george_overloads</span><span class="special">,</span> <span class="identifier">wack_em</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">3</span><span class="special">)</span>
 </pre>
 <p>
        will generate a set of thin wrappers for george's <tt class="literal">wack_em</tt>
@@ -460,14 +483,15 @@ Namespaces are one honking great idea -- let's do more of those!
        in a class named <tt class="literal">george_overloads</tt> that can then be used
        as an argument to <tt class="literal">def(...)</tt>:
      </p>
-<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"wack_em"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">george</span><span class="special">::</span><span class="identifier">wack_em</span><span class="special">,</span> <span class="identifier">george_overloads</span><span class="special">());</span>
+<pre class="programlisting">
+<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"wack_em"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">george</span><span class="special">::</span><span class="identifier">wack_em</span><span class="special">,</span> <span class="identifier">george_overloads</span><span class="special">());</span>
 </pre>
 <p>
        See the <a href="../../../../v2/overloads.html#BOOST_PYTHON_FUNCTION_OVERLOADS-spec" target="_top">overloads
        reference</a> for details.
      </p>
 <a name="default_arguments.init_and_optional"></a><h2>
-<a name="id467992"></a>
+<a name="id466799"></a>
        init and optional
      </h2>
 <p>
@@ -475,7 +499,8 @@ Namespaces are one honking great idea -- let's do more of those!
        arguments or a sequence of overloads. Remember <tt class="literal">init&lt;...&gt;</tt>?
        For example, given a class X with a constructor:
      </p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">X</span>
+<pre class="programlisting">
+<span class="keyword">struct</span> <span class="identifier">X</span>
 <span class="special">{</span>
    <span class="identifier">X</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">char</span> <span class="identifier">b</span> <span class="special">=</span> <span class="char">'D'</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">c</span> <span class="special">=</span> <span class="string">"constructor"</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">);</span>
    <span class="comment">/*...*/</span>
@@ -484,7 +509,8 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
        You can easily add this constructor to Boost.Python in one shot:
      </p>
-<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">init</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;</span> <span class="special">&gt;())</span>
+<pre class="programlisting">
+<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">init</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;</span> <span class="special">&gt;())</span>
 </pre>
 <p>
        Notice the use of <tt class="literal">init&lt;...&gt;</tt> and <tt class="literal">optional&lt;...&gt;</tt>
@@ -500,7 +526,8 @@ Namespaces are one honking great idea -- let's do more of those!
        used for overloaded functions and member functions with a common sequence
        of initial arguments. Here is an example:
      </p>
-<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">foo</span><span class="special">()</span>
+<pre class="programlisting">
+<span class="keyword">void</span> <span class="identifier">foo</span><span class="special">()</span>
 <span class="special">{</span>
   <span class="comment">/*...*/</span>
 <span class="special">}</span>
@@ -524,19 +551,21 @@ Namespaces are one honking great idea -- let's do more of those!
        Like in the previous section, we can generate thin wrappers for these overloaded
        functions in one-shot:
      </p>
-<pre class="programlisting"><span class="identifier">BOOST_PYTHON_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">foo_overloads</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">3</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="identifier">BOOST_PYTHON_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">foo_overloads</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">3</span><span class="special">)</span>
 </pre>
 <p>
        Then...
      </p>
-<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="special">(</span><span class="keyword">void</span><span class="special">(*)(</span><span class="keyword">bool</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">))</span><span class="number">0</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
+<pre class="programlisting">
+<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="special">(</span><span class="keyword">void</span><span class="special">(*)(</span><span class="keyword">bool</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">))</span><span class="number">0</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
 </pre>
 <p>
        Notice though that we have a situation now where we have a minimum of zero
        (0) arguments and a maximum of 3 arguments.
      </p>
 <a name="auto_overloading.manual_wrapping"></a><h2>
-<a name="id468767"></a>
+<a name="id467581"></a>
        Manual Wrapping
      </h2>
 <p>
@@ -555,18 +584,21 @@ Namespaces are one honking great idea -- let's do more of those!
        to automatically wrap the first three of the <tt class="literal">def</tt>s and
        manually wrap just the last. Here's how we'll do this:
      </p>
-<pre class="programlisting"><span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">xf_overloads</span><span class="special">,</span> <span class="identifier">f</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">4</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">xf_overloads</span><span class="special">,</span> <span class="identifier">f</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">4</span><span class="special">)</span>
 </pre>
 <p>
        Create a member function pointers as above for both X::f overloads:
      </p>
-<pre class="programlisting"><span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx1</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">char</span><span class="special">)</span>    <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
+<pre class="programlisting">
+<span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx1</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">char</span><span class="special">)</span>    <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
 <span class="keyword">int</span>     <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx2</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)</span>        <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
 </pre>
 <p>
        Then...
      </p>
-<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx1</span><span class="special">,</span> <span class="identifier">xf_overloads</span><span class="special">());</span>
+<pre class="programlisting">
+<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx1</span><span class="special">,</span> <span class="identifier">xf_overloads</span><span class="special">());</span>
 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx2</span><span class="special">)</span>
 </pre>
 </div>
--- a/doc/tutorial/doc/html/python/hello.html
+++ b/doc/tutorial/doc/html/python/hello.html
@@ -12,10 +12,10 @@
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
@@ -26,7 +26,7 @@
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="python.hello"></a> Building Hello World</h2></div></div></div>
 <a name="hello.from_start_to_finish"></a><h2>
-<a name="id388718"></a>
+<a name="id387672"></a>
      From Start To Finish
    </h2>
 <p>
@@ -92,7 +92,7 @@
      platforms. The complete list of Bjam executables can be found <a href="http://sourceforge.net/project/showfiles.php?group_id=7586" target="_top">here</a>.
    </p>
 <a name="hello.let_s_jam_"></a><h2>
-<a name="id387300"></a>
+<a name="id386265"></a>
      Let's Jam!
    </h2>
 <p>
@@ -108,7 +108,7 @@
      you going.
    </p>
 <a name="hello.running_bjam"></a><h2>
-<a name="id387357"></a>
+<a name="id386322"></a>
      Running bjam
    </h2>
 <p>
@@ -156,7 +156,8 @@ using python : 2.4 : C:/dev/tools<span class="emphasis"><em>Python</em></span> ;
 <p>
      Finally:
    </p>
-<pre class="programlisting"><span class="identifier">bjam</span>
+<pre class="programlisting">
+<span class="identifier">bjam</span>
 </pre>
 <p>
      It should be building now:
@@ -179,17 +180,6 @@ bjam
      Or something similar. If all is well, you should now have built the DLLs and
      run the Python program.
    </p>
-<div class="note"><table border="0" summary="Note">
-<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/html/images/note.png"></td>
-<th align="left">Note</th>
-</tr>
-<tr><td colspan="2" align="left" valign="top"><p>
-        Starting from Boost 1.35, bjam erases the generated executables (e.g. pyd
-        file) after the test has concluded to conserve disk space. To keep bjam from
-        doing that, pass --preserve-test-targets to bjam.
-      </p></td></tr>
-</table></div>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
        </p>
--- a/doc/tutorial/doc/html/python/iterators.html
+++ b/doc/tutorial/doc/html/python/iterators.html
@@ -12,10 +12,10 @@
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
@@ -64,7 +64,8 @@
    </p>
 <p>
    </p>
-<pre class="programlisting"><span class="identifier">iter</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">__iter__</span><span class="special">()</span>         <span class="comment"># get iterator
+<pre class="programlisting">
+<span class="identifier">iter</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">__iter__</span><span class="special">()</span>         <span class="comment"># get iterator
 </span><span class="keyword">try</span><span class="special">:</span>
    <span class="keyword">while</span> <span class="number">1</span><span class="special">:</span>
    <span class="identifier">y</span> <span class="special">=</span> <span class="identifier">iter</span><span class="special">.</span><span class="identifier">next</span><span class="special">()</span>         <span class="comment"># get each item
@@ -78,14 +79,16 @@
    </p>
 <p>
    </p>
-<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">get_iterator</span> <span class="special">=</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;();</span>
+<pre class="programlisting">
+<span class="identifier">object</span> <span class="identifier">get_iterator</span> <span class="special">=</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;();</span>
 <span class="identifier">object</span> <span class="identifier">iter</span> <span class="special">=</span> <span class="identifier">get_iterator</span><span class="special">(</span><span class="identifier">v</span><span class="special">);</span>
 <span class="identifier">object</span> <span class="identifier">first</span> <span class="special">=</span> <span class="identifier">iter</span><span class="special">.</span><span class="identifier">next</span><span class="special">();</span>
 </pre>
 <p>
      Or for use in class_&lt;&gt;:
    </p>
-<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"__iter__"</span><span class="special">,</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;())</span>
+<pre class="programlisting">
+<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"__iter__"</span><span class="special">,</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;())</span>
 </pre>
 <p>
      <span class="bold"><b>range</b></span>
@@ -131,7 +134,8 @@
    </p>
 <p>
    </p>
-<pre class="programlisting"><span class="identifier">f</span> <span class="special">=</span> <span class="identifier">Field</span><span class="special">()</span>
+<pre class="programlisting">
+<span class="identifier">f</span> <span class="special">=</span> <span class="identifier">Field</span><span class="special">()</span>
 <span class="keyword">for</span> <span class="identifier">x</span> <span class="keyword">in</span> <span class="identifier">f</span><span class="special">.</span><span class="identifier">pions</span><span class="special">:</span>
    <span class="identifier">smash</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span>
 <span class="keyword">for</span> <span class="identifier">y</span> <span class="keyword">in</span> <span class="identifier">f</span><span class="special">.</span><span class="identifier">bogons</span><span class="special">:</span>
@@ -142,7 +146,8 @@
    </p>
 <p>
    </p>
-<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">&gt;(</span><span class="string">"Field"</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">&gt;(</span><span class="string">"Field"</span><span class="special">)</span>
    <span class="special">.</span><span class="identifier">property</span><span class="special">(</span><span class="string">"pions"</span><span class="special">,</span> <span class="identifier">range</span><span class="special">(&amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">p_begin</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">p_end</span><span class="special">))</span>
    <span class="special">.</span><span class="identifier">property</span><span class="special">(</span><span class="string">"bogons"</span><span class="special">,</span> <span class="identifier">range</span><span class="special">(&amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">b_begin</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">b_end</span><span class="special">));</span>
 </pre>
@@ -158,7 +163,8 @@
    </p>
 <p>
    </p>
-<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
+<pre class="programlisting">
+<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">void</span> <span class="identifier">list_assign</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">l</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">o</span><span class="special">)</span> <span class="special">{</span>
    <span class="comment">// Turn a Python sequence into an STL input range
 </span>    <span class="identifier">stl_input_iterator</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">begin</span><span class="special">(</span><span class="identifier">o</span><span class="special">),</span> <span class="identifier">end</span><span class="special">;</span>
@@ -177,7 +183,8 @@
    </p>
 <p>
    </p>
-<pre class="programlisting"><span class="identifier">x</span> <span class="special">=</span> <span class="identifier">list_int</span><span class="special">();</span>
+<pre class="programlisting">
+<span class="identifier">x</span> <span class="special">=</span> <span class="identifier">list_int</span><span class="special">();</span>
 <span class="identifier">x</span><span class="special">.</span><span class="identifier">assign</span><span class="special">([</span><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span><span class="special">])</span>
 </pre>
 </div>
--- a/doc/tutorial/doc/html/python/object.html
+++ b/doc/tutorial/doc/html/python/object.html
@@ -12,10 +12,10 @@
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
@@ -62,7 +62,8 @@
      </p>
 <p>
      </p>
-<pre class="programlisting"><span class="keyword">def</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">y</span><span class="special">):</span>
+<pre class="programlisting">
+<span class="keyword">def</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">y</span><span class="special">):</span>
     <span class="keyword">if</span> <span class="special">(</span><span class="identifier">y</span> <span class="special">==</span> <span class="string">'foo'</span><span class="special">):</span>
         <span class="identifier">x</span><span class="special">[</span><span class="number">3</span><span class="special">:</span><span class="number">7</span><span class="special">]</span> <span class="special">=</span> <span class="string">'bar'</span>
     <span class="keyword">else</span><span class="special">:</span>
@@ -77,7 +78,8 @@
      </p>
 <p>
      </p>
-<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">object</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">y</span><span class="special">)</span> <span class="special">{</span>
+<pre class="programlisting">
+<span class="identifier">object</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">object</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">y</span><span class="special">)</span> <span class="special">{</span>
     <span class="keyword">if</span> <span class="special">(</span><span class="identifier">y</span> <span class="special">==</span> <span class="string">"foo"</span><span class="special">)</span>
         <span class="identifier">x</span><span class="special">.</span><span class="identifier">slice</span><span class="special">(</span><span class="number">3</span><span class="special">,</span><span class="number">7</span><span class="special">)</span> <span class="special">=</span> <span class="string">"bar"</span><span class="special">;</span>
     <span class="keyword">else</span>
@@ -124,20 +126,23 @@
        These derived <tt class="literal">object</tt> types act like real Python types.
        For instance:
      </p>
-<pre class="programlisting"><span class="identifier">str</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">==&gt;</span> <span class="string">"1"</span>
+<pre class="programlisting">
+<span class="identifier">str</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">==&gt;</span> <span class="string">"1"</span>
 </pre>
 <p>
        Wherever appropriate, a particular derived <tt class="literal">object</tt> has
        corresponding Python type's methods. For instance, <tt class="literal">dict</tt>
        has a <tt class="literal">keys()</tt> method:
      </p>
-<pre class="programlisting"><span class="identifier">d</span><span class="special">.</span><span class="identifier">keys</span><span class="special">()</span>
+<pre class="programlisting">
+<span class="identifier">d</span><span class="special">.</span><span class="identifier">keys</span><span class="special">()</span>
 </pre>
 <p>
        <tt class="literal">make_tuple</tt> is provided for declaring <span class="emphasis"><em>tuple literals</em></span>.
        Example:
      </p>
-<pre class="programlisting"><span class="identifier">make_tuple</span><span class="special">(</span><span class="number">123</span><span class="special">,</span> <span class="char">'D'</span><span class="special">,</span> <span class="string">"Hello, World"</span><span class="special">,</span> <span class="number">0.0</span><span class="special">);</span>
+<pre class="programlisting">
+<span class="identifier">make_tuple</span><span class="special">(</span><span class="number">123</span><span class="special">,</span> <span class="char">'D'</span><span class="special">,</span> <span class="string">"Hello, World"</span><span class="special">,</span> <span class="number">0.0</span><span class="special">);</span>
 </pre>
 <p>
        In C++, when Boost.Python <tt class="literal">object</tt>s are used as arguments
@@ -145,7 +150,8 @@
        <tt class="literal">f</tt>, as declared below, is wrapped, it will only accept
        instances of Python's <tt class="literal">str</tt> type and subtypes.
      </p>
-<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">name</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">name</span><span class="special">)</span>
 <span class="special">{</span>
    <span class="identifier">object</span> <span class="identifier">n2</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"upper"</span><span class="special">)();</span>   <span class="comment">// NAME = name.upper()
 </span>    <span class="identifier">str</span> <span class="identifier">NAME</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">.</span><span class="identifier">upper</span><span class="special">();</span>            <span class="comment">// better
@@ -155,13 +161,15 @@
 <p>
        In finer detail:
      </p>
-<pre class="programlisting"><span class="identifier">str</span> <span class="identifier">NAME</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">.</span><span class="identifier">upper</span><span class="special">();</span>
+<pre class="programlisting">
+<span class="identifier">str</span> <span class="identifier">NAME</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">.</span><span class="identifier">upper</span><span class="special">();</span>
 </pre>
 <p>
        Illustrates that we provide versions of the str type's methods as C++ member
        functions.
      </p>
-<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">msg</span> <span class="special">=</span> <span class="string">"%s is bigger than %s"</span> <span class="special">%</span> <span class="identifier">make_tuple</span><span class="special">(</span><span class="identifier">NAME</span><span class="special">,</span><span class="identifier">name</span><span class="special">);</span>
+<pre class="programlisting">
+<span class="identifier">object</span> <span class="identifier">msg</span> <span class="special">=</span> <span class="string">"%s is bigger than %s"</span> <span class="special">%</span> <span class="identifier">make_tuple</span><span class="special">(</span><span class="identifier">NAME</span><span class="special">,</span><span class="identifier">name</span><span class="special">);</span>
 </pre>
 <p>
        Demonstrates that you can write the C++ equivalent of <tt class="literal">"format"
@@ -176,17 +184,19 @@
 <p>
        Python:
      </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">dict</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">__dict__</span><span class="special">)</span>     <span class="comment"># copies x.__dict__
+<pre class="programlisting">
+<span class="special">&gt;&gt;&gt;</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">dict</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">__dict__</span><span class="special">)</span>     <span class="comment"># copies x.__dict__
 </span><span class="special">&gt;&gt;&gt;</span> <span class="identifier">d</span><span class="special">[</span><span class="string">'whatever'</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span>        <span class="comment"># modifies the copy
 </span></pre>
 <p>
        C++:
      </p>
-<pre class="programlisting"><span class="identifier">dict</span> <span class="identifier">d</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span>  <span class="comment">// copies x.__dict__
+<pre class="programlisting">
+<span class="identifier">dict</span> <span class="identifier">d</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span>  <span class="comment">// copies x.__dict__
 </span><span class="identifier">d</span><span class="special">[</span><span class="char">'whatever'</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>           <span class="comment">// modifies the copy
 </span></pre>
 <a name="derived_object_types.class__lt_t_gt__as_objects"></a><h2>
-<a name="id470756"></a>
+<a name="id469586"></a>
        class_&lt;T&gt; as objects
      </h2>
 <p>
@@ -197,7 +207,8 @@
 <p>
        We can use this to create wrapped instances. Example:
      </p>
-<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">vec345</span> <span class="special">=</span> <span class="special">(</span>
+<pre class="programlisting">
+<span class="identifier">object</span> <span class="identifier">vec345</span> <span class="special">=</span> <span class="special">(</span>
    <span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Vec2</span><span class="special">&gt;(</span><span class="string">"Vec2"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;())</span>
        <span class="special">.</span><span class="identifier">def_readonly</span><span class="special">(</span><span class="string">"length"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Point</span><span class="special">::</span><span class="identifier">length</span><span class="special">)</span>
        <span class="special">.</span><span class="identifier">def_readonly</span><span class="special">(</span><span class="string">"angle"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Point</span><span class="special">::</span><span class="identifier">angle</span><span class="special">)</span>
@@ -214,14 +225,16 @@
        can be achieved with the <tt class="literal">extract&lt;T&gt;</tt> function. Consider
        the following:
      </p>
-<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">o</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">);</span> <span class="comment">// compile error
+<pre class="programlisting">
+<span class="keyword">double</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">o</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">);</span> <span class="comment">// compile error
 </span></pre>
 <p>
        In the code above, we got a compiler error because Boost.Python <tt class="literal">object</tt>
        can't be implicitly converted to <tt class="literal">double</tt>s. Instead, what
        we wanted to do above can be achieved by writing:
      </p>
-<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">l</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;(</span><span class="identifier">o</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">));</span>
+<pre class="programlisting">
+<span class="keyword">double</span> <span class="identifier">l</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;(</span><span class="identifier">o</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">));</span>
 <span class="identifier">Vec2</span><span class="special">&amp;</span> <span class="identifier">v</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">Vec2</span><span class="special">&amp;&gt;(</span><span class="identifier">o</span><span class="special">);</span>
 <span class="identifier">assert</span><span class="special">(</span><span class="identifier">l</span> <span class="special">==</span> <span class="identifier">v</span><span class="special">.</span><span class="identifier">length</span><span class="special">());</span>
 </pre>
@@ -238,7 +251,8 @@
        be extracted, an appropriate exception is thrown. To avoid an exception,
        we need to test for extractibility:
      </p>
-<pre class="programlisting"><span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">Vec2</span><span class="special">&amp;&gt;</span> <span class="identifier">x</span><span class="special">(</span><span class="identifier">o</span><span class="special">);</span>
+<pre class="programlisting">
+<span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">Vec2</span><span class="special">&amp;&gt;</span> <span class="identifier">x</span><span class="special">(</span><span class="identifier">o</span><span class="special">);</span>
 <span class="keyword">if</span> <span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">check</span><span class="special">())</span> <span class="special">{</span>
    <span class="identifier">Vec2</span><span class="special">&amp;</span> <span class="identifier">v</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">();</span> <span class="special">...</span>
 </pre>
@@ -246,7 +260,8 @@
        <span class="inlinemediaobject"><img src="../images/tip.png" alt="tip"></span> The astute reader might have noticed that the <tt class="literal">extract&lt;T&gt;</tt>
        facility in fact solves the mutable copying problem:
      </p>
-<pre class="programlisting"><span class="identifier">dict</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">dict</span><span class="special">&gt;(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span>
+<pre class="programlisting">
+<span class="identifier">dict</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">dict</span><span class="special">&gt;(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span>
 <span class="identifier">d</span><span class="special">[</span><span class="string">"whatever"</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>          <span class="comment">// modifies x.__dict__ !
 </span></pre>
 </div>
@@ -261,12 +276,14 @@
        typing to C++'s strong static typing (in C++, ints cannot be implicitly converted
        to enums). To illustrate, given a C++ enum:
      </p>
-<pre class="programlisting"><span class="keyword">enum</span> <span class="identifier">choice</span> <span class="special">{</span> <span class="identifier">red</span><span class="special">,</span> <span class="identifier">blue</span> <span class="special">};</span>
+<pre class="programlisting">
+<span class="keyword">enum</span> <span class="identifier">choice</span> <span class="special">{</span> <span class="identifier">red</span><span class="special">,</span> <span class="identifier">blue</span> <span class="special">};</span>
 </pre>
 <p>
        the construct:
      </p>
-<pre class="programlisting"><span class="identifier">enum_</span><span class="special">&lt;</span><span class="identifier">choice</span><span class="special">&gt;(</span><span class="string">"choice"</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="identifier">enum_</span><span class="special">&lt;</span><span class="identifier">choice</span><span class="special">&gt;(</span><span class="string">"choice"</span><span class="special">)</span>
    <span class="special">.</span><span class="identifier">value</span><span class="special">(</span><span class="string">"red"</span><span class="special">,</span> <span class="identifier">red</span><span class="special">)</span>
    <span class="special">.</span><span class="identifier">value</span><span class="special">(</span><span class="string">"blue"</span><span class="special">,</span> <span class="identifier">blue</span><span class="special">)</span>
    <span class="special">;</span>
@@ -298,7 +315,8 @@
      </p>
 <p>
      </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">my_module</span><span class="special">.</span><span class="identifier">choice</span><span class="special">.</span><span class="identifier">red</span>
+<pre class="programlisting">
+<span class="special">&gt;&gt;&gt;</span> <span class="identifier">my_module</span><span class="special">.</span><span class="identifier">choice</span><span class="special">.</span><span class="identifier">red</span>
 <span class="identifier">my_module</span><span class="special">.</span><span class="identifier">choice</span><span class="special">.</span><span class="identifier">red</span>
 </pre>
 <p>
@@ -307,7 +325,8 @@
      </p>
 <p>
      </p>
-<pre class="programlisting"><span class="identifier">scope</span> <span class="identifier">in_X</span> <span class="special">=</span> <span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;(</span><span class="string">"X"</span><span class="special">)</span>
+<pre class="programlisting">
+<span class="identifier">scope</span> <span class="identifier">in_X</span> <span class="special">=</span> <span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;(</span><span class="string">"X"</span><span class="special">)</span>
                <span class="special">.</span><span class="identifier">def</span><span class="special">(</span> <span class="special">...</span> <span class="special">)</span>
                <span class="special">.</span><span class="identifier">def</span><span class="special">(</span> <span class="special">...</span> <span class="special">)</span>
            <span class="special">;</span>
--- a/doc/tutorial/doc/html/python/techniques.html
+++ b/doc/tutorial/doc/html/python/techniques.html
@@ -11,10 +11,10 @@
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
+<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
@@ -53,7 +53,8 @@
        <tt class="literal">sounds</tt>. Our library already has a neat C++ namespace hierarchy,
        like so:
      </p>
-<pre class="programlisting"><span class="identifier">sounds</span><span class="special">::</span><span class="identifier">core</span>
+<pre class="programlisting">
+<span class="identifier">sounds</span><span class="special">::</span><span class="identifier">core</span>
 <span class="identifier">sounds</span><span class="special">::</span><span class="identifier">io</span>
 <span class="identifier">sounds</span><span class="special">::</span><span class="identifier">filters</span>
 </pre>
@@ -61,14 +62,16 @@
        We would like to present this same hierarchy to the Python user, allowing
        him to write code like this:
      </p>
-<pre class="programlisting"><span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
+<pre class="programlisting">
+<span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
 <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo</span><span class="special">(...)</span> <span class="comment"># echo is a C++ function
 </span></pre>
 <p>
        The first step is to write the wrapping code. We have to export each module
        separately with Boost.Python, like this:
      </p>
-<pre class="programlisting"><span class="special">/*</span> <span class="identifier">file</span> <span class="identifier">core</span><span class="special">.</span><span class="identifier">cpp</span> <span class="special">*/</span>
+<pre class="programlisting">
+<span class="special">/*</span> <span class="identifier">file</span> <span class="identifier">core</span><span class="special">.</span><span class="identifier">cpp</span> <span class="special">*/</span>
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">core</span><span class="special">)</span>
 <span class="special">{</span>
    <span class="special">/*</span> <span class="identifier">export</span> <span class="identifier">everything</span> <span class="keyword">in</span> <span class="identifier">the</span> <span class="identifier">sounds</span><span class="special">::</span><span class="identifier">core</span> <span class="identifier">namespace</span> <span class="special">*/</span>
@@ -126,7 +129,8 @@
      </p>
 <p>
      </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">io</span>
+<pre class="programlisting">
+<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">io</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">sound</span> <span class="special">=</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">io</span><span class="special">.</span><span class="identifier">open</span><span class="special">(</span><span class="string">'file.mp3'</span><span class="special">)</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">new_sound</span> <span class="special">=</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo</span><span class="special">(</span><span class="identifier">sound</span><span class="special">,</span> <span class="number">1.0</span><span class="special">)</span>
@@ -148,7 +152,8 @@
      </p>
 <p>
      </p>
-<pre class="programlisting"><span class="comment">/* file core.cpp */</span>
+<pre class="programlisting">
+<span class="comment">/* file core.cpp */</span>
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">_core</span><span class="special">)</span>
 <span class="special">{</span>
    <span class="special">...</span>
@@ -180,7 +185,8 @@
      </p>
 <p>
      </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">_core</span>
+<pre class="programlisting">
+<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">_core</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">_core</span><span class="special">.</span><span class="identifier">foo</span><span class="special">(...)</span>
 </pre>
 <p>
@@ -190,13 +196,15 @@
        entire namespace from <tt class="literal">_core.pyd</tt> to <tt class="literal">core/__init__.py</tt>.
        So add this line of code to <tt class="literal">sounds<span class="emphasis"><em>core</em></span>__init__.py</tt>:
      </p>
-<pre class="programlisting"><span class="keyword">from</span> <span class="identifier">_core</span> <span class="keyword">import</span> <span class="special">*</span>
+<pre class="programlisting">
+<span class="keyword">from</span> <span class="identifier">_core</span> <span class="keyword">import</span> <span class="special">*</span>
 </pre>
 <p>
        We do the same for the other packages. Now the user accesses the functions
        and classes in the extension modules like before:
      </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
+<pre class="programlisting">
+<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo</span><span class="special">(...)</span>
 </pre>
 <p>
@@ -209,7 +217,8 @@
        a file named <tt class="literal">sounds/filters/echo_noise.py</tt> and code our
        function:
      </p>
-<pre class="programlisting"><span class="keyword">import</span> <span class="identifier">_filters</span>
+<pre class="programlisting">
+<span class="keyword">import</span> <span class="identifier">_filters</span>
 <span class="keyword">def</span> <span class="identifier">echo_noise</span><span class="special">(</span><span class="identifier">sound</span><span class="special">):</span>
    <span class="identifier">s</span> <span class="special">=</span> <span class="identifier">_filters</span><span class="special">.</span><span class="identifier">echo</span><span class="special">(</span><span class="identifier">sound</span><span class="special">)</span>
    <span class="identifier">s</span> <span class="special">=</span> <span class="identifier">_filters</span><span class="special">.</span><span class="identifier">noise</span><span class="special">(</span><span class="identifier">sound</span><span class="special">)</span>
@@ -218,13 +227,15 @@
 <p>
        Next, we add this line to <tt class="literal">sounds<span class="emphasis"><em>filters</em></span>__init__.py</tt>:
      </p>
-<pre class="programlisting"><span class="keyword">from</span> <span class="identifier">echo_noise</span> <span class="keyword">import</span> <span class="identifier">echo_noise</span>
+<pre class="programlisting">
+<span class="keyword">from</span> <span class="identifier">echo_noise</span> <span class="keyword">import</span> <span class="identifier">echo_noise</span>
 </pre>
 <p>
        And that's it. The user now accesses this function like any other function
        from the <tt class="literal">filters</tt> package:
      </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
+<pre class="programlisting">
+<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo_noise</span><span class="special">(...)</span>
 </pre>
 </div>
@@ -235,7 +246,8 @@
        Thanks to Python's flexibility, you can easily add new methods to a class,
        even after it was already created:
      </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">class</span> <span class="identifier">C</span><span class="special">(</span><span class="identifier">object</span><span class="special">):</span> <span class="keyword">pass</span>
+<pre class="programlisting">
+<span class="special">&gt;&gt;&gt;</span> <span class="keyword">class</span> <span class="identifier">C</span><span class="special">(</span><span class="identifier">object</span><span class="special">):</span> <span class="keyword">pass</span>
 <span class="special">&gt;&gt;&gt;</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="comment"># a regular function
 </span><span class="special">&gt;&gt;&gt;</span> <span class="keyword">def</span> <span class="identifier">C_str</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span> <span class="keyword">return</span> <span class="string">'A C instance!'</span>
@@ -258,7 +270,8 @@
      </p>
 <p>
      </p>
-<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">point</span> <span class="special">{...};</span>
+<pre class="programlisting">
+<span class="keyword">class</span> <span class="identifier">point</span> <span class="special">{...};</span>

 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">_geom</span><span class="special">)</span>
 <span class="special">{</span>
@@ -271,7 +284,8 @@
      </p>
 <p>
      </p>
-<pre class="programlisting"><span class="keyword">from</span> <span class="identifier">_geom</span> <span class="keyword">import</span> <span class="special">*</span>
+<pre class="programlisting">
+<span class="keyword">from</span> <span class="identifier">_geom</span> <span class="keyword">import</span> <span class="special">*</span>

 <span class="comment"># a regular function
 </span><span class="keyword">def</span> <span class="identifier">point_str</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span>
@@ -303,7 +317,8 @@
        You can even add a little syntactic sugar with the use of metaclasses. Let's
        create a special metaclass that "injects" methods in other classes.
      </p>
-<pre class="programlisting"><span class="comment"># The one Boost.Python uses for all wrapped classes.
+<pre class="programlisting">
+<span class="comment"># The one Boost.Python uses for all wrapped classes.
 </span><span class="comment"># You can use here any class exported by Boost instead of "point"
 </span><span class="identifier">BoostPythonMetaclass</span> <span class="special">=</span> <span class="identifier">point</span><span class="special">.</span><span class="identifier">__class__</span>

@@ -326,7 +341,8 @@
 <p>
        Now let's see how it got:
      </p>
-<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">point</span><span class="special">()</span>
+<pre class="programlisting">
+<span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">point</span><span class="special">()</span>
 <span class="identifier">Point</span><span class="special">(</span><span class="identifier">x</span><span class="special">=</span><span class="number">10</span><span class="special">,</span> <span class="identifier">y</span><span class="special">=</span><span class="number">10</span><span class="special">)</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">point</span><span class="special">().</span><span class="identifier">foo</span><span class="special">()</span>
 <span class="identifier">foo</span><span class="special">!</span>
@@ -334,7 +350,8 @@
 <p>
        Another useful idea is to replace constructors with factory functions:
      </p>
-<pre class="programlisting"><span class="identifier">_point</span> <span class="special">=</span> <span class="identifier">point</span>
+<pre class="programlisting">
+<span class="identifier">_point</span> <span class="special">=</span> <span class="identifier">point</span>

 <span class="keyword">def</span> <span class="identifier">point</span><span class="special">(</span><span class="identifier">x</span><span class="special">=</span><span class="number">0</span><span class="special">,</span> <span class="identifier">y</span><span class="special">=</span><span class="number">0</span><span class="special">):</span>
    <span class="keyword">return</span> <span class="identifier">_point</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">y</span><span class="special">)</span>
@@ -357,7 +374,8 @@
      </p>
 <p>
      </p>
-<pre class="programlisting"><span class="comment">/* file point.cpp */</span>
+<pre class="programlisting">
+<span class="comment">/* file point.cpp */</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">point</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

@@ -379,7 +397,8 @@
        Now you create a file <tt class="literal">main.cpp</tt>, which contains the <tt class="literal">BOOST_PYTHON_MODULE</tt>
        macro, and call the various export functions inside it.
      </p>
-<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">export_point</span><span class="special">();</span>
+<pre class="programlisting">
+<span class="keyword">void</span> <span class="identifier">export_point</span><span class="special">();</span>
 <span class="keyword">void</span> <span class="identifier">export_triangle</span><span class="special">();</span>

 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">_geom</span><span class="special">)</span>
@@ -392,7 +411,8 @@
        Compiling and linking together all this files produces the same result as
        the usual approach:
      </p>
-<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<pre class="programlisting">
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">point</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">triangle</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span>

--- a/doc/tutorial/doc/tutorial.qbk
+++ b/doc/tutorial/doc/tutorial.qbk
@@ -1,5 +1,5 @@
 [library python
-    [version 2.0]
+    [version 1.0]
    [authors [de Guzman, Joel], [Abrahams, David]]
    [copyright 2002 2003 2004 2005 Joel de Guzman, David Abrahams]
    [category inter-language support]
@@ -1381,10 +1381,10 @@ interpreter. This may be fixed in a future version of boost.python.]
 [section Using the interpreter]

 As you probably already know, objects in Python are reference-counted.
-Naturally, the [^PyObject]s of the Python C API are also reference-counted.
+Naturally, the [^PyObject]s of the Python\/C API are also reference-counted.
 There is a difference however. While the reference-counting is fully
-automatic in Python, the Python C API requires you to do it
-[@http://www.python.org/doc/current/c-api/refcounting.html by hand]. This is
+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
 messy and especially hard to get right in the presence of C++ exceptions.
 Fortunately Boost.Python provides the [@../../../v2/handle.html handle] and
 [@../../../v2/object.html object] class templates to automate the process.
@@ -1466,7 +1466,7 @@ If an exception occurs in the evaluation of the python expression,
 The [^error_already_set] exception class doesn't carry any information in itself.
 To find out more about the Python exception that occurred, you need to use the
 [@http://www.python.org/doc/api/exceptionHandling.html exception handling functions]
-of the Python C API in your catch-statement. This can be as simple as calling
+of the Python/C API in your catch-statement. This can be as simple as calling
 [@http://www.python.org/doc/api/exceptionHandling.html#l2h-70 PyErr_Print()] to
 print the exception's traceback to the console, or comparing the type of the
 exception with those of the [@http://www.python.org/doc/api/standardExceptions.html
--- a/doc/tutorial/index.html
+++ b/doc/tutorial/index.html
@@ -11,8 +11,8 @@
    <a href="doc/html/index.html">link</a> &nbsp;<hr>
    <p>© Copyright Beman Dawes, 2001</p>
    <p>Distributed under the Boost Software License, Version 1.0. (See 
-    accompanying file <a href="../../../../LICENSE_1_0.txt">
+    accompanying file <a href="../../../LICENSE_1_0.txt">
    LICENSE_1_0.txt</a> or copy at
    <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
  </body>
-</html>
+</html>
--- a/doc/v2/CallPolicies.html
+++ b/doc/v2/CallPolicies.html
@@ -137,7 +137,7 @@
        <td valign="top"><code>P::extract_return_type</code></td>

        <td>A model of <a href=
-          "../../../mpl/doc/refmanual/metafunction.html">Metafunction</a>.</td>
+          "../../../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>
--- a/doc/v2/Dereferenceable.html
+++ b/doc/v2/Dereferenceable.html
@@ -4,7 +4,7 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href="../../../../boost.css">
+<link rel="stylesheet" type="text/css" href=../../../../boost.css>
 <title>Boost.Python - Dereferenceable Concept</title>
 </head>
 <body link="#0000ff" vlink="#800080">
--- a/doc/v2/Extractor.html
+++ b/doc/v2/Extractor.html
@@ -4,7 +4,7 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href="../../../../boost.css">
+<link rel="stylesheet" type="text/css" href=../../../../boost.css>
 <title>Boost.Python - Extractor Concept</title>
 </head>
 <body link="#0000ff" vlink="#800080">
--- a/doc/v2/HolderGenerator.html
+++ b/doc/v2/HolderGenerator.html
@@ -4,7 +4,7 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href="../../../../boost.css">
+<link rel="stylesheet" type="text/css" href=../../../../boost.css>
 <title>Boost.Python - Holder Concept</title>
 </head>
 <body link="#0000ff" vlink="#800080">
--- a/doc/v2/instance_holder.html
+++ b/doc/v2/instance_holder.html
--- a/doc/v2/lvalue_from_pytype.html
+++ b/doc/v2/lvalue_from_pytype.html
--- a/doc/v2/object.html
+++ b/doc/v2/object.html
@@ -74,32 +74,6 @@
            </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>

@@ -354,102 +328,6 @@ 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>

@@ -655,11 +533,6 @@ 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;
@@ -669,8 +542,6 @@ 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
      //
@@ -709,25 +580,6 @@ 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>
@@ -756,21 +608,6 @@ 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;
@@ -1101,11 +938,11 @@ object sum_items(object seq)
 </pre>
    <p>Revised 
    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  27 May, 2008
+  13 January, 2006
  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
    </p>

    <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2008.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2006.</i></p>
  </body>
 </html>
--- a/doc/v2/operators.html
+++ b/doc/v2/operators.html
--- a/doc/v2/pickle.html
+++ b/doc/v2/pickle.html
@@ -1,93 +1,112 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
+"http://www.w3.org/TR/REC-html40/strict.dtd">

-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-  <title>Boost.Python Pickle Support</title>
-</head>
+<title>Boost.Python Pickle Support</title>

-<body>
-  <div>
-    <img src="../../../../boost.png" alt="boost.png (6897 bytes)" align=
-    "center" width="277" height="86" />
-    <hr />
+<div>

-    <h1>Boost.Python Pickle Support</h1>Pickle is a Python module for object
-    serialization, also known as persistence, marshalling, or flattening.
+<img src="../../../../boost.png"
+     alt="boost.png (6897 bytes)"
+     align="center"
+     width="277" height="86">

-    <p>It is often necessary to save and restore the contents of an object to
-    a file. One approach to this problem is to write a pair of functions that
-    read and write data from a file in a special format. A powerful
-    alternative approach is to use Python's pickle module. Exploiting
-    Python's ability for introspection, the pickle module recursively
-    converts nearly arbitrary Python objects into a stream of bytes that can
-    be written to a file.</p>
+<hr>
+<h1>Boost.Python Pickle Support</h1>

-    <p>The Boost Python Library supports the pickle module through the
-    interface as described in detail in the <a href=
-    "http://www.python.org/doc/current/lib/module-pickle.html">Python Library
-    Reference for pickle.</a> This interface involves the special methods
-    <tt>__getinitargs__</tt>, <tt>__getstate__</tt> and <tt>__setstate__</tt>
-    as described in the following. Note that Boost.Python is also fully
-    compatible with Python's cPickle module.</p>
-    <hr />
+Pickle is a Python module for object serialization, also known
+as persistence, marshalling, or flattening.

-    <h2>The Boost.Python Pickle Interface</h2>At the user level, the
-    Boost.Python pickle interface involves three special methods:
+<p>
+It is often necessary to save and restore the contents of an object to
+a file. One approach to this problem is to write a pair of functions
+that read and write data from a file in a special format. A powerful
+alternative approach is to use Python's pickle module. Exploiting
+Python's ability for introspection, the pickle module recursively
+converts nearly arbitrary Python objects into a stream of bytes that
+can be written to a file.

-    <dl>
-      <dt><strong><tt>__getinitargs__</tt></strong></dt>
+<p>
+The Boost Python Library supports the pickle module
+through the interface as described in detail in the
+<a href="http://www.python.org/doc/current/lib/module-pickle.html"
+>Python Library Reference for pickle.</a> This interface
+involves the special methods <tt>__getinitargs__</tt>,
+<tt>__getstate__</tt> and <tt>__setstate__</tt> as described
+in the following. Note that Boost.Python is also fully compatible
+with Python's cPickle module.

-      <dd>
-        When an instance of a Boost.Python extension class is pickled, the
-        pickler tests if the instance has a <tt>__getinitargs__</tt> method.
-        This method must return a Python tuple (it is most convenient to use
-        a boost::python::tuple). When the instance is restored by the
-        unpickler, the contents of this tuple are used as the arguments for
-        the class constructor.
+<hr>
+<h2>The Boost.Python Pickle Interface</h2>

-        <p>If <tt>__getinitargs__</tt> is not defined, <tt>pickle.load</tt>
-        will call the constructor (<tt>__init__</tt>) without arguments;
-        i.e., the object must be default-constructible.</p>
-      </dd>
+At the user level, the Boost.Python pickle interface involves three special
+methods:

-      <dt><strong><tt>__getstate__</tt></strong></dt>
+<dl>
+<dt>
+<strong><tt>__getinitargs__</tt></strong>
+<dd>
+  When an instance of a Boost.Python extension class is pickled, the
+  pickler tests if the instance has a <tt>__getinitargs__</tt> method.
+  This method must return a Python tuple (it is most convenient to use
+  a boost::python::tuple). When the instance is restored by the
+  unpickler, the contents of this tuple are used as the arguments for
+  the class constructor.

-      <dd>When an instance of a Boost.Python extension class is pickled, the
-      pickler tests if the instance has a <tt>__getstate__</tt> method. This
-      method should return a Python object representing the state of the
-      instance.</dd>
+  <p>
+  If <tt>__getinitargs__</tt> is not defined, <tt>pickle.load</tt>
+  will call the constructor (<tt>__init__</tt>) without arguments;
+  i.e., the object must be default-constructible.

-      <dt><strong><tt>__setstate__</tt></strong></dt>
+<p>
+<dt>
+<strong><tt>__getstate__</tt></strong>

-      <dd>When an instance of a Boost.Python extension class is restored by
-      the unpickler (<tt>pickle.load</tt>), it is first constructed using the
-      result of <tt>__getinitargs__</tt> as arguments (see above).
-      Subsequently the unpickler tests if the new instance has a
-      <tt>__setstate__</tt> method. If so, this method is called with the
-      result of <tt>__getstate__</tt> (a Python object) as the argument.</dd>
-    </dl>The three special methods described above may be <tt>.def()</tt>'ed
-    individually by the user. However, Boost.Python provides an easy to use
-    high-level interface via the
-    <strong><tt>boost::python::pickle_suite</tt></strong> class that also
-    enforces consistency: <tt>__getstate__</tt> and <tt>__setstate__</tt>
-    must be defined as pairs. Use of this interface is demonstrated by the
-    following examples.
-    <hr />
+<dd>
+  When an instance of a Boost.Python extension class is pickled, the
+  pickler tests if the instance has a <tt>__getstate__</tt> method.
+  This method should return a Python object representing the state of
+  the instance.

-    <h2>Examples</h2>There are three files in <tt>boost/libs/python/test</tt>
-    that show how to provide pickle support.
-    <hr />
+<p>
+<dt>
+<strong><tt>__setstate__</tt></strong>

-    <h3><a href="../../test/pickle1.cpp"><tt>pickle1.cpp</tt></a></h3>The C++
-    class in this example can be fully restored by passing the appropriate
-    argument to the constructor. Therefore it is sufficient to define the
-    pickle interface method <tt>__getinitargs__</tt>. This is done in the
-    following way:
+<dd>
+  When an instance of a Boost.Python extension class is restored by the
+  unpickler (<tt>pickle.load</tt>), it is first constructed using the
+  result of <tt>__getinitargs__</tt> as arguments (see above). Subsequently
+  the unpickler tests if the new instance has a <tt>__setstate__</tt>
+  method. If so, this method is called with the result of
+  <tt>__getstate__</tt> (a Python object) as the argument.

-    <ul>
-      <li>1. Definition of the C++ pickle function:
-        <pre>
+</dl>
+
+The three special methods described above may be <tt>.def()</tt>'ed
+individually by the user. However, Boost.Python provides an easy to use
+high-level interface via the
+<strong><tt>boost::python::pickle_suite</tt></strong> class that also
+enforces consistency: <tt>__getstate__</tt> and <tt>__setstate__</tt>
+must be defined as pairs. Use of this interface is demonstrated by the
+following examples.
+
+<hr>
+<h2>Examples</h2>
+
+There are three files in 
+<tt>boost/libs/python/test</tt> that show how to
+provide pickle support.
+
+<hr>
+<h3><a href="../../test/pickle1.cpp"><tt>pickle1.cpp</tt></a></h3>
+
+    The C++ class in this example can be fully restored by passing the
+    appropriate argument to the constructor. Therefore it is sufficient
+    to define the pickle interface method <tt>__getinitargs__</tt>.
+    This is done in the following way:
+
+<ul>
+<li>1. Definition of the C++ pickle function:
+<pre>
  struct world_pickle_suite : boost::python::pickle_suite
  {
    static
@@ -98,28 +117,26 @@
    }
  };
 </pre>
-      </li>
-
-      <li>2. Establishing the Python binding:
-        <pre>
+<li>2. Establishing the Python binding:
+<pre>
  class_&lt;world&gt;("world", args&lt;const std::string&amp;&gt;())
      // ...
      .def_pickle(world_pickle_suite())
      // ...
 </pre>
-      </li>
-    </ul>
-    <hr />
+</ul>

-    <h3><a href="../../test/pickle2.cpp"><tt>pickle2.cpp</tt></a></h3>The C++
-    class in this example contains member data that cannot be restored by any
-    of the constructors. Therefore it is necessary to provide the
-    <tt>__getstate__</tt>/<tt>__setstate__</tt> pair of pickle interface
-    methods:
+<hr>
+<h3><a href="../../test/pickle2.cpp"><tt>pickle2.cpp</tt></a></h3>

-    <ul>
-      <li>1. Definition of the C++ pickle functions:
-        <pre>
+    The C++ class in this example contains member data that cannot be
+    restored by any of the constructors. Therefore it is necessary to
+    provide the <tt>__getstate__</tt>/<tt>__setstate__</tt> pair of
+    pickle interface methods:
+
+<ul>
+<li>1. Definition of the C++ pickle functions:
+<pre>
  struct world_pickle_suite : boost::python::pickle_suite
  {
    static
@@ -144,76 +161,92 @@
    }
  };
 </pre>
-      </li>
-
-      <li>2. Establishing the Python bindings for the entire suite:
-        <pre>
+<li>2. Establishing the Python bindings for the entire suite:
+<pre>
  class_&lt;world&gt;("world", args&lt;const std::string&amp;&gt;())
      // ...
      .def_pickle(world_pickle_suite())
      // ...
 </pre>
-      </li>
-    </ul>
+</ul>

-    <p>For simplicity, the <tt>__dict__</tt> is not included in the result of
-    <tt>__getstate__</tt>. This is not generally recommended, but a valid
-    approach if it is anticipated that the object's <tt>__dict__</tt> will
-    always be empty. Note that the safety guard described below will catch
-    the cases where this assumption is violated.</p>
-    <hr />
+    <p>
+    For simplicity, the <tt>__dict__</tt> is not included in the result
+    of <tt>__getstate__</tt>. This is not generally recommended, but a
+    valid approach if it is anticipated that the object's
+    <tt>__dict__</tt> will always be empty. Note that the safety guard
+    described below will catch the cases where this assumption is violated.

-    <h3><a href="../../test/pickle3.cpp"><tt>pickle3.cpp</tt></a></h3>This
-    example is similar to <a href=
-    "../../test/pickle2.cpp"><tt>pickle2.cpp</tt></a>. However, the object's
-    <tt>__dict__</tt> is included in the result of <tt>__getstate__</tt>.
-    This requires a little more code but is unavoidable if the object's
-    <tt>__dict__</tt> is not always empty.
-    <hr />
+<hr>
+<h3><a href="../../test/pickle3.cpp"><tt>pickle3.cpp</tt></a></h3>

-    <h2>Pitfall and Safety Guard</h2>The pickle protocol described above has
-    an important pitfall that the end user of a Boost.Python extension module
-    might not be aware of:
+    This example is similar to <a
+    href="../../test/pickle2.cpp"><tt>pickle2.cpp</tt></a>. However, the
+    object's <tt>__dict__</tt> is included in the result of
+    <tt>__getstate__</tt>.  This requires a little more code but is
+    unavoidable if the object's <tt>__dict__</tt> is not always empty.

-    <p><strong><tt>__getstate__</tt> is defined and the instance's
-    <tt>__dict__</tt> is not empty.</strong></p>
+<hr>
+<h2>Pitfall and Safety Guard</h2>

-    <p>The author of a Boost.Python extension class might provide a
-    <tt>__getstate__</tt> method without considering the possibilities
-    that:</p>
+The pickle protocol described above has an important pitfall that the
+end user of a Boost.Python extension module might not be aware of:
+<p>
+<strong>
+<tt>__getstate__</tt> is defined and the instance's <tt>__dict__</tt>
+is not empty.
+</strong>
+<p>

-    <ul>
-      <li>his class is used in Python as a base class. Most likely the
-      <tt>__dict__</tt> of instances of the derived class needs to be pickled
-      in order to restore the instances correctly.</li>
+  The author of a Boost.Python extension class might provide a
+  <tt>__getstate__</tt> method without considering the possibilities
+  that:

-      <li>the user adds items to the instance's <tt>__dict__</tt> directly.
-      Again, the <tt>__dict__</tt> of the instance then needs to be
-      pickled.</li>
-    </ul>
+  <p>
+  <ul>
+  <li>
+    his class is used in Python as a base class. Most likely the
+    <tt>__dict__</tt> of instances of the derived class needs to be
+    pickled in order to restore the instances correctly.

-    <p>To alert the user to this highly unobvious problem, a safety guard is
-    provided. If <tt>__getstate__</tt> is defined and the instance's
-    <tt>__dict__</tt> is not empty, Boost.Python tests if the class has an
-    attribute <tt>__getstate_manages_dict__</tt>. An exception is raised if
-    this attribute is not defined:</p>
-    <pre>
+  <p>
+  <li>
+    the user adds items to the instance's <tt>__dict__</tt> directly.
+    Again, the <tt>__dict__</tt> of the instance then needs to be
+    pickled.
+
+  </ul>
+  <p>
+
+  To alert the user to this highly unobvious problem, a safety guard is
+  provided. If <tt>__getstate__</tt> is defined and the instance's
+  <tt>__dict__</tt> is not empty, Boost.Python tests if the class has
+  an attribute <tt>__getstate_manages_dict__</tt>. An exception is
+  raised if this attribute is not defined:
+
+<pre>
    RuntimeError: Incomplete pickle support (__getstate_manages_dict__ not set)
-</pre>To resolve this problem, it should first be established that the <tt>
-    __getstate__</tt> and <tt>__setstate__</tt> methods manage the
-    instances's <tt>__dict__</tt> correctly. Note that this can be done
-    either at the C++ or the Python level. Finally, the safety guard should
-    intentionally be overridden. E.g. in C++ (from <a href=
-    "../../test/pickle3.cpp"><tt>pickle3.cpp</tt></a>):
-    <pre>
+</pre>
+
+  To resolve this problem, it should first be established that the
+  <tt>__getstate__</tt> and <tt>__setstate__</tt> methods manage the
+  instances's <tt>__dict__</tt> correctly. Note that this can be done
+  either at the C++ or the Python level. Finally, the safety guard
+  should intentionally be overridden. E.g. in C++ (from
+  <a href="../../test/pickle3.cpp"><tt>pickle3.cpp</tt></a>):
+
+<pre>
  struct world_pickle_suite : boost::python::pickle_suite
  {
    // ...

    static bool getstate_manages_dict() { return true; }
  };
-</pre>Alternatively in Python:
-    <pre>
+</pre>
+
+  Alternatively in Python:
+
+<pre>
    import your_bpl_module
    class your_class(your_bpl_module.your_class):
      __getstate_manages_dict__ = 1
@@ -222,41 +255,54 @@
      def __setstate__(self, state):
        # your code here
 </pre>
-    <hr />

-    <h2>Practical Advice</h2>
+<hr>
+<h2>Practical Advice</h2>

-    <ul>
-      <li>In Boost.Python extension modules with many extension classes,
-      providing complete pickle support for all classes would be a
-      significant overhead. In general complete pickle support should only be
-      implemented for extension classes that will eventually be pickled.</li>
+<ul>
+<li>
+  In Boost.Python extension modules with many extension classes,
+  providing complete pickle support for all classes would be a
+  significant overhead. In general complete pickle support should
+  only be implemented for extension classes that will eventually
+  be pickled.

-      <li>Avoid using <tt>__getstate__</tt> if the instance can also be
-      reconstructed by way of <tt>__getinitargs__</tt>. This automatically
-      avoids the pitfall described above.</li>
+<p>
+<li>
+  Avoid using <tt>__getstate__</tt> if the instance can also be
+  reconstructed by way of <tt>__getinitargs__</tt>. This automatically
+  avoids the pitfall described above.

-      <li>If <tt>__getstate__</tt> is required, include the instance's
-      <tt>__dict__</tt> in the Python object that is returned.</li>
-    </ul>
-    <hr />
+<p>
+<li>
+  If <tt>__getstate__</tt> is required, include the instance's
+  <tt>__dict__</tt> in the Python object that is returned.

-    <h2>Light-weight alternative: pickle support implemented in Python</h2>
+</ul>

-    <h3><a href="../../test/pickle4.cpp"><tt>pickle4.cpp</tt></a></h3>The
-    <tt>pickle4.cpp</tt> example demonstrates an alternative technique for
-    implementing pickle support. First we direct Boost.Python via the
-    <tt>class_::enable_pickling()</tt> member function to define only the
-    basic attributes required for pickling:
-    <pre>
+<hr>
+<h2>Light-weight alternative: pickle support implemented in Python</h2>
+
+<h3><a href="../../test/pickle4.cpp"><tt>pickle4.cpp</tt></a></h3>
+
+The <tt>pickle4.cpp</tt> example demonstrates an alternative technique
+for implementing pickle support. First we direct Boost.Python via
+the <tt>class_::enable_pickling()</tt> member function to define only
+the basic attributes required for pickling:
+
+<pre>
  class_&lt;world&gt;("world", args&lt;const std::string&amp;&gt;())
      // ...
      .enable_pickling()
      // ...
-</pre>This enables the standard Python pickle interface as described in the
-Python documentation. By "injecting" a <tt>__getinitargs__</tt> method into
-the definition of the wrapped class we make all instances pickleable:
-    <pre>
+</pre>
+
+This enables the standard Python pickle interface as described
+in the Python documentation. By &quot;injecting&quot; a
+<tt>__getinitargs__</tt> method into the definition of the wrapped
+class we make all instances pickleable:
+
+<pre>
  # import the wrapped world class
  from pickle4_ext import world

@@ -266,15 +312,18 @@ the definition of the wrapped class we make all instances pickleable:

  # now inject __getinitargs__ (Python is a dynamic language!)
  world.__getinitargs__ = world_getinitargs
-</pre>See also the <a href=
-"../tutorial/doc/html/python/techniques.html#python.extending_wrapped_objects_in_python">
-    tutorial section</a> on injecting additional methods from Python.
-    <hr />
-    © Copyright Ralf W. Grosse-Kunstleve 2001-2004. Distributed under the
-    Boost Software License, Version 1.0. (See accompanying file
-    LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+</pre>

-    <p>Updated: Feb 2004.</p>
-  </div>
-</body>
-</html>
+See also the
+<a href="../tutorial/doc/html/python/techniques.html#python.extending_wrapped_objects_in_python"
+>tutorial section</a> on injecting additional methods from Python.
+
+<hr>
+
+&copy; Copyright Ralf W. Grosse-Kunstleve 2001-2004. Distributed under
+  the Boost Software License, Version 1.0. (See accompanying file
+  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+<p>
+Updated: Feb 2004.
+</div>
--- a/doc/v2/raw_function.html
+++ b/doc/v2/raw_function.html
--- a/doc/v2/return_arg.html
+++ b/doc/v2/return_arg.html
--- a/doc/v2/stl_iterator.html
+++ b/doc/v2/stl_iterator.html
--- a/doc/v2/type_id.html
+++ b/doc/v2/type_id.html
--- a/doc/v2/wrapper.html
+++ b/doc/v2/wrapper.html
--- a/example/Jamroot
+++ b/example/Jamroot
--- a/example/boost-build.jam
+++ b/example/boost-build.jam
--- a/example/quickstart/Jamroot
+++ b/example/quickstart/Jamroot
--- a/example/tutorial/Jamroot
+++ b/example/tutorial/Jamroot
@@ -2,15 +2,6 @@
 # Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-import python ;
-
-if ! [ python.configured ]
-{
-    ECHO "notice: no Python configured in user-config.jam" ;
-    ECHO "notice: will use default configuration" ;
-    using python ;
-}
-
 # Specify the path to the Boost project.  If you move this project,
 # adjust this path to refer to the Boost root directory.
 use-project boost
--- a/include/boost/python/arg_from_python.hpp
+++ b/include/boost/python/arg_from_python.hpp
--- a/include/boost/python/base_type_traits.hpp
+++ b/include/boost/python/base_type_traits.hpp
--- a/include/boost/python/borrowed.hpp
+++ b/include/boost/python/borrowed.hpp
--- a/include/boost/python/call.hpp
+++ b/include/boost/python/call.hpp
@@ -38,10 +38,7 @@ namespace boost { namespace python {

 # endif // CALL_DWA2002411_HPP

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

 # undef N

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

 # endif // CALL_METHOD_DWA2002411_HPP

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

 # undef N

-#endif // BOOST_PP_ITERATION_DEPTH()
 #endif // BOOST_PP_IS_ITERATING
--- a/include/boost/python/cast.hpp
+++ b/include/boost/python/cast.hpp
--- a/include/boost/python/converter/arg_from_python.hpp
+++ b/include/boost/python/converter/arg_from_python.hpp
--- a/include/boost/python/converter/arg_to_python.hpp
+++ b/include/boost/python/converter/arg_to_python.hpp
--- a/include/boost/python/converter/arg_to_python_base.hpp
+++ b/include/boost/python/converter/arg_to_python_base.hpp
--- a/include/boost/python/converter/context_result_converter.hpp
+++ b/include/boost/python/converter/context_result_converter.hpp
--- a/include/boost/python/converter/object_manager.hpp
+++ b/include/boost/python/converter/object_manager.hpp
--- a/include/boost/python/converter/pytype_function.hpp
+++ b/include/boost/python/converter/pytype_function.hpp
--- a/include/boost/python/converter/return_from_python.hpp
+++ b/include/boost/python/converter/return_from_python.hpp
--- a/include/boost/python/converter/shared_ptr_from_python.hpp
+++ b/include/boost/python/converter/shared_ptr_from_python.hpp
@@ -45,14 +45,10 @@ struct shared_ptr_from_python
        if (data->convertible == source)
            new (storage) shared_ptr<T>();
        else
-        {
-            boost::shared_ptr<void> hold_convertible_ref_count(
-              (void*)0, shared_ptr_deleter(handle<>(borrowed(source))) );
-            // use aliasing constructor
            new (storage) shared_ptr<T>(
-                hold_convertible_ref_count,
-                static_cast<T*>(data->convertible));
-        }
+                static_cast<T*>(data->convertible),
+                shared_ptr_deleter(handle<>(borrowed(source)))
+                );
        
        data->convertible = storage;
    }
--- a/include/boost/python/def_visitor.hpp
+++ b/include/boost/python/def_visitor.hpp
--- a/include/boost/python/detail/borrowed_ptr.hpp
+++ b/include/boost/python/detail/borrowed_ptr.hpp
--- a/include/boost/python/detail/convertible.hpp
+++ b/include/boost/python/detail/convertible.hpp
--- a/include/boost/python/detail/copy_ctor_mutates_rhs.hpp
+++ b/include/boost/python/detail/copy_ctor_mutates_rhs.hpp
--- a/include/boost/python/detail/decorated_type_id.hpp
+++ b/include/boost/python/detail/decorated_type_id.hpp
@@ -55,8 +55,8 @@ inline decorated_type_info::decorated_type_info(type_info base_t, decoration dec
 inline bool decorated_type_info::operator<(decorated_type_info const& rhs) const
 {
    return m_decoration < rhs.m_decoration
-      || (m_decoration == rhs.m_decoration
-          && m_base_type < rhs.m_base_type);
+        || m_decoration == rhs.m_decoration
+           && m_base_type < rhs.m_base_type;
 }

 inline bool decorated_type_info::operator==(decorated_type_info const& rhs) const
--- a/include/boost/python/detail/def_helper_fwd.hpp
+++ b/include/boost/python/detail/def_helper_fwd.hpp
--- a/include/boost/python/detail/enable_if.hpp
+++ b/include/boost/python/detail/enable_if.hpp
--- a/include/boost/python/detail/force_instantiate.hpp
+++ b/include/boost/python/detail/force_instantiate.hpp
--- a/include/boost/python/detail/is_shared_ptr.hpp
+++ b/include/boost/python/detail/is_shared_ptr.hpp
--- a/include/boost/python/detail/is_wrapper.hpp
+++ b/include/boost/python/detail/is_wrapper.hpp
--- a/include/boost/python/detail/nullary_function_adaptor.hpp
+++ b/include/boost/python/detail/nullary_function_adaptor.hpp
--- a/include/boost/python/detail/operator_id.hpp
+++ b/include/boost/python/detail/operator_id.hpp
--- a/include/boost/python/detail/prefix.hpp
+++ b/include/boost/python/detail/prefix.hpp
--- a/include/boost/python/detail/python_type.hpp
+++ b/include/boost/python/detail/python_type.hpp
--- a/include/boost/python/detail/result.hpp
+++ b/include/boost/python/detail/result.hpp
@@ -86,10 +86,7 @@ result(X const&, short = 0) { return 0; }
 # endif // RESULT_DWA2002521_HPP

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

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

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

-#endif // BOOST_PP_ITERATION_DEPTH()
 #endif
--- a/include/boost/python/detail/unwind_type.hpp
+++ b/include/boost/python/detail/unwind_type.hpp
--- a/include/boost/python/detail/unwrap_type_id.hpp
+++ b/include/boost/python/detail/unwrap_type_id.hpp
--- a/include/boost/python/detail/unwrap_wrapper.hpp
+++ b/include/boost/python/detail/unwrap_wrapper.hpp
--- a/include/boost/python/detail/value_arg.hpp
+++ b/include/boost/python/detail/value_arg.hpp
--- a/include/boost/python/detail/wrapper_base.hpp
+++ b/include/boost/python/detail/wrapper_base.hpp
--- a/include/boost/python/docstring_options.hpp
+++ b/include/boost/python/docstring_options.hpp
--- a/include/boost/python/enum.hpp
+++ b/include/boost/python/enum.hpp
@@ -41,7 +41,7 @@ inline enum_<T>::enum_(char const* name, char const* doc )
        , &enum_<T>::convertible_from_python
        , &enum_<T>::construct
        , type_id<T>()
-        , doc
+		, doc
        )
 {
 }
--- a/include/boost/python/handle.hpp
+++ b/include/boost/python/handle.hpp
--- a/include/boost/python/handle_fwd.hpp
+++ b/include/boost/python/handle_fwd.hpp
--- a/include/boost/python/instance_holder.hpp
+++ b/include/boost/python/instance_holder.hpp
--- a/include/boost/python/iterator.hpp
+++ b/include/boost/python/iterator.hpp
@@ -14,16 +14,6 @@
 # include <boost/type_traits/cv_traits.hpp>
 # include <boost/type_traits/transform_traits.hpp>

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

--- a/include/boost/python/lvalue_from_pytype.hpp
+++ b/include/boost/python/lvalue_from_pytype.hpp
--- a/include/boost/python/make_constructor.hpp
+++ b/include/boost/python/make_constructor.hpp
@@ -105,12 +105,12 @@ namespace detail
      // If the BasePolicy_ supplied a result converter it would be
      // ignored; issue an error if it's not the default.
 #if defined _MSC_VER && _MSC_VER < 1300
-      typedef is_same<
+	  typedef is_same<
              typename BasePolicy_::result_converter
            , default_result_converter
          > same_result_converter;
-      //see above for explanation
-      BOOST_STATIC_ASSERT(same_result_converter::value) ;
+	  //see above for explanation
+	  BOOST_STATIC_ASSERT(same_result_converter::value) ;
 #else
      BOOST_MPL_ASSERT_MSG(
         (is_same<
--- a/include/boost/python/object.hpp
+++ b/include/boost/python/object.hpp
--- a/include/boost/python/object/class_metadata.hpp
+++ b/include/boost/python/object/class_metadata.hpp
--- a/include/boost/python/object/function_doc_signature.hpp
+++ b/include/boost/python/object/function_doc_signature.hpp
--- a/include/boost/python/object/inheritance_query.hpp
+++ b/include/boost/python/object/inheritance_query.hpp
--- a/include/boost/python/object/make_holder.hpp
+++ b/include/boost/python/object/make_holder.hpp
@@ -47,10 +47,7 @@ template <int nargs> struct make_holder;

 # endif // MAKE_HOLDER_DWA20011215_HPP

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

 # undef N

-#endif // BOOST_PP_ITERATION_DEPTH()
 #endif
--- a/include/boost/python/object/pointer_holder.hpp
+++ b/include/boost/python/object/pointer_holder.hpp
@@ -170,10 +170,7 @@ void* pointer_holder_back_reference<Pointer, Value>::holds(type_info dst_t, bool
 # endif // POINTER_HOLDER_DWA20011215_HPP

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

 # undef N

-#endif // BOOST_PP_ITERATION_DEPTH()
 #endif
--- a/include/boost/python/object/stl_iterator_core.hpp
+++ b/include/boost/python/object/stl_iterator_core.hpp
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Daniel James	2eb45f4cbc	Escape some slashes which were confusing quickbook. [SVN r43286]	2008-02-17 12:24:17 +00:00
Daniel James	04883c754d	Some more fixes for an over-enthusiastic search and replace. [SVN r43278]	2008-02-16 11:07:24 +00:00
Daniel James	7a91e60637	Fix some search and replace errors. [SVN r43277]	2008-02-16 11:00:33 +00:00
Daniel James	4e2f5eebda	Point 'more' links at the site. [SVN r43169]	2008-02-07 23:08:19 +00:00
Daniel James	f3ef198b36	Change people links to link to the site. [SVN r43168]	2008-02-07 22:27:50 +00:00
Daniel James	3e5616ff69	Roll back links to the beta site. [SVN r43163]	2008-02-07 20:47:08 +00:00
Daniel James	6449c56efe	Merge. [SVN r42905]	2008-01-21 20:15:02 +00:00
Daniel James	2b1967c72d	Merge from trunk. [SVN r42243]	2007-12-22 15:36:31 +00:00
Daniel James	cb1b967c39	Merge from trunk, finally. [SVN r41817]	2007-12-07 01:12:02 +00:00
Daniel James	ce5c967d18	Update a load of links in Boost.Python. I'm afraid that several are in generated documentation. [SVN r41720]	2007-12-05 00:01:04 +00:00
Daniel James	c156dc603a	Create a branch to fix links on. [SVN r41573]	2007-12-02 10:07:42 +00:00
Jürgen Hunold	5cbb539ec5	Remove unused paramters. Add -Wextra to gcc flags to enable more warnings. [SVN r41550]	2007-12-01 20:26:37 +00:00
Jürgen Hunold	40e4940877	Silence compiler by adding cosmetic virtual destructors. [SVN r41549]	2007-12-01 20:24:51 +00:00
Jürgen Hunold	ab0911cf53	Silence compiler by adding cosmetic virtual destructors. [SVN r41544]	2007-12-01 19:27:06 +00:00
Dave Abrahams	0d81eb6695	Boost.Python: * Workarounds for many SunCC 5.9 bugs * Suppression of many SunCC 5.9 warnings * Improve the style of some test invocations in Jamfile [SVN r41521]	2007-12-01 02:15:17 +00:00
Dave Abrahams	e0b535df1e	Try to extend the workaround to SunPro 5.9, since we're marked as not working on 5.8 [SVN r41408]	2007-11-26 22:01:50 +00:00
Ralf W. Grosse-Kunstleve	d2517faa78	g++ 4.3.0 compatibility (4.3.0 20071125 (experimental)) [SVN r41404]	2007-11-26 20:46:28 +00:00
Beman Dawes	8cd4ff8950	Remove extra ) from prior commit [SVN r41355]	2007-11-25 13:56:09 +00:00
Dave Abrahams	26f77691ee	Attempt SunPro workaround [SVN r41352]	2007-11-25 09:02:01 +00:00
Joel de Guzman	6e7f594027	fix for trac ticket #1450 [SVN r41164]	2007-11-17 01:51:04 +00:00
Beman Dawes	eada30f0cb	Get rid of .cvsignore files [SVN r41107]	2007-11-15 15:20:27 +00:00
Joel de Guzman	e919ffdac4	refresh docs [SVN r41082]	2007-11-14 10:24:21 +00:00
Joel de Guzman	1cf41fd031	fix mismatch include guard [SVN r41019]	2007-11-11 22:32:48 +00:00
Nikolay Mladenov	7b67118271	changed handle cast to downcast [SVN r40935]	2007-11-08 16:28:44 +00:00
Nikolay Mladenov	e14c702a40	added forgotten array_object_manager_traits::get_pytype [SVN r40889]	2007-11-07 16:06:55 +00:00
Joel de Guzman	d303ea16fc	added copyright and license info for each page. [SVN r40871]	2007-11-07 03:35:49 +00:00
Ralf W. Grosse-Kunstleve	65114d8637	reinterpret_cast -> const_cast; commented out dead code removed [SVN r40749]	2007-11-04 18:08:28 +00:00
Joel de Guzman	597dfc586b	tutorial update [SVN r40734]	2007-11-04 00:12:29 +00:00
Dave Abrahams	6a3085ad5d	Merging some of the more obvious changes from RC_1_34_0 [SVN r40714]	2007-11-03 03:25:13 +00:00
Joel de Guzman	190d0d7ea6	replacing reinterpret_cast with static_cast<PySliceObject>(static_cast<void>(i)) [SVN r40712]	2007-11-03 03:05:26 +00:00
Eric Niebler	8b915a15ff	merge Changeset 37947 [SVN r40675]	2007-11-02 04:35:01 +00:00
Dave Abrahams	90c5c19220	Take out print statement I added for debugging purposes. [SVN r40536]	2007-10-28 19:24:02 +00:00
Dave Abrahams	cfe6f96f69	Closes #1379 , really this time. The old code would sandwich argv[1] between quotes and interpret it as a string, so backslashes in windows paths were interpreted as escape sequences. [SVN r40535]	2007-10-28 19:22:21 +00:00
Vladimir Prus	77907c5369	Make sure every library can be installed by using bjam stage\|install in libs/<library>/build. [SVN r40475]	2007-10-26 09:04:25 +00:00
Rene Rivera	512b30c971	Do not refer to nonexistent target when python is not configured. [SVN r40216]	2007-10-20 16:36:18 +00:00
Rene Rivera	f005518686	Fix build system error when Python is not configured, without preventing the BPL target from being declared. Instead the target is now unbuildable, and will be skipped when Python is not configured. [SVN r40156]	2007-10-18 16:11:41 +00:00
Rene Rivera	274a219965	Remove BPL build conditional as it prevents normal build failures. [SVN r39731]	2007-10-06 19:46:39 +00:00
Ralf W. Grosse-Kunstleve	abc4abf84a	gcc 4.3.0 compatibility (resolves new "changes meaning" error) [SVN r39434]	2007-09-20 23:20:45 +00:00
Nikolay Mladenov	94a3ced83a	fixed cpp signature related test failure [SVN r39372]	2007-09-18 17:51:47 +00:00
Nikolay Mladenov	7eb0c678ee	epydoc friendlier formatting [SVN r39371]	2007-09-18 17:32:06 +00:00
Nikolay Mladenov	92460adce6	tabs removes, code reformatting [SVN r39370]	2007-09-18 17:28:23 +00:00
Nikolay Mladenov	8cfd3fb2ef	epydoc friendlier formatting [SVN r39368]	2007-09-18 17:16:31 +00:00
Nikolay Mladenov	62ef542eaf	fixed problem reported by Neal Becker; added a test case [SVN r39223]	2007-09-12 21:31:39 +00:00
Ralf W. Grosse-Kunstleve	5809078ba9	Patches by Nikolay Mladenov (nickm at sitius com): new pythonic signatures; docstring support for enums; fix unrelated Visual C++ 6 problem [SVN r39191]	2007-09-11 16:53:50 +00:00
Vladimir Prus	04e54d670c	Remove V1 Jamfiles [SVN r38516]	2007-08-08 19:02:26 +00:00
Stefan Seefeld	dd7c0a7f3d	Fix ticket #1115 . [SVN r38289]	2007-07-26 16:11:18 +00:00
Stefan Seefeld	71f54cc920	Fix ticket #1115 . [SVN r38288]	2007-07-26 14:41:41 +00:00
Ralf W. Grosse-Kunstleve	9de994c0d1	Hans Meine's extra new-line for epydoc with reST compatibility [SVN r37906]	2007-06-06 00:00:57 +00:00
Stefan Seefeld	e9caacc428	More fixes for embedding python docs. [SVN r37709]	2007-05-18 15:52:55 +00:00
Stefan Seefeld	5070e84f70	Enhance documentation for embedding python. [SVN r37708]	2007-05-18 15:22:43 +00:00
Stefan Seefeld	fe23d9885f	Add new eval() function. [SVN r37560]	2007-05-02 13:11:20 +00:00
Ralf W. Grosse-Kunstleve	e7ee17b71b	MIPSpro: undo Python 2.5.1 define (the define leads to many warnings) [SVN r37502]	2007-04-25 04:45:17 +00:00
Dave Abrahams	5edb63d01c	Some progress on Python build guide. Minor fixes to getting started guide. [SVN r37418]	2007-04-11 23:35:08 +00:00
Dave Abrahams	f4b3aab7d4	Checkpoint before reorg [SVN r37370]	2007-04-05 20:13:13 +00:00
Dave Abrahams	6af67d1a4c	kill off BBv1 project archive [SVN r37367]	2007-04-05 17:19:20 +00:00
Dave Abrahams	16d975ba5c	Bringing forward BBv2/Python support and a few other things that were obviously more up-to-date on the RC branch. Removed the Boost.Python v1 zip archive. [SVN r37346]	2007-04-03 17:10:53 +00:00
Dave Abrahams	4fc5cafd40	Some progress on new build/test guide. [SVN r37333]	2007-04-02 05:24:25 +00:00
Stefan Seefeld	1b5cd10f7c	Fix reference counting error. [SVN r37312]	2007-03-28 18:12:08 +00:00
Stefan Seefeld	0f91872518	Fix import_ failure. [SVN r37142]	2007-03-05 18:51:04 +00:00
Stefan Seefeld	dc6b2979e4	Add copyright notice. [SVN r37132]	2007-03-02 17:16:51 +00:00
Stefan Seefeld	50034140c4	Fix boost::python::import. [SVN r37120]	2007-03-01 15:17:29 +00:00
Dave Abrahams	08a6f35ec2	Correct testing bugs: either changing assert(...) or BOOST_ASSERT(...) to BOOST_TEST (in my code only) or adding "return boost::report_errors();" where it was clearly missing (and a pure bug, in anyone's code). [SVN r37057]	2007-02-24 22:40:59 +00:00
Dave Abrahams	67236ffbad	New build instructions in progress [SVN r36879]	2007-02-03 16:55:07 +00:00
Dave Abrahams	96ab7a80a4	Remove BBv1 for good [SVN r36323]	2006-12-11 05:02:34 +00:00
Dave Abrahams	d8c3ff199e	Remove BBv1 for good [SVN r36321]	2006-12-11 03:35:10 +00:00
Dave Abrahams	0c4ebef579	Fix auto-link to look at the right variable. Make boost-build.jam point at the v2 Boost. [SVN r36318]	2006-12-11 02:54:48 +00:00
Dave Abrahams	8fe9d41b58	Cleaned out flotsam and improved comments [SVN r36317]	2006-12-11 02:50:55 +00:00
Dave Abrahams	8a4590b2ef	Enable auto-linking [SVN r36291]	2006-12-07 17:44:05 +00:00
Ralf W. Grosse-Kunstleve	d67b040683	fixes to support pickling of enums (by Shashank Bapat) [SVN r36256]	2006-12-03 20:43:48 +00:00
Beman Dawes	2db61657f2	Add copyright, license [SVN r35905]	2006-11-07 19:11:57 +00:00
Dave Abrahams	6d2ee96ba3	improve error message [SVN r35822]	2006-11-03 16:34:53 +00:00
Stefan Seefeld	a74c8e3da3	Fix symbol visibility. [SVN r35754]	2006-10-27 21:19:47 +00:00
Ralf W. Grosse-Kunstleve	9f4d39d9fe	correct trivial, obvious accident: stray line removed [SVN r35599]	2006-10-13 22:06:17 +00:00
Dave Abrahams	31c19644ed	make numpy tests portable to Darwin with older docutils [SVN r35597]	2006-10-13 21:34:26 +00:00
Dave Abrahams	600d444136	Fix some problems with testing on old docutils installations [SVN r35594]	2006-10-13 19:35:28 +00:00
Dave Abrahams	c3bd0fcbad	Make object comparison operators return object instead of bool, to accomodate strange beasts like numarray arrays that return arrays that can't be used as truth values from their comparison ops. Fix numpy test for portability with old doctest (again!) [SVN r35572]	2006-10-12 09:07:07 +00:00
Dave Abrahams	991a7c198a	Workaround vc6 bugs [SVN r35568]	2006-10-12 06:41:55 +00:00
Dave Abrahams	9b67f0447d	Suppress a couple of msvc class/struct warnings [SVN r35567]	2006-10-12 06:41:18 +00:00
Dave Abrahams	b714f6cc23	Adjust tests to account for numarray behavior differences [SVN r35539]	2006-10-10 22:44:09 +00:00
Dave Abrahams	479a6ba4fc	Try for backward compatibility with older versions of doctest [SVN r35535]	2006-10-10 18:12:43 +00:00
Dave Abrahams	d78836b828	Fix lots of bugs in the numeric interface and tests. Tests: * Coerce a result to bool to deal with Python's new Bool type * Better reporting of mismatches in expected and received results * Remove bogus nullary y.astype() call * Fix all uses of trace and diagonal so they don't cause errors * Use appropriate typecodes * Use doctest detailed API to run just the relevant tests * Factor out error handling from macro API: * Added get_module_name() function to get current numeric module * new_(x) now returns an array instead of object * Fixed the signatures of the factory() family of functions * Updated docs accordingly. [SVN r35528]	2006-10-09 04:05:25 +00:00
Dave Abrahams	7a59131d37	Fix missing #include [SVN r35524]	2006-10-08 05:17:20 +00:00
Dave Abrahams	5ab00bc9c8	Fix long-standing misnaming of "factory" method as "array" [SVN r35428]	2006-09-29 22:24:12 +00:00
Dave Abrahams	94500ae36d	Tests and fixes for a bad interaction between wrapper<> and operators support. "self" arguments weren't getting unwrapped properly. [SVN r35365]	2006-09-28 14:41:01 +00:00
Dave Abrahams	5e5d34cc36	Fixed broken links [SVN r35329]	2006-09-26 04:23:32 +00:00
Ralf W. Grosse-Kunstleve	c6f2aa4ef2	new boost/python/ssize_t.hpp; avoids potential clash of Py_ssize_t typedef and PY_SSIZE_T_MIN/MAX macros with definitions from other libraries [SVN r35325]	2006-09-26 00:25:07 +00:00
Dave Abrahams	c7fb2f7047	Attempt GCC-3.4.4 and 4.0.1 workarounds [SVN r35276]	2006-09-22 15:12:04 +00:00
Vladimir Prus	afedc1cd9a	Add tests [SVN r35244]	2006-09-21 07:26:35 +00:00
Gottfried Ganßauge	070e02d7d5	Renamed from opaque_pointer_converter.html [SVN r35242]	2006-09-21 07:07:14 +00:00
Dave Abrahams	ccc56c2a4c	Apply Boost license, with permission from Prabhu Ramachandran. [SVN r35240]	2006-09-21 03:43:59 +00:00
Dave Abrahams	e00a88ff49	Fix inspection issues [SVN r35239]	2006-09-21 02:40:19 +00:00
Stefan Seefeld	e527bc860f	Fix copyright issues. [SVN r35236]	2006-09-20 22:30:39 +00:00
Dave Abrahams	921e306b9a	Fix license/copyright [SVN r35234]	2006-09-20 21:59:03 +00:00
Dave Abrahams	bed1d26904	Return an int, not a string, on success from check_numeric_array_rich_slice, since that's what the tests expect. [SVN r35184]	2006-09-18 22:21:50 +00:00
Dave Abrahams	41a342f026	vc6/7 workaround [SVN r35164]	2006-09-18 18:25:12 +00:00
Dave Abrahams	cee8e07046	Checkin missing op_repr definition [SVN r35153]	2006-09-18 02:59:31 +00:00
Dave Abrahams	0806e89964	More informative error messages Better autoconfiguration [SVN r35140]	2006-09-17 02:41:20 +00:00
Dave Abrahams	f5421ca6b2	Default to Python 2.4 in Unix builds Applied contributed patches http://tinyurl.com/ndljr and http://tinyurl.com/18r [SVN r35138]	2006-09-16 18:43:53 +00:00
Ralf W. Grosse-Kunstleve	eea7697175	if __name__ == '__main__' [SVN r35114]	2006-09-14 21:57:56 +00:00
Ralf W. Grosse-Kunstleve	777ce7b561	magic coding: iso-latin1 comment added to avoid Python SyntaxError [SVN r35113]	2006-09-14 21:53:00 +00:00
Gottfried Ganßauge	864ece5539	cross module compatibility test for opaque [SVN r35111]	2006-09-14 19:06:33 +00:00
Gottfried Ganßauge	2610eb9acb	Type object for opaque initialized with PyType_Clear. opaque is registered only if not another module has already registered a conversion for that pointer type. Doc update. [SVN r35104]	2006-09-14 05:59:29 +00:00
Dave Abrahams	567a2c7b89	attempt unverified workaround for http://tinyurl.com/gvrgd [SVN r35103]	2006-09-13 22:47:11 +00:00
Dave Abrahams	05070faf12	Attempt to capture better debugging info in output [SVN r35079]	2006-09-12 23:58:40 +00:00
Dave Abrahams	ad8069314d	Move definition of BOOST_PYTHON_SUPPRESS_REGISTRY_INITIALIZATION back where it belongs. [SVN r35076]	2006-09-12 22:37:09 +00:00
Dave Abrahams	9366c48351	add missing license/copyright info [SVN r35068]	2006-09-11 22:08:18 +00:00
Dave Abrahams	5a14319753	SunPro workarounds [SVN r35067]	2006-09-11 10:38:14 +00:00
Joel de Guzman	279a4f7888	Update [SVN r35006]	2006-08-31 06:01:57 +00:00
Dave Abrahams	d3418d494c	Restort BOOST_PYTHON_STATIC_LIB. We don't want to create exported symbols. [SVN r34942]	2006-08-24 19:03:35 +00:00
Dave Abrahams	c839427246	Sun workaround [SVN r34939]	2006-08-24 13:04:59 +00:00
Dave Abrahams	dd3a136b18	Attempted Sun workaround [SVN r34914]	2006-08-22 11:50:35 +00:00
Dave Abrahams	48696918de	Try not specifying static link, to see if it makes Darwin happy [SVN r34871]	2006-08-11 15:50:21 +00:00
Dave Abrahams	88be35ddc2	Attempt Sun-5.8 workaround [SVN r34864]	2006-08-11 00:47:48 +00:00
Gennaro Prota	9ee0d36a1d	removed tabs (inspect tool) [SVN r34722]	2006-07-24 22:25:35 +00:00
Gennaro Prota	f240e0bab6	removed tabs (inspect tool) [SVN r34720]	2006-07-24 22:20:25 +00:00
Gennaro Prota	4081605e4b	removed tabs (inspect tool) [SVN r34719]	2006-07-24 22:14:15 +00:00
Gennaro Prota	f332ff2d89	minor fix: violation of min/max guidelines [SVN r34717]	2006-07-24 22:04:05 +00:00
Vladimir Prus	ec77608840	Clarify comment [SVN r34668]	2006-07-22 12:53:49 +00:00
Vladimir Prus	f5a69a1dab	Windows fix: use <library>/pytho/python_for_extensions, not <use>, so that we actually link to Python import lib on windows. [SVN r34666]	2006-07-22 12:28:00 +00:00
Vladimir Prus	a1e865061c	Don't link Boost.Python to python library, and don't require <threading>multi for embedding applications. * libs/python/build/Jamfile.v2: (boost_python): Don't link to /python//python. Use /python//python_for_extensions. * libs/python/test/Jamfile.v2: Remove <threading>multi project requirements. (py-run): Link to /python//python. (exec): Likewise. * tools/build/v2/tools/python.jam: (pthread): Declare. (init-unix): Add 'pthread' to extra-libs. ( [SVN r34662]	2006-07-22 07:12:10 +00:00
Ralf W. Grosse-Kunstleve	596e92404a	old misunderstanding corrected (L-BFGS) [SVN r34504]	2006-07-11 04:09:41 +00:00
Joel de Guzman	2640f5af94	new css [SVN r34426]	2006-06-29 09:35:52 +00:00
Joel de Guzman	0605e9fdcf	minor tweak [SVN r34375]	2006-06-22 13:43:09 +00:00
Joel de Guzman	cf68da0b19	added test for vector<string> [SVN r34374]	2006-06-22 13:33:46 +00:00
Joel de Guzman	d3c474b295	terminology tweak [SVN r34360]	2006-06-20 14:01:12 +00:00
Joel de Guzman	c9300e07c2	added custom converter test for map indexing suite [SVN r34359]	2006-06-20 00:33:22 +00:00
Ralf W. Grosse-Kunstleve	cab94a7bba	adjustments for new MIPSpro 7.4.4 [SVN r34132]	2006-06-02 05:39:50 +00:00
Ralf W. Grosse-Kunstleve	caa9cb8268	Python 2.5 compatibility [SVN r34017]	2006-05-18 22:41:14 +00:00
Ralf W. Grosse-Kunstleve	66ac61450e	avoid Visual C++ 7.1 "resolved overload was found by argument-dependent lookup" warning [SVN r34016]	2006-05-18 22:09:20 +00:00
Ralf W. Grosse-Kunstleve	59f81def56	Python include must appear before any system include [SVN r34010]	2006-05-18 18:47:12 +00:00
Ralf W. Grosse-Kunstleve	92862028b7	MIPSpro 7.3.1 compatibility [SVN r34009]	2006-05-18 18:46:26 +00:00
Ralf W. Grosse-Kunstleve	b0ba7dfc50	also exercise OVERLOADS with docstring [SVN r34006]	2006-05-18 16:15:59 +00:00
Ralf W. Grosse-Kunstleve	fe3abeda9f	much more informative pickle error messages if pickling is not enabled [SVN r34004]	2006-05-18 15:49:41 +00:00
Markus Schöpflin	3fdfb30e33	Include python first, fixes error on Tru64/CXX. [SVN r33454]	2006-03-23 09:38:03 +00:00
Vladimir Prus	cdcf8633bb	Force multithreading for Python test. Workaround for problem described in http://thread.gmane.org/gmane.comp.lib.boost.devel/139601 [SVN r33434]	2006-03-22 09:53:34 +00:00