*** empty log message ***

[SVN r32838]

build/Jamfile

@@ -0,0 +1,99 @@
+#  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
+#  distribute this software is granted provided this copyright notice appears
+#  in all copies. This software is provided "as is" without express or implied
+#  warranty, and with no claim as to its suitability for any purpose.
+#
+# Boost.Python library Jamfile
+
+
+# declare the location of this subproject relative to the root
+subproject libs/python/build ;
+
+# bring in the rules for python
+import python ;
+
+if [ check-python-config ]
+{
+    
+  local bpl-linkflags ;
+
+  if $(UNIX) && ( $(OS) = AIX )
+  {
+      bpl-linkflags = <linkflags>"-e initlibboost_python" ;
+  }
+
+  # Enabling intrinsics (/0i) or maximize speed (/02) seem to cause
+  # internal compiler errors with this toolset.
+  local msvc-stlport-workarounds
+    = <optimization>off "<cxxflags>-Ogty -O1 -Gs" ;
+    
+  local sources =
+    numeric.cpp
+    list.cpp
+    long.cpp
+    dict.cpp
+    tuple.cpp
+    str.cpp
+    slice.cpp
+
+    aix_init_module.cpp
+    converter/from_python.cpp
+    converter/registry.cpp
+    converter/type_id.cpp
+    object/enum.cpp
+    object/class.cpp
+    object/function.cpp
+    object/inheritance.cpp
+    object/life_support.cpp
+    object/pickle_support.cpp
+    errors.cpp
+    module.cpp
+    converter/builtin_converters.cpp
+    converter/arg_to_python_base.cpp
+    object/iterator.cpp
+    object/stl_iterator.cpp
+    object_protocol.cpp
+    object_operators.cpp
+    wrapper.cpp
+    exec.cpp
+    import.cpp
+    ;
+  
+  dll boost_python
+    : ../src/$(sources)
+    : $(BOOST_PYTHON_V2_PROPERTIES)
+      <define>BOOST_PYTHON_SOURCE
+      $(bpl-linkflags)
+        <msvc-stlport><release>$(msvc-stlport-workarounds)
+        <darwin><*><linkflags>-bind_at_load
+        <gcc-3_3-darwin><*><linkflags>-bind_at_load
+      ;
+
+  template extension
+    : <dll>boost_python
+    : <sysinclude>../../..
+    ;
+  
+  lib boost_python
+    : # sources
+      ../src/$(sources)
+        
+    : # requirements
+      $(BOOST_PYTHON_V2_PROPERTIES)
+      <define>BOOST_PYTHON_SOURCE
+      <define>BOOST_STATIC_LIB
+      $(bpl-linkflags)
+        <msvc-stlport><release>$(msvc-stlport-workarounds)
+      ;
+
+  stage bin-stage : <dll>boost_python <lib>boost_python
+    : <tag><debug>"_debug"
+      <tag><debug-python>"_pydebug"
+    :
+        debug release
+    ;
+
+  install python lib
+    : <dll>boost_python <lib>boost_python
+    ;
+}

build/Jamfile.v2

@@ -1,22 +1,32 @@
-# Copyright David Abrahams 2001-2006. Distributed under the Boost
-# Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
 import os ;
 import modules ;
 
 import python ;
 
+if [ python.configured ] {
+    
 
 project boost/python
-  : source-location ../src
-  ;
+    : source-location ../src
+        : requirements 
+	#<include>$(PYTHON_PATH)/include
+        #  $(lib_condition)<library-path>$(PYTHON_PATH)/libs
+        #    <link>shared:<library>$(PYTHON_LIB)
+        #    <define>$(defines)
+        #: usage-requirements # requirement that will be propageted to *users* of this library
+        #  <include>$(PYTHON_PATH)/include
 
-rule cond ( test ? : yes * : no * ) { if $(test) { return $(yes) ; } else { return $(no) ; } }
-rule unless ( test ? : yes * : no * ) { if ! $(test) { return $(yes) ; } else { return $(no) ; } }
+# We have a bug which causes us to conclude that conditionalized
+# properties in this section are not free.
+#          $(lib_condition)<library-path>$(PYTHON_PATH)/lib/python2.2/config
+#            <shared>true:<find-library>$(PYTHON_LIB)
+            
+        # <library-path>$(PYTHON_PATH)/lib/python2.2/config
+        #    <library>$(PYTHON_LIB)
+    ;
 
 lib boost_python
-    : # sources
+    : 
     numeric.cpp
     list.cpp
     long.cpp
@@ -46,35 +56,14 @@ lib boost_python
     wrapper.cpp
     import.cpp
     exec.cpp
-    object/function_doc_signature.cpp
-    :   # requirements
-        <link>static:<define>BOOST_PYTHON_STATIC_LIB 
+    :   <link>static:<define>BOOST_PYTHON_STATIC_LIB 
         <define>BOOST_PYTHON_SOURCE
-      
-        # On Windows, all code using Python has to link to the Python
-        # import library.
-        #
-        # On *nix we never link libboost_python to libpython.  When
-        # extending Python, all Python symbols are provided by the
-        # Python interpreter executable.  When embedding Python, the
-        # client executable is expected to explicitly link to
-        # /python//python (the target representing libpython) itself.
-        #
-        # python_for_extensions is a target defined by Boost.Build to
-        # provide the Python include paths, and on Windows, the Python
-        # import library, as usage requirements.
-        [ cond [ python.configured ] : <library>/python//python_for_extensions ]
-        
-        # we prevent building when there is no python available
-        # as it's not possible anyway, and to cause dependents to
-        # fail to build
-        [ unless [ python.configured ] : <build>no ]
-      
-    :   # default build
-        <link>shared
-    :   # usage requirements
-        <link>static:<define>BOOST_PYTHON_STATIC_LIB 
-        <link>shared:<define>BOOST_PYTHON_DYNAMIC_LIB
+	<library>/python//python
+    : <link>shared
     ;
-
-boost-install boost_python ;
+}
+else
+{
+    ECHO "warning: Python location is not configured" ;
+    ECHO "warning: the Boost.Python library won't be built" ;
+}

doc/Jamfile

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

doc/PyConDC_2003/bpl.html

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

doc/PyConDC_2003/bpl.txt

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

doc/PyConDC_2003/bpl_mods.txt

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

doc/PyConDC_2003/default.css

@@ -5,8 +5,6 @@
 :version: $Revision$
 :copyright: This stylesheet has been placed in the public domain.
 
-boostinspect:nolicense
-
 Default cascading style sheet for the HTML output of Docutils.
 */
 

doc/boost.css

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

doc/building.html

@@ -1,415 +1,460 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Docutils 0.5: http://docutils.sourceforge.net/" />
-<title>Boost C++ Libraries: Boost.Python Build and Test HOWTO</title>
-<link rel="stylesheet" href="../../../rst.css" type="text/css" />
-</head>
-<body>
-<div class="document" id="logo-boost-python-build-and-test-howto">
-<h1 class="title"><a class="reference" href="../index.htm"><img alt="Boost C++ Libraries:" class="boost-logo" src="../boost.png" /></a> Boost.Python Build and Test HOWTO</h1>
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at -->
-<!-- http://www.boost.org/LICENSE_1_0.txt) -->
-<div class="contents sidebar small topic">
-<p class="topic-title first"><a id="contents" name="contents">Contents</a></p>
-<ul class="auto-toc simple">
-<li><a class="reference" href="#requirements" id="id20" name="id20">1&nbsp;&nbsp;&nbsp;Requirements</a></li>
-<li><a class="reference" href="#background" id="id21" name="id21">2&nbsp;&nbsp;&nbsp;Background</a></li>
-<li><a class="reference" href="#getting-boost-python-binaries" id="id22" name="id22">3&nbsp;&nbsp;&nbsp;Getting Boost.Python Binaries</a><ul class="auto-toc">
-<li><a class="reference" href="#no-install-quickstart" id="id23" name="id23">3.1&nbsp;&nbsp;&nbsp;No-Install Quickstart</a></li>
-<li><a class="reference" href="#installing-boost-python-on-your-system" id="id24" name="id24">3.2&nbsp;&nbsp;&nbsp;Installing Boost.Python on your System</a></li>
-</ul>
-</li>
-<li><a class="reference" href="#configuring-boost-build" id="id25" name="id25">4&nbsp;&nbsp;&nbsp;Configuring Boost.Build</a></li>
-<li><a class="reference" href="#building-an-extension-module" id="id26" name="id26">5&nbsp;&nbsp;&nbsp;Building an Extension Module</a></li>
-<li><a class="reference" href="#testing" id="id27" name="id27">6&nbsp;&nbsp;&nbsp;Testing</a></li>
-<li><a class="reference" href="#advanced-configuration" id="id28" name="id28">7&nbsp;&nbsp;&nbsp;Advanced Configuration</a><ul class="auto-toc">
-<li><a class="reference" href="#python-configuration-parameters" id="id29" name="id29">7.1&nbsp;&nbsp;&nbsp;Python Configuration Parameters</a></li>
-<li><a class="reference" href="#examples" id="id30" name="id30">7.2&nbsp;&nbsp;&nbsp;Examples</a></li>
-</ul>
-</li>
-<li><a class="reference" href="#choosing-a-boost-python-library-binary" id="id31" name="id31">8&nbsp;&nbsp;&nbsp;Choosing a Boost.Python Library Binary</a><ul class="auto-toc">
-<li><a class="reference" href="#the-dynamic-binary" id="id32" name="id32">8.1&nbsp;&nbsp;&nbsp;The Dynamic Binary</a></li>
-<li><a class="reference" href="#the-static-binary" id="id33" name="id33">8.2&nbsp;&nbsp;&nbsp;The Static Binary</a></li>
-</ul>
-</li>
-<li><a class="reference" href="#notes-for-mingw-and-cygwin-with-mno-cygwin-gcc-users" id="id34" name="id34">9&nbsp;&nbsp;&nbsp;Notes for MinGW (and Cygwin with -mno-cygwin) GCC Users</a></li>
-</ul>
-</div>
-<div class="section">
-<h1><a class="toc-backref" href="#id20" id="requirements" name="requirements">1&nbsp;&nbsp;&nbsp;Requirements</a></h1>
-<p>Boost.Python requires <a class="reference" href="http://www.python.org/2.2">Python 2.2</a><a class="footnote-reference" href="#id16" id="id2" name="id2"><sup>1</sup></a> <em>or</em> <a class="reference" href="http://www.python.org"><em>newer</em></a>.</p>
-</div>
-<div class="section">
-<h1><a class="toc-backref" href="#id21" id="background" name="background">2&nbsp;&nbsp;&nbsp;Background</a></h1>
-<p>There are two basic models for combining C++ and Python:</p>
-<ul class="simple">
-<li><a class="reference" href="http://www.python.org/doc/current/ext/intro.html">extending</a>, in which the end-user launches the Python interpreter
-executable and imports Python “extension modules” written in C++.
-Think of taking a library written in C++ and giving it a Python
-interface so Python programmers can use it.  From Python, these
-modules look just like regular Python modules.</li>
-<li><a class="reference" href="http://www.python.org/doc/current/ext/embedding.html">embedding</a>, in which the end-user launches a program written
-in C++ that in turn invokes the Python interpreter as a library
-subroutine.  Think of adding scriptability to an existing
-application.</li>
-</ul>
-<p>The key distinction between extending and embedding is the location
-of C++' <tt class="docutils literal"><span class="pre">main()</span></tt> function: in the Python interpreter executable,
-or in some other program, respectively.  Note that even when
-embedding Python in another program, <a class="reference" href="http://www.python.org/doc/current/ext/extending-with-embedding.html">extension modules are often
-the best way to make C/C++ functionality accessible to Python
-code</a>, so the use of extension modules is really at the heart of
-both models.</p>
-<p>Except in rare cases, extension modules are built as
-dynamically-loaded libraries with a single entry point, which means
-you can change them without rebuilding either the other extension
-modules or the executable containing <tt class="docutils literal"><span class="pre">main()</span></tt>.</p>
-</div>
-<div class="section">
-<h1><a class="toc-backref" href="#id22" id="getting-boost-python-binaries" name="getting-boost-python-binaries">3&nbsp;&nbsp;&nbsp;Getting Boost.Python Binaries</a></h1>
-<p>Since Boost.Python is a separately-compiled (as opposed to
-<a class="reference" href="../../../more/getting_started/windows.html#header-only-libraries">header-only</a>) library, its user relies on the services of a
-Boost.Python library binary.</p>
-<div class="section">
-<h2><a class="toc-backref" href="#id23" id="no-install-quickstart" name="no-install-quickstart">3.1&nbsp;&nbsp;&nbsp;No-Install Quickstart</a></h2>
-<p>If you just want to get started quickly building and testing
-Boost.Python extension modules, or embedding Python in an
-executable, you don't need to worry about installing Boost.Python
-binaries explicitly.  These instructions use <a class="reference" href="../../../tools/build">Boost.Build</a> projects,
-which will build those binaries as soon as they're needed.  Your
-first tests may take a little longer while you wait for
-Boost.Python to build, but doing things this way will save you from
-worrying about build intricacies like which library binaries to use
-for a specific compiler configuration.</p>
-<div class="note">
-<p class="first admonition-title">Note</p>
-<p>Of course it's possible to use other build systems to
-build Boost.Python and its extensions, but they are not
-officially supported by Boost and <strong>99% of all “I can't build
-Boost.Python” problems come from trying to use another build
-system</strong>.</p>
-<p class="last">If you want to use another system anyway, we suggest that you
-follow these instructions, and then invoke <tt class="docutils literal"><span class="pre">bjam</span></tt> with the
-<tt class="docutils literal"><span class="pre">-a</span> <span class="pre">-o</span></tt><em>filename</em> option to dump the build commands it executes
-to a file, so you can see what your build system needs to do.</p>
-</div>
-</div>
-<div class="section">
-<h2><a class="toc-backref" href="#id24" id="installing-boost-python-on-your-system" name="installing-boost-python-on-your-system">3.2&nbsp;&nbsp;&nbsp;Installing Boost.Python on your System</a></h2>
-<p>If you need a regular, installation of the Boost.Python library
-binaries on your system, the Boost <a class="reference" href="../../../more/getting_started/index.html">Getting Started Guide</a> will
-walk you through the steps of installing one.  If building binaries
-from source, you might want to supply the <tt class="docutils literal"><span class="pre">--with-python</span></tt>
-argument to <tt class="docutils literal"><span class="pre">bjam</span></tt> (or the <tt class="docutils literal"><span class="pre">--with-libraries=python</span></tt> argument
-to <tt class="docutils literal"><span class="pre">configure</span></tt>), so only the Boost.Python binary will be built,
-rather than all the Boost binaries.</p>
-</div>
-</div>
-<div class="section">
-<h1><a class="toc-backref" href="#id25" id="configuring-boost-build" name="configuring-boost-build">4&nbsp;&nbsp;&nbsp;Configuring Boost.Build</a></h1>
-<p>As described in the <a class="reference" href="http://www.boost.orgdoc/html/bbv2/advanced.html#bbv2.advanced.configuration">Boost.Build reference manual</a>, a file called
-<tt class="docutils literal"><span class="pre">user-config.jam</span></tt> in your home
-directory<a class="footnote-reference" href="#home-dir" id="id5" name="id5"><sup>7</sup></a> is used to
-describe the build resources available to the build system.  You'll
-need to tell it about your Python installation.</p>
-<div class="admonition-users-of-unix-variant-oses admonition">
-<p class="first admonition-title">Users of Unix-Variant OSes</p>
-<p class="last">If you are using a unix-variant OS and you ran Boost's
-<tt class="docutils literal"><span class="pre">configure</span></tt> script, it may have generated a
-<tt class="docutils literal"><span class="pre">user-config.jam</span></tt> for you.<a class="footnote-reference" href="#overwrite" id="id7" name="id7"><sup>4</sup></a> If your <tt class="docutils literal"><span class="pre">configure</span></tt>/<tt class="docutils literal"><span class="pre">make</span></tt> sequence was successful and Boost.Python binaries
-were built, your <tt class="docutils literal"><span class="pre">user-config.jam</span></tt> file is probably already
-correct.</p>
-</div>
-<p>If you have a fairly “standard” python installation for your
-platform, there's very little you need to do to describe it.
-Simply having</p>
-<pre class="literal-block">
-import toolset : using ;
-using python ;
-</pre>
-<p>in a <tt class="docutils literal"><span class="pre">user-config.jam</span></tt> file in your home directory<a class="footnote-reference" href="#home-dir" id="id8" name="id8"><sup>7</sup></a>
-should be enough.<a class="footnote-reference" href="#user-config-jam" id="id9" name="id9"><sup>6</sup></a>  For more complicated setups,
-see <a class="reference" href="#advanced-configuration">Advanced Configuration</a>.</p>
-<div class="note">
-<p class="first admonition-title">Note</p>
-<p class="last">You might want to pass the <tt class="docutils literal"><span class="pre">--debug-configuration</span></tt>
-option to <tt class="docutils literal"><span class="pre">bjam</span></tt> the first few times you invoke it, to make
-sure that Boost.Build is correctly locating all the parts of
-your Python installation.  If it isn't, consider passing some of
-the optional <a class="reference" href="#python-configuration-parameters">Python configuration parameters</a> detailed below.</p>
-</div>
-</div>
-<div class="section">
-<h1><a class="toc-backref" href="#id26" id="building-an-extension-module" name="building-an-extension-module">5&nbsp;&nbsp;&nbsp;Building an Extension Module</a></h1>
-</div>
-<div class="section">
-<h1><a class="toc-backref" href="#id27" id="testing" name="testing">6&nbsp;&nbsp;&nbsp;Testing</a></h1>
-</div>
-<div class="section">
-<h1><a class="toc-backref" href="#id28" id="advanced-configuration" name="advanced-configuration">7&nbsp;&nbsp;&nbsp;Advanced Configuration</a></h1>
-<p>If you have several versions of Python installed, or Python is
-installed in an unusual way, you may want to supply any or all of
-the following optional parameters to <tt class="docutils literal"><span class="pre">using</span> <span class="pre">python</span></tt>.</p>
-<div class="section">
-<h2><a class="toc-backref" href="#id29" id="python-configuration-parameters" name="python-configuration-parameters">7.1&nbsp;&nbsp;&nbsp;Python Configuration Parameters</a></h2>
-<dl class="docutils">
-<dt>version</dt>
-<dd>the version of Python to use.  Should be in Major.Minor
-format, for example, <tt class="docutils literal"><span class="pre">2.3</span></tt>.  Do not include the subminor
-version (i.e. <em>not</em> <tt class="docutils literal"><span class="pre">2.5.1</span></tt>).  If you have multiple Python
-versions installed, the version will usually be the only
-additional argument required.</dd>
-<dt>cmd-or-prefix</dt>
-<dd>preferably, a command that invokes a Python
-interpreter.  Alternatively, the installation prefix for Python
-libraries and header files.  Use the alternative formulation if
-there is no appropriate Python executable available.</dd>
-<dt>includes</dt>
-<dd>the <tt class="docutils literal"><span class="pre">#include</span></tt> path for Python headers.</dd>
-<dt>libraries</dt>
-<dd>the path to Python library binaries.  On MacOS/Darwin,
-you can also pass the path of the Python framework.</dd>
-<dt>condition</dt>
-<dd>if specified, should be a set of Boost.Build
-properties that are matched against the build configuration when
-Boost.Build selects a Python configuration to use.</dd>
-<dt>extension-suffix</dt>
-<dd>A string to append to the name of extension
-modules before the true filename extension.  You almost certainly
-don't need to use this.  Usually this suffix is only used when
-targeting a Windows debug build of Python, and will be set
-automatically for you based on the value of the
-<tt class="docutils literal"><span class="pre">&lt;python-debugging&gt;</span></tt> feature.  However, at least one Linux
-distribution (Ubuntu Feisty Fawn) has a specially configured
-<a class="reference" href="https://wiki.ubuntu.com/PyDbgBuilds">python-dbg</a> package that claims to use such a suffix.</dd>
-</dl>
-</div>
-<div class="section">
-<h2><a class="toc-backref" href="#id30" id="examples" name="examples">7.2&nbsp;&nbsp;&nbsp;Examples</a></h2>
-<p>Note that in the examples below, case and <em>especially whitespace</em> are
-significant.</p>
-<ul>
-<li><p class="first">If you have both python 2.5 and python 2.4 installed,
-<tt class="docutils literal"><span class="pre">user-config.jam</span></tt> might contain:</p>
-<pre class="literal-block">
-using python : 2.5 ;  # Make both versions of Python available
+<html>
+  <head>
+    <meta name="generator" content=
+    "HTML Tidy for Cygwin (vers 1st April 2002), see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="boost.css">
 
-using python : 2.4 ;  # To build with python 2.4, add python=2.4
-                      # to your command line.
-</pre>
-<p>The first version configured (2.5) becomes the default.  To build
-against python 2.4, add <tt class="docutils literal"><span class="pre">python=2.4</span></tt> to the <tt class="docutils literal"><span class="pre">bjam</span></tt> command line.</p>
-</li>
-<li><p class="first">If you have python installed in an unusual location, you might
-supply the path to the interpreter in the <tt class="docutils literal"><span class="pre">cmd-or-prefix</span></tt>
-parameter:</p>
-<pre class="literal-block">
-using python : : /usr/local/python-2.6-beta/bin/python ;
-</pre>
-</li>
-<li><p class="first">If you have a separate build of Python for use with a particular
-toolset, you might supply that toolset in the <tt class="docutils literal"><span class="pre">condition</span></tt>
-parameter:</p>
-<pre class="literal-block">
-using python ;  # use for most toolsets
+    <title>Boost.Python - Building and Testing</title>
+  </head>
 
-# Use with Intel C++ toolset
-using python
-     : # version
-     : c:\\Devel\\Python-2.5-IntelBuild\\PCBuild\\python # cmd-or-prefix
-     : # includes
-     : # libraries
-     : &lt;toolset&gt;intel # condition
-     ;
-</pre>
-</li>
-<li><p class="first">You can set up your user-config.jam so a bjam built under Windows
-can build/test both Windows and <a class="reference" href="http://cygwin.com">Cygwin</a> python extensions.  Just pass
-<tt class="docutils literal"><span class="pre">&lt;target-os&gt;cygwin</span></tt> in the <tt class="docutils literal"><span class="pre">condition</span></tt> parameter
-for the cygwin python installation:</p>
-<pre class="literal-block">
-# windows installation
-using python ;
+  <body link="#0000ff" vlink="#800080">
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../boost.png" border="0"></a></h3>
+        </td>
 
-# cygwin installation
-using python : : c:\\cygwin\\bin\\python2.5 : : : &lt;target-os&gt;cygwin ;
-</pre>
-<p>when you put target-os=cygwin in your build request, it should build
-with the cygwin version of python:<a class="footnote-reference" href="#flavor" id="id11" name="id11"><sup>5</sup></a></p>
-<blockquote>
-<p>bjam target-os=cygwin toolset=gcc</p>
-</blockquote>
-<p>This is supposed to work the other way, too (targeting windows
-python with a <a class="reference" href="http://cygwin.com">Cygwin</a> bjam) but it seems as though the support in
-Boost.Build's toolsets for building that way is broken at the
-time of this writing.</p>
-</li>
-<li><p class="first">Note that because of <a class="reference" href="http://zigzag.cs.msu.su/boost.build/wiki/AlternativeSelection">the way Boost.Build currently selects target
-alternatives</a>, you might have be very explicit in your build
-requests.  For example, given:</p>
-<pre class="literal-block">
-using python : 2.5 ; # a regular windows build
-using python : 2.4 : : : : &lt;target-os&gt;cygwin ;
-</pre>
-<p>building with</p>
-<pre class="literal-block">
-bjam target-os=cygwin
-</pre>
-<p>will yield an error.  Instead, you'll need to write:</p>
-<pre class="literal-block">
-bjam target-os=cygwin/python=2.4
-</pre>
-</li>
-</ul>
-</div>
-</div>
-<div class="section">
-<h1><a class="toc-backref" href="#id31" id="choosing-a-boost-python-library-binary" name="choosing-a-boost-python-library-binary">8&nbsp;&nbsp;&nbsp;Choosing a Boost.Python Library Binary</a></h1>
-<p>If—instead of letting Boost.Build construct and link withthe right
-libraries automatically—you choose to use a pre-built Boost.Python
-library, you'll need to think about which one to link with.  The
-Boost.Python binary comes in both static and dynamic flavors.  Take
-care to choose the right flavor for your application.<a class="footnote-reference" href="#naming" id="id13" name="id13"><sup>2</sup></a></p>
-<div class="section">
-<h2><a class="toc-backref" href="#id32" id="the-dynamic-binary" name="the-dynamic-binary">8.1&nbsp;&nbsp;&nbsp;The Dynamic Binary</a></h2>
-<p>The dynamic library is the safest and most-versatile choice:</p>
-<ul class="simple">
-<li>A single copy of the library code is used by all extension
-modules built with a given toolset.<a class="footnote-reference" href="#toolset-specific" id="id14" name="id14"><sup>3</sup></a></li>
-<li>The library contains a type conversion registry.  Because one
-registry is shared among all extension modules, instances of a
-class exposed to Python in one dynamically-loaded extension
-module can be passed to functions exposed in another such module.</li>
-</ul>
-</div>
-<div class="section">
-<h2><a class="toc-backref" href="#id33" id="the-static-binary" name="the-static-binary">8.2&nbsp;&nbsp;&nbsp;The Static Binary</a></h2>
-<p>It might be appropriate to use the static Boost.Python library in
-any of the following cases:</p>
-<ul class="simple">
-<li>You are <a class="reference" href="http://www.python.org/doc/current/ext/intro.html">extending</a> python and the types exposed in your
-dynamically-loaded extension module don't need to be used by any
-other Boost.Python extension modules, and you don't care if the
-core library code is duplicated among them.</li>
-<li>You are <a class="reference" href="http://www.python.org/doc/current/ext/embedding.html">embedding</a> python in your application and either:<ul>
-<li>You are targeting a Unix variant OS other than MacOS or AIX,
-where the dynamically-loaded extension modules can “see” the
-Boost.Python library symbols that are part of the executable.</li>
-<li>Or, you have statically linked some Boost.Python extension
-modules into your application and you don't care if any
-dynamically-loaded Boost.Python extension modules are able to
-use the types exposed by your statically-linked extension
-modules (and vice-versa).</li>
-</ul>
-</li>
-</ul>
-</div>
-</div>
-<div class="section">
-<h1><a class="toc-backref" href="#id34" id="notes-for-mingw-and-cygwin-with-mno-cygwin-gcc-users" name="notes-for-mingw-and-cygwin-with-mno-cygwin-gcc-users">9&nbsp;&nbsp;&nbsp;Notes for MinGW (and Cygwin with -mno-cygwin) GCC Users</a></h1>
-<p>If you are using a version of Python prior to 2.4.1 with a MinGW
-prior to 3.0.0 (with binutils-2.13.90-20030111-1), you will need to
-create a MinGW-compatible version of the Python library; the one
-shipped with Python will only work with a Microsoft-compatible
-linker. Follow the instructions in the “Non-Microsoft” section of
-the “Building Extensions: Tips And Tricks” chapter in <a class="reference" href="http://www.python.org/doc/current/inst/index.html">Installing
-Python Modules</a> to create <tt class="docutils literal"><span class="pre">libpythonXX.a</span></tt>, where <tt class="docutils literal"><span class="pre">XX</span></tt>
-corresponds to the major and minor version numbers of your Python
-installation.</p>
-<hr class="docutils" />
-<table class="docutils footnote" frame="void" id="id16" rules="none">
-<colgroup><col class="label" /><col /></colgroup>
-<tbody valign="top">
-<tr><td class="label"><a class="fn-backref" href="#id2" name="id16">[1]</a></td><td>Note that although we tested earlier versions of
-Boost.Python with Python 2.2, and we don't <em>think</em> we've done
-anything to break compatibility, this release of Boost.Python
-may not have been tested with versions of Python earlier than
-2.4, so we're not 100% sure that python 2.2 and 2.3 are
-supported.</td></tr>
-</tbody>
-</table>
-<table class="docutils footnote" frame="void" id="naming" rules="none">
-<colgroup><col class="label" /><col /></colgroup>
-<tbody valign="top">
-<tr><td class="label"><a class="fn-backref" href="#id13" name="naming">[2]</a></td><td><p class="first">Information about how to identify the
-static and dynamic builds of Boost.Python:</p>
-<ul class="simple">
-<li><a class="reference" href="../../../more/getting_started/windows.html#library-naming">on Windows</a></li>
-<li><a class="reference" href="../../../more/getting_started/unix-variants.html#library-naming">on Unix variants</a></li>
-</ul>
-<p class="last">Be sure to read this section even if your compiler supports
-auto-linking, as Boost.Python does not yet take advantage of
-that feature.</p>
-</td></tr>
-</tbody>
-</table>
-<table class="docutils footnote" frame="void" id="toolset-specific" rules="none">
-<colgroup><col class="label" /><col /></colgroup>
-<tbody valign="top">
-<tr><td class="label"><a class="fn-backref" href="#id14" name="toolset-specific">[3]</a></td><td>Because of the way most *nix platforms
-share symbols among dynamically-loaded objects, I'm not
-certainextension modules built with different compiler toolsets
-will always use different copies of the Boost.Python library
-when loaded into the same Python instance.  Not using different
-libraries could be a good thing if the compilers have compatible
-ABIs, because extension modules built with the two libraries
-would be interoperable.  Otherwise, it could spell disaster,
-since an extension module and the Boost.Python library would
-have different ideas of such things as class layout. I would
-appreciate someone doing the experiment to find out what
-happens.</td></tr>
-</tbody>
-</table>
-<table class="docutils footnote" frame="void" id="overwrite" rules="none">
-<colgroup><col class="label" /><col /></colgroup>
-<tbody valign="top">
-<tr><td class="label"><a class="fn-backref" href="#id7" name="overwrite">[4]</a></td><td><tt class="docutils literal"><span class="pre">configure</span></tt> overwrites the existing
-<tt class="docutils literal"><span class="pre">user-config.jam</span></tt> in your home directory
-(if any) after making a backup of the old version.</td></tr>
-</tbody>
-</table>
-<table class="docutils footnote" frame="void" id="flavor" rules="none">
-<colgroup><col class="label" /><col /></colgroup>
-<tbody valign="top">
-<tr><td class="label"><a class="fn-backref" href="#id11" name="flavor">[5]</a></td><td>Note that the <tt class="docutils literal"><span class="pre">&lt;target-os&gt;cygwin</span></tt> feature is
-different from the <tt class="docutils literal"><span class="pre">&lt;flavor&gt;cygwin</span></tt> subfeature of the <tt class="docutils literal"><span class="pre">gcc</span></tt>
-toolset, and you might need handle both explicitly if you also
-have a MinGW GCC installed.</td></tr>
-</tbody>
-</table>
-<table class="docutils footnote" frame="void" id="user-config-jam" rules="none">
-<colgroup><col class="label" /><col /></colgroup>
-<tbody valign="top">
-<tr><td class="label"><a class="fn-backref" href="#id9" name="user-config-jam">[6]</a></td><td>Create the <tt class="docutils literal"><span class="pre">user-config.jam</span></tt> file if you don't
-already have one.</td></tr>
-</tbody>
-</table>
-<table class="docutils footnote" frame="void" id="home-dir" rules="none">
-<colgroup><col class="label" /><col /></colgroup>
-<tbody valign="top">
-<tr><td class="label"><a name="home-dir">[7]</a></td><td><em>(<a class="fn-backref" href="#id5">1</a>, <a class="fn-backref" href="#id8">2</a>)</em> <p>Windows users, your home directory can be
-found by typing:</p>
-<pre class="literal-block">
-ECHO %HOMEDRIVE%%HOMEPATH%
-</pre>
-<p class="last">into a <a class="reference" href="../../../more/getting_started/windows.html#or-build-from-the-command-prompt">Windows command prompt</a></p>
-</td></tr>
-</tbody>
-</table>
-</div>
-</div>
-<div class="footer">
-<hr class="footer" />
-<a class="reference" href="./building.rst">View document source</a>.
-Generated on: 2007-04-05 20:04 UTC.
-Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+        <td valign="top">
+          <h1 align="center"><a href="index.html">Boost.Python</a></h1>
 
-</div>
-</body>
+          <h2 align="center">Building and Testing</h2>
+        </td>
+      </tr>
+    </table>
+    <hr>
+
+    <h2>Contents</h2>
+
+    <dl class="Reference">
+      <dt><a href="#requirements">Requirements</a></dt>
+
+      <dt><a href="#building">Building Boost.Python</a></dt>
+
+      <dd>
+        <dl class="index">
+          <dt><a href="#configuration">Configuration</a></dt>
+
+          <dt><a href="#cygwin_configuration">Configuration for Cygwin GCC
+          from a Windows prompt</a></dt>
+
+          <dt><a href="#results">Results</a></dt>
+
+          <dt><a href="#cygwin">Notes for Cygwin GCC Users</a></dt>
+
+          <dt><a href="#mingw">Notes for MinGW (and Cygwin with -mno-cygwin)
+          GCC Users</a></dt>
+
+          <dt><a href="#testing">Testing</a></dt>
+        </dl>
+      </dd>
+
+      <dt><a href="#building_ext">Building your Extension Module</a></dt>
+
+      <dt><a href="#variants">Build Variants</a></dt>
+
+      <dt><a href="#VisualStudio">Building Using the Microsoft Visual Studio
+      IDE</a></dt>
+    </dl>
+    <hr>
+
+    <h2><a name="requirements">Requirements</a></h2>
+    <b>Boost.Python</b> version 2 requires <a href=
+    "http://www.python.org/2.2">Python 2.2</a> <i>or <a href=
+    "http://www.python.org">newer</a></i>. An unsupported archive of
+    Boost.Python version 1, which works with versions of Python since 1.5.2,
+    is available <a href="../build/python_v1.zip">here</a>. 
+
+    <h2><a name="building">Building Boost.Python</a></h2>
+
+    <p>Normally, Boost.Python extension modules must be linked with the
+    <code>boost_python</code> shared library. In special circumstances you
+    may want to link to a static version of the <code>boost_python</code>
+    library, but if multiple Boost.Python extension modules are used
+    together, it will prevent sharing of types across extension modules, and
+    consume extra code space. To build <code>boost_python</code>, use <a
+    href="../../../tools/build/v1/build_system.htm">Boost.Build</a> in the
+    usual way from the <code>libs/python/build</code> subdirectory of your
+    boost installation (if you have already built boost from the top level
+    this may have no effect, since the work is already done).</p>
+
+    <h3><a name="configuration">Basic Configuration</a></h3> You may
+    need to configure the following variables to point Boost.Build at
+    your Python installation.  Variables can be either set in the
+    environment or passed on the <code>bjam</code> command-line
+    as <code>-s</code><i>name</i><code>=</code><i>value</i>.  Variable
+    names are case-sensitive.
+
+    <table border="1" summary="build configuration variables">
+      <tr>
+        <th>Variable Name</th>
+
+        <th>Semantics</th>
+
+        <th>Default</th>
+
+        <th>Notes</th>
+      </tr>
+
+      <tr>
+      <tr>
+        <td><code>PYTHON_VERSION</code></td>
+
+        <td>The The 2-part python Major.Minor version number</td>
+
+        <td><code>2.4</code></td>
+
+        <td>Be sure not to include a third number, e.g. <b>not</b>
+        "<code>2.2.1</code>", even if that's the version you have.</td>
+      </tr>
+
+        <td><code>PYTHON_ROOT</code></td>
+
+        <td>The root directory of your Python installation</td>
+
+        <td>Windows:&nbsp;<code>c:/Python</code><i>(10*Version)</i>, e.g. <code>c:/Python24</code>
+<br>
+        *nix/Cygwin:&nbsp;<code>/usr</code></td>
+
+        <td>On *nix, this should be the <code>--prefix=</code> directory used
+        to configure Python when it was built and installed.</td>
+      </tr>
+
+      <tr>
+        <td><code>PYTHON_INCLUDES</code></td>
+
+        <td>path to Python <code>#include</code> directories</td>
+
+        <td>Autoconfigured from <code>PYTHON_ROOT</code>. Try the default
+        before attempting to set it yourself.</td>
+      </tr>
+
+      <tr>
+        <td><code>PYTHON_LIB_PATH</code></td>
+
+        <td>path to Python library object.</td>
+
+        <td>Autoconfigured from <code>PYTHON_ROOT</code>. Try the default
+        before attempting to set it yourself.</td>
+      </tr>
+    </table>
+
+    <h3><a name="cygwin_configuration">Configuration for Cygwin GCC from a
+    Windows prompt</a></h3>
+    The following settings may be useful when building with <a href=
+    "http://www.cygwin.com">Cygwin</a> GCC (not MinGW) from a Windows command
+    shell using a Windows build of <code>bjam</code>. <b>If
+    "<code>bjam&nbsp;-v</code>" does not report "<code>OS=NT</code>", these
+    settings do not apply to you</b>; you should use the <a href=
+    "#configuration">normal configuration</a> variables instead. They are
+    only useful when building and testing with multiple toolsets on Windows
+    using a single build command, since Cygwin GCC requires a different build
+    of Python. 
+
+    <table border="1" summary=
+    "Cygwin GCC under NT build configuration variables">
+      <tr>
+        <th>Variable Name</th>
+
+        <th>Semantics</th>
+
+        <th>Default</th>
+      </tr>
+
+      <tr>
+        <td><code>CYGWIN_PYTHON_[DEBUG_]VERSION</code></td>
+
+        <td>The version of python being used under Cygwin.</td>
+
+        <td>$(PYTHON_VERSION)</td>
+      </tr>
+
+      <tr>
+        <td><code>CYGWIN_PYTHON_[DEBUG_]ROOT</code></td>
+
+        <td>*nix-style path containing the <code>include/</code> directory
+        containing
+        <code>python$(CYGWIN_PYTHON_[DEBUG_]VERSION)/python.h</code>.</td>
+
+        <td>$(PYTHON_ROOT)</td>
+      </tr>
+
+      <tr>
+        <td><code>CYGWIN_PYTHON_[DEBUG_]LIB_PATH</code></td>
+
+        <td>path containing the user's Cygwin Python import lib
+        <code>libpython$(CYGWIN_PYTHON_[DEBUG_]VERSION).dll.a</code></td>
+
+        <td>Autoconfigured from <code>CYGWIN_PYTHON_ROOT</code></td>
+      </tr>
+
+      <tr>
+        <td><code>CYGWIN_PYTHON_[DEBUG_]DLL_PATH</code></td>
+
+        <td>path containing the user's Cygwin Python dll
+        (<code>libpython$(CYGWIN_PYTHON_[DEBUG_]VERSION).dll</code>)</td>
+
+        <td><code>/bin</code></td>
+      </tr>
+    </table>
+
+    <h3><a name="cygwin">Notes for Cygwin GCC Users</a></h3>
+
+    <p>If you are using Cygwin GCC to build extension modules, you must use a
+    Cygwin build of Python. The regular Win32 Python installation that you
+    can download from <a href="http://www.python.org">python.org</a> will not
+    work with your compiler because the dynamic linking conventions are
+    different (you can use <a href="http://www.mingw.org/">MinGW</a> GCC if
+    you want to build extension modules which are compatible with a stock
+    Win32 Python). The Cygwin installer may be able to install an appropriate
+    version of Python, or you can follow the traditional <a href=
+    "http://www.python.org/download/download_source.html">Unix installation
+    process</a> to build Python from source.</p>
+
+    <p>The special build configuration variables listed <a href=
+    "#cygwin_configuration">above</a> make it possible to use a regular Win32
+    build of bjam to build and test Boost.Python and Boost.Python extensions
+    using Cygwin GCC and targeting a Cygwin build of Python.</p>
+
+    <h3><a name="mingw">Notes for MinGW (and Cygwin with -mno-cygwin) GCC
+    Users</a></h3>
+
+    <p>If you are using a version of Python prior to 2.4.1 with a
+    MinGW prior to 3.0.0 (with binutils-2.13.90-20030111-1), you will
+    need to create a MinGW-compatible version of the Python library;
+    the one shipped with Python will only work with a
+    Microsoft-compatible linker. Follow the instructions in the
+    "Non-Microsoft" section of the "Building Extensions: Tips And Tricks"
+    chapter in <a href=
+    "http://www.python.org/doc/current/inst/index.html">Installing Python
+    Modules</a> to create <code>libpythonXX.a</code>, where <code>XX</code>
+    corresponds to the major and minor version numbers of your Python
+    installation.</p>
+
+    <h3><a name="results">Results</a></h3>
+
+    <p>The build process will create a
+    <code>libs/python/build/bin-stage</code> subdirectory of the boost root
+    (or of <code>$(ALL_LOCATE_TARGET)</code>, if you have set that variable),
+    containing the built libraries. The libraries are actually built to
+    unique directories for each toolset and variant elsewhere in the
+    filesystem, and copied to the <code>bin-stage</code> directory as a
+    convenience, so if you build with multiple toolsets at once, the product
+    of later toolsets will overwrite that of earlier toolsets in
+    <code>bin-stage</code>.</p>
+
+    <h3><a name="testing">Testing</a></h3>
+
+    <p>To build and test Boost.Python, start from the
+    <code>libs/python/test</code> directory and invoke</p>
+
+    <blockquote>
+<pre>
+bjam -sTOOLS=<i><a href=
+"../../../more/getting_started.html#Tools">toolset</a></i> test
+</pre>
+    </blockquote>
+    This will update all of the Boost.Python v1 test and example targets. The
+    tests are relatively verbose by default. To get less-verbose output, you
+    might try 
+
+    <blockquote>
+<pre>
+bjam -sTOOLS=<i><a href=
+"../../../more/getting_started.html#Tools">toolset</a></i> -sPYTHON_TEST_ARGS= test
+</pre>
+    </blockquote>
+    By default, <code>PYTHON_TEST_ARGS</code> is set to <code>-v</code>.
+
+    <h2><a name="building_ext">Building your Extension Module</a></h2>
+    Though there are other approaches, the smoothest and most reliable way to
+    build an extension module using Boost.Python is with Boost.Build. If you
+    have to use another build system, you should use Boost.Build at least
+    once with the "<code><b>-n</b></code>" option so you can see the
+    command-lines it uses, and replicate them. You are likely to run into
+    compilation or linking problems otherwise. 
+
+    <p>The files required to build a Boost.Python extension module using bjam
+    are the "local" files <tt>Jamfile</tt>, <tt>Jamrules</tt>, and
+    <tt>boost_build.jam</tt>, and the <tt>boost/</tt>
+    and <tt>tools/build/v1/</tt> subdirectories of your Boost
+    tree. The latter directory contains the source code of the
+    Boost.Build system, which is used to generate the correct build
+    commands for your extension module.  The '<tt>v1</tt>' refers to
+    Boost.Build version 1. Version 2 is pre-release and currently not
+    ready for general use.
+
+    <p>
+    The <tt>libs/python/example/</tt> project we're going to build is
+    set up to automatically rebuild the Boost.Python library in place
+    whenever it's out-of-date rather than just reusing an existing
+    library, so you'll also need the Boost.Python library sources in
+    <tt>boost/python/src/</tt>.
+    </p>
+
+    <blockquote>
+      <b>Note:</b> Third-party package and distribution maintainers
+      for various operating systems sometimes split up Boost's
+      structure or omit parts of it, so if you didn't download an
+      official <a href=
+    "http://sourceforge.net/project/showfiles.php?group_id=7586">Boost
+    release</a> you might want to <a href=
+      "http://cvs.sourceforge.net/viewcvs.py/boost/boost/">browse our CVS
+      structure</a> to make sure you have everything you need, and in the
+      right places.
+    </blockquote>
+
+    <p>The <code>libs/python/example</code>
+    subdirectory of your boost installation contains a small example which
+    builds and tests two extensions. To build your own extensions copy the
+    example subproject and make the following two edits:</p>
+
+    <ol>
+      <li>
+        <code><a href=
+        "../example/boost-build.jam"><b>boost-build.jam</b></a></code> - edit
+        the line which reads 
+
+        <blockquote>
+<pre>
+boost-build ../../../tools/build/v1 ;
+</pre>
+        </blockquote>
+        so that the path refers to the <code>tools/build/v1</code>
+        subdirectory of your Boost installation. 
+      </li>
+
+      <li>
+        <code><a href="../example/Jamrules"><b>Jamrules</b></a></code> - edit
+        the line which reads 
+
+        <blockquote>
+<pre>
+path-global BOOST_ROOT : ../../.. ;
+</pre>
+        </blockquote>
+        so that the path refers to the root directory of your Boost
+        installation.
+      </li>
+    </ol>
+
+    <p>The instructions <a href="#testing">above</a> for testing Boost.Python
+    apply equally to your new extension modules in this subproject.</p>
+
+    <h2><a name="variants">Build Variants</a></h2>
+    Three <a href=
+    "../../../tools/build/v1/build_system.htm#variants">variant</a>
+    configurations of all python-related targets are supported, and can be
+    selected by setting the <code><a href=
+    "../../../tools/build/v1/build_system.htm#user_globals">BUILD</a></code>
+    variable: 
+
+    <ul>
+      <li><code>release</code> (optimization, <tt>-DNDEBUG</tt>)</li>
+
+      <li><code>debug</code> (no optimization <tt>-D_DEBUG</tt>)</li>
+
+      <li><code>debug-python</code> (no optimization, <tt>-D_DEBUG
+      -DBOOST_DEBUG_PYTHON</tt>)</li>
+    </ul>
+
+    <p>The first two variants of the <code>boost_python</code> library are
+    built by default, and are compatible with the default Python
+    distribution. The <code>debug-python</code> variant corresponds to a
+    specially-built debugging version of Python. On *nix platforms, this
+    python is built by adding <code>--with-pydebug</code> when configuring
+    the Python build. On Windows, the debugging version of Python is
+    generated by the "Win32 Debug" target of the <code>PCBuild.dsw</code>
+    Visual C++ 6.0 project in the <code>PCBuild</code> subdirectory of your
+    Python distribution. Extension modules built with Python debugging
+    enabled are <b>not link-compatible</b> with a non-debug build of Python.
+    Since few people actually have a debug build of Python (it doesn't come
+    with the standard distribution), the normal <code>debug</code> variant
+    builds modules which are compatible with ordinary Python.</p>
+
+    <p>On many windows compilers, when extension modules are built with
+    <tt>-D_DEBUG</tt>, Python defaults to <i>force</i> linking with a special
+    debugging version of the Python DLL. Since this debug DLL isn't supplied
+    with the default Python installation for Windows, Boost.Python uses
+    <tt><a href=
+    "../../../boost/python/detail/wrap_python.hpp">boost/python/detail/wrap_python.hpp</a></tt>
+    to temporarily undefine <tt>_DEBUG</tt> when <tt>Python.h</tt> is
+    <tt>#include</tt>d - unless <code>BOOST_DEBUG_PYTHON</code> is
+    defined.</p>
+
+    <p>If you want the extra runtime checks available with the debugging
+    version of the library, <tt>#define BOOST_DEBUG_PYTHON</tt> to re-enable
+    python debuggin, and link with the <code>debug-python</code> variant of
+    <tt>boost_python</tt>.</p>
+
+    <p>If you do not <tt>#define BOOST_DEBUG_PYTHON</tt>, be sure that any
+    source files in your extension module <tt>#include&nbsp;&lt;<a href=
+    "../../../boost/python/detail/wrap_python.hpp">boost/python/detail/wrap_python.hpp</a>&gt;</tt>
+    instead of the usual <tt>Python.h</tt>, or you will have link
+    incompatibilities.<br>
+    </p>
+
+    <h2><a name="VisualStudio">Building Using the Microsoft Visual Studio
+    IDE</a></h2>
+
+    <p>For the those of you who feel more comfortable in the IDE world, a
+    workspace and project file have been included in the <code>
+    libs/python/build/VisualStudio</code> subdirectory.
+    It builds release and debug versions of the Boost.Python libraries and
+    places them and the same directory as Jamfile build does, though the
+    intermediate object files are placed in a different directory. The files
+    have been created using Microsoft Visual C++ version 6, but they should
+    work for later versions as well. You will need to tell the IDE where to
+    find the Python <code>Include/</code> and <code>Libs/</code> directories.
+    Under <b>Tools&gt;Options&gt;Directories</b>, add an entry for the Python
+    include dir (i.e. <code>c:/Python22/Include</code>), and one for the Lib
+    (i.e. <code>c:/Python/Libs</code>. Make sure it is <code>Libs</code> with
+    an "<code>s</code>" and not just <code>Lib</code>).</p>
+
+    <h3>Using the IDE for your own projects</h3>
+
+    <p>Building your own projects using the IDE is slightly more complicated.
+    Firstly, you need to make sure that the project you create as the right
+    kind. It should be a "Win32 Dynamic-Link Library". The default one that
+    Visual Studio 6 creates needs some modifications: turn on RTTI, and
+    change the debug and release builds to use the respective debug and
+    release Multithreaded DLL versions. You should probably turn off
+    incremental linking too -- I believe it a bit flaky. If you do this, then
+    change the "Debug Info" to "Program Database" to get rid of the Edit and
+    Continue warning.</p>
+
+    <p>You'll need to add the Boost root directory under
+    <b>Tools&gt;Options&gt;Directories</b> to get your code compiling. To
+    make it link, add the above <code>boost_python.dsp</code> file to your
+    workspace, and make your project depend upon it (under
+    <b>Project&gt;Dependencies</b>). You should be able to build now.</p>
+
+    <p>Lastly, go to the <b>Project Settings&gt;Debug</b> Page and add the
+    <code>Python.exe</code> as the executable for the project. Set a startup
+    directory, and make sure that your current project's output dll, the
+    <code>boost_python.dll</code> and the <code>python22.dll</code> are on
+    the current <code>PATH</code>. If you have a python script that tests
+    your dll, then add it in the "Program Arguments". Now, if all went well,
+    you should be able to hit the Run (F5) button, and debug your code.</p>
+
+    <blockquote>
+      <em>The Visual Studio project files are graciously contributed and
+        maintained by <a href="mailto:brett.calcott@gmail.com">Brett
+      Calcott</a></em>.
+    </blockquote>
+    <hr>
+
+    <p>&copy; Copyright David Abrahams 2002-2004. Permission to copy,
+    use, modify, sell and distribute this document is granted provided
+    this copyright notice appears in all copies. This document is
+    provided ``as is'' without express or implied warranty, and with
+    no claim as to its suitability for any purpose.</p>
+
+    <p>Updated: 13 April 2004 (David Abrahams)</p>
+  </body>
 </html>
+

doc/building.rst

@@ -1,404 +0,0 @@
-.. Copyright David Abrahams 2006. Distributed under the Boost
-.. Software License, Version 1.0. (See accompanying
-.. file LICENSE_1_0.txt or copy at
-.. http://www.boost.org/LICENSE_1_0.txt)
-
-==============================================
- |(logo)|__ Boost.Python Build and Test HOWTO
-==============================================
-
-.. |(logo)| image:: ../boost.png
-   :alt: Boost C++ Libraries:
-   :class: boost-logo
-
-__ ../index.htm
-
-
-.. section-numbering::
-   :depth: 2
-
-.. contents:: Contents
-   :depth: 2
-   :class: sidebar small
-
-.. |newer| replace:: *newer*
-
-Requirements
-============
-
-Boost.Python requires `Python 2.2`_ [#2.2]_ *or* |newer|__.  
-
-.. _Python 2.2: http://www.python.org/2.2
-__ http://www.python.org
-
-No-Install Quickstart
-=====================
-
-There is no need to install Boost in order to get started using
-Boost.Python.  These instructions use Boost.Build_ projects,
-which will build those binaries as soon as they're needed.  Your
-first tests may take a little longer while you wait for
-Boost.Python to build, but doing things this way will save you from
-worrying about build intricacies like which library binaries to use
-for a specific compiler configuration.
-
-.. Note:: Of course it's possible to use other build systems to
-   build Boost.Python and its extensions, but they are not
-   officially supported by Boost.  Moreover **99% of all “I can't
-   build Boost.Python” problems come from trying to use another
-   build system**.
-
-   If you want to use another system anyway, we suggest that you
-   follow these instructions, and then invoke ``bjam`` with the
-   ``-a -o``\ *filename* option to dump the build commands it executes
-   to a file, so you can see what your build system needs to do.
-
-1. Get Boost; see sections 1 and 2 of the Boost `Getting Started Guide`_.
-2. Get the ``bjam`` build driver.  See sections 5.2.1-5.2.3 of the
-   Boost `Getting Started Guide`_.
-3. cd into the ``libs/python/test/example`` directory.   
-
-.. _Getting Started Guide: ../../../more/getting_started/index.html
-
-
-Background
-==========
-
-There are two basic models for combining C++ and Python:
-
-- extending_, in which the end-user launches the Python interpreter
-  executable and imports Python “extension modules” written in C++.
-  Think of taking a library written in C++ and giving it a Python
-  interface so Python programmers can use it.  From Python, these
-  modules look just like regular Python modules.
-
-- embedding_, in which the end-user launches a program written
-  in C++ that in turn invokes the Python interpreter as a library
-  subroutine.  Think of adding scriptability to an existing
-  application.
-
-.. _extending: http://www.python.org/doc/current/ext/intro.html
-.. _embedding: http://www.python.org/doc/current/ext/embedding.html
-
-The key distinction between extending and embedding is the location
-of C++' ``main()`` function: in the Python interpreter executable,
-or in some other program, respectively.  Note that even when
-embedding Python in another program, `extension modules are often
-the best way to make C/C++ functionality accessible to Python
-code`__, so the use of extension modules is really at the heart of
-both models.
-
-__ http://www.python.org/doc/current/ext/extending-with-embedding.html
-
-Except in rare cases, extension modules are built as
-dynamically-loaded libraries with a single entry point, which means
-you can change them without rebuilding either the other extension
-modules or the executable containing ``main()``.
-
-Getting Boost.Python Binaries
-=============================
-
-Since Boost.Python is a separately-compiled (as opposed to
-`header-only`_) library, its user relies on the services of a
-Boost.Python library binary.  
-
-.. _header-only: ../../../more/getting_started/windows.html#header-only-libraries
-
-Installing Boost.Python on your System
---------------------------------------
-
-If you need a regular, installation of the Boost.Python library
-binaries on your system, the Boost `Getting Started Guide`_ will
-walk you through the steps of installing one.  If building binaries
-from source, you might want to supply the ``--with-python``
-argument to ``bjam`` (or the ``--with-libraries=python`` argument
-to ``configure``), so only the Boost.Python binary will be built,
-rather than all the Boost binaries.
-
-Configuring Boost.Build
-=======================
-
-As described in the `Boost.Build reference manual`__, a file called
-``user-config.jam`` in your home
-directory [#home-dir]_ is used to
-describe the build resources available to the build system.  You'll
-need to tell it about your Python installation.
-
-__ http://www.boost.orgdoc/html/bbv2/advanced.html#bbv2.advanced.configuration
-
-.. Admonition:: Users of Unix-Variant OSes
-
-   If you are using a unix-variant OS and you ran Boost's
-   ``configure`` script, it may have generated a
-   ``user-config.jam`` for you. [#overwrite]_ If your ``configure``\
-   /\ ``make`` sequence was successful and Boost.Python binaries
-   were built, your ``user-config.jam`` file is probably already
-   correct.
-
-If you have a fairly “standard” python installation for your
-platform, there's very little you need to do to describe it.
-Simply having ::
-
-  
-  import toolset : using ; 
-  using python ;
-
-in a ``user-config.jam`` file in your home directory [#home-dir]_ 
-should be enough. [#user-config.jam]_  For more complicated setups,
-see `Advanced Configuration`_.
-
-.. Note:: You might want to pass the ``--debug-configuration``
-   option to ``bjam`` the first few times you invoke it, to make
-   sure that Boost.Build is correctly locating all the parts of
-   your Python installation.  If it isn't, consider passing some of
-   the optional `Python configuration parameters`_ detailed below.
-
-Building an Extension Module
-============================
-
-
-Testing
-=======
-
-
-Advanced Configuration
-======================
-
-If you have several versions of Python installed, or Python is
-installed in an unusual way, you may want to supply any or all of
-the following optional parameters to ``using python``.
-
-Python Configuration Parameters
--------------------------------
-
-version
-  the version of Python to use.  Should be in Major.Minor
-  format, for example, ``2.3``.  Do not include the subminor
-  version (i.e. *not* ``2.5.1``).  If you have multiple Python
-  versions installed, the version will usually be the only
-  additional argument required.
-
-cmd-or-prefix
-  preferably, a command that invokes a Python
-  interpreter.  Alternatively, the installation prefix for Python
-  libraries and header files.  Use the alternative formulation if
-  there is no appropriate Python executable available.
-
-includes
-  the ``#include`` path for Python headers. 
-
-libraries
-  the path to Python library binaries.  On MacOS/Darwin,
-  you can also pass the path of the Python framework.
-
-condition
-  if specified, should be a set of Boost.Build
-  properties that are matched against the build configuration when
-  Boost.Build selects a Python configuration to use.  
-
-extension-suffix
-  A string to append to the name of extension
-  modules before the true filename extension.  You almost certainly
-  don't need to use this.  Usually this suffix is only used when
-  targeting a Windows debug build of Python, and will be set
-  automatically for you based on the value of the
-  ``<python-debugging>`` feature.  However, at least one Linux
-  distribution (Ubuntu Feisty Fawn) has a specially configured
-  `python-dbg`__ package that claims to use such a suffix.
-
-__ https://wiki.ubuntu.com/PyDbgBuilds
-
-
-Examples
---------
-
-Note that in the examples below, case and *especially whitespace* are
-significant.
-
-- If you have both python 2.5 and python 2.4 installed,
-  ``user-config.jam`` might contain::
-  
-    using python : 2.5 ;  # Make both versions of Python available 
-
-    using python : 2.4 ;  # To build with python 2.4, add python=2.4 
-                          # to your command line.
-
-  The first version configured (2.5) becomes the default.  To build
-  against python 2.4, add ``python=2.4`` to the ``bjam`` command line.
-
-- If you have python installed in an unusual location, you might
-  supply the path to the interpreter in the ``cmd-or-prefix``
-  parameter::
-
-    using python : : /usr/local/python-2.6-beta/bin/python ;
-
-- If you have a separate build of Python for use with a particular
-  toolset, you might supply that toolset in the ``condition``
-  parameter::
-
-    using python ;  # use for most toolsets
-    
-    # Use with Intel C++ toolset
-    using python 
-         : # version
-         : c:\\Devel\\Python-2.5-IntelBuild\\PCBuild\\python # cmd-or-prefix
-         : # includes
-         : # libraries
-         : <toolset>intel # condition
-         ;
-
-- You can set up your user-config.jam so a bjam built under Windows 
-  can build/test both Windows and Cygwin_ python extensions.  Just pass
-  ``<target-os>cygwin`` in the ``condition`` parameter
-  for the cygwin python installation::
-
-    # windows installation
-    using python ;
-
-    # cygwin installation
-    using python : : c:\\cygwin\\bin\\python2.5 : : : <target-os>cygwin ;
-
-  when you put target-os=cygwin in your build request, it should build
-  with the cygwin version of python: [#flavor]_
-
-    bjam target-os=cygwin toolset=gcc 
-
-  This is supposed to work the other way, too (targeting windows
-  python with a Cygwin_ bjam) but it seems as though the support in
-  Boost.Build's toolsets for building that way is broken at the
-  time of this writing.
-
-- Note that because of `the way Boost.Build currently selects target
-  alternatives`__, you might have be very explicit in your build
-  requests.  For example, given::
-
-    using python : 2.5 ; # a regular windows build
-    using python : 2.4 : : : : <target-os>cygwin ;
-
-  building with ::
-
-    bjam target-os=cygwin
-
-  will yield an error.  Instead, you'll need to write::
-
-    bjam target-os=cygwin/python=2.4
-
-.. _Cygwin: http://cygwin.com
-
-__ http://zigzag.cs.msu.su/boost.build/wiki/AlternativeSelection
-
-Choosing a Boost.Python Library Binary
-======================================
-
-If—instead of letting Boost.Build construct and link withthe right
-libraries automatically—you choose to use a pre-built Boost.Python
-library, you'll need to think about which one to link with.  The
-Boost.Python binary comes in both static and dynamic flavors.  Take
-care to choose the right flavor for your application. [#naming]_
-
-The Dynamic Binary
-------------------
-
-The dynamic library is the safest and most-versatile choice:
-
-- A single copy of the library code is used by all extension
-  modules built with a given toolset. [#toolset-specific]_
-
-- The library contains a type conversion registry.  Because one
-  registry is shared among all extension modules, instances of a
-  class exposed to Python in one dynamically-loaded extension
-  module can be passed to functions exposed in another such module.
-
-The Static Binary
------------------
-
-It might be appropriate to use the static Boost.Python library in
-any of the following cases:
-
-- You are extending_ python and the types exposed in your
-  dynamically-loaded extension module don't need to be used by any
-  other Boost.Python extension modules, and you don't care if the
-  core library code is duplicated among them.
-
-- You are embedding_ python in your application and either:
-
-  - You are targeting a Unix variant OS other than MacOS or AIX,
-    where the dynamically-loaded extension modules can “see” the
-    Boost.Python library symbols that are part of the executable.
-
-  - Or, you have statically linked some Boost.Python extension
-    modules into your application and you don't care if any
-    dynamically-loaded Boost.Python extension modules are able to
-    use the types exposed by your statically-linked extension
-    modules (and vice-versa).
-
-Notes for MinGW (and Cygwin with -mno-cygwin) GCC Users
-=======================================================
-
-If you are using a version of Python prior to 2.4.1 with a MinGW
-prior to 3.0.0 (with binutils-2.13.90-20030111-1), you will need to
-create a MinGW-compatible version of the Python library; the one
-shipped with Python will only work with a Microsoft-compatible
-linker. Follow the instructions in the “Non-Microsoft” section of
-the “Building Extensions: Tips And Tricks” chapter in `Installing
-Python Modules`__ to create ``libpythonXX.a``, where ``XX``
-corresponds to the major and minor version numbers of your Python
-installation.
-
-__ http://www.python.org/doc/current/inst/index.html
-
------------------------------
-
-.. [#2.2] Note that although we tested earlier versions of
-   Boost.Python with Python 2.2, and we don't *think* we've done
-   anything to break compatibility, this release of Boost.Python
-   may not have been tested with versions of Python earlier than
-   2.4, so we're not 100% sure that python 2.2 and 2.3 are
-   supported.
-
-.. [#naming] Information about how to identify the
-   static and dynamic builds of Boost.Python:
-
-   * `on Windows`__
-   * `on Unix variants`__
-
-   __ ../../../more/getting_started/windows.html#library-naming
-   __ ../../../more/getting_started/unix-variants.html#library-naming
-
-   Be sure to read this section even if your compiler supports
-   auto-linking, as Boost.Python does not yet take advantage of
-   that feature.
-
-.. [#toolset-specific] Because of the way most \*nix platforms
-   share symbols among dynamically-loaded objects, I'm not
-   certainextension modules built with different compiler toolsets
-   will always use different copies of the Boost.Python library
-   when loaded into the same Python instance.  Not using different
-   libraries could be a good thing if the compilers have compatible
-   ABIs, because extension modules built with the two libraries
-   would be interoperable.  Otherwise, it could spell disaster,
-   since an extension module and the Boost.Python library would
-   have different ideas of such things as class layout. I would
-   appreciate someone doing the experiment to find out what
-   happens.
-
-.. [#overwrite] ``configure`` overwrites the existing
-   ``user-config.jam`` in your home directory
-   (if any) after making a backup of the old version.
-
-.. [#flavor] Note that the ``<target-os>cygwin`` feature is
-   different from the ``<flavor>cygwin`` subfeature of the ``gcc``
-   toolset, and you might need handle both explicitly if you also
-   have a MinGW GCC installed.
-
-.. [#user-config.jam] Create the ``user-config.jam`` file if you don't
-   already have one.  
-
-.. [#home-dir] Windows users, your home directory can be
-   found by typing::
-
-     ECHO %HOMEDRIVE%%HOMEPATH%
-
-   into a `Windows command prompt`__
-
-__ ../../../more/getting_started/windows.html#or-build-from-the-command-prompt

doc/index.html

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

doc/news.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
   <meta name="generator" content=
@@ -32,43 +29,7 @@
   <hr>
 
   <dl class="page-index">
-    <dt>Current SVN</dt>
-
-    <dd>
-      <ul>
-        <li>Pythonic signatures are now automatically appended to the
-        docstrings.
-
-        <li>Use <a href="v2/docstring_options.html"
-        ><code>docstring_options.hpp</code></a> header 
-        control the content of docstrings.
-	
-	<li>This new feature increases the size of the modules by about 14%.
-        If this is not acceptable it can be turned off by defining the macro
-        BOOST_PYTHON_NO_PY_SIGNATURES. Modules compiled with and without the macro
-        defined are compatible.
-        </li>
-	<li> If BOOST_PYTHON_NO_PY_SIGNATURES is undefined, this version defines the 
-        macro BOOST_PYTHON_SUPPORTS_PY_SIGNATURES. This allows writing code that will compile
-        with older version of Boost.Python (see <a href="v2/pytype_function.html#examples">here</a>).
-        </li>
-	<li>By defining BOOST_PYTHON_PY_SIGNATURES_PROPER_INIT_SELF_TYPE, and at a cost
-        of another 14% size increase, proper pythonic type is generated for the "self"
-        parameter of the __init__ methods.
-        </li>
-        
-        <li> To support this new feature changes were made to the 
-        <a href="v2/to_python_converter.html"><code>to_python_converter.hpp</code></a>, 
-        <a href="v2/default_call_policies.html"><code>default_call_policies</code></a>,
-        <a href="v2/ResultConverter.html"><code>ResultConverter</code></a>,
-        <a href="v2/CallPolicies.html"><code>CallPolicies</code></a> and some others.
-        Efforts were made not to have interface breaking changes. 
-        </li>
-
-      </ul>
-    </dd>
-
-    <dt>12 May 2007 - 1.34.0 release</dt>
+    <dt>Current CVS</dt>
 
     <dd>
       <ul>
@@ -78,12 +39,6 @@
         <li>New <a href="v2/docstring_options.html"
         ><code>docstring_options.hpp</code></a> header to
         control the content of docstrings.
-
-        <li>Support for converting <code>void*</code> to/from python,
-        with <code><a
-        href="v2/opaque.html">opaque_pointer_converter</a></code>
-        as the return value policy.  Thanks to Niall Douglas for the
-        initial patch.
       </ul>
     </dd>
 
@@ -255,7 +210,7 @@ BOOST_PYTHON_MODULE(test)
 
     <dd><a href="mailto:Gottfried.Ganssauge-at-haufe.de">Gottfried
     Gan&szlig;auge</a> has contributed <a href=
-    "v2/opaque.html">opaque pointer support</a>.<br>
+    "v2/opaque_pointer_converter.html">opaque pointer support</a>.<br>
     <a href="mailto:nicodemus-at-globalite.com.br">Bruno da Silva de
     Oliveira</a> has contributed the exciting <a href=
     "../pyste/index.html">Pyste</a> ("Pie-steh") package.</dd>

doc/polymorphism.txt

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

doc/projects.html

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

doc/support.html

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

doc/tutorial/doc/Jamfile.v2

@@ -1,6 +1,3 @@
-# Copyright Joel de Guzman 2006. Distributed under the Boost
-# Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 project boost/libs/python/doc/tutorial/doc ;
 
 import boostbook : boostbook ;

doc/tutorial/doc/html/boostbook.css

@@ -23,24 +23,23 @@
 
     p 
     {
-        text-align: left;
-        font-size: 10pt; 
-        line-height: 1.15;
+        text-align: justify;
+        font-size: 11pt; 
+        line-height: 1.2;
     }
 
 /*=============================================================================
     Program listings
 =============================================================================*/
 
-    /* Code on paragraphs */
-    p tt.computeroutput
+    tt.computeroutput
     {
-        font-size: 9pt;
+        font-size: 10pt;
     }
 
     pre.synopsis
     {
-        font-size: 90%;
+        font-size: 10pt;
         margin: 1pc 4% 0pc 4%;
         padding: 0.5pc 0.5pc 0.5pc 0.5pc;
     }
@@ -48,36 +47,32 @@
     .programlisting, 
     .screen
     {
-        font-size: 9pt;
+        font-size: 10pt;
         display: block;
         margin: 1pc 4% 0pc 4%;
         padding: 0.5pc 0.5pc 0.5pc 0.5pc;
     }
 
-    /* Program listings in tables don't get borders */
-    td .programlisting, 
-    td .screen
-    {
-        margin: 0pc 0pc 0pc 0pc;
-        padding:  0pc 0pc 0pc 0pc;
-    }
-
 /*=============================================================================
     Headings
 =============================================================================*/
 
-    h1, h2, h3, h4, h5, h6 
+    h1, 
+    h2, 
+    h3, 
+    h4, 
+    h5, 
+    h6 
     { 
         text-align: left; 
-        margin: 1em 0em 0.5em 0em;
-        font-weight: bold;
+        margin-top: 2pc; 
     }
 
-    h1 { font: 140% }
+    h1 { font: 170% }
     h2 { font: bold 140% }
-    h3 { font: bold 130% }
-    h4 { font: bold 120% }
-    h5 { font: italic 110% }
+    h3 { font: bold 120% }
+    h4 { font: bold 100% }
+    h5 { font: italic 100% }
     h6 { font: italic 100% }
 
     /* Top page titles */
@@ -94,41 +89,12 @@
         margin-bottom: 1pc;
     }
 
-    h1.title { font-size: 140% }
-    h2.title { font-size: 140% }
-    h3.title { font-size: 130% }
-    h4.title { font-size: 120% }
-    h5.title { font-size: 110% }
-    h6.title { font-size: 100% }
-
-    .section h1 
-    {
-        margin: 0em 0em 0.5em 0em;
-        font-size: 140%;
-    }
-
-    .section h2 { font-size: 140% }
-    .section h3 { font-size: 130% }
-    .section h4 { font-size: 120% }
-    .section h5 { font-size: 110% }
-    .section h6 { font-size: 100% }
-
-    /* Code on titles */
-    h1 tt.computeroutput { font-size: 140% }
-    h2 tt.computeroutput { font-size: 140% }
-    h3 tt.computeroutput { font-size: 130% }
-    h4 tt.computeroutput { font-size: 120% }
-    h5 tt.computeroutput { font-size: 110% }
-    h6 tt.computeroutput { font-size: 100% }
-
-/*=============================================================================
-    Author
-=============================================================================*/
-
-    h3.author 
-    { 
-        font-size: 100% 
-    }
+    h1.title { font-size: 220% }
+    h2.title { font-size: 220% }
+    h3.title { font-size: 170% }
+    h4.title { font-size: 140% }
+    h5.title { font-size: 120% }
+    h6.title { font-size: 120% }
 
 /*=============================================================================
     Lists
@@ -136,20 +102,20 @@
 
     li
     {
-        font-size: 10pt;
+        font-size: 11pt;
         line-height: 1.3;
     }
     
     /* Unordered lists */
     ul 
     {
-        text-align: left;
+        text-align: justify;
     }
     
     /* Ordered lists */
     ol 
     {
-        text-align: left;
+        text-align: justify;
     }
 
 /*=============================================================================
@@ -193,9 +159,9 @@
     .toc
     {
        margin: 1pc 4% 0pc 4%;
-       padding: 0.1pc 1pc 0.1pc 1pc;
-       font-size: 80%; 
-       line-height: 1.15;
+       padding: 0.5pc;
+       font-size: 11pt; 
+       line-height: 1.3;
     }
     
     .boost-toc
@@ -214,6 +180,7 @@
         margin-left: 4%;
         padding-right: 0.5em; 
         padding-left: 0.5em;
+        font-size: 120%;
     }
     
     .informaltable table, 
@@ -235,8 +202,8 @@
     div.table table tr td
     {
         padding: 0.5em;
-        text-align: left;
-        font-size: 9pt;
+        text-align: justify;
+        font-size: 11pt;
     }
 
     div.informaltable table tr th, 
@@ -244,76 +211,51 @@
     {
         padding: 0.5em 0.5em 0.5em 0.5em;
         border: 1pt solid white;
-        font-size: 80%;
     }
 
 /*=============================================================================
     Blurbs
 =============================================================================*/
 
-    div.note,
-    div.tip,
-    div.important,
-    div.caution,
-    div.warning,
-    p.blurb
+    div.informaltable table tr td.blurb
     {
-        font-size: 9pt; /* A little bit smaller than the main text */
+        font-size: 10pt; /* A little bit smaller than the main text */
         line-height: 1.2;
-        display: block;
-        margin: 1pc 4% 0pc 4%;
-        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
     }
     
-    p.blurb img
+    td.blurb img
     {
         padding: 1pt;
     }
 
-/*=============================================================================
-    Variable Lists
-=============================================================================*/
-
-    /* Make the terms in definition lists bold */
-    div.variablelist dl dt,
-    span.term
-    {
-        font-weight: bold;
-        font-size: 10pt;
-    }
-
-    div.variablelist table tbody tr td
-    {
-        text-align: left;
-        vertical-align: top;
-        padding: 0em 2em 0em 0em;
-        font-size: 10pt;
-        margin: 0em 0em 0.5em 0em;
-        line-height: 1;
-    }
-
-    div.variablelist dl dt
-    {
-        margin-bottom: 0.2em;
-    }
-
-    div.variablelist dl dd
-    {
-        margin: 0em 0em 0.5em 2em;
-        font-size: 10pt;
-    }
-
-    div.variablelist table tbody tr td p,
-    div.variablelist dl dd p
-    {
-        margin: 0em 0em 0.5em 0em;
-        line-height: 1;
-    }
-
 /*=============================================================================
     Misc
 =============================================================================*/
 
+    /* Tone down the title of Parameter lists */
+    div.variablelist p.title
+    {
+        font-weight: bold;
+        font-size: 100%;
+        text-align: left;
+    }
+    
+    /* Tabularize parameter lists */
+    div.variablelist dl dt
+    {
+        float: left;
+        clear: left;
+        display: block;
+        font-style: italic;
+    }
+    
+    div.variablelist dl dd
+    {
+        display: block;
+        clear:   right;
+        padding-left: 8pc;
+    }
+
     /* Title of books and articles in bibliographies */
     span.title
     {
@@ -352,14 +294,6 @@
         {
             color: #9c5a9c;
         }
-
-        h1 a, h2 a, h3 a, h4 a, h5 a, h6 a,
-        h1 a:hover, h2 a:hover, h3 a:hover, h4 a:hover, h5 a:hover, h6 a:hover,
-        h1 a:visited, h2 a:visited, h3 a:visited, h4 a:visited, h5 a:visited, h6 a:visited
-        {
-            text-decoration: none; /* no underline */
-            color: #000000;
-        }
     
     /* Syntax Highlighting */
         .keyword        { color: #0000AA; }
@@ -388,50 +322,41 @@
     /* Program listing */
         pre.synopsis
         {
-            border: 1px solid #DCDCDC;
+            background-color: #F3F3F3;
+            border: 1pt solid #C0C0C0;
         }
     
         .programlisting, 
         .screen
         {
-            border: 1px solid #DCDCDC;
-        }
-    
-        td .programlisting, 
-        td .screen
-        {
-            border: 0px solid #DCDCDC;
+            background-color: #F3F3F3;
+            border: 1pt solid #C0C0C0;
         }
     
     /* Blurbs */
-        div.note,
-        div.tip,
-        div.important,
-        div.caution,
-        div.warning,
-        p.blurb
+        div.informaltable table tr td.blurb
         {
-            border: 1px solid #DCDCDC;
+            background-color: #FFFFF0;
+            border: 1pt solid #707070;
         }
     
     /* Table of contents */
         .toc
         {
-            border: 1px solid #DCDCDC;
+            background-color: #F3F3F3;
         }
     
     /* Tables */
         div.informaltable table tr td, 
         div.table table tr td
         {
-            border: 1px solid #DCDCDC;
+            background-color: #F0F0F0;
         }
     
         div.informaltable table tr th, 
         div.table table tr th
         {
-            background-color: #F0F0F0;
-            border: 1px solid #DCDCDC;
+            background-color: #E4E4E4;
         }
     
     /* Misc */
@@ -471,12 +396,6 @@
             border: 1px solid gray;
         }
     
-        td .programlisting, 
-        td .screen
-        {
-            border: 0px solid #DCDCDC;
-        }
-    
     /* Table of contents */
         .toc
         {

doc/tutorial/doc/html/index.html

@@ -3,13 +3,13 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Chapter 1. python 1.0</title>
 <link rel="stylesheet" href="boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.72.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
 <link rel="start" href="index.html" title="Chapter 1. python 1.0">
-<link rel="next" href="python/hello.html" title="Building Hello World">
+<link rel="next" href="python/hello.html" title=" Building Hello World">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%">
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../boost.png"></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="../../../../../../people/people.htm">People</a></td>
@@ -31,7 +31,7 @@
 <div><p class="copyright">Copyright © 2002-2005 Joel
       de Guzman, David Abrahams</p></div>
 <div><div class="legalnotice">
-<a name="id2632684"></a><p>
+<a name="id427816"></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>)
@@ -83,20 +83,20 @@
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="python.quickstart"></a>QuickStart</h2></div></div></div>
 <p>
-      The Boost Python Library is 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.
-      It is designed to wrap C++ interfaces non-intrusively, so that you should not
-      have to change the C++ code at all in order to wrap it, making Boost.Python
+      QuickStartThe Boost Python Library is 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. It is designed to wrap C++ interfaces non-intrusively, so that you
+      should not have to change the C++ code at all in order to wrap it, making Boost.Python
       ideal for exposing 3rd-party libraries to Python. The library's use of advanced
       metaprogramming techniques simplifies its syntax for users, so that wrapping
       code takes on the look of a kind of declarative interface definition language
       (IDL).
     </p>
-<a name="quickstart.hello_world"></a><h3>
-<a name="id2595112"></a>
+<a name="quickstart.hello_world"></a><h2>
+<a name="id372244"></a>
       Hello World
-    </h3>
+    </h2>
 <p>
       Following C/C++ tradition, let's start with the "hello, world". A
       C++ Function:
@@ -123,29 +123,19 @@
       That's it. We're done. We can now build this as a shared library. The resulting
       DLL is now visible to Python. Here's a sample Python session:
     </p>
-<p>
-    </p>
+<p></p>
 <pre class="programlisting">
 <span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span>
 <span class="identifier">hello</span><span class="special">,</span> <span class="identifier">world</span>
 </pre>
-<p>
-    </p>
-<div class="blockquote"><blockquote class="blockquote">
-<p>
-        </p>
-<p>
-          <span class="emphasis"><em><span class="bold"><strong>Next stop... Building your Hello World
-          module from start to finish...</strong></span></em></span>
-        </p>
-<p>
-      </p>
-</blockquote></div>
+<p></p>
+<div class="blockquote"><blockquote class="blockquote"><p><span class="emphasis"><em><span class="bold"><b>Next stop... Building your Hello World module
+        from start to finish...</b></span></em></span></p></blockquote></div>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><small><p>Last revised: May 18, 2007 at 15:46:01 GMT</p></small></td>
+<td align="left"><small><p>Last revised: October 31, 2005 at 18:46:06 GMT</p></small></td>
 <td align="right"><small></small></td>
 </tr></table>
 <hr>

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

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

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

@@ -1,17 +1,17 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Exception Translation</title>
+<title> Exception Translation</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.72.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
 <link rel="start" href="../index.html" title="Chapter 1. python 1.0">
 <link rel="up" href="../index.html" title="Chapter 1. python 1.0">
 <link rel="prev" href="iterators.html" title="Iterators">
-<link rel="next" href="techniques.html" title="General Techniques">
+<link rel="next" href="techniques.html" title=" General Techniques">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%">
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></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="../../../../../../../people/people.htm">People</a></td>
@@ -26,9 +26,10 @@
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="python.exception"></a> Exception Translation</h2></div></div></div>
 <p>
-      All C++ exceptions must be caught at the boundary with Python code. This boundary
-      is the point where C++ meets Python. Boost.Python provides a default exception
-      handler that translates selected standard exceptions, then gives up:
+      Exception TranslationAll C++ exceptions must be caught at the boundary with
+      Python code. This boundary 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>

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

@@ -1,17 +1,17 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Exposing Classes</title>
+<title> Exposing Classes</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.72.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
 <link rel="start" href="../index.html" title="Chapter 1. python 1.0">
 <link rel="up" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="prev" href="hello.html" title="Building Hello World">
+<link rel="prev" href="hello.html" title=" Building Hello World">
 <link rel="next" href="functions.html" title="Functions">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%">
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></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="../../../../../../../people/people.htm">People</a></td>
@@ -35,7 +35,7 @@
 <dt><span class="section"><a href="exposing.html#python.class_operators_special_functions">Class Operators/Special Functions</a></span></dt>
 </dl></div>
 <p>
-      Now let's expose a C++ class to Python.
+      Exposing ClassesNow let's expose a C++ class to Python.
     </p>
 <p>
       Consider a C++ class/struct that we want to expose to Python:
@@ -64,13 +64,12 @@
 <span class="special">}</span>
 </pre>
 <p>
-      Here, we wrote a C++ class wrapper that exposes the member functions <code class="literal">greet</code>
-      and <code class="literal">set</code>. Now, after building our module as a shared library,
-      we may use our class <code class="literal">World</code> in Python. Here's a sample Python
+      Here, we wrote a C++ class wrapper that exposes the member functions <tt class="literal">greet</tt>
+      and <tt class="literal">set</tt>. Now, after building our module as a shared library,
+      we may use our class <tt class="literal">World</tt> in Python. Here's a sample Python
       session:
     </p>
-<p>
-    </p>
+<p></p>
 <pre class="programlisting">
 <span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="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>
@@ -82,10 +81,10 @@
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.constructors"></a>Constructors</h3></div></div></div>
 <p>
-        Our previous example didn't have any explicit constructors. Since <code class="literal">World</code>
-        is declared as a plain struct, it has an implicit default constructor. Boost.Python
-        exposes the default constructor by default, which is why we were able to
-        write
+        ConstructorsOur previous example didn't have any explicit constructors. Since
+        <tt class="literal">World</tt> is declared as a plain struct, it has an implicit
+        default constructor. Boost.Python 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>
@@ -94,8 +93,7 @@
         We may wish to wrap a class with a non-default constructor. Let us build
         on our previous example:
       </p>
-<p>
-      </p>
+<p></p>
 <pre class="programlisting">
 <span class="keyword">struct</span> <span class="identifier">World</span>
 <span class="special">{</span>
@@ -106,9 +104,9 @@
 <span class="special">};</span>
 </pre>
 <p>
-        This time <code class="literal">World</code> has no default constructor; our previous
+        This time <tt class="literal">World</tt> has no default constructor; our previous
         wrapping code would fail to compile when the library tried to expose it.
-        We have to tell <code class="literal">class_&lt;World&gt;</code> about the constructor
+        We have to tell <tt class="literal">class_&lt;World&gt;</tt> about the constructor
         we want to expose instead.
       </p>
 <pre class="programlisting">
@@ -123,14 +121,13 @@
     <span class="special">;</span>
 <span class="special">}</span>
 </pre>
-<p>
-        <code class="literal">init&lt;std::string&gt;()</code> exposes the constructor taking
-        in a <code class="literal">std::string</code> (in Python, constructors are spelled
-        "<code class="literal">"<span class="underline">_init</span>_"</code>").
+<p><tt class="literal">init&lt;std::string&gt;()</tt> exposes the constructor taking
+        in a <tt class="literal">std::string</tt> (in Python, constructors are spelled
+        "<tt class="literal">"<span class="underline">_init</span>_"</tt>").
       </p>
 <p>
-        We can expose additional constructors by passing more <code class="literal">init&lt;...&gt;</code>s
-        to the <code class="literal">def()</code> member function. Say for example we have
+        We can expose additional constructors by passing more <tt class="literal">init&lt;...&gt;</tt>s
+        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">
@@ -142,13 +139,13 @@
 </pre>
 <p>
         On the other hand, if we do not wish to expose any constructors at all, we
-        may use <code class="literal">no_init</code> instead:
+        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>
 <p>
-        This actually adds an <code class="literal"><span class="underline">_init</span>_</code>
+        This actually adds an <tt class="literal"><span class="underline">_init</span>_</tt>
         method which always raises a Python RuntimeError exception.
       </p>
 </div>
@@ -156,10 +153,10 @@
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.class_data_members"></a>Class Data Members</h3></div></div></div>
 <p>
-        Data members may also be exposed to Python so that they can be accessed as
-        attributes of the corresponding Python class. Each data member that we wish
-        to be exposed may be regarded as <span class="bold"><strong>read-only</strong></span>
-        or <span class="bold"><strong>read-write</strong></span>. Consider this class <code class="literal">Var</code>:
+        Class Data MembersData members may also be exposed to Python so that they
+        can be accessed as attributes of the corresponding Python class. Each data
+        member that we wish 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>
@@ -170,7 +167,7 @@
 <span class="special">};</span>
 </pre>
 <p>
-        Our C++ <code class="literal">Var</code> class and its data members can be exposed
+        Our C++ <tt class="literal">Var</tt> class and its data members can be exposed
         to Python:
       </p>
 <pre class="programlisting">
@@ -182,8 +179,7 @@
         Then, in Python, assuming we have placed our Var class inside the namespace
         hello as we did before:
       </p>
-<p>
-      </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>
 <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>
@@ -191,8 +187,8 @@
 <span class="identifier">pi</span> <span class="keyword">is</span> <span class="identifier">around</span> <span class="number">3.14</span>
 </pre>
 <p>
-        Note that <code class="literal">name</code> is exposed as <span class="bold"><strong>read-only</strong></span>
-        while <code class="literal">value</code> is exposed as <span class="bold"><strong>read-write</strong></span>.
+        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
@@ -205,13 +201,13 @@
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.class_properties"></a>Class Properties</h3></div></div></div>
 <p>
-        In C++, classes with public data members are usually frowned upon. Well designed
-        classes that take advantage of encapsulation hide the class' data members.
-        The only way to access the class' data is through access (getter/setter)
-        functions. Access functions expose class properties. Here's an example:
-      </p>
-<p>
+        Class PropertiesIn C++, classes with public data members are usually frowned
+        upon. Well designed classes that take advantage of encapsulation hide the
+        class' data members. The only way to access the class' data is through access
+        (getter/setter) functions. Access functions expose class properties. Here's
+        an example:
       </p>
+<p></p>
 <pre class="programlisting">
 <span class="keyword">struct</span> <span class="identifier">Num</span>
 <span class="special">{</span>
@@ -224,7 +220,7 @@
 <p>
         However, in Python attribute access is fine; it doesn't neccessarily break
         encapsulation to let users handle attributes directly, because the attributes
-        can just be a different syntax for a method call. Wrapping our <code class="literal">Num</code>
+        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">
@@ -235,8 +231,7 @@
 <p>
         And at last, in Python:
       </p>
-<p>
-      </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>
 <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>
@@ -245,12 +240,11 @@
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">rovalue</span> <span class="special">=</span> <span class="number">2.17</span> <span class="comment"># error!
 </span></pre>
 <p>
-        Take note that the class property <code class="literal">rovalue</code> is exposed as
-        <span class="bold"><strong>read-only</strong></span> since the <code class="literal">rovalue</code>
+        Take note that the class property <tt class="literal">rovalue</tt> is exposed as
+        <span class="bold"><b>read-only</b></span> since the <tt class="literal">rovalue</tt>
         setter member function is not passed in:
       </p>
-<p>
-      </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>
@@ -259,7 +253,7 @@
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.inheritance"></a>Inheritance</h3></div></div></div>
 <p>
-        In the previous examples, we dealt with classes that are not polymorphic.
+        InheritanceIn the previous examples, we dealt with classes that are not polymorphic.
         This is not often the case. Much of the time, we will be wrapping polymorphic
         classes and class hierarchies related by inheritance. We will often have
         to write Boost.Python wrappers for classes that are derived from abstract
@@ -273,7 +267,7 @@
 <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 <code class="literal">Base</code> and <code class="literal">Derived</code>
+        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">
@@ -282,7 +276,7 @@
 <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 <code class="literal">Base</code>:
+        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>
@@ -290,8 +284,8 @@
     <span class="special">;</span>
 </pre>
 <p>
-        Now we can inform Boost.Python of the inheritance relationship between <code class="literal">Derived</code>
-        and its base class <code class="literal">Base</code>. Thus:
+        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>
@@ -307,15 +301,15 @@
           member functions)
         </li>
 <li>
-<span class="bold"><strong>If</strong></span> Base is polymorphic, <code class="literal">Derived</code>
+<span class="bold"><b>If</b></span> Base is polymorphic, <tt class="literal">Derived</tt>
           objects which have been passed to Python via a pointer or reference to
-          <code class="literal">Base</code> can be passed where a pointer or reference to
-          <code class="literal">Derived</code> is expected.
+          <tt class="literal">Base</tt> can be passed where a pointer or reference to
+          <tt class="literal">Derived</tt> is expected.
         </li>
 </ol></div>
 <p>
-        Now, we shall expose the C++ free functions <code class="literal">b</code> and <code class="literal">d</code>
-        and <code class="literal">factory</code>:
+        Now, we shall 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>
@@ -323,11 +317,11 @@
 <span class="identifier">def</span><span class="special">(</span><span class="string">"factory"</span><span class="special">,</span> <span class="identifier">factory</span><span class="special">);</span>
 </pre>
 <p>
-        Note that free function <code class="literal">factory</code> is being used to generate
-        new instances of class <code class="literal">Derived</code>. In such cases, we use
-        <code class="literal">return_value_policy&lt;manage_new_object&gt;</code> to instruct
-        Python to adopt the pointer to <code class="literal">Base</code> and hold the instance
-        in a new Python <code class="literal">Base</code> object until the the Python object
+        Note that free function <tt class="literal">factory</tt> is being used to generate
+        new instances of class <tt class="literal">Derived</tt>. In such cases, we use
+        <tt class="literal">return_value_policy&lt;manage_new_object&gt;</tt> to instruct
+        Python to adopt the pointer to <tt class="literal">Base</tt> and hold the instance
+        in a new Python <tt class="literal">Base</tt> object until the the Python object
         is destroyed. We shall see more of Boost.Python <a href="functions.html#python.call_policies" title="Call Policies">call
         policies</a> later.
       </p>
@@ -341,9 +335,9 @@
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.class_virtual_functions"></a>Class Virtual Functions</h3></div></div></div>
 <p>
-        In this section, we shall learn how to make functions behave polymorphically
-        through virtual functions. Continuing our example, let us add a virtual function
-        to our <code class="literal">Base</code> class:
+        Class Virtual FunctionsIn this section, we shall learn how to make functions
+        behave polymorphically 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>
@@ -356,11 +350,11 @@
         One of the goals of Boost.Python is to be minimally intrusive on an existing
         C++ design. In principle, it should be possible to expose the interface for
         a 3rd party library without changing it. It is not ideal to add anything
-        to our class <code class="computeroutput"><span class="identifier">Base</span></code>. Yet, when
+        to our class <tt class="computeroutput"><span class="identifier">Base</span></tt>. Yet, when
         you have a virtual function that's going to be overridden in Python and called
-        polymorphically <span class="bold"><strong>from C++</strong></span>, we'll need to
+        polymorphically <span class="bold"><b>from C++</b></span>, we'll need to
         add some scaffoldings to make things work properly. What we'll do is write
-        a class wrapper that derives from <code class="computeroutput"><span class="identifier">Base</span></code>
+        a class wrapper that derives from <tt class="computeroutput"><span class="identifier">Base</span></tt>
         that will unintrusively hook into the virtual functions so that a Python
         override may be called:
       </p>
@@ -374,52 +368,52 @@
 <span class="special">};</span>
 </pre>
 <p>
-        Notice too that in addition to inheriting from <code class="computeroutput"><span class="identifier">Base</span></code>,
-        we also multiply- inherited <code class="computeroutput"><span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span></code> (See <a href="../../../../v2/wrapper.html" target="_top">Wrapper</a>).
-        The <code class="computeroutput"><span class="identifier">wrapper</span></code> template makes
+        Notice too that in addition to inheriting from <tt class="computeroutput"><span class="identifier">Base</span></tt>,
+        we also multiply- inherited <tt class="computeroutput"><span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span></tt> (See <a href="../../../../v2/wrapper.html" target="_top">Wrapper</a>).
+        The <tt class="computeroutput"><span class="identifier">wrapper</span></tt> template makes
         the job of wrapping classes that are meant to overridden in Python, easier.
       </p>
-<div class="sidebar">
-<p class="title"><b></b></p>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/alert.png"></span> <span class="bold"><b>MSVC6/7 Workaround</b></span><br><br> If you are using
+              Microsoft Visual C++ 6 or 7, you have to write <tt class="computeroutput"><span class="identifier">f</span></tt>
+              as:<br><br><tt class="computeroutput"><span class="keyword">return</span> <span class="identifier">call</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get_override</span><span class="special">(</span><span class="string">"f"</span><span class="special">).</span><span class="identifier">ptr</span><span class="special">());</span></tt>.</td></tr></tbody>
+</table></div>
 <p>
-        <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><strong>MSVC6/7 Workaround</strong></span><br>
-        <br> If you are using Microsoft Visual C++ 6 or 7, you have to write <code class="computeroutput"><span class="identifier">f</span></code> as:<br> <br> <code class="computeroutput"><span class="keyword">return</span>
-        <span class="identifier">call</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get_override</span><span class="special">(</span><span class="string">"f"</span><span class="special">).</span><span class="identifier">ptr</span><span class="special">());</span></code>.
-      </p>
-</div>
-<p>
-        BaseWrap's overridden virtual member function <code class="computeroutput"><span class="identifier">f</span></code>
-        in effect calls the corresponding method of the Python object through <code class="computeroutput"><span class="identifier">get_override</span></code>.
+        BaseWrap's overridden virtual member function <tt class="computeroutput"><span class="identifier">f</span></tt>
+        in effect calls the corresponding method of the Python object through <tt class="computeroutput"><span class="identifier">get_override</span></tt>.
       </p>
 <p>
-        Finally, exposing <code class="computeroutput"><span class="identifier">Base</span></code>:
+        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>
     <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">pure_virtual</span><span class="special">(&amp;</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">))</span>
     <span class="special">;</span>
 </pre>
-<p>
-        <code class="computeroutput"><span class="identifier">pure_virtual</span></code> signals Boost.Python
-        that the function <code class="computeroutput"><span class="identifier">f</span></code> is a
+<p><tt class="computeroutput"><span class="identifier">pure_virtual</span></tt> signals Boost.Python
+        that the function <tt class="computeroutput"><span class="identifier">f</span></tt> is a
         pure virtual function.
       </p>
-<div class="sidebar">
-<p class="title"><b></b></p>
-<p>
-        <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> <span class="bold"><strong>member function and methods</strong></span><br>
-        <br> Python, like many object oriented languages uses the term <span class="bold"><strong>methods</strong></span>. Methods correspond roughly to C++'s <span class="bold"><strong>member functions</strong></span>
-      </p>
-</div>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/note.png"></span> <span class="bold"><b>member function and methods</b></span><br><br> Python,
+              like many object oriented languages uses the term <span class="bold"><b>methods</b></span>.
+              Methods correspond roughly to C++'s <span class="bold"><b>member functions</b></span>
+</td></tr></tbody>
+</table></div>
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.virtual_functions_with_default_implementations"></a>Virtual Functions with Default Implementations</h3></div></div></div>
 <p>
-        We've seen in the previous section how classes with pure virtual functions
-        are wrapped using Boost.Python's <a href="../../../../v2/wrapper.html" target="_top">class
-        wrapper</a> facilities. If we wish to wrap <span class="bold"><strong>non</strong></span>-pure-virtual
-        functions instead, the mechanism is a bit different.
+        Virtual Functions with Default ImplementationsWe've seen in the previous
+        section how classes with pure virtual functions are wrapped using Boost.Python's
+        <a href="../../../../v2/wrapper.html" target="_top">class wrapper</a> facilities. If
+        we wish to wrap <span class="bold"><b>non</b></span>-pure-virtual functions
+        instead, the mechanism is a bit different.
       </p>
 <p>
         Recall that in the <a href="exposing.html#python.class_virtual_functions" title="Class Virtual Functions">previous
@@ -433,8 +427,8 @@
 <span class="special">};</span>
 </pre>
 <p>
-        had a pure virtual function <code class="literal">f</code>. If, however, its member
-        function <code class="literal">f</code> was not declared as pure virtual:
+        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>
@@ -460,19 +454,17 @@
 <span class="special">};</span>
 </pre>
 <p>
-        Notice how we implemented <code class="computeroutput"><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">f</span></code>. Now,
-        we have to check if there is an override for <code class="computeroutput"><span class="identifier">f</span></code>.
-        If none, then we call <code class="computeroutput"><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">()</span></code>.
+        Notice how we implemented <tt class="computeroutput"><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">f</span></tt>. Now,
+        we have to check if there is an override for <tt class="computeroutput"><span class="identifier">f</span></tt>.
+        If none, then we call <tt class="computeroutput"><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">()</span></tt>.
       </p>
-<div class="sidebar">
-<p class="title"><b></b></p>
-<p>
-        <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><strong>MSVC6/7 Workaround</strong></span><br>
-        <br> If you are using Microsoft Visual C++ 6 or 7, you have to rewrite
-        the line with the <code class="computeroutput"><span class="special">*</span><span class="identifier">note</span><span class="special">*</span></code> as:<br> <br> <code class="computeroutput"><span class="keyword">return</span>
-        <span class="identifier">call</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*&gt;(</span><span class="identifier">f</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">());</span></code>.
-      </p>
-</div>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/alert.png"></span> <span class="bold"><b>MSVC6/7 Workaround</b></span><br><br> If you are using
+              Microsoft Visual C++ 6 or 7, you have to rewrite the line with the
+              <tt class="computeroutput"><span class="special">*</span><span class="identifier">note</span><span class="special">*</span></tt> as:<br><br><tt class="computeroutput"><span class="keyword">return</span> <span class="identifier">call</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*&gt;(</span><span class="identifier">f</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">());</span></tt>.</td></tr></tbody>
+</table></div>
 <p>
         Finally, exposing:
       </p>
@@ -482,16 +474,15 @@
     <span class="special">;</span>
 </pre>
 <p>
-        Take note that we expose both <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span></code> and <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">default_f</span></code>. Boost.Python needs to keep track
-        of 1) the dispatch function <code class="literal">f</code> and 2) the forwarding function
-        to its default implementation <code class="literal">default_f</code>. There's a special
-        <code class="literal">def</code> function for this purpose.
+        Take note that we expose both <tt class="computeroutput"><span class="special">&amp;</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span></tt> and <tt class="computeroutput"><span class="special">&amp;</span><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">default_f</span></tt>. Boost.Python needs to keep track
+        of 1) the dispatch function <tt class="literal">f</tt> and 2) the forwarding function
+        to its default implementation <tt class="literal">default_f</tt>. There's a special
+        <tt class="literal">def</tt> function for this purpose.
       </p>
 <p>
         In Python, the results would be as expected:
       </p>
-<p>
-      </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>
 <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>
@@ -501,14 +492,14 @@
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">derived</span> <span class="special">=</span> <span class="identifier">Derived</span><span class="special">()</span>
 </pre>
 <p>
-        Calling <code class="literal">base.f()</code>:
+        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>
 <span class="number">0</span>
 </pre>
 <p>
-        Calling <code class="literal">derived.f()</code>:
+        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>
@@ -518,21 +509,20 @@
 <div class="section" lang="en">
 <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><h3>
-<a name="id2646169"></a>
-        Python Operators
-      </h3>
+<a name="class_operators_special_functions.class_operators_special_functionspython_operators"></a><h2>
+<a name="id447955"></a>
+        Class Operators/Special FunctionsPython Operators
+      </h2>
 <p>
         C is well known for the abundance of operators. C++ extends this to the extremes
         by allowing operator overloading. Boost.Python takes advantage of this and
         makes it easy to wrap C++ operator-powered classes.
       </p>
 <p>
-        Consider a file position class <code class="literal">FilePos</code> and a set of operators
+        Consider a file position class <tt class="literal">FilePos</tt> and a set of operators
         that take on FilePos instances:
       </p>
-<p>
-      </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>
 
@@ -561,16 +551,16 @@
 <p>
         The code snippet above is very clear and needs almost no explanation at all.
         It is virtually the same as the operators' signatures. Just take note that
-        <code class="literal">self</code> refers to FilePos object. Also, not every class
-        <code class="literal">T</code> that you might need to interact with in an operator
-        expression is (cheaply) default-constructible. You can use <code class="literal">other&lt;T&gt;()</code>
-        in place of an actual <code class="literal">T</code> instance when writing "self
+        <tt class="literal">self</tt> refers to FilePos object. Also, not every class
+        <tt class="literal">T</tt> that you might need to interact with in an operator
+        expression is (cheaply) default-constructible. You can use <tt class="literal">other&lt;T&gt;()</tt>
+        in place of an actual <tt class="literal">T</tt> instance when writing "self
         expressions".
       </p>
-<a name="class_operators_special_functions.special_methods"></a><h3>
-<a name="id2646853"></a>
+<a name="class_operators_special_functions.special_methods"></a><h2>
+<a name="id448698"></a>
         Special Methods
-      </h3>
+      </h2>
 <p>
         Python has a few more <span class="emphasis"><em>Special Methods</em></span>. Boost.Python
         supports all of the standard special method names supported by real Python
@@ -596,15 +586,13 @@
 <p>
         Need we say more?
       </p>
-<div class="sidebar">
-<p class="title"><b></b></p>
-<p>
-        <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> What is the business of <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code>? Well, the method <code class="computeroutput"><span class="identifier">str</span></code>
-        requires the <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code>
-        to do its work (i.e. <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code> is used by the method defined by
-        <code class="computeroutput"><span class="identifier">def</span><span class="special">(</span><span class="identifier">str</span><span class="special">(</span><span class="identifier">self</span><span class="special">))</span></code>.
-      </p>
-</div>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/note.png"></span>
+              What is the business of <tt class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></tt>? Well, the method <tt class="computeroutput"><span class="identifier">str</span></tt> requires the <tt class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></tt> to do its work (i.e. <tt class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></tt>
+              is used by the method defined by <tt class="computeroutput"><span class="identifier">def</span><span class="special">(</span><span class="identifier">str</span><span class="special">(</span><span class="identifier">self</span><span class="special">))</span></tt>.</td></tr></tbody>
+</table></div>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>

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

@@ -3,15 +3,15 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Functions</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.72.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
 <link rel="start" href="../index.html" title="Chapter 1. python 1.0">
 <link rel="up" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="prev" href="exposing.html" title="Exposing Classes">
-<link rel="next" href="object.html" title="Object Interface">
+<link rel="prev" href="exposing.html" title=" Exposing Classes">
+<link rel="next" href="object.html" title=" Object Interface">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%">
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></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="../../../../../../../people/people.htm">People</a></td>
@@ -32,24 +32,16 @@
 <dt><span class="section"><a href="functions.html#python.auto_overloading">Auto-Overloading</a></span></dt>
 </dl></div>
 <p>
-      In this chapter, we'll look at Boost.Python powered functions in closer detail.
-      We shall see some facilities to make exposing C++ functions to Python safe
-      from potential pifalls such as dangling pointers and references. We shall also
-      see facilities that will make it even easier for us to expose C++ functions
+      FunctionsIn this chapter, we'll look at Boost.Python powered functions in closer
+      detail. We shall see some facilities to make exposing C++ functions to Python
+      safe from potential pifalls such as dangling pointers and references. We shall
+      also see facilities that will make it even easier for us to expose C++ functions
       that take advantage of C++ features such as overloading and default arguments.
     </p>
-<div class="blockquote"><blockquote class="blockquote">
-<p>
-        </p>
-<p>
-          <span class="emphasis"><em>Read on...</em></span>
-        </p>
-<p>
-      </p>
-</blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p><span class="emphasis"><em>Read on...</em></span></p></blockquote></div>
 <p>
       But before you do, you might want to fire up Python 2.2 or later and type
-      <code class="literal">&gt;&gt;&gt; import this</code>.
+      <tt class="literal">&gt;&gt;&gt; import this</tt>.
     </p>
 <pre class="programlisting">&gt;&gt;&gt; import this
 The Zen of Python, by Tim Peters
@@ -68,7 +60,7 @@ In the face of ambiguity, refuse the temptation to guess.
 There should be one-- and preferably only one --obvious way to do it
 Although that way may not be obvious at first unless you're Dutch.
 Now is better than never.
-Although never is often better than <span class="bold"><strong>right</strong></span> now.
+Although never is often better than <span class="bold"><b>right</b></span> now.
 If the implementation is hard to explain, it's a bad idea.
 If the implementation is easy to explain, it may be a good idea.
 Namespaces are one honking great idea -- let's do more of those!
@@ -77,15 +69,15 @@ Namespaces are one honking great idea -- let's do more of those!
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.call_policies"></a>Call Policies</h3></div></div></div>
 <p>
-        In C++, we often deal with arguments and return types such as pointers and
-        references. Such primitive types are rather, ummmm, low level and they really
-        don't tell us much. At the very least, we don't know the owner of the pointer
-        or the referenced object. No wonder languages such as Java and Python never
-        deal with such low level entities. In C++, it's usually considered a good
-        practice to use smart pointers which exactly describe ownership semantics.
-        Still, even good C++ interfaces use raw references and pointers sometimes,
-        so Boost.Python must deal with them. To do this, it may need your help. Consider
-        the following C++ function:
+        Call PoliciesIn C++, we often deal with arguments and return types such as
+        pointers and references. Such primitive types are rather, ummmm, low level
+        and they really don't tell us much. At the very least, we don't know the
+        owner of the pointer or the referenced object. No wonder languages such as
+        Java and Python never deal with such low level entities. In C++, it's usually
+        considered a good practice to use smart pointers which exactly describe ownership
+        semantics. Still, even good C++ interfaces use raw references and pointers
+        sometimes, 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>
@@ -96,9 +88,9 @@ Namespaces are one honking great idea -- let's do more of those!
         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>
+<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> # <span class="identifier">x</span> <span class="identifier">refers</span> <span class="identifier">to</span> <span class="identifier">some</span> <span class="identifier">C</span><span class="special">++</span> <span class="identifier">X</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">del</span> <span class="identifier">y</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">some_method</span><span class="special">()</span> <span class="preprocessor"># CRASH</span><span class="special">!</span>
+<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">some_method</span><span class="special">()</span> # <span class="identifier">CRASH</span><span class="special">!</span>
 </pre>
 <p>
         What's the problem?
@@ -126,25 +118,24 @@ Namespaces are one honking great idea -- let's do more of those!
       </p>
 <div class="orderedlist"><ol type="1">
 <li>
-<code class="literal">f</code> is called passing in a reference to <code class="literal">y</code>
-          and a pointer to <code class="literal">z</code>
+<tt class="literal">f</tt> is called passing in a reference to <tt class="literal">y</tt>
+          and a pointer to <tt class="literal">z</tt>
 </li>
 <li>
-          A reference to <code class="literal">y.x</code> is returned
+          A reference to <tt class="literal">y.x</tt> is returned
         </li>
 <li>
-<code class="literal">y</code> is deleted. <code class="literal">x</code> is a dangling reference
+<tt class="literal">y</tt> is deleted. <tt class="literal">x</tt> is a dangling reference
         </li>
 <li>
-<code class="literal">x.some_method()</code> is called
+<tt class="literal">x.some_method()</tt> is called
         </li>
-<li><span class="bold"><strong>BOOM!</strong></span></li>
+<li><span class="bold"><b>BOOM!</b></span></li>
 </ol></div>
 <p>
         We could copy result into a new object:
       </p>
-<p>
-      </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
 </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
@@ -158,8 +149,7 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         Our problems do not end there. Suppose Y is implemented as follows:
       </p>
-<p>
-      </p>
+<p></p>
 <pre class="programlisting">
 <span class="keyword">struct</span> <span class="identifier">Y</span>
 <span class="special">{</span>
@@ -168,16 +158,16 @@ Namespaces are one honking great idea -- let's do more of those!
 <span class="special">};</span>
 </pre>
 <p>
-        Notice that the data member <code class="literal">z</code> is held by class Y using
+        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>
-<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>
+<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> # <span class="identifier">y</span> <span class="identifier">refers</span> <span class="identifier">to</span> <span class="identifier">z</span>
+<span class="special">&gt;&gt;&gt;</span> <span class="identifier">del</span> <span class="identifier">z</span>       # <span class="identifier">Kill</span> <span class="identifier">the</span> <span class="identifier">z</span> <span class="identifier">object</span>
+<span class="special">&gt;&gt;&gt;</span> <span class="identifier">y</span><span class="special">.</span><span class="identifier">z_value</span><span class="special">()</span> # <span class="identifier">CRASH</span><span class="special">!</span>
 </pre>
 <p>
-        For reference, here's the implementation of <code class="literal">f</code> again:
+        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>
@@ -191,33 +181,33 @@ Namespaces are one honking great idea -- let's do more of those!
       </p>
 <div class="orderedlist"><ol type="1">
 <li>
-<code class="literal">f</code> is called passing in a reference to <code class="literal">y</code>
-          and a pointer to <code class="literal">z</code>
+<tt class="literal">f</tt> is called passing in a reference to <tt class="literal">y</tt>
+          and a pointer to <tt class="literal">z</tt>
 </li>
 <li>
-          A pointer to <code class="literal">z</code> is held by <code class="literal">y</code>
+          A pointer to <tt class="literal">z</tt> is held by <tt class="literal">y</tt>
 </li>
 <li>
-          A reference to <code class="literal">y.x</code> is returned
+          A reference to <tt class="literal">y.x</tt> is returned
         </li>
 <li>
-<code class="literal">z</code> is deleted. <code class="literal">y.z</code> is a dangling pointer
+<tt class="literal">z</tt> is deleted. <tt class="literal">y.z</tt> is a dangling pointer
         </li>
 <li>
-<code class="literal">y.z_value()</code> is called
+<tt class="literal">y.z_value()</tt> is called
         </li>
 <li>
-<code class="literal">z-&gt;value()</code> is called
+<tt class="literal">z-&gt;value()</tt> is called
         </li>
-<li><span class="bold"><strong>BOOM!</strong></span></li>
+<li><span class="bold"><b>BOOM!</b></span></li>
 </ol></div>
-<a name="call_policies.call_policies"></a><h3>
-<a name="id2648560"></a>
+<a name="call_policies.call_policies"></a><h2>
+<a name="id450599"></a>
         Call Policies
-      </h3>
+      </h2>
 <p>
         Call Policies may be used in situations such as the example detailed above.
-        In our example, <code class="literal">return_internal_reference</code> and <code class="literal">with_custodian_and_ward</code>
+        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">
@@ -226,27 +216,27 @@ Namespaces are one honking great idea -- let's do more of those!
         <span class="identifier">with_custodian_and_ward</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">&gt;</span> <span class="special">&gt;());</span>
 </pre>
 <p>
-        What are the <code class="literal">1</code> and <code class="literal">2</code> parameters, you
+        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>
 <p>
-        Informs Boost.Python that the first argument, in our case <code class="literal">Y&amp;
-        y</code>, is the owner of the returned reference: <code class="literal">X&amp;</code>.
-        The "<code class="literal">1</code>" simply specifies the first argument.
-        In short: "return an internal reference <code class="literal">X&amp;</code> owned
-        by the 1st argument <code class="literal">Y&amp; y</code>".
+        Informs Boost.Python that the first argument, in our case <tt class="literal">Y&amp;
+        y</tt>, is the owner of the returned reference: <tt class="literal">X&amp;</tt>.
+        The "<tt class="literal">1</tt>" simply specifies the first argument.
+        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>
 <p>
         Informs Boost.Python that the lifetime of the argument indicated by ward
-        (i.e. the 2nd argument: <code class="literal">Z* z</code>) is dependent on the lifetime
-        of the argument indicated by custodian (i.e. the 1st argument: <code class="literal">Y&amp;
-        y</code>).
+        (i.e. the 2nd argument: <tt class="literal">Z* z</tt>) is dependent on the lifetime
+        of the argument indicated by custodian (i.e. the 1st argument: <tt class="literal">Y&amp;
+        y</tt>).
       </p>
 <p>
         It is also important to note that we have defined two policies above. Two
@@ -263,52 +253,52 @@ Namespaces are one honking great idea -- let's do more of those!
       </p>
 <div class="itemizedlist"><ul type="disc">
 <li>
-<span class="bold"><strong>with_custodian_and_ward</strong></span><br> Ties lifetimes
+<span class="bold"><b>with_custodian_and_ward</b></span><br> Ties lifetimes
           of the arguments
         </li>
 <li>
-<span class="bold"><strong>with_custodian_and_ward_postcall</strong></span><br>
+<span class="bold"><b>with_custodian_and_ward_postcall</b></span><br>
           Ties lifetimes of the arguments and results
         </li>
 <li>
-<span class="bold"><strong>return_internal_reference</strong></span><br> Ties lifetime
+<span class="bold"><b>return_internal_reference</b></span><br> Ties lifetime
           of one argument to that of result
         </li>
 <li>
-<span class="bold"><strong>return_value_policy&lt;T&gt; with T one of:</strong></span><br>
+<span class="bold"><b>return_value_policy&lt;T&gt; with T one of:</b></span><br>
 </li>
 <li>
-<span class="bold"><strong>reference_existing_object</strong></span><br> naive
+<span class="bold"><b>reference_existing_object</b></span><br> naive
           (dangerous) approach
         </li>
 <li>
-<span class="bold"><strong>copy_const_reference</strong></span><br> Boost.Python
+<span class="bold"><b>copy_const_reference</b></span><br> Boost.Python
           v1 approach
         </li>
 <li>
-<span class="bold"><strong>copy_non_const_reference</strong></span><br>
+<span class="bold"><b>copy_non_const_reference</b></span><br>
 </li>
 <li>
-<span class="bold"><strong>manage_new_object</strong></span><br> Adopt a pointer
+<span class="bold"><b>manage_new_object</b></span><br> Adopt a pointer
           and hold the instance
         </li>
 </ul></div>
-<div class="sidebar">
-<p class="title"><b></b></p>
-<p>
-        <span class="inlinemediaobject"><img src="../images/smiley.png" alt="smiley"></span> <span class="bold"><strong>Remember the Zen, Luke:</strong></span><br>
-        <br> "Explicit is better than implicit"<br> "In the face
-        of ambiguity, refuse the temptation to guess"<br>
-      </p>
-</div>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/smiley.png"></span> <span class="bold"><b>Remember the Zen, Luke:</b></span><br><br> "Explicit
+              is better than implicit"<br> "In the face of ambiguity,
+              refuse the temptation to guess"<br>
+</td></tr></tbody>
+</table></div>
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.overloading"></a>Overloading</h3></div></div></div>
 <p>
-        The following illustrates a scheme for manually wrapping an overloaded member
-        functions. Of course, the same technique can be applied to wrapping overloaded
-        non-member functions.
+        OverloadingThe following illustrates a scheme for manually wrapping an overloaded
+        member functions. Of course, the same technique can be applied to wrapping
+        overloaded non-member functions.
       </p>
 <p>
         We have here our C++ class:
@@ -361,22 +351,22 @@ Namespaces are one honking great idea -- let's do more of those!
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.default_arguments"></a>Default Arguments</h3></div></div></div>
 <p>
-        Boost.Python wraps (member) function pointers. Unfortunately, C++ function
-        pointers carry no default argument info. Take a function <code class="literal">f</code>
+        Default ArgumentsBoost.Python wraps (member) function pointers. Unfortunately,
+        C++ function 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>
 <p>
-        But the type of a pointer to the function <code class="literal">f</code> has no information
+        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!
 </span></pre>
 <p>
-        When we pass this function pointer to the <code class="literal">def</code> function,
+        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">
@@ -410,10 +400,10 @@ Namespaces are one honking great idea -- let's do more of those!
           are overloaded with a common sequence of initial arguments
         </li>
 </ul></div>
-<a name="default_arguments.boost_python_function_overloads"></a><h3>
-<a name="id2650414"></a>
+<a name="default_arguments.boost_python_function_overloads"></a><h2>
+<a name="id452559"></a>
         BOOST_PYTHON_FUNCTION_OVERLOADS
-      </h3>
+      </h2>
 <p>
         Boost.Python now has a way to make it easier. For instance, given a function:
       </p>
@@ -431,19 +421,19 @@ Namespaces are one honking great idea -- let's do more of those!
 </pre>
 <p>
         will automatically create the thin wrappers for us. This macro will create
-        a class <code class="literal">foo_overloads</code> that can be passed on to <code class="literal">def(...)</code>.
+        a class <tt class="literal">foo_overloads</tt> that can be passed on to <tt class="literal">def(...)</tt>.
         The third and fourth macro argument are the minimum arguments and maximum
-        arguments, respectively. In our <code class="literal">foo</code> function the minimum
-        number of arguments is 1 and the maximum number of arguments is 4. The <code class="literal">def(...)</code>
+        arguments, respectively. In our <tt class="literal">foo</tt> function the minimum
+        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>
-<a name="default_arguments.boost_python_member_function_overloads"></a><h3>
-<a name="id2650701"></a>
+<a name="default_arguments.boost_python_member_function_overloads"></a><h2>
+<a name="id452863"></a>
         BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS
-      </h3>
+      </h2>
 <p>
         Objects here, objects there, objects here there everywhere. More frequently
         than anything else, we need to expose member functions of our classes to
@@ -452,7 +442,7 @@ Namespaces are one honking great idea -- let's do more of those!
         play. Another macro is provided to make this a breeze.
       </p>
 <p>
-        Like <code class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</code>, <code class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</code>
+        Like <tt class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</tt>, <tt class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt>
         may be used to automatically create the thin wrappers for wrapping member
         functions. Let's have an example:
       </p>
@@ -473,11 +463,11 @@ Namespaces are one honking great idea -- let's do more of those!
 <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 <code class="literal">wack_em</code>
+        will generate a set of thin wrappers for george's <tt class="literal">wack_em</tt>
         member function accepting a minimum of 1 and a maximum of 3 arguments (i.e.
         the third and fourth macro argument). The thin wrappers are all enclosed
-        in a class named <code class="literal">george_overloads</code> that can then be used
-        as an argument to <code class="literal">def(...)</code>:
+        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>
@@ -486,13 +476,13 @@ Namespaces are one honking great idea -- let's do more of those!
         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><h3>
-<a name="id2651031"></a>
+<a name="default_arguments.init_and_optional"></a><h2>
+<a name="id453212"></a>
         init and optional
-      </h3>
+      </h2>
 <p>
         A similar facility is provided for class constructors, again, with default
-        arguments or a sequence of overloads. Remember <code class="literal">init&lt;...&gt;</code>?
+        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">
@@ -509,7 +499,7 @@ Namespaces are one honking great idea -- let's do more of those!
 <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 <code class="literal">init&lt;...&gt;</code> and <code class="literal">optional&lt;...&gt;</code>
+        Notice the use of <tt class="literal">init&lt;...&gt;</tt> and <tt class="literal">optional&lt;...&gt;</tt>
         to signify the default (optional arguments).
       </p>
 </div>
@@ -517,10 +507,10 @@ Namespaces are one honking great idea -- let's do more of those!
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.auto_overloading"></a>Auto-Overloading</h3></div></div></div>
 <p>
-        It was mentioned in passing in the previous section that <code class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</code>
-        and <code class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</code> can also be
-        used for overloaded functions and member functions with a common sequence
-        of initial arguments. Here is an example:
+        Auto-OverloadingIt was mentioned in passing in the previous section that
+        <tt class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</tt> and <tt class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt>
+        can also be used for overloaded functions and member functions with a common
+        sequence of initial arguments. Here is an example:
       </p>
 <pre class="programlisting">
 <span class="keyword">void</span> <span class="identifier">foo</span><span class="special">()</span>
@@ -554,30 +544,30 @@ Namespaces are one honking great idea -- let's do more of those!
         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>
+<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
 </pre>
 <p>
         Notice though that we have a situation now where we have a minimum of zero
         (0) arguments and a maximum of 3 arguments.
       </p>
-<a name="auto_overloading.manual_wrapping"></a><h3>
-<a name="id2651734"></a>
+<a name="auto_overloading.manual_wrapping"></a><h2>
+<a name="id453917"></a>
         Manual Wrapping
-      </h3>
+      </h2>
 <p>
-        It is important to emphasize however that <span class="bold"><strong>the overloaded
-        functions must have a common sequence of initial arguments</strong></span>. Otherwise,
+        It is important to emphasize however that <span class="bold"><b>the overloaded
+        functions must have a common sequence of initial arguments</b></span>. Otherwise,
         our scheme above will not work. If this is not the case, we have to wrap
         our functions <a href="functions.html#python.overloading" title="Overloading">manually</a>.
       </p>
 <p>
         Actually, we can mix and match manual wrapping of overloaded functions and
-        automatic wrapping through <code class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</code>
-        and its sister, <code class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</code>. Following
+        automatic wrapping through <tt class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt>
+        and its sister, <tt class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</tt>. Following
         up on our example presented in the section <a href="functions.html#python.overloading" title="Overloading">on
         overloading</a>, since the first 4 overload functins have a common sequence
-        of initial arguments, we can use <code class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</code>
-        to automatically wrap the first three of the <code class="literal">def</code>s and
+        of initial arguments, we can use <tt class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt>
+        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">

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

@@ -1,17 +1,17 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Building Hello World</title>
+<title> Building Hello World</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.72.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
 <link rel="start" href="../index.html" title="Chapter 1. python 1.0">
 <link rel="up" href="../index.html" title="Chapter 1. python 1.0">
 <link rel="prev" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="next" href="exposing.html" title="Exposing Classes">
+<link rel="next" href="exposing.html" title=" Exposing Classes">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%">
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></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="../../../../../../../people/people.htm">People</a></td>
@@ -25,29 +25,27 @@
 <div class="section" lang="en">
 <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><h3>
-<a name="id2595436"></a>
-      From Start To Finish
-    </h3>
+<a name="hello._building_hello_worldfrom_start_to_finish"></a><h2>
+<a name="id442456"></a>
+      Building Hello WorldFrom Start To Finish
+    </h2>
 <p>
       Now the first thing you'd want to do is to build the Hello World module and
       try it for yourself in Python. In this section, we shall outline the steps
       necessary to achieve that. We shall use the build tool that comes bundled with
-      every boost distribution: <span class="bold"><strong>bjam</strong></span>.
+      every boost distribution: <span class="bold"><b>bjam</b></span>.
     </p>
-<div class="sidebar">
-<p class="title"><b></b></p>
-<p>
-      <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> <span class="bold"><strong>Building without bjam</strong></span><br>
-      <br> Besides bjam, there are of course other ways to get your module built.
-      What's written here should not be taken as "the one and only way".
-      There are of course other build tools apart from <code class="literal">bjam</code>.<br>
-      <br> Take note however that the preferred build tool for Boost.Python is
-      bjam. There are so many ways to set up the build incorrectly. Experience shows
-      that 90% of the "I can't build Boost.Python" problems come from people
-      who had to use a different tool.
-    </p>
-</div>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/note.png"></span> <span class="bold"><b>Building without bjam</b></span><br><br> Besides bjam,
+            there are of course other ways to get your module built. What's written
+            here should not be taken as "the one and only way". There are
+            of course other build tools apart from <tt class="literal">bjam</tt>.<br><br> Take note however that the preferred build tool for Boost.Python
+            is bjam. There are so many ways to set up the build incorrectly. Experience
+            shows that 90% of the "I can't build Boost.Python" problems
+            come from people who had to use a different tool. </td></tr></tbody>
+</table></div>
 <p>
       We shall skip over the details. Our objective will be to simply create the
       hello world module and run it in Python. For a complete reference to building
@@ -78,7 +76,7 @@
       if you are on Unix.
     </p>
 <p>
-      The tutorial example can be found in the directory: <code class="literal">libs/python/example/tutorial</code>.
+      The tutorial example can be found in the directory: <tt class="literal">libs/python/example/tutorial</tt>.
       There, you can find:
     </p>
 <div class="itemizedlist"><ul type="disc">
@@ -90,23 +88,21 @@
       </li>
 </ul></div>
 <p>
-      The <code class="literal">hello.cpp</code> file is our C++ hello world example. The
-      <code class="literal">Jamfile</code> is a minimalist <span class="emphasis"><em>bjam</em></span> script
+      The <tt class="literal">hello.cpp</tt> file is our C++ hello world example. The
+      <tt class="literal">Jamfile</tt> is a minimalist <span class="emphasis"><em>bjam</em></span> script
       that builds the DLLs for us.
     </p>
 <p>
       Before anything else, you should have the bjam executable in your boost directory
-      or somewhere in your path such that <code class="literal">bjam</code> can be executed
+      or somewhere in your path such that <tt class="literal">bjam</tt> can be executed
       in the command line. Pre-built Boost.Jam executables are available for most
       platforms. The complete list of Bjam executables can be found <a href="http://sourceforge.net/project/showfiles.php?group_id=7586" target="_top">here</a>.
     </p>
-<a name="hello.let_s_jam_"></a><h3>
-<a name="id2595623"></a>
+<a name="hello.let_s_jam_"></a><h2>
+<a name="id373799"></a>
       Let's Jam!
-    </h3>
-<p>
-      <span class="inlinemediaobject"><img src="../images/jam.png" alt="jam"></span>
-    </p>
+    </h2>
+<p><span class="inlinemediaobject"><img src="../images/jam.png"></span></p>
 <p>
       Here is our minimalist Jamfile:
     </p>
@@ -123,13 +119,13 @@ extension hello                     # Declare a Python extension called hello
 </pre>
 <p>
       First, we need to specify our location. You may place your project anywhere.
-      <code class="literal">project-root</code> allows you to do that.
+      <tt class="literal">project-root</tt> allows you to do that.
     </p>
 <pre class="programlisting">project-root ;
 </pre>
 <p>
       By doing so, you'll need a Jamrules file. Simply copy the one in the <a href="../../../../../example/tutorial/Jamrules" target="_top">example/tutorial directory</a>
-      and tweak the <code class="literal">path-global BOOST_ROOT</code> to where your boost
+      and tweak the <tt class="literal">path-global BOOST_ROOT</tt> to where your boost
       root directory is. The file has <a href="../../../../../example/tutorial/Jamrules" target="_top">detailed
       instructions</a> you can follow.
     </p>
@@ -139,7 +135,7 @@ extension hello                     # Declare a Python extension called hello
 <pre class="programlisting">import python ;
 </pre>
 <p>
-      Finally we declare our <code class="literal">hello</code> extension:
+      Finally we declare our <tt class="literal">hello</tt> extension:
     </p>
 <pre class="programlisting">extension hello                     # Declare a Python extension called hello
 :   hello.cpp                       # source
@@ -151,26 +147,19 @@ extension hello                     # Declare a Python extension called hello
 <p>
       The last part tells BJam that we are depending on the Boost Python Library.
     </p>
-<a name="hello.running_bjam"></a><h3>
-<a name="id2595752"></a>
+<a name="hello.running_bjam"></a><h2>
+<a name="id373910"></a>
       Running bjam
-    </h3>
-<p>
-      <span class="emphasis"><em>bjam</em></span> is run using your operating system's command line
+    </h2>
+<p><span class="emphasis"><em>bjam</em></span> is run using your operating system's command line
       interpreter.
     </p>
-<div class="blockquote"><blockquote class="blockquote">
-<p>
-        </p>
-<p>
-          Start it up.
-        </p>
-<p>
-      </p>
-</blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+        Start it up.
+      </p></blockquote></div>
 <p>
       Make sure that the environment is set so that we can invoke the C++ compiler.
-      With MSVC, that would mean running the <code class="literal">Vcvars32.bat</code> batch
+      With MSVC, that would mean running the <tt class="literal">Vcvars32.bat</tt> batch
       file. For instance:
     </p>
 <pre class="programlisting">C:\Program Files\Microsoft Visual Studio .NET 2003\Common7\Tools\vsvars32.bat
@@ -183,24 +172,24 @@ extension hello                     # Declare a Python extension called hello
 set PYTHON_VERSION=2.2
 </pre>
 <p>
-      The above assumes that the Python installation is in <code class="literal">c:/dev/tools/python</code>
+      The above assumes that the Python installation is in <tt class="literal">c:/dev/tools/python</tt>
       and that we are using Python version 2.2. You'll have to tweak these appropriately.
     </p>
-<div class="sidebar">
-<p class="title"><b></b></p>
-<p>
-      <span class="inlinemediaobject"><img src="../images/tip.png" alt="tip"></span> Be sure not to include a third number, e.g. <span class="bold"><strong>not</strong></span> "2.2.1", even if that's the version you
-      have.
-    </p>
-</div>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/tip.png"></span>
+            Be sure not to include a third number, e.g. <span class="bold"><b>not</b></span>
+            "2.2.1", even if that's the version you have.</td></tr></tbody>
+</table></div>
 <p>
       Take note that you may also do that through the Jamrules file we put in our
       project as detailed above. The file has <a href="../../../../../example/tutorial/Jamrules" target="_top">detailed
       instructions</a> you can follow.
     </p>
 <p>
-      Now we are ready... Be sure to <code class="literal">cd</code> to <code class="literal">libs/python/example/tutorial</code>
-      where the tutorial <code class="literal">"hello.cpp"</code> and the <code class="literal">"Jamfile"</code>
+      Now we are ready... Be sure to <tt class="literal">cd</tt> to <tt class="literal">libs/python/example/tutorial</tt>
+      where the tutorial <tt class="literal">"hello.cpp"</tt> and the <tt class="literal">"Jamfile"</tt>
       is situated.
     </p>
 <p>
@@ -262,35 +251,23 @@ b and object bin\tutorial\hello.pyd\vc-7_1\debug\threading-multi\hello.exp
 <p>
       if you are on Unix.
     </p>
-<p>
-      <code class="literal">boost_python.dll</code> and <code class="literal">hello.pyd</code> can be
-      found somewhere in your project's <code class="literal">bin</code> directory. After a
-      successful build, you make it possible for the system to find boost_python.dll
-      or libboost_python.so (usually done with LD_LIBRARY_PATH, DYLD_LIBRARY_PATH,
-      or some other variable on *nix and with PATH on Windows) and for Python to
-      find the hello module (Done with PYTHONPATH on all systems.)
+<p><tt class="literal">boost_python.dll</tt> and <tt class="literal">hello.pyd</tt> can be
+      found somewhere in your project's <tt class="literal">bin</tt> directory. After a
+      successful build, you can just link in these DLLs with the Python interpreter.
+      In Windows for example, you can simply put these libraries inside the directory
+      where the Python executable is.
     </p>
 <p>
       You may now fire up Python and run our hello module:
     </p>
-<p>
-    </p>
+<p></p>
 <pre class="programlisting">
 <span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span>
 <span class="identifier">hello</span><span class="special">,</span> <span class="identifier">world</span>
 </pre>
-<p>
-    </p>
-<div class="blockquote"><blockquote class="blockquote">
-<p>
-        </p>
-<p>
-          <span class="bold"><strong>There you go... Have fun!</strong></span>
-        </p>
-<p>
-      </p>
-</blockquote></div>
+<p></p>
+<div class="blockquote"><blockquote class="blockquote"><p><span class="bold"><b>There you go... Have fun!</b></span></p></blockquote></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

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

@@ -3,15 +3,15 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Iterators</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.72.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
 <link rel="start" href="../index.html" title="Chapter 1. python 1.0">
 <link rel="up" href="../index.html" title="Chapter 1. python 1.0">
 <link rel="prev" href="embedding.html" title="Embedding">
-<link rel="next" href="exception.html" title="Exception Translation">
+<link rel="next" href="exception.html" title=" Exception Translation">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%">
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></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="../../../../../../../people/people.htm">People</a></td>
@@ -26,12 +26,10 @@
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="python.iterators"></a>Iterators</h2></div></div></div>
 <p>
-      In C++, and STL in particular, we see iterators everywhere. Python also has
-      iterators, but these are two very different beasts.
-    </p>
-<p>
-      <span class="bold"><strong>C++ iterators:</strong></span>
+      IteratorsIn C++, and STL in particular, we see iterators everywhere. Python
+      also has iterators, but these are two very different beasts.
     </p>
+<p><span class="bold"><b>C++ iterators:</b></span></p>
 <div class="itemizedlist"><ul type="disc">
 <li>
         C++ has 5 type categories (random-access, bidirectional, forward, input,
@@ -44,9 +42,7 @@
         A pair of iterators is needed to represent a (first/last) range.
       </li>
 </ul></div>
-<p>
-      <span class="bold"><strong>Python Iterators:</strong></span>
-    </p>
+<p><span class="bold"><b>Python Iterators:</b></span></p>
 <div class="itemizedlist"><ul type="disc">
 <li>
         1 category (forward)
@@ -59,11 +55,10 @@
       </li>
 </ul></div>
 <p>
-      The typical Python iteration protocol: <code class="literal"><span class="bold"><strong>for y
-      in x...</strong></span></code> is as follows:
-    </p>
-<p>
+      The typical Python iteration protocol: <tt class="literal"><span class="bold"><b>for y
+      in x...</b></span></tt> is as follows:
     </p>
+<p></p>
 <pre class="programlisting">
 <span class="identifier">iter</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">__iter__</span><span class="special">()</span>         <span class="comment"># get iterator
 </span><span class="keyword">try</span><span class="special">:</span>
@@ -74,11 +69,10 @@
 </span></pre>
 <p>
       Boost.Python provides some mechanisms to make C++ iterators play along nicely
-      as Python iterators. What we need to do is to produce appropriate <code class="computeroutput"><span class="identifier">__iter__</span></code> function from C++ iterators that
+      as Python iterators. What we need to do is to produce appropriate <tt class="computeroutput"><span class="identifier">__iter__</span></tt> function from C++ iterators that
       is compatible with the Python iteration protocol. For example:
     </p>
-<p>
-    </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>
 <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>
@@ -90,9 +84,7 @@
 <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"><strong>range</strong></span>
-    </p>
+<p><span class="bold"><b>range</b></span></p>
 <p>
       We can create a Python savvy iterator using the range function:
     </p>
@@ -118,22 +110,19 @@
         adaptable function object (use Target parameter)
       </li>
 </ul></div>
-<p>
-      <span class="bold"><strong>iterator</strong></span>
-    </p>
+<p><span class="bold"><b>iterator</b></span></p>
 <div class="itemizedlist"><ul type="disc"><li>
         iterator&lt;T, Policies&gt;()
       </li></ul></div>
 <p>
-      Given a container <code class="literal">T</code>, iterator is a shortcut that simply
-      calls <code class="literal">range</code> with &amp;T::begin, &amp;T::end.
+      Given a container <tt class="literal">T</tt>, iterator is a shortcut that simply
+      calls <tt class="literal">range</tt> with &amp;T::begin, &amp;T::end.
     </p>
 <p>
       Let's put this into action... Here's an example from some hypothetical bogon
       Particle accelerator code:
     </p>
-<p>
-    </p>
+<p></p>
 <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>
@@ -144,25 +133,21 @@
 <p>
       Now, our C++ Wrapper:
     </p>
-<p>
-    </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>
     <span class="special">.</span><span class="identifier">property</span><span class="special">(</span><span class="string">"pions"</span><span class="special">,</span> <span class="identifier">range</span><span class="special">(&amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">p_begin</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">p_end</span><span class="special">))</span>
     <span class="special">.</span><span class="identifier">property</span><span class="special">(</span><span class="string">"bogons"</span><span class="special">,</span> <span class="identifier">range</span><span class="special">(&amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">b_begin</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">b_end</span><span class="special">));</span>
 </pre>
-<p>
-      <span class="bold"><strong>stl_input_iterator</strong></span>
-    </p>
+<p><span class="bold"><b>stl_input_iterator</b></span></p>
 <p>
       So far, we have seen how to expose C++ iterators and ranges to Python. Sometimes
       we wish to go the other way, though: we'd like to pass a Python sequence to
       an STL algorithm or use it to initialize an STL container. We need to make
-      a Python iterator look like an STL iterator. For that, we use <code class="computeroutput"><span class="identifier">stl_input_iterator</span><span class="special">&lt;&gt;</span></code>.
-      Consider how we might implement a function that exposes <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">assign</span><span class="special">()</span></code> to Python:
-    </p>
-<p>
+      a Python iterator look like an STL iterator. For that, we use <tt class="computeroutput"><span class="identifier">stl_input_iterator</span><span class="special">&lt;&gt;</span></tt>.
+      Consider how we might implement a function that exposes <tt class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">assign</span><span class="special">()</span></tt> to Python:
     </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>
 <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>
@@ -178,11 +163,10 @@
 </span>    <span class="special">;</span>
 </pre>
 <p>
-      Now in Python, we can assign any integer sequence to <code class="computeroutput"><span class="identifier">list_int</span></code>
+      Now in Python, we can assign any integer sequence to <tt class="computeroutput"><span class="identifier">list_int</span></tt>
       objects:
     </p>
-<p>
-    </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>
 <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>

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

@@ -1,9 +1,9 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Object Interface</title>
+<title> Object Interface</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.72.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
 <link rel="start" href="../index.html" title="Chapter 1. python 1.0">
 <link rel="up" href="../index.html" title="Chapter 1. python 1.0">
 <link rel="prev" href="functions.html" title="Functions">
@@ -11,7 +11,7 @@
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%">
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></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="../../../../../../../people/people.htm">People</a></td>
@@ -32,36 +32,33 @@
 <dt><span class="section"><a href="object.html#python.enums">Enums</a></span></dt>
 </dl></div>
 <p>
-      Python is dynamically typed, unlike C++ which is statically typed. Python variables
-      may hold an integer, a float, list, dict, tuple, str, long etc., among other
-      things. In the viewpoint of Boost.Python and C++, these Pythonic variables
-      are just instances of class <code class="literal">object</code>. We shall see in this
-      chapter how to deal with Python objects.
+      Object InterfacePython is dynamically typed, unlike C++ which is statically
+      typed. Python variables may hold an integer, a float, list, dict, tuple, str,
+      long etc., among other things. In the viewpoint of Boost.Python and C++, these
+      Pythonic variables are just instances of class <tt class="literal">object</tt>. We
+      shall see in this chapter how to deal with Python objects.
     </p>
 <p>
       As mentioned, one of the goals of Boost.Python is to provide a bidirectional
       mapping between C++ and Python while maintaining the Python feel. Boost.Python
-      C++ <code class="literal">object</code>s are as close as possible to Python. This should
+      C++ <tt class="literal">object</tt>s are as close as possible to Python. This should
       minimize the learning curve significantly.
     </p>
-<p>
-      <span class="inlinemediaobject"><img src="../images/python.png" alt="python"></span>
-    </p>
+<p><span class="inlinemediaobject"><img src="../images/python.png"></span></p>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.basic_interface"></a>Basic Interface</h3></div></div></div>
 <p>
-        Class <code class="literal">object</code> wraps <code class="literal">PyObject*</code>. All the
-        intricacies of dealing with <code class="literal">PyObject</code>s such as managing
-        reference counting are handled by the <code class="literal">object</code> class. C++
-        object interoperability is seamless. Boost.Python C++ <code class="literal">object</code>s
+        Basic InterfaceClass <tt class="literal">object</tt> wraps <tt class="literal">PyObject*</tt>.
+        All the intricacies of dealing with <tt class="literal">PyObject</tt>s such as
+        managing reference counting are handled by the <tt class="literal">object</tt>
+        class. C++ object interoperability is seamless. Boost.Python C++ <tt class="literal">object</tt>s
         can in fact be explicitly constructed from any C++ object.
       </p>
 <p>
         To illustrate, this Python code snippet:
       </p>
-<p>
-      </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>
      <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>
@@ -76,8 +73,7 @@
 <p>
         Can be rewritten in C++ using Boost.Python facilities this way:
       </p>
-<p>
-      </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>
      <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>
@@ -99,8 +95,8 @@
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.derived_object_types"></a>Derived Object types</h3></div></div></div>
 <p>
-        Boost.Python comes with a set of derived <code class="literal">object</code> types
-        corresponding to that of Python's:
+        Derived Object typesBoost.Python comes with a set of derived <tt class="literal">object</tt>
+        types corresponding to that of Python's:
       </p>
 <div class="itemizedlist"><ul type="disc">
 <li>
@@ -123,32 +119,31 @@
         </li>
 </ul></div>
 <p>
-        These derived <code class="literal">object</code> types act like real Python types.
+        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>
 <p>
-        Wherever appropriate, a particular derived <code class="literal">object</code> has
-        corresponding Python type's methods. For instance, <code class="literal">dict</code>
-        has a <code class="literal">keys()</code> method:
+        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>
-<p>
-        <code class="literal">make_tuple</code> is provided for declaring <span class="emphasis"><em>tuple literals</em></span>.
+<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>
 <p>
-        In C++, when Boost.Python <code class="literal">object</code>s are used as arguments
+        In C++, when Boost.Python <tt class="literal">object</tt>s are used as arguments
         to functions, subtype matching is required. For example, when a function
-        <code class="literal">f</code>, as declared below, is wrapped, it will only accept
-        instances of Python's <code class="literal">str</code> type and subtypes.
+        <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>
@@ -172,18 +167,17 @@
 <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 <code class="literal">"format"
-        % x,y,z</code> in Python, which is useful since there's no easy way to
+        Demonstrates that you can write the C++ equivalent of <tt class="literal">"format"
+        % x,y,z</tt> in Python, which is useful since there's no easy way to
         do that in std C++.
       </p>
-<div class="sidebar">
-<p class="title"><b></b></p>
-<p>
-        <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><strong>Beware</strong></span> the common pitfall
-        of forgetting that the constructors of most of Python's mutable types make
-        copies, just as in Python.
-      </p>
-</div>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/alert.png"></span> <span class="bold"><b>Beware</b></span> the common pitfall of forgetting that
+              the constructors of most of Python's mutable types make copies, just
+              as in Python. </td></tr></tbody>
+</table></div>
 <p>
         Python:
       </p>
@@ -198,12 +192,12 @@
 <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><h3>
-<a name="id2653534"></a>
+<a name="derived_object_types.class__lt_t_gt__as_objects"></a><h2>
+<a name="id455806"></a>
         class_&lt;T&gt; as objects
-      </h3>
+      </h2>
 <p>
-        Due to the dynamic nature of Boost.Python objects, any <code class="literal">class_&lt;T&gt;</code>
+        Due to the dynamic nature of Boost.Python objects, any <tt class="literal">class_&lt;T&gt;</tt>
         may also be one of these types! The following code snippet wraps the class
         (type) object.
       </p>
@@ -224,16 +218,16 @@
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.extracting_c___objects"></a>Extracting C++ objects</h3></div></div></div>
 <p>
-        At some point, we will need to get C++ values out of object instances. This
-        can be achieved with the <code class="literal">extract&lt;T&gt;</code> function. Consider
-        the following:
+        Extracting C++ objectsAt some point, we will need to get C++ values out of
+        object instances. This 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
 </span></pre>
 <p>
-        In the code above, we got a compiler error because Boost.Python <code class="literal">object</code>
-        can't be implicitly converted to <code class="literal">double</code>s. Instead, what
+        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">
@@ -243,14 +237,14 @@
 </pre>
 <p>
         The first line attempts to extract the "length" attribute of the
-        Boost.Python <code class="literal">object</code>. The second line attempts to <span class="emphasis"><em>extract</em></span>
-        the <code class="literal">Vec2</code> object from held by the Boost.Python <code class="literal">object</code>.
+        Boost.Python <tt class="literal">object</tt>. The second line attempts to <span class="emphasis"><em>extract</em></span>
+        the <tt class="literal">Vec2</tt> object from held by the Boost.Python <tt class="literal">object</tt>.
       </p>
 <p>
         Take note that we said "attempt to" above. What if the Boost.Python
-        <code class="literal">object</code> does not really hold a <code class="literal">Vec2</code>
+        <tt class="literal">object</tt> does not really hold a <tt class="literal">Vec2</tt>
         type? This is certainly a possibility considering the dynamic nature of Python
-        <code class="literal">object</code>s. To be on the safe side, if the C++ type can't
+        <tt class="literal">object</tt>s. To be on the safe side, if the C++ type can't
         be extracted, an appropriate exception is thrown. To avoid an exception,
         we need to test for extractibility:
       </p>
@@ -259,8 +253,8 @@
 <span class="keyword">if</span> <span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">check</span><span class="special">())</span> <span class="special">{</span>
     <span class="identifier">Vec2</span><span class="special">&amp;</span> <span class="identifier">v</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">();</span> <span class="special">...</span>
 </pre>
-<p>
-        <span class="inlinemediaobject"><img src="../images/tip.png" alt="tip"></span> The astute reader might have noticed that the <code class="literal">extract&lt;T&gt;</code>
+<p><span class="inlinemediaobject"><img src="../images/tip.png"></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">
@@ -272,12 +266,12 @@
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.enums"></a>Enums</h3></div></div></div>
 <p>
-        Boost.Python has a nifty facility to capture and wrap C++ enums. While Python
-        has no <code class="literal">enum</code> type, we'll often want to expose our C++ enums
-        to Python as an <code class="literal">int</code>. Boost.Python's enum facility makes
-        this easy while taking care of the proper conversions from Python's dynamic
-        typing to C++'s strong static typing (in C++, ints cannot be implicitly converted
-        to enums). To illustrate, given a C++ enum:
+        EnumsBoost.Python has a nifty facility to capture and wrap C++ enums. While
+        Python has no <tt class="literal">enum</tt> type, we'll often want to expose our
+        C++ enums to Python as an <tt class="literal">int</tt>. Boost.Python's enum facility
+        makes this easy while taking care of the proper conversions from Python's
+        dynamic 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>
@@ -293,24 +287,22 @@
 </pre>
 <p>
         can be used to expose to Python. The new enum type is created in the current
-        <code class="literal">scope()</code>, which is usually the current module. The snippet
-        above creates a Python class derived from Python's <code class="literal">int</code>
+        <tt class="literal">scope()</tt>, which is usually the current module. The snippet
+        above creates a Python class derived from Python's <tt class="literal">int</tt>
         type which is associated with the C++ type passed as its first parameter.
       </p>
-<div class="sidebar">
-<p class="title"><b></b></p>
-<p>
-        <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> <span class="bold"><strong>what is a scope?</strong></span><br>
-        <br> The scope is a class that has an associated global Python object which
-        controls the Python namespace in which new extension classes and wrapped
-        functions will be defined as attributes. Details can be found <a href="../../../../v2/scope.html" target="_top">here</a>.
-      </p>
-</div>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/note.png"></span> <span class="bold"><b>what is a scope?</b></span><br><br> The scope is a
+              class that has an associated global Python object which controls the
+              Python namespace in which new extension classes and wrapped functions
+              will be defined as attributes. Details can be found <a href="../../../../v2/scope.html" target="_top">here</a>.</td></tr></tbody>
+</table></div>
 <p>
         You can access those values in Python as
       </p>
-<p>
-      </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>
 <span class="identifier">my_module</span><span class="special">.</span><span class="identifier">choice</span><span class="special">.</span><span class="identifier">red</span>
@@ -319,8 +311,7 @@
         where my_module is the module where the enum is declared. You can also create
         a new scope around a class:
       </p>
-<p>
-      </p>
+<p></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>
                 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span> <span class="special">...</span> <span class="special">)</span>

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

@@ -1,16 +1,16 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>General Techniques</title>
+<title> General Techniques</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.72.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
 <link rel="start" href="../index.html" title="Chapter 1. python 1.0">
 <link rel="up" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="prev" href="exception.html" title="Exception Translation">
+<link rel="prev" href="exception.html" title=" Exception Translation">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%">
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td valign="top"><img alt="boost.png (6897 bytes)" width="277" height="86" src="../../../../../../../boost.png"></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="../../../../../../../people/people.htm">People</a></td>
@@ -30,16 +30,16 @@
 <dt><span class="section"><a href="techniques.html#python.reducing_compiling_time">Reducing Compiling Time</a></span></dt>
 </dl></div>
 <p>
-      Here are presented some useful techniques that you can use while wrapping code
-      with Boost.Python.
+      General TechniquesHere are presented some useful techniques that you can use
+      while wrapping code with Boost.Python.
     </p>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.creating_packages"></a>Creating Packages</h3></div></div></div>
 <p>
-        A Python package is a collection of modules that provide to the user a certain
-        functionality. If you're not familiar on how to create packages, a good introduction
-        to them is provided in the <a href="http://www.python.org/doc/current/tut/node8.html" target="_top">Python
+        Creating PackagesA Python package is a collection of modules that provide
+        to the user a certain functionality. If you're not familiar on how to create
+        packages, a good introduction to them is provided in the <a href="http://www.python.org/doc/current/tut/node8.html" target="_top">Python
         Tutorial</a>.
       </p>
 <p>
@@ -50,7 +50,7 @@
 <p>
         We have a C++ library that works with sounds: reading and writing various
         formats, applying filters to the sound data, etc. It is named (conveniently)
-        <code class="literal">sounds</code>. Our library already has a neat C++ namespace hierarchy,
+        <tt class="literal">sounds</tt>. Our library already has a neat C++ namespace hierarchy,
         like so:
       </p>
 <pre class="programlisting">
@@ -93,18 +93,18 @@
 <span class="special">}</span>
 </pre>
 <p>
-        Compiling these files will generate the following Python extensions: <code class="literal">core.pyd</code>,
-        <code class="literal">io.pyd</code> and <code class="literal">filters.pyd</code>.
+        Compiling these files will generate the following Python extensions: <tt class="literal">core.pyd</tt>,
+        <tt class="literal">io.pyd</tt> and <tt class="literal">filters.pyd</tt>.
       </p>
-<div class="sidebar">
-<p class="title"><b></b></p>
-<p>
-        <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> The extension <code class="literal">.pyd</code> is used for python
-        extension modules, which are just shared libraries. Using the default for
-        your system, like <code class="literal">.so</code> for Unix and <code class="literal">.dll</code>
-        for Windows, works just as well.
-      </p>
-</div>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/note.png"></span>
+              The extension <tt class="literal">.pyd</tt> is used for python extension
+              modules, which are just shared libraries. Using the default for your
+              system, like <tt class="literal">.so</tt> for Unix and <tt class="literal">.dll</tt>
+              for Windows, works just as well.</td></tr></tbody>
+</table></div>
 <p>
         Now, we create this directory structure for our Python package:
       </p>
@@ -115,17 +115,16 @@
     io.pyd
 </pre>
 <p>
-        The file <code class="literal">__init__.py</code> is what tells Python that the directory
-        <code class="literal">sounds/</code> is actually a Python package. It can be a empty
+        The file <tt class="literal">__init__.py</tt> is what tells Python that the directory
+        <tt class="literal">sounds/</tt> is actually a Python package. It can be a empty
         file, but can also perform some magic, that will be shown later.
       </p>
 <p>
-        Now our package is ready. All the user has to do is put <code class="literal">sounds</code>
+        Now our package is ready. All the user has to do is put <tt class="literal">sounds</tt>
         into his <a href="http://www.python.org/doc/current/tut/node8.html#SECTION008110000000000000000" target="_top">PYTHONPATH</a>
         and fire up the interpreter:
       </p>
-<p>
-      </p>
+<p></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>
 <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>
@@ -147,8 +146,7 @@
         If we want this flexibility, we will have to complicate our package hierarchy
         a little. First, we will have to change the name of the extension modules:
       </p>
-<p>
-      </p>
+<p></p>
 <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>
@@ -159,7 +157,7 @@
 </pre>
 <p>
         Note that we added an underscore to the module name. The filename will have
-        to be changed to <code class="literal">_core.pyd</code> as well, and we do the same
+        to be changed to <tt class="literal">_core.pyd</tt> as well, and we do the same
         to the other extension modules. Now, we change our package hierarchy like
         so:
       </p>
@@ -167,12 +165,12 @@
     __init__.py
     core/
         __init__.py
-        <span class="underline">core.pyd
+        _core.pyd
     filters/
-        \</span>_init__.py
-        <span class="underline">filters.pyd
+        __init__.py
+        _filters.pyd
     io/
-        \</span>_init__.py
+        __init__.py
         _io.pyd
 </pre>
 <p>
@@ -180,18 +178,17 @@
         to each one. But if we leave it that way, the user will have to access the
         functions in the core module with this syntax:
       </p>
-<p>
-      </p>
+<p></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>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">_core</span><span class="special">.</span><span class="identifier">foo</span><span class="special">(...)</span>
 </pre>
 <p>
-        which is not what we want. But here enters the <code class="literal">__init__.py</code>
-        magic: everything that is brought to the <code class="literal">__init__.py</code> namespace
+        which is not what we want. But here enters the <tt class="literal">__init__.py</tt>
+        magic: everything that is brought to the <tt class="literal">__init__.py</tt> namespace
         can be accessed directly by the user. So, all we have to do is bring the
-        entire namespace from <code class="literal">_core.pyd</code> to <code class="literal">core/__init__.py</code>.
-        So add this line of code to <code class="literal">sounds<span class="emphasis"><em>core</em></span>__init__.py</code>:
+        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>
@@ -208,10 +205,10 @@
         with the additional benefit that we can easily add pure Python functions
         to any module, in a way that the user can't tell the difference between a
         C++ function and a Python function. Let's add a <span class="emphasis"><em>pure</em></span>
-        Python function, <code class="literal">echo_noise</code>, to the <code class="literal">filters</code>
-        package. This function applies both the <code class="literal">echo</code> and <code class="literal">noise</code>
-        filters in sequence in the given <code class="literal">sound</code> object. We create
-        a file named <code class="literal">sounds/filters/echo_noise.py</code> and code our
+        Python function, <tt class="literal">echo_noise</tt>, to the <tt class="literal">filters</tt>
+        package. This function applies both the <tt class="literal">echo</tt> and <tt class="literal">noise</tt>
+        filters in sequence in the given <tt class="literal">sound</tt> object. We create
+        a file named <tt class="literal">sounds/filters/echo_noise.py</tt> and code our
         function:
       </p>
 <pre class="programlisting">
@@ -222,14 +219,14 @@
     <span class="keyword">return</span> <span class="identifier">s</span>
 </pre>
 <p>
-        Next, we add this line to <code class="literal">sounds<span class="emphasis"><em>filters</em></span>__init__.py</code>:
+        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>
 <p>
         And that's it. The user now accesses this function like any other function
-        from the <code class="literal">filters</code> package:
+        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>
@@ -240,8 +237,8 @@
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.extending_wrapped_objects_in_python"></a>Extending Wrapped Objects in Python</h3></div></div></div>
 <p>
-        Thanks to Python's flexibility, you can easily add new methods to a class,
-        even after it was already created:
+        Extending Wrapped Objects in PythonThanks 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>
@@ -259,14 +256,12 @@
 <span class="identifier">A</span> <span class="identifier">C</span> <span class="identifier">instance</span><span class="special">!</span>
 </pre>
 <p>
-        Yes, Python rox. <span class="inlinemediaobject"><img src="../images/smiley.png" alt="smiley"></span>
-      </p>
+        Yes, Python rox. <span class="inlinemediaobject"><img src="../images/smiley.png"></span></p>
 <p>
         We can do the same with classes that were wrapped with Boost.Python. Suppose
-        we have a class <code class="literal">point</code> in C++:
-      </p>
-<p>
+        we have a class <tt class="literal">point</tt> in C++:
       </p>
+<p></p>
 <pre class="programlisting">
 <span class="keyword">class</span> <span class="identifier">point</span> <span class="special">{...};</span>
 
@@ -277,10 +272,9 @@
 </pre>
 <p>
         If we are using the technique from the previous session, <a href="techniques.html#python.creating_packages" title="Creating Packages">Creating
-        Packages</a>, we can code directly into <code class="literal">geom/__init__.py</code>:
-      </p>
-<p>
+        Packages</a>, we can code directly into <tt class="literal">geom/__init__.py</tt>:
       </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>
 
@@ -291,8 +285,7 @@
 <span class="comment"># now we turn it into a member function
 </span><span class="identifier">point</span><span class="special">.</span><span class="identifier">__str__</span> <span class="special">=</span> <span class="identifier">point_str</span>
 </pre>
-<p>
-        <span class="bold"><strong>All</strong></span> point instances created from C++ will
+<p><span class="bold"><b>All</b></span> point instances created from C++ will
         also have this member function! This technique has several advantages:
       </p>
 <div class="itemizedlist"><ul type="disc">
@@ -364,13 +357,12 @@
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.reducing_compiling_time"></a>Reducing Compiling Time</h3></div></div></div>
 <p>
-        If you have ever exported a lot of classes, you know that it takes quite
-        a good time to compile the Boost.Python wrappers. Plus the memory consumption
-        can easily become too high. If this is causing you problems, you can split
-        the class_ definitions in multiple files:
-      </p>
-<p>
+        Reducing Compiling TimeIf you have ever exported a lot of classes, you know
+        that it takes quite a good time to compile the Boost.Python wrappers. Plus
+        the memory consumption can easily become too high. If this is causing you
+        problems, you can split the class_ definitions in multiple files:
       </p>
+<p></p>
 <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>
@@ -391,7 +383,7 @@
 <span class="special">}</span>
 </pre>
 <p>
-        Now you create a file <code class="literal">main.cpp</code>, which contains the <code class="literal">BOOST_PYTHON_MODULE</code>
+        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">
@@ -427,23 +419,22 @@
         exporting it to Python at the same time: changes in a class will only demand
         the compilation of a single cpp, instead of the entire wrapper code.
       </p>
-<div class="sidebar">
-<p class="title"><b></b></p>
-<p>
-        <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> If you're exporting your classes with <a href="../../../../../pyste/index.html" target="_top">Pyste</a>,
-        take a look at the <code class="literal">--multiple</code> option, that generates the
-        wrappers in various files as demonstrated here.
-      </p>
-</div>
-<div class="sidebar">
-<p class="title"><b></b></p>
-<p>
-        <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> This method is useful too if you are getting the error
-        message <span class="emphasis"><em>"fatal error C1204:Compiler limit:internal structure
-        overflow"</em></span> when compiling a large source file, as explained
-        in the <a href="../../../../v2/faq.html#c1204" target="_top">FAQ</a>.
-      </p>
-</div>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/note.png"></span>
+              If you're exporting your classes with <a href="../../../../../pyste/index.html" target="_top">Pyste</a>,
+              take a look at the <tt class="literal">--multiple</tt> option, that generates
+              the wrappers in various files as demonstrated here.</td></tr></tbody>
+</table></div>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<tbody><tr><td class="blurb">
+<span class="inlinemediaobject"><img src="../images/note.png"></span>
+              This method is useful too if you are getting the error message <span class="emphasis"><em>"fatal
+              error C1204:Compiler limit:internal structure overflow"</em></span>
+              when compiling a large source file, as explained in the <a href="../../../../v2/faq.html#c1204" target="_top">FAQ</a>.</td></tr></tbody>
+</table></div>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>

doc/tutorial/doc/tutorial.qbk

@@ -252,10 +252,9 @@ if you are on Windows, and
 if you are on Unix.
 
 [^boost_python.dll] and [^hello.pyd] can be found somewhere in your project's
-[^bin] directory. After a successful build, you make it possible for the system 
-to find boost_python.dll or libboost_python.so (usually done with LD_LIBRARY_PATH, 
-DYLD_LIBRARY_PATH, or some other variable on *nix and with PATH on Windows) and 
-for Python to find the hello module (Done with PYTHONPATH on all systems.)
+[^bin] directory. After a successful build, you can just link in these DLLs with 
+the Python interpreter. In Windows for example, you can simply put these libraries 
+inside the directory where the Python executable is.
 
 You may now fire up Python and run our hello module:
 
@@ -1100,7 +1099,7 @@ overloaded functions in one-shot:
 
 Then...
 
-    .def("foo", (void(*)(bool, int, char))0, foo_overloads());
+    .def("foo", foo, foo_overloads());
 
 Notice though that we have a situation now where we have a minimum of zero
 (0) arguments and a maximum of 3 arguments.
@@ -1365,6 +1364,11 @@ create a new scope around a class:
 
 [def Py_Initialize          [@http://www.python.org/doc/current/api/initialization.html#l2h-652  Py_Initialize]]
 [def Py_Finalize            [@http://www.python.org/doc/current/api/initialization.html#l2h-656  Py_Finalize]]
+[def PyRun_String           [@http://www.python.org/doc/current/api/veryhigh.html#l2h-55         PyRun_String]]
+[def PyRun_File             [@http://www.python.org/doc/current/api/veryhigh.html#l2h-56         PyRun_File]]
+[def Py_eval_input          [@http://www.python.org/doc/current/api/veryhigh.html#l2h-58         Py_eval_input]]
+[def Py_file_input          [@http://www.python.org/doc/current/api/veryhigh.html#l2h-59         Py_file_input]]
+[def Py_single_input        [@http://www.python.org/doc/current/api/veryhigh.html#l2h-60         Py_single_input]]
 [def Py_XINCREF             [@http://www.python.org/doc/current/api/countingRefs.html#l2h-65     Py_XINCREF]]
 [def Py_XDECREF             [@http://www.python.org/doc/current/api/countingRefs.html#l2h-67     Py_XDECREF]]
 [def PyImport_AppendInittab [@http://www.python.org/doc/current/api/importing.html#l2h-137       PyImport_AppendInittab]]
@@ -1391,17 +1395,17 @@ all. So stay tuned... :-)
 
 [h2 Building embedded programs]
 
-To be able to embed python into your programs, you have to link to
-both Boost.Python's as well as Python's own runtime library.
+To be able to use embedding in your programs, they have to be linked to
+both Boost.Python's and Python's static link library.
 
-Boost.Python's library comes in two variants. Both are located
+Boost.Python's static link library comes in two variants. Both are located
 in Boost's [^/libs/python/build/bin-stage] subdirectory. On Windows, the
 variants are called [^boost_python.lib] (for release builds) and
 [^boost_python_debug.lib] (for debugging). If you can't find the libraries,
 you probably haven't built Boost.Python yet. See
 [@../../../building.html Building and Testing] on how to do this.
 
-Python's library can be found in the [^/libs] subdirectory of
+Python's static link library can be found in the [^/libs] subdirectory of
 your Python directory. On Windows it is called pythonXY.lib where X.Y is
 your major Python version number.
 
@@ -1439,11 +1443,7 @@ steps:
 
 # Call other Python C API routines to use the interpreter.\n\n
 
-[/ # Call Py_Finalize() to stop the interpreter and release its resources.]
-
-[blurb __note__ [*Note that at this time you must not call Py_Finalize() to stop the
-interpreter. This may be fixed in a future version of boost.python.]
-]
+# Call Py_Finalize() to stop the interpreter and release its resources.
 
 (Of course, there can be other C++ code between all of these steps.)
 
@@ -1460,76 +1460,171 @@ messy and especially hard to get right in the presence of C++ exceptions.
 Fortunately Boost.Python provides the [@../../../v2/handle.html handle] and
 [@../../../v2/object.html object] class templates to automate the process.
 
+[h2 Reference-counting handles and objects]
+
+There are two ways in which a function in the Python/C API can return a
+[^PyObject*]: as a ['borrowed reference] or as a ['new reference]. Which of
+these a function uses, is listed in that function's documentation. The two
+require slightely different approaches to reference-counting but both can
+be 'handled' by Boost.Python.
+
+For a function returning a ['borrowed reference] we'll have to tell the
+[^handle] that the [^PyObject*] is borrowed with the aptly named
+[@../../../v2/handle.html#borrowed-spec borrowed] function. Two functions
+returning borrowed references are PyImport_AddModule and PyModule_GetDict.
+The former returns a reference to an already imported module, the latter
+retrieves a module's namespace dictionary. Let's use them to retrieve the
+namespace of the [^__main__] module:
+
+    object main_module((
+        handle<>(borrowed(PyImport_AddModule("__main__")))));
+
+    object main_namespace = main_module.attr("__dict__");
+
+For a function returning a ['new reference] we can just create a [^handle]
+out of the raw [^PyObject*] without wrapping it in a call to borrowed. One
+such function that returns a new reference is PyRun_String which we'll
+discuss in the next section.
+
+[blurb __note__ [*Handle is a class ['template], so why haven't we been using any template parameters?]\n
+\n
+[^handle] has a single template parameter specifying the type of the managed object. This type is [^PyObject] 99% of the time, so the parameter was defaulted to [^PyObject] for convenience. Therefore we can use the shorthand [^handle<>] instead of the longer, but equivalent, [^handle<PyObject>].
+]
+
 [h2 Running Python code]
 
-Boost.python provides three related functions to run Python code from C++.
+To run Python code from C++ there is a family of functions in the API
+starting with the PyRun prefix. You can find the full list of these
+functions [@http://www.python.org/doc/current/api/veryhigh.html here]. They
+all work similarly so we will look at only one of them, namely:
 
-    object eval(str expression, object globals = object(), object locals = object())
-    object exec(str code, object globals = object(), object locals = object())
-    object exec_file(str filename, object globals = object(), object locals = object())
+    PyObject* PyRun_String(char *str, int start, PyObject *globals, PyObject *locals)
 
-eval evaluates the given expression and returns the resulting value.
-exec executes the given code (typically a set of statements) returning the result,
-and exec_file executes the code contained in the given file.
+PyRun_String takes the code to execute as a null-terminated (C-style)
+string in its [^str] parameter. The function returns a new reference to a
+Python object. Which object is returned depends on the [^start] paramater.
 
-The [^globals] and [^locals] parameters are Python dictionaries
+The [^start] parameter is the start symbol from the Python grammar to use
+for interpreting the code. The possible values are:
+
+[table Start symbols
+
+    [[Py_eval_input]   [for interpreting isolated expressions]]
+    [[Py_file_input]   [for interpreting sequences of statements]]
+    [[Py_single_input] [for interpreting a single statement]]
+]
+
+When using Py_eval_input, the input string must contain a single expression
+and its result is returned. When using Py_file_input, the string can
+contain an abitrary number of statements and None is returned.
+Py_single_input works in the same way as Py_file_input but only accepts a
+single statement.
+
+Lastly, the [^globals] and [^locals] parameters are Python dictionaries
 containing the globals and locals of the context in which to run the code.
 For most intents and purposes you can use the namespace dictionary of the
 [^__main__] module for both parameters.
 
-Boost.python provides a function to import a module:
+We have already seen how to get the [^__main__] module's namespace so let's
+run some Python code in it:
 
-    object import(str name)
+    object main_module((
+        handle<>(borrowed(PyImport_AddModule("__main__")))));
 
-import imports a python module (potentially loading it into the running process
-first), and returns it.
-
-Let's import the [^__main__] module and run some Python code in its namespace:
-
-    object main_module = import("__main__");
     object main_namespace = main_module.attr("__dict__");
 
-    object ignored = exec("hello = file('hello.txt', 'w')\n"
-                          "hello.write('Hello world!')\n"
-                          "hello.close()",
-                          main_namespace);
+    handle<> ignored((PyRun_String(
+
+        "hello = file('hello.txt', 'w')\n"
+        "hello.write('Hello world!')\n"
+        "hello.close()"
+
+      , Py_file_input
+      , main_namespace.ptr()
+      , main_namespace.ptr())
+    ));
+
+Because the Python/C API doesn't know anything about [^object]s, we used
+the object's [^ptr] member function to retrieve the [^PyObject*].
 
 This should create a file called 'hello.txt' in the current directory
 containing a phrase that is well-known in programming circles.
 
-[h2 Manipulating Python objects]
+[blurb
+    __note__ [*Note] that we wrap the return value of PyRun_String in a
+    (nameless) [^handle] even though we are not interested in it. If we didn't
+    do this, the the returned object would be kept alive unnecessarily. Unless
+    you want to be a Dr. Frankenstein, always wrap [^PyObject*]s in [^handle]s.
+]
 
-Often we'd like to have a class to manipulate Python objects. 
-But we have already seen such a class above, and in the 
-[@python/object.html previous section]: the aptly named [^object] class 
-and its derivatives. We've already seen that they can be constructed from 
-a [^handle]. The following examples should further illustrate this fact:
+[h2 Beyond handles]
+
+It's nice that [^handle] manages the reference counting details for us, but
+other than that it doesn't do much. Often we'd like to have a more useful
+class to manipulate Python objects. But we have already seen such a class
+above, and in the [@python/object.html previous section]: the aptly
+named [^object] class and it's derivatives. We've already seen that they
+can be constructed from a [^handle]. The following examples should further
+illustrate this fact:
+
+    object main_module((
+         handle<>(borrowed(PyImport_AddModule("__main__")))));
 
-    object main_module = import("__main__");
     object main_namespace = main_module.attr("__dict__");
-    object ignored = exec("result = 5 ** 2", main_namespace);
+
+    handle<> ignored((PyRun_String(
+
+        "result = 5 ** 2"
+
+        , Py_file_input
+        , main_namespace.ptr()
+        , main_namespace.ptr())
+    ));
+
     int five_squared = extract<int>(main_namespace["result"]);
 
 Here we create a dictionary object for the [^__main__] module's namespace.
 Then we assign 5 squared to the result variable and read this variable from
-the dictionary. Another way to achieve the same result is to use eval instead,
-which returns the result directly:
+the dictionary. Another way to achieve the same result is to let
+PyRun_String return the result directly with Py_eval_input:
+
+    object result((handle<>(
+        PyRun_String("5 ** 2"
+            , Py_eval_input
+            , main_namespace.ptr()
+            , main_namespace.ptr()))
+    ));
 
-    object result = eval("5 ** 2");
     int five_squared = extract<int>(result);
 
+[blurb
+    __note__ [*Note] that [^object]'s member function to return the wrapped
+    [^PyObject*] is called [^ptr] instead of [^get]. This makes sense if you
+    take into account the different functions that [^object] and [^handle]
+    perform.
+]
+
 [h2 Exception handling]
 
-If an exception occurs in the evaluation of the python expression,
-[@../../../v2/errors.html#error_already_set-spec error_already_set] is thrown:
+If an exception occurs in the execution of some Python code, the PyRun_String
+function returns a null pointer. Constructing a [^handle] out of this null
+pointer throws [@../../../v2/errors.html#error_already_set-spec error_already_set],
+so basically, the Python exception is automatically translated into a
+C++ exception when using [^handle]:
 
     try
     {
-        object result = eval("5/0");
+        object result((handle<>(PyRun_String(
+            "5/0"
+          , Py_eval_input
+          , main_namespace.ptr()
+          , main_namespace.ptr()))
+        ));
+
         // execution will never get here:
         int five_divided_by_zero = extract<int>(result);
     }
-    catch(error_already_set const &)
+    catch(error_already_set)
     {
         // handle the exception in some way
     }
@@ -1543,7 +1638,7 @@ print the exception's traceback to the console, or comparing the type of the
 exception with those of the [@http://www.python.org/doc/api/standardExceptions.html
 standard exceptions]:
 
-    catch(error_already_set const &)
+    catch(error_already_set)
     {
         if (PyErr_ExceptionMatches(PyExc_ZeroDivisionError))
         {
@@ -1559,6 +1654,21 @@ standard exceptions]:
 (To retrieve even more information from the exception you can use some of the other
 exception handling functions listed [@http://www.python.org/doc/api/exceptionHandling.html here].)
 
+If you'd rather not have [^handle] throw a C++ exception when it is constructed, you
+can use the [@../../../v2/handle.html#allow_null-spec allow_null] function in the same
+way you'd use borrowed:
+
+    handle<> result((allow_null(PyRun_String(
+        "5/0"
+       , Py_eval_input
+       , main_namespace.ptr()
+       , main_namespace.ptr()))));
+
+    if (!result)
+        // Python exception occurred
+    else
+        // everything went okay, it's safe to use the result
+
 [endsect]
 [endsect] [/ Embedding]
 

doc/tutorial/index.html

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

doc/v2/Apr2002.html

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

doc/v2/CallPolicies.html

@@ -1,14 +1,11 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
     "HTML Tidy for Windows (vers 1st August 2002), see www.w3.org">
     <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-    <link rel="stylesheet" type="text/css" href="../../../../boost.css">
+    <link rel="stylesheet" type="text/css" href=../../../../boost.css>
 
     <title>Boost.Python - CallPolicies Concept</title>
   </head>
@@ -60,7 +57,6 @@
 
       <li><code>postcall</code> - Python argument tuple and result management
       after the wrapped object is invoked</li>
-      <li><code>extract_return_type</code> - metafunction for extracting the return type from a given signature type sequence</li>
     </ol>
 
     <h2><a name="composition"></a>CallPolicies Composition</h2>
@@ -133,16 +129,7 @@
         reference count must be decremented; if another existing object is
         returned, its reference count must be incremented.</td>
       </tr>
-      <tr>
-        <td valign="top"><code>P::extract_return_type</code></td>
-
-        <td>A model of <a href=
-          "../../../doc/refmanual/metafunction.html">Metafunction</a>.</td>
-
-        <td>An MPL unary <a href=
-          "../../../mpl/doc/refmanual/metafunction.html">Metafunction</a> used extract the return type from a given signature. By default it is derived from mpl::front.</td>
-      </tr>
-  </table>
+    </table>
     Models of CallPolicies are required to be <a href=
     "../../../utility/CopyConstructible.html">CopyConstructible</a>. 
     <hr>

doc/v2/Dereferenceable.html

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

doc/v2/Extractor.html

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

doc/v2/HolderGenerator.html

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

doc/v2/Jun2002.html

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

doc/v2/Mar2002.html

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

doc/v2/May2002.html

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

doc/v2/ObjectWrapper.html

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

doc/v2/ResultConverter.html

@@ -1,12 +1,7 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href="../../../../boost.css">
+<link rel="stylesheet" type="text/css" href=../../../../boost.css>
 <title>Boost.Python - ResultConverter Concept</title>
 </head>
 <body link="#0000ff" vlink="#800080">
@@ -26,12 +21,10 @@
 <dl class="page-index"> 
   <dt><a href="#introduction">Introduction</a></dt>
   <dt><a href="#concept-requirements">Concept Requirements</a></dt>
-  <dd>
-    <dl class="page-index"> 
-      <dt><a href="#ResultConverter-concept">ResultConverter Concept</a></dt>
-      <dt><a href="#ResultConverterGenerator-concept">ResultConverterGenerator Concept</a></dt>
-    </dl>
-  </dd>
+  <dl class="page-index"> 
+    <dt><a href="#ResultConverter-concept">ResultConverter Concept</a></dt>
+    <dt><a href="#ResultConverterGenerator-concept">ResultConverterGenerator Concept</a></dt>
+  </dl>
 </dl>
 
 <h2><a name="introduction"></a>Introduction</h2>
@@ -83,13 +76,6 @@ denotes an object of type <code><b>R</b></code>.
     href="http://www.python.org/doc/current/api/exceptionHandling.html#l2h-71">PyErr_Occurred</a>
     should return non-zero.</td>
   </tr>
-  <tr> 
-    <td valign="top"><code>c.get_pytype()</code></td>
-    <td><code>PyTypeObject const*</code></td>
-    <td>A pointer to a Python Type object corresponding to result of the conversion,
-    or <code>0</code>. Used for documentation generation. If <code>0</code> is returned
-    the generated type in the documentation will be <b>object</b> .</td>
-  </tr>
 </table>
 
 <h3><a name="ResultConverterGenerator-concept"></a>ResultConverterGenerator Concept</h3>

doc/v2/acknowledgments.html

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

doc/v2/args.html

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

doc/v2/call.html

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

doc/v2/call_method.html

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

doc/v2/callbacks.html

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

doc/v2/callbacks.txt

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

doc/v2/class.html

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

doc/v2/configuration.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -139,41 +136,6 @@
         compares <code>typeid(T).name()</code> instead of using and comparing
         the <code>std::type_info</code> objects directly.</td>
       </tr>
-      <tr>
-        <td valign="top"><code>BOOST_PYTHON_NO_PY_SIGNATURES</code></td>
-
-        <td valign="top" align="center"><i>not&nbsp;defined</i></td>
-
-        <td valign="top">If defined for a module no pythonic signatures are generated 
-        for the docstrings of the module functions, and no python type is associated with any
-        of the converters registered by the module. This also reduces the binary size of the 
-        module by about 14% (gcc compiled).<br>
-        If defined for the boost_python runtime library, the default for the 
-        <code>docstring_options.enable_py_signatures()</code> is set to <code>false</code>.
-        </td>
-
-      </tr>
-      <tr>
-        <td valign="top"><code>BOOST_PYTHON_SUPPORTS_PY_SIGNATURES</code></td>
-
-        <td valign="top" align="center"><i>defined if <code>BOOST_PYTHON_NO_PY_SIGNATURES</code> is undefined</i></td>
-
-        <td valign="top">This macro is defined to enable a smooth transition from older Boost.Python versions
-        which do not support pythonic signatures. For example usage see 
-        <a href="pytype_function.html#examples">here</a>.
-        </td>
-
-      </tr>
-      <tr>
-        <td valign="top"><code>BOOST_PYTHON_PY_SIGNATURES_PROPER_INIT_SELF_TYPE</code></td>
-
-        <td valign="top" align="center"><i>not&nbsp;defined</i></td>
-
-        <td valign="top">If defined the python type of <code>__init__</code> method "self" parameters
-        is properly generated, otherwise <code><b>object</b></code> is used. It is undefined
-        by default because it increases the binary size of the module by about 14% (gcc compiled).</td>
-
-      </tr>
     </table>
     <hr>
 

doc/v2/copy_const_reference.html

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

doc/v2/copy_non_const_reference.html

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

doc/v2/data_members.html

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

doc/v2/def.html

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

doc/v2/def_visitor.html

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

doc/v2/default_call_policies.html

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

doc/v2/definitions.html

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

doc/v2/dict.html

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

doc/v2/docstring_options.html

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

doc/v2/enum.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -89,7 +86,7 @@ namespace boost { namespace python
   template &lt;class T&gt;
   class enum_ : public <a href="object.html#object-spec">object</a>
   {
-    enum_(char const* name, char const* doc = 0);
+    enum_(char const* name);
     enum_&lt;T&gt;&amp; value(char const* name, T);
     enum_&lt;T&gt;&amp; export_values();
   };
@@ -99,7 +96,7 @@ namespace boost { namespace python
     <h4><a name="enum_-spec-ctors"></a>Class template <code>enum_</code>
     constructors</h4>
 <pre>
-enum_(char const* name, char const* doc=0);
+enum_(char const* name);
 </pre>
 
     <dl class="function-semantics">
@@ -131,7 +128,7 @@ inline enum_&lt;T&gt;&amp; value(char const* name, T x);
 
       <dt><b>Effects:</b> adds an instance of the wrapped enumeration
       type with value <code>x</code> to the type's dictionary as the
-      <code>name</code>d attribute.</dt>
+      <code>name</code>d attribute</dt>.
 
       <dt><b>Returns:</b> <code>*this</code></dt>
 
@@ -146,7 +143,7 @@ inline enum_&lt;T&gt;&amp; export_values();
       <dt><b>Effects:</b> sets attributes in the current <a
         href="scope.html#scope-spec"><code>scope</code></a> with the
         same names and values as all enumeration values exposed so far
-        by calling <code>value()</code>.</dt>
+        by calling <code>value()</code></dt>.
 
       <dt><b>Returns:</b> <code>*this</code></dt>
 

doc/v2/errors.html

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

doc/v2/exception_translator.html

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

doc/v2/exec.html

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

doc/v2/extract.html

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

doc/v2/faq.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -569,7 +566,7 @@ handle&lt;&gt; f_wrap()
 ...
 
 def("f", f_wrap());
-class_&lt;X,X_wrap,boost::noncopyable&gt;("X", init&lt;int&gt;())
+class_&lt;X,X_wrap&gt;("X", init&lt;int&gt;())
    ...
    ;
 </pre>
@@ -851,11 +848,11 @@ BOOST_PYTHON_MODULE(custom_string)
 
     <p>Revised
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     12 March, 2006
+     28 January, 2004
     <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002-2006.</i></p>
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002-2003.</i></p>
   </body>
 </html>

doc/v2/feb2002.html

@@ -360,8 +360,7 @@
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 
 
-  <p class="c3">&copy; Copyright <a href=
-  "../../../../people/dave_abrahams.htm">Dave Abrahams</a> 2002. 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>
+    <p class="c3">&copy; Copyright <a href= 
+    "../../../../people/dave_abrahams.htm">Dave Abrahams</a>
+    2002. 
 

doc/v2/function_doc_signature.html

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

doc/v2/handle.html

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

doc/v2/has_back_reference.html

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

doc/v2/implicit.html

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

doc/v2/import.html

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

doc/v2/index.html

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

doc/v2/indexing.html

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

doc/v2/init.html

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

doc/v2/instance_holder.html

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

doc/v2/iterator.html

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

doc/v2/list.html

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

doc/v2/long.html

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

doc/v2/lvalue_from_pytype.html

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

doc/v2/make_function.html

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

doc/v2/manage_new_object.html

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

doc/v2/module.html

@@ -104,7 +104,5 @@ RuntimeError: Unidentifiable C++ Exception
 
 
     <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002. </i> Distributed
-  under the Boost Software License, Version 1.0. (See accompanying file
-  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)</p>
+    Abrahams</a> 2002. </i>
 

doc/v2/numeric.html

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

doc/v2/object.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -854,12 +851,12 @@ void del(proxy&lt;T&gt; const&amp; x);
     </dl>
 <pre>
 <a name="comparisons-spec"></a>
-template&lt;class L,class R&gt; object operator&gt;(L const&amp;l,R const&amp;r);
-template&lt;class L,class R&gt; object operator&gt;=(L const&amp;l,R const&amp;r);
-template&lt;class L,class R&gt; object operator&lt;(L const&amp;l,R const&amp;r);
-template&lt;class L,class R&gt; object operator&lt;=(L const&amp;l,R const&amp;r);
-template&lt;class L,class R&gt; object operator==(L const&amp;l,R const&amp;r);
-template&lt;class L,class R&gt; object operator!=(L const&amp;l,R const&amp;r);
+template&lt;class L,class R&gt; bool operator&gt;(L const&amp;l,R const&amp;r);
+template&lt;class L,class R&gt; bool operator&gt;=(L const&amp;l,R const&amp;r);
+template&lt;class L,class R&gt; bool operator&lt;(L const&amp;l,R const&amp;r);
+template&lt;class L,class R&gt; bool operator&lt;=(L const&amp;l,R const&amp;r);
+template&lt;class L,class R&gt; bool operator==(L const&amp;l,R const&amp;r);
+template&lt;class L,class R&gt; bool operator!=(L const&amp;l,R const&amp;r);
 </pre>
 
     <dl class="function-semantics">

doc/v2/opaque.html

@@ -1,138 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<!-- Copyright 2003..2006 Haufe Mediengruppe. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
-
-<html>
-  <head>
-    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-    <link rel="stylesheet" type="text/css" href="../boost.css">
-
-    <title>Boost.Python - &lt;boost/python/opaque_pointer_converter.hpp&gt;</title>
-  </head>
-
-  <body>
-    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
-    "header">
-      <tr>
-        <td valign="top" width="300">
-          <h3><a href="../../../../index.htm"><img height="86" width="277"
-          alt="C++ Boost" src="../../../../boost.png" border="0"></a></h3>
-        </td>
-
-        <td valign="top">
-          <h1 align="center"><a href="../index.html">Boost.Python</a></h1>
-
-          <h2 align="center">Header
-          &lt;boost/python/opaque_pointer_converter.hpp&gt;</h2>
-        </td>
-      </tr>
-    </table>
-    <hr>
-
-    <h2>Contents</h2>
-
-    <dl class="page-index">
-      <dt><a href="#classes">Classes</a></dt>
-
-      <dd>
-        <dl class="page-index">
-          <dt><a href="#opaque-spec">Class template
-          <code>opaque&lt;Pointee&gt;</code></a></dt>
-
-          <dd>
-            <dl class="page-index">
-              <dt><a href="#opaque-spec-synopsis">Class template
-              <code>opaque</code> synopsis</a></dt>
-            </dl>
-          </dd>
-        </dl>
-      </dd>
-
-      <dt><a href="#macros">Macros</a></dt>
-      <dd>
-        <dl class="page-index">
-          <dt><a href="#BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID-spec">Macro
-          <code>BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID</code></a></dt>
-        </dl>
-      </dd>
-
-      <dt><a href="#see-also">See Also</a></dt>
-    </dl>
-    <hr>
-
-    <h2><a name="classes"></a>Classes</h2>
-
-    <h3><a name="opaque-spec"></a>Class template
-    <code>opaque&lt;P&gt;</code></h3>
-
-    <p><code>opaque&lt;&gt;</code> registers itself as a converter from
-      Python objects to pointers to undefined types and vice versa.</p>
-
-    <h4><a name="opaque-spec-synopsis"></a>Class template
-    <code>opaque</code> synopsis</h4>
-<pre>
-namespace boost { namespace python
-{
-    template&lt;class Pointee&gt;
-    struct opaque
-    {
-        opaque();
-    };
-}}
-</pre>
-
-    <h4><a name="opaque-spec-constructor"></a>Class template
-    <code>opaque</code> constructor</h4>
-<pre>
-opaque();
-</pre>
-
-    <dl class="function-semantics">
-      <dt><b>Effects:</b>
-    <ul>
-        <li>Registers the instance as a 
-        <a href="lvalue_from_pytype.html#lvalue_from_pytype-spec"> <code>lvalue_from_pytype</code></a>
-        converter from Python objects into opaque pointers.</p>
-        <p>The Python Objects created are named after the type pointed to
-          by the opaque pointer being wrapped.</p></li>
-        <li>Registers the instance as a 
-          <a href="to_python_converter.html#to_python_converter-spec"> <code>to_python_converter</code></a>
-        from opaque pointers to Python objects.</p></li>
-    </ul>
-    <p>If there is already an instance registered by another module, this
-      instance doesn't try to register again in order to avoid warnings
-      about multiple registrations.</p>
-
-    <h4>Note</h4>
-    <p>Normally only a single instance of this class is created for every
-      Pointee.</p>
-    </dt>
-    </dl>
-
-    <h2><a name="macros"></a>Macros</h2>
-
-    <h3><a name="BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID-spec"></a>
-      Macro BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID(Pointee)</h3>
-    <p>This macro must be used to define specializations of the 
-      <a href="type_id.html#type_id-spec">type_id</a> function
-      which can't be instantiated for incomplete types.</p>
-    <h4>Note</h4>
-    <p>The macro must be invoked in every translation unit which uses the
-      opaque converter.</p>
-
-    <h2><a name="see-also"></a>See Also</h2>
-        <p>
-          <a href="return_opaque_pointer.html">return_opaque_pointer</a>
-        </p>
-
-    <p>Revised 
-  10 September, 2006
-    </p>
-
-    <p><i>&copy; Copyright 2003..2006 Haufe Mediengruppe. All Rights
-    Reserved.</i></p>
-  </body>
-</html>
-

doc/v2/opaque_pointer_converter.html

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

doc/v2/operators.html

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

doc/v2/overloads.html

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

doc/v2/pickle.html

@@ -320,9 +320,11 @@ See also the
 
 <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)
+&copy; Copyright Ralf W. Grosse-Kunstleve 2001-2004. Permission to copy,
+use, modify, sell and distribute this document is granted provided this
+copyright notice appears in all copies. This document is provided "as
+is" without express or implied warranty, and with no claim as to its
+suitability for any purpose.
 
 <p>
 Updated: Feb 2004.

doc/v2/platforms.html

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

doc/v2/pointee.html

@@ -112,8 +112,5 @@ BOOST_PYTHON_MODULE(pointee_demo)
 
 
     <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002. </i>   Distributed
-  under the Boost Software License, Version 1.0. (See accompanying file
-  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)</p>
-
+    Abrahams</a> 2002. </i>
 

doc/v2/progress_reports.html

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

doc/v2/ptr.html

@@ -259,7 +259,5 @@ void pass_as_arg(expensive_to_copy* x, PyObject* f)
 
 
     <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
-    Abrahams</a> 2002. </i> Distributed
-  under the Boost Software License, Version 1.0. (See accompanying file
-  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)</p>
+    Abrahams</a> 2002. </i>
 

doc/v2/python.html

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

doc/v2/pytype_function.html

@@ -1,370 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<!-- Copyright Nikolay Mladenov 2007. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
-<html>
-<head>
-  <meta http-equiv="Content-Type" content=
-  "text/html; charset=us-ascii">
-  <link rel="stylesheet" type="text/css" href="../boost.css">
-
-  <title>Boost.Python -
-  &lt;boost/python/doobject/pytype_function.hpp&gt;</title>
-</head>
-
-<body>
-  <table border="0" cellpadding="7" cellspacing="0" width="100%"
-  summary="header">
-    <tr>
-      <td valign="top" width="300">
-        <h3><a href="../../../../index.htm"><img height="86" width=
-        "277" alt="C++ Boost" src="../../../../boost.png" border=
-        "0"></a></h3>
-      </td>
-
-      <td valign="top">
-        <h1 align="center"><a href=
-        "../index.html">Boost.Python</a></h1>
-
-        <h2 align="center">Header
-        &lt;boost/python/converter/pytype_function.hpp&gt;</h2>
-      </td>
-    </tr>
-  </table>
-  <hr>
-
-  <h2>Contents</h2>
-
-  <dl class="page-index">
-    <dt><a href="#introduction">Introduction</a></dt>
-
-    <dt><a href="#classes">Classes</a></dt>
-
-    <dd>
-      <dl class="page-index">
-        <dt><a href="#wrap_pytype-spec">Class
-        <code>wrap_pytype</code></a></dt>
-
-        <dd>
-          <dl class="page-index">
-            <dt><a href="#wrap_pytype-spec-synopsis">Class
-            <code>wrap_pytype</code> synopsis</a></dt>
-
-          </dl>
-        </dd>
-      </dl>
-    </dd>
-
-    <dd>
-      <dl class="page-index">
-        <dt><a href="#registered_pytype-spec">Class
-        <code>registered_pytype</code></a></dt>
-
-        <dd>
-          <dl class="page-index">
-            <dt><a href="#registered_pytype-spec-synopsis">Class
-            <code>registered_pytype</code> synopsis</a></dt>
-
-          </dl>
-        </dd>
-      </dl>
-    </dd>
-
-    <dd>
-      <dl class="page-index">
-        <dt><a href="#expected_from_python_type-spec">Class
-        <code>expected_from_python_type</code></a></dt>
-
-        <dd>
-          <dl class="page-index">
-            <dt><a href="#expected_from_python_type-spec-synopsis">Class
-            <code>expected_from_python_type</code> synopsis</a></dt>
-
-          </dl>
-        </dd>
-      </dl>
-    </dd>
-
-    <dd>
-      <dl class="page-index">
-        <dt><a href="#to_python_target_type-spec">Class
-        <code>to_python_target_type</code></a></dt>
-
-        <dd>
-          <dl class="page-index">
-            <dt><a href="#to_python_target_type-spec-synopsis">Class
-            <code>to_python_target_type</code> synopsis</a></dt>
-
-          </dl>
-        </dd>
-      </dl>
-    </dd>
-
-    <dt><a href="#examples">Examples</a></dt>
-  </dl>
-  <hr>
-
-  <h2><a name="introduction" id=
-  "introduction"></a>Introduction</h2>
-
-  <p>To support Pythonic signatures the converters should supply a <code>get_pytype</code> function
-  returning a pointer to the associated <code>PyTypeObject</code>. See for example
-  <a href="ResultConverter.html#ResultConverter-concept">ResultConverter</a> or 
-  <a href="to_python_converter.html#to_python_converter-spec">to_python_converter</a>.
-  The classes in this header file are meant to be used when implmenting <code>get_pytype</code>.
-  There are also <code>_direct</code> versions of the templates of <code>class T</code> which
-  should be used with undecorated type parameter, expected to be in the conversion registry when the module loads.
-  </p>
-
-  <h2><a name="classes" id="classes"></a>Classes</h2>
-
-  <h3><a name="wrap_pytype-spec" id=
-  "wrap_pytype-spec"></a>Class
-  <code>wrap_pytype</code></h3>
-
-  <p>
-   This template generates a static <code>get_pytype</code> member returning the template parameter.
-  </p>
-
-  <h4><a name="wrap_pytype-spec-synopsis" id=
-  "wrap_pytype-spec-synopsis"></a>Class
-  <code>wrap_pytype</code> synopsis</h4>
-  <pre>
-namespace boost { namespace python { namespace converter{
-
-    template &lt; PyTypeObject const *pytype &gt;
-    class wrap_pytype 
-    {
-      public:
-          static PyTypeObject const *get_pytype(){return pytype; }
-    };
-
-}}}
-</pre>
-
-
-  <h3><a name="registered_pytype-spec" id=
-  "registered_pytype-spec"></a>Class
-  <code>registered_pytype</code></h3>
-
-  <p>
-   This template should be used with template parameters which are (possibly decorated)
-   types exported to python using <a href="class.html"><code>class_</code></a>.
-   The generated a static <code>get_pytype</code> member 
-   returns the corresponding python type.
-  </p>
-
-  <h4><a name="registered_pytype-spec-synopsis" id=
-  "registered_pytype-spec-synopsis"></a>Class
-  <code>registered_pytype</code> synopsis</h4>
-  <pre>
-namespace boost { namespace python { namespace converter{
-
-    template &lt; class T &gt;
-    class registered_pytype 
-    {
-      public:
-          static PyTypeObject const *get_pytype();
-    };
-
-}}}
-</pre>
-
-
-  <h3><a name="expected_from_python_type-spec" id=
-  "expected_from_python_type-spec"></a>Class
-  <code>expected_from_python_type</code></h3>
-
-  <p>
-   This template generates a static <code>get_pytype</code> member which inspects the registered
-   <code>from_python</code> converters for the type <code>T</code> and returns a matching python type.
-  </p>
-
-  <h4><a name="expected_from_python_type-spec-synopsis" id=
-  "expected_from_python_type-spec-synopsis"></a>Class
-  <code>expected_from_python_type</code> synopsis</h4>
-  <pre>
-namespace boost { namespace python { namespace converter{
-
-    template &lt; class T &gt;
-    class expected_from_python_type 
-    {
-      public:
-          static PyTypeObject const *get_pytype();
-    };
-
-}}}
-</pre>
-
-
-  <h3><a name="to_python_target_type-spec" id=
-  "to_python_target_type-spec"></a>Class
-  <code>to_python_target_type</code></h3>
-
-  <p>
-   This template generates a static <code>get_pytype</code> member returning the 
-   python type to which T can be converted.
-  </p>
-
-  <h4><a name="to_python_target_type-spec-synopsis" id=
-  "to_python_target_type-spec-synopsis"></a>Class
-  <code>to_python_target_type</code> synopsis</h4>
-  <pre>
-namespace boost { namespace python { namespace converter{
-
-    template &lt; class T &gt;
-    class to_python_target_type 
-    {
-      public:
-          static PyTypeObject const *get_pytype();
-    };
-
-}}}
-</pre>
-
-
-  <h2><a name="examples" id="examples"></a>Examples</h2>
-
-    This example presumes that someone has implemented the standard <a href=
-    "http://www.python.org/doc/2.2/ext/dnt-basics.html">noddy example
-    module</a> from the Python documentation, and placed the corresponding
-    declarations in <code>"noddy.h"</code>. Because
-    <code>noddy_NoddyObject</code> is the ultimate trivial extension type,
-    the example is a bit contrived: it wraps a function for which all
-    information is contained in the <i>type</i> of its return value.
-
-    <h3>C++ module definition</h3>
-<pre>
-#include &lt;boost/python/reference.hpp&gt;
-#include &lt;boost/python/module.hpp&gt;
-#include "noddy.h"
-
-struct tag {};
-tag make_tag() { return tag(); }
-
-using namespace boost::python;
-
-struct tag_to_noddy 
-#if defined BOOST_PYTHON_SUPPORTS_PY_SIGNATURES //unnecessary overhead if py signatures are not supported
-: wrap_pytype<&amp;noddy_NoddyType> //inherits get_pytype from wrap_pytype
-#endif
-{
-    static PyObject* convert(tag const&amp; x)
-    {
-        return PyObject_New(noddy_NoddyObject, &amp;noddy_NoddyType);
-    }
-};
-
-BOOST_PYTHON_MODULE(to_python_converter)
-{
-    def("make_tag", make_tag);
-    to_python_converter&lt;tag, tag_to_noddy
-#if defined BOOST_PYTHON_SUPPORTS_PY_SIGNATURES //invalid if py signatures are not supported
-          , true
-#endif
-          &gt;(); //"true" because tag_to_noddy has member get_pytype
-}
-</pre>
-
-
-<p>The following example registers to and from python converters using the templates
-<code>expected_from_python_type</code> and <code>to_pyhton_target_type</code>.
-</p>
-<pre>
-#include &lt;boost/python/module.hpp&gt;
-#include &lt;boost/python/def.hpp&gt;
-#include &lt;boost/python/extract.hpp&gt;
-#include &lt;boost/python/to_python_converter.hpp&gt;
-#include &lt;boost/python/class.hpp&gt;
-
-using namespace boost::python;
-
-struct A
-{
-};
-
-struct B
-{
-  A a;
-  B(const A& a_):a(a_){}
-};
-
-// Converter from A to python int
-struct BToPython 
-#if defined BOOST_PYTHON_SUPPORTS_PY_SIGNATURES //unnecessary overhead if py signatures are not supported
-   : converter::to_python_target_type&lt;A&gt;  //inherits get_pytype
-#endif
-{
-  static PyObject* convert(const B& b)
-  {
-    return incref(object(b.a).ptr());
-  }
-};
-
-// Conversion from python int to A
-struct BFromPython
-{
-  BFromPython()
-  {
-    boost::python::converter::registry::push_back
-        ( &amp;convertible
-        , &amp;construct
-        , type_id&lt; B &gt;()
-#if defined BOOST_PYTHON_SUPPORTS_PY_SIGNATURES //invalid if py signatures are not supported
-        , &amp;converter::expected_from_python_type&lt;A&gt;::get_pytype//convertible to A can be converted to B
-#endif
-        );
-  }
-
-  static void* convertible(PyObject* obj_ptr)
-  {
-      extract&lt;const A&&gt; ex(obj_ptr);
-      if (!ex.check()) return 0;
-      return obj_ptr;
-  }
-
-  static void construct(
-      PyObject* obj_ptr,
-      converter::rvalue_from_python_stage1_data* data)
-  {
-    void* storage = (
-        (converter::rvalue_from_python_storage&lt; B &gt;*)data)-&gt; storage.bytes;
-
-    extract&lt;const A&&gt; ex(obj_ptr);
-    new (storage) B(ex());
-    data->convertible = storage;
-  }
-};
-
-
-B func(const B& b) { return b ; }
-
-BOOST_PYTHON_MODULE(pytype_function_ext)
-{
-  to_python_converter&lt; B , BToPython
-#if defined BOOST_PYTHON_SUPPORTS_PY_SIGNATURES //invalid if py signatures are not supported
-             ,true 
-#endif
-             &gt;(); //has get_pytype
-  BFromPython();
-
-  class_&lt;A&gt;("A") ;
-
-  def("func", &amp;func);
-
-}
-
-
-
-&gt;&gt;&gt; from pytype_function_ext import *
-&gt;&gt;&gt; print func.__doc__
-func( (A)arg1) -> A :
-    C++ signature:
-         struct B func(struct B)
-</pre>
-
-
-  <p><i>&copy; Copyright <a href="mailto:nickm at sitius dot com">Nikolay Mladenov</a> 2007.</i></p>
-</body>
-</html>

doc/v2/raw_function.html

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

doc/v2/reference.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -609,66 +606,6 @@
         </dl>
       </dd>
 
-      <dd>
-        <a name="function_documentation"></a> 
-
-        <h3>Function documentation</h3>
-
-        <dl class="index">
-          <dt><a href=
-          "function_doc_signature.html">function_doc_signature.hpp</a></dt>
-
-          <dd>
-            <dl class="index">
-              <dt><a href=
-              "function_doc_signature.html#classes">Classes</a></dt>
-
-              <dd>
-                <dl class="index">
-                  <dt><a href=
-                  "function_doc_signature.html#function_doc_signature_generator-spec">function_doc_signature_generator</a></dt>
-
-                </dl>
-              </dd>
-            </dl>
-          </dd>
-        </dl>
-        <dl class="index">
-          <dt><a href=
-          "pytype_function.html">pytype_function.hpp</a></dt>
-
-          <dd>
-            <dl class="index">
-              <dt><a href=
-              "pytype_function.html#classes">Classes</a></dt>
-
-              <dd>
-                <dl class="index">
-                  <dt><a href=
-                  "pytype_function.html#wrap_pytype-spec">wrap_pytype</a></dt>
-
-                </dl>
-                <dl class="index">
-                  <dt><a href=
-                  "pytype_function.html#expected_from_python_type-spec">expected_from_python_type</a></dt>
-
-                </dl>
-                <dl class="index">
-                  <dt><a href=
-                  "pytype_function.html#to_python_target_type-spec">to_python_target_type</a></dt>
-
-                </dl>
-                <dl class="index">
-                  <dt><a href=
-                  "pytype_function.html#registered_pytype-spec">registered_pytype</a></dt>
-
-                </dl>
-              </dd>
-            </dl>
-          </dd>
-        </dl>
-      </dd>
-
       <dd>
         <a name="models_of_call_policies"></a> 
 
@@ -967,26 +904,26 @@
       </dd>
 
       <dt><a href=
-      "opaque.html">opaque_pointer_converter.hpp</a></dt>
+      "opaque_pointer_converter.html">opaque_pointer_converter.hpp</a></dt>
 
       <dd>
         <dl class="index">
           <dt><a href=
-          "opaque.html#classes">Classes</a></dt>
+          "opaque_pointer_converter.html#classes">Classes</a></dt>
 
           <dd>
             <dl class="index">
               <dt><a href=
-              "opaque.html#opaque-spec">opaque</a></dt>
+              "opaque_pointer_converter.html#opaque_pointer_converter-spec">opaque_pointer_converter</a></dt>
             </dl>
           </dd>
 
-          <dt><a href="opaque.html#macros">Macros</a></dt>
+          <dt><a href="opaque_pointer_converter.html#macros">Macros</a></dt>
 
           <dd>
             <dl class="index">
               <dt><a href=
-              "opaque.html#BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID-spec">
+              "opaque_pointer_converter.html#BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID-spec">
               BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID</a></dt>
             </dl>
           </dd>
@@ -1037,7 +974,6 @@
 
           <dd>
             <dl class="index">
-              <dt><a href="exec.html#eval-spec">eval</a></dt>
               <dt><a href="exec.html#exec-spec">exec</a></dt>
               <dt><a href="exec.html#exec_file-spec">exec_file</a></dt>
             </dl>
@@ -1155,16 +1091,6 @@
           </dd>
         </dl>
       </dd>
-
-      <dt><a href="ssize_t.html">ssize_t.hpp</a></dt>
-
-      <dd>
-        <dl class="index">
-          <dt><a href="ssize_t.html#typedefs">Typedefs</a></dt>
-
-          <dt><a href="ssize_t.html#constants">Constants</a></dt>
-        </dl>
-      </dd>
     </dl>
 
     <h2><a name="topics">Topics</a></h2>

doc/v2/reference_existing_object.html

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

doc/v2/register_ptr_to_python.html

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

doc/v2/return_arg.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta name="generator" content=
@@ -125,8 +122,6 @@ namespace boost { namespace python
    {
       static PyObject* postcall(PyObject*, PyObject* result);
       struct result_converter{ template &lt;class T&gt; struct apply; };
-      template &lt;class Sig&gt; struct extract_return_type : mpl::at_c&lt;Sig, arg_pos&gt;{};
-
    };
 }}
 </pre>

doc/v2/return_by_value.html

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

doc/v2/return_internal_reference.html

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

doc/v2/return_opaque_pointer.html

@@ -1,8 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 
-<!-- Copyright David Abrahams 2006. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
@@ -70,7 +67,7 @@
           undefined types such that the return value is copied into a
           new Python object.</p>
         <p>In addition to specifying the <code>return_opaque_pointer</code>
-          policy the <a href="opaque.html#BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID-spec">
+          policy the <a href="opaque_pointer_converter.html#BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID-spec">
           <code>BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID</code></a> macro must be
           used to define specializations for the 
           <a href="type_id.html#type_id-spec">type_id</a> function
@@ -177,8 +174,8 @@ if __name__ == '__main__':
 
     <h2><a name="see-also"></a>See Also</h2>
         <p>
-          <a href="opaque.html">
-            opaque</a>
+          <a href="opaque_pointer_converter.html">
+            opaque_pointer_converter</a>
         </p>
 
     <p>Revised