Merge pull request #13 from ax3l/fix-missingPlaceholderInclude

Fix Trac #10932 Missing Include: Bind Placeholders

build/Jamfile.v2

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

class.cpp

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

doc/PyConDC_2003/bpl_mods.txt

@@ -27,7 +27,6 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
           Somerville, MA 02143
 :Contact: dave@boost-consulting.com
 :organization: `Boost Consulting`_
-:date: $Date$
 :status: This is a "work in progress"
 :version: 1
 :copyright: Copyright David Abrahams 2002. All rights reserved

doc/PyConDC_2003/default.css

@@ -1,8 +1,6 @@
 /*
 :Author: David Goodger
 :Contact: goodger@users.sourceforge.net
-:date: $Date$
-:version: $Revision$
 :copyright: This stylesheet has been placed in the public domain.
 
 boostinspect:nolicense

doc/building.html

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

doc/building.rst

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

doc/news.html

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

doc/projects.html

@@ -375,27 +375,54 @@
       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>
+    <dt><b><a href="http://polybori.sourceforge.net/">PolyBoRi</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><a href="mailto:brickenstein@mfo.de"
+        >Michael Brickenstein</a> writes:</p>
 
-      <p>For our internal software, we implement core data structures in C
-      and expose them to Python using Boost.Python. Algorithm development 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>
+      <blockquote>
+        <p>The core of PolyBoRi is a C++ library, which provides
+        high-level data types for Boolean polynomials and monomials,
+        exponent vectors, as well as for the underlying polynomial
+        rings and subsets of the powerset of the Boolean variables. As
+        a unique approach, binary decision diagrams are used as
+        internal storage type for polynomial structures. On top of
+        this C++-library we provide a Python interface. This allows
+        parsing of complex polynomial systems, as well as sophisticated
+        and extendable strategies for Gr&ouml;bner basis computation.
+        Boost.Python has helped us to create this interface in a
+        very clean way.</p>
+      </blockquote>
+    </dd>
+
+    <dt><b><a href="http://pyrap.googlecode.com/">Pyrap</a></b></dt>
+    <dd>
+      <p><a href="diepen@astron.nl"
+        >Ger van Diepen</a> writes:</p>
+
+      <blockquote>
+        <p>Pyrap is the python interface to the Radio-Astronomical Package
+        casacore (<a href="http://casacore.googlecode.com/"
+        >casacore.googlecode.com</a>). Astronomers love pyrap because
+        it makes it easily possible to get their data (observed with
+        radio-astronomical telescopes like LOFAR, ASKAP, and eVLA) in numpy
+        arrays and do basic data inspection and manipulation using the many
+        python packages that are available.</p>
+
+        <p>Boost.Python made it quite easily possible to create converters for
+        the various data types, also for numpy arrays and individual elements
+        of a numpy array. It's nice they work fully recursively. Mapping C++
+        functions to Python was straightforward.</p>
+      </blockquote>
+    </dd>
+
+    <dt><b><a href="http://www.rdkit.org/"
+           >RDKit: Cheminformatics and Machine Learning Software</a></b></dt>
+
+    <dd>
+      A collection of cheminformatics and machine-learning software
+      written in C++ and Python.
     </dd>
   </dl>
 
@@ -435,11 +462,11 @@
   </dl>
   <hr>
 
-  <p>Revised 
+  <p>Revised
   <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-   15 July, 2003</p>
+   29 May, 2008</p>
 
   <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
-  Abrahams</a> 2002-2003.</i></p>
+  Abrahams</a> 2002-2008.</i></p>
 </body>
 </html>

doc/tutorial/doc/Jamfile.v2

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

doc/tutorial/doc/html/index.html

@@ -1,10 +1,10 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Chapter 1. python 1.0</title>
-<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-<link rel="start" href="index.html" title="Chapter 1. python 1.0">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Chapter&#160;1.&#160;python 2.0</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="index.html" title="Chapter&#160;1.&#160;python 2.0">
 <link rel="next" href="python/hello.html" title="Building Hello World">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -12,26 +12,26 @@
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/people/people.htm">People</a></td>
-<td align="center"><a href="http://www.boost.org/more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
-<div class="spirit-nav"><a accesskey="n" href="python/hello.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a></div>
-<div class="chapter" lang="en">
+<div class="spirit-nav"><a accesskey="n" href="python/hello.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a></div>
+<div class="chapter">
 <div class="titlepage"><div>
 <div><h2 class="title">
-<a name="python"></a>Chapter 1. python 1.0</h2></div>
+<a name="python"></a>Chapter&#160;1.&#160;python 2.0</h2></div>
 <div><div class="author"><h3 class="author">
 <span class="firstname">Joel</span> <span class="surname">de Guzman</span>
 </h3></div></div>
 <div><div class="author"><h3 class="author">
 <span class="firstname">David</span> <span class="surname">Abrahams</span>
 </h3></div></div>
-<div><p class="copyright">Copyright © 2002-2005 Joel
+<div><p class="copyright">Copyright &#169; 2002-2005 Joel
       de Guzman, David Abrahams</p></div>
 <div><div class="legalnotice">
-<a name="id2625929"></a><p>
+<a name="python.legal"></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>)
@@ -42,8 +42,8 @@
 <p><b>Table of Contents</b></p>
 <dl>
 <dt><span class="section"><a href="index.html#python.quickstart">QuickStart</a></span></dt>
-<dt><span class="section"><a href="python/hello.html"> Building Hello World</a></span></dt>
-<dt><span class="section"><a href="python/exposing.html"> Exposing Classes</a></span></dt>
+<dt><span class="section"><a href="python/hello.html">Building Hello World</a></span></dt>
+<dt><span class="section"><a href="python/exposing.html">Exposing Classes</a></span></dt>
 <dd><dl>
 <dt><span class="section"><a href="python/exposing.html#python.constructors">Constructors</a></span></dt>
 <dt><span class="section"><a href="python/exposing.html#python.class_data_members">Class Data Members</a></span></dt>
@@ -60,18 +60,19 @@
 <dt><span class="section"><a href="python/functions.html#python.default_arguments">Default Arguments</a></span></dt>
 <dt><span class="section"><a href="python/functions.html#python.auto_overloading">Auto-Overloading</a></span></dt>
 </dl></dd>
-<dt><span class="section"><a href="python/object.html"> Object Interface</a></span></dt>
+<dt><span class="section"><a href="python/object.html">Object Interface</a></span></dt>
 <dd><dl>
 <dt><span class="section"><a href="python/object.html#python.basic_interface">Basic Interface</a></span></dt>
 <dt><span class="section"><a href="python/object.html#python.derived_object_types">Derived Object types</a></span></dt>
 <dt><span class="section"><a href="python/object.html#python.extracting_c___objects">Extracting C++ objects</a></span></dt>
 <dt><span class="section"><a href="python/object.html#python.enums">Enums</a></span></dt>
+<dt><span class="section"><a href="python/object.html#python.creating_python_object">Creating <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">object</span></code> from <code class="computeroutput"><span class="identifier">PyObject</span><span class="special">*</span></code></a></span></dt>
 </dl></dd>
 <dt><span class="section"><a href="python/embedding.html">Embedding</a></span></dt>
 <dd><dl><dt><span class="section"><a href="python/embedding.html#python.using_the_interpreter">Using the interpreter</a></span></dt></dl></dd>
 <dt><span class="section"><a href="python/iterators.html">Iterators</a></span></dt>
-<dt><span class="section"><a href="python/exception.html"> Exception Translation</a></span></dt>
-<dt><span class="section"><a href="python/techniques.html"> General Techniques</a></span></dt>
+<dt><span class="section"><a href="python/exception.html">Exception Translation</a></span></dt>
+<dt><span class="section"><a href="python/techniques.html">General Techniques</a></span></dt>
 <dd><dl>
 <dt><span class="section"><a href="python/techniques.html#python.creating_packages">Creating Packages</a></span></dt>
 <dt><span class="section"><a href="python/techniques.html#python.extending_wrapped_objects_in_python">Extending Wrapped Objects in Python</a></span></dt>
@@ -79,7 +80,7 @@
 </dl></dd>
 </dl>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="python.quickstart"></a>QuickStart</h2></div></div></div>
 <p>
@@ -93,16 +94,15 @@
       code takes on the look of a kind of declarative interface definition language
       (IDL).
     </p>
-<a name="quickstart.hello_world"></a><h3>
-<a name="id2625972"></a>
+<h3>
+<a name="quickstart.hello_world"></a>
       Hello World
     </h3>
 <p>
       Following C/C++ tradition, let's start with the "hello, world". A
       C++ Function:
     </p>
-<pre class="programlisting">
-<span class="keyword">char</span> <span class="keyword">const</span><span class="special">*</span> <span class="identifier">greet</span><span class="special">()</span>
+<pre class="programlisting"><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*</span> <span class="identifier">greet</span><span class="special">()</span>
 <span class="special">{</span>
    <span class="keyword">return</span> <span class="string">"hello, world"</span><span class="special">;</span>
 <span class="special">}</span>
@@ -110,8 +110,7 @@
 <p>
       can be exposed to Python by writing a Boost.Python wrapper:
     </p>
-<pre class="programlisting">
-<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">hello_ext</span><span class="special">)</span>
 <span class="special">{</span>
@@ -123,32 +122,21 @@
       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>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello_ext</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello_ext</span>
+<span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">hello_ext</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span>
 <span class="identifier">hello</span><span class="special">,</span> <span class="identifier">world</span>
 </pre>
-<p>
-    </p>
-<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>
+<div class="blockquote"><blockquote class="blockquote"><p>
+        <span class="emphasis"><em><span class="bold"><strong>Next stop... Building your Hello World module
+        from start to finish...</strong></span></em></span>
+      </p></blockquote></div>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: March 15, 2008 at 13:46:47 GMT</small></p></td>
+<td align="left"><p><small>Last revised: December 26, 2011 at 21:58:39 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>
-<div class="spirit-nav"><a accesskey="n" href="python/hello.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a></div>
+<div class="spirit-nav"><a accesskey="n" href="python/hello.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a></div>
 </body>
 </html>

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

@@ -1,28 +1,28 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>Embedding</title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="prev" href="object.html" title=" Object Interface">
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
+<link rel="prev" href="object.html" title="Object Interface">
 <link rel="next" href="iterators.html" title="Iterators">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="object.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="iterators.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="object.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="iterators.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="python.embedding"></a>Embedding</h2></div></div></div>
 <div class="toc"><dl><dt><span class="section"><a href="embedding.html#python.using_the_interpreter">Using the interpreter</a></span></dt></dl></div>
@@ -39,28 +39,28 @@
       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><h2>
-<a name="id471329"></a>
+<h3>
+<a name="embedding.building_embedded_programs"></a>
       Building embedded programs
-    </h2>
+    </h3>
 <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.
     </p>
 <p>
       Boost.Python's 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
+      <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.
     </p>
 <p>
-      Python's library can be found in the <tt class="literal">/libs</tt> subdirectory
+      Python's library can be found in the <code class="literal">/libs</code> subdirectory
       of your Python directory. On Windows it is called pythonXY.lib where X.Y is
       your major Python version number.
     </p>
 <p>
-      Additionally, Python's <tt class="literal">/include</tt> subdirectory has to be added
+      Additionally, Python's <code class="literal">/include</code> subdirectory has to be added
       to your include path.
     </p>
 <p>
@@ -81,72 +81,64 @@ exe embedded_program # name of the executable
     &lt;library-path&gt;$(PYTHON_LIB_PATH)
     &lt;find-library&gt;$(PYTHON_EMBEDDED_LIBRARY) ;
 </pre>
-<a name="embedding.getting_started"></a><h2>
-<a name="id471434"></a>
+<h3>
+<a name="embedding.getting_started"></a>
       Getting started
-    </h2>
+    </h3>
 <p>
       Being able to build is nice, but there is nothing to build yet. Embedding the
       Python interpreter into one of your C++ programs requires these 4 steps:
     </p>
-<div class="orderedlist"><ol type="1">
-<li>
-        #include <tt class="literal">&lt;boost/python.hpp&gt;</tt>
-</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 <tt class="literal"><span class="underline">_main</span>_</tt>
-        module.
-      </li>
-<li>
-        Call other Python C API routines to use the interpreter.
-      </li>
+<div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+          #include <code class="literal">&lt;boost/python.hpp&gt;</code>
+        </li>
+<li class="listitem">
+          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">__main__</code> module.
+        </li>
+<li class="listitem">
+          Call other Python C API routines to use the interpreter.
+        </li>
 </ol></div>
 <div class="note"><table border="0" summary="Note">
 <tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/html/images/note.png"></td>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
 <th align="left">Note</th>
 </tr>
-<tr><td colspan="2" align="left" valign="top"><p>
-        <span class="bold"><b>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.</b></span>
+<tr><td align="left" valign="top"><p>
+        <span class="bold"><strong>Note that at this time you must not call <a href="http://www.python.org/doc/current/api/initialization.html#l2h-656" target="_top">Py_Finalize</a>()
+        to stop the interpreter. This may be fixed in a future version of boost.python.</strong></span>
       </p></td></tr>
 </table></div>
 <p>
       (Of course, there can be other C++ code between all of these steps.)
     </p>
-<div class="blockquote"><blockquote class="blockquote">
-<p>
-        </p>
-<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>
-<p>
-      </p>
-</blockquote></div>
-<div class="section" lang="en">
+<div class="blockquote"><blockquote class="blockquote"><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></blockquote></div>
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.using_the_interpreter"></a>Using the interpreter</h3></div></div></div>
 <p>
         As you probably already know, objects in Python are reference-counted. Naturally,
-        the <tt class="literal">PyObject</tt>s of the Python/C API are also reference-counted.
+        the <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
+        in Python, the Python C API requires you to do it <a href="http://www.python.org/doc/current/c-api/refcounting.html" target="_top">by
+        hand</a>. This is messy and especially hard to get right in the presence
         of C++ exceptions. Fortunately Boost.Python provides the <a href="../../../../v2/handle.html" target="_top">handle</a>
         and <a href="../../../../v2/object.html" target="_top">object</a> class templates to
         automate the process.
       </p>
-<a name="using_the_interpreter.running_python_code"></a><h2>
-<a name="id471597"></a>
+<h3>
+<a name="using_the_interpreter.running_python_code"></a>
         Running Python code
-      </h2>
+      </h3>
 <p>
         Boost.python provides three related functions to run Python code from C++.
       </p>
-<pre class="programlisting">
-<span class="identifier">object</span> <span class="identifier">eval</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">expression</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">globals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">(),</span> <span class="identifier">object</span> <span class="identifier">locals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">())</span>
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">eval</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">expression</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">globals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">(),</span> <span class="identifier">object</span> <span class="identifier">locals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">())</span>
 <span class="identifier">object</span> <span class="identifier">exec</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">code</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">globals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">(),</span> <span class="identifier">object</span> <span class="identifier">locals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">())</span>
 <span class="identifier">object</span> <span class="identifier">exec_file</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">filename</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">globals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">(),</span> <span class="identifier">object</span> <span class="identifier">locals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">())</span>
 </pre>
@@ -156,28 +148,25 @@ exe embedded_program # name of the executable
         and exec_file executes the code contained in the given file.
       </p>
 <p>
-        The <tt class="literal">globals</tt> and <tt class="literal">locals</tt> parameters are
+        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 <tt class="literal"><span class="underline">_main</span>_</tt>
-        module for both parameters.
+        dictionary of the <code class="literal">__main__</code> module for both parameters.
       </p>
 <p>
         Boost.python provides a function to import a module:
       </p>
-<pre class="programlisting">
-<span class="identifier">object</span> <span class="identifier">import</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">name</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">import</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">name</span><span class="special">)</span>
 </pre>
 <p>
         import imports a python module (potentially loading it into the running process
         first), and returns it.
       </p>
 <p>
-        Let's import the <tt class="literal"><span class="underline">_main</span>_</tt>
-        module and run some Python code in its namespace:
+        Let's import the <code class="literal">__main__</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>
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">main_module</span> <span class="special">=</span> <span class="identifier">import</span><span class="special">(</span><span class="string">"__main__"</span><span class="special">);</span>
 <span class="identifier">object</span> <span class="identifier">main_namespace</span> <span class="special">=</span> <span class="identifier">main_module</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">);</span>
 
 <span class="identifier">object</span> <span class="identifier">ignored</span> <span class="special">=</span> <span class="identifier">exec</span><span class="special">(</span><span class="string">"hello = file('hello.txt', 'w')\n"</span>
@@ -189,74 +178,70 @@ exe embedded_program # name of the executable
         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><h2>
-<a name="id472185"></a>
+<h3>
+<a name="using_the_interpreter.manipulating_python_objects"></a>
         Manipulating Python objects
-      </h2>
+      </h3>
 <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 <tt class="literal">object</tt> class and its
-        derivatives. We've already seen that they can be constructed from a <tt class="literal">handle</tt>.
+        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>.
         The following examples should further illustrate this fact:
       </p>
-<pre class="programlisting">
-<span class="identifier">object</span> <span class="identifier">main_module</span> <span class="special">=</span> <span class="identifier">import</span><span class="special">(</span><span class="string">"__main__"</span><span class="special">);</span>
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">main_module</span> <span class="special">=</span> <span class="identifier">import</span><span class="special">(</span><span class="string">"__main__"</span><span class="special">);</span>
 <span class="identifier">object</span> <span class="identifier">main_namespace</span> <span class="special">=</span> <span class="identifier">main_module</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">);</span>
 <span class="identifier">object</span> <span class="identifier">ignored</span> <span class="special">=</span> <span class="identifier">exec</span><span class="special">(</span><span class="string">"result = 5 ** 2"</span><span class="special">,</span> <span class="identifier">main_namespace</span><span class="special">);</span>
 <span class="keyword">int</span> <span class="identifier">five_squared</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">main_namespace</span><span class="special">[</span><span class="string">"result"</span><span class="special">]);</span>
 </pre>
 <p>
-        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:
+        Here we create a dictionary object for the <code class="literal">__main__</code> module's
+        namespace. Then we assign 5 squared to the result variable and read this
+        variable from the dictionary. Another way to achieve the same result is to
+        use eval instead, which returns the result directly:
       </p>
-<pre class="programlisting">
-<span class="identifier">object</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">eval</span><span class="special">(</span><span class="string">"5 ** 2"</span><span class="special">);</span>
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">eval</span><span class="special">(</span><span class="string">"5 ** 2"</span><span class="special">);</span>
 <span class="keyword">int</span> <span class="identifier">five_squared</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">result</span><span class="special">);</span>
 </pre>
-<a name="using_the_interpreter.exception_handling"></a><h2>
-<a name="id472557"></a>
+<h3>
+<a name="using_the_interpreter.exception_handling"></a>
         Exception handling
-      </h2>
+      </h3>
 <p>
         If an exception occurs in the evaluation of the python expression, <a href="../../../../v2/errors.html#error_already_set-spec" target="_top">error_already_set</a>
         is thrown:
       </p>
-<pre class="programlisting">
-<span class="keyword">try</span>
+<pre class="programlisting"><span class="keyword">try</span>
 <span class="special">{</span>
     <span class="identifier">object</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">eval</span><span class="special">(</span><span class="string">"5/0"</span><span class="special">);</span>
-    <span class="comment">// execution will never get here:
-</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="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="special">{</span>
-    <span class="comment">// handle the exception in some way
-</span><span class="special">}</span>
+    <span class="comment">// handle the exception in some way</span>
+<span class="special">}</span>
 </pre>
 <p>
-        The <tt class="literal">error_already_set</tt> exception class doesn't carry any
+        The <code class="literal">error_already_set</code> exception class doesn't carry any
         information in itself. To find out more about the Python exception that occurred,
         you need to use the <a href="http://www.python.org/doc/api/exceptionHandling.html" target="_top">exception
-        handling functions</a> of the Python<span class="emphasis"><em>C API in your catch-statement.
-        This can be as simple as calling [@http:</em></span>/www.python.org/doc/api/exceptionHandling.html#l2h-70
-        PyErr_Print()] to print the exception's traceback to the console, or comparing
-        the type of the exception with those of the <a href="http://www.python.org/doc/api/standardExceptions.html" target="_top">standard
+        handling functions</a> of the Python C API in your catch-statement. This
+        can be as simple as calling <a href="http://www.python.org/doc/api/exceptionHandling.html#l2h-70" target="_top">PyErr_Print()</a>
+        to print the exception's traceback to the console, or comparing the type
+        of the exception with those of the <a href="http://www.python.org/doc/api/standardExceptions.html" target="_top">standard
         exceptions</a>:
       </p>
-<pre class="programlisting">
-<span class="keyword">catch</span><span class="special">(</span><span class="identifier">error_already_set</span> <span class="keyword">const</span> <span class="special">&amp;)</span>
+<pre class="programlisting"><span class="keyword">catch</span><span class="special">(</span><span class="identifier">error_already_set</span> <span class="keyword">const</span> <span class="special">&amp;)</span>
 <span class="special">{</span>
     <span class="keyword">if</span> <span class="special">(</span><span class="identifier">PyErr_ExceptionMatches</span><span class="special">(</span><span class="identifier">PyExc_ZeroDivisionError</span><span class="special">))</span>
     <span class="special">{</span>
-        <span class="comment">// handle ZeroDivisionError specially
-</span>    <span class="special">}</span>
+        <span class="comment">// handle ZeroDivisionError specially</span>
+    <span class="special">}</span>
     <span class="keyword">else</span>
     <span class="special">{</span>
-        <span class="comment">// print all other errors to stderr
-</span>        <span class="identifier">PyErr_Print</span><span class="special">();</span>
+        <span class="comment">// print all other errors to stderr</span>
+        <span class="identifier">PyErr_Print</span><span class="special">();</span>
     <span class="special">}</span>
 <span class="special">}</span>
 </pre>
@@ -268,7 +253,7 @@ exe embedded_program # name of the executable
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
       de Guzman, David Abrahams<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
@@ -278,7 +263,7 @@ exe embedded_program # name of the executable
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="object.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="iterators.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="object.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="iterators.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

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

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

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

@@ -1,30 +1,30 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Exposing Classes</title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="prev" href="hello.html" title=" Building Hello World">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Exposing Classes</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
+<link rel="prev" href="hello.html" title="Building Hello World">
 <link rel="next" href="functions.html" title="Functions">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="hello.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="functions.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="hello.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="functions.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="python.exposing"></a> Exposing Classes</h2></div></div></div>
+<a name="python.exposing"></a>Exposing Classes</h2></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="exposing.html#python.constructors">Constructors</a></span></dt>
 <dt><span class="section"><a href="exposing.html#python.class_data_members">Class Data Members</a></span></dt>
@@ -40,8 +40,7 @@
 <p>
       Consider a C++ class/struct that we want to expose to Python:
     </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">World</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">World</span>
 <span class="special">{</span>
     <span class="keyword">void</span> <span class="identifier">set</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">msg</span><span class="special">)</span> <span class="special">{</span> <span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">msg</span> <span class="special">=</span> <span class="identifier">msg</span><span class="special">;</span> <span class="special">}</span>
     <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">greet</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">msg</span><span class="special">;</span> <span class="special">}</span>
@@ -51,8 +50,7 @@
 <p>
       We can expose this to Python by writing a corresponding Boost.Python C++ Wrapper:
     </p>
-<pre class="programlisting">
-<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">;</span>
 
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">hello</span><span class="special">)</span>
@@ -64,55 +62,47 @@
 <span class="special">}</span>
 </pre>
 <p>
-      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
+      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
       session:
     </p>
-<p>
-    </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">planet</span> <span class="special">=</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">World</span><span class="special">()</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">planet</span><span class="special">.</span><span class="identifier">set</span><span class="special">(</span><span class="string">'howdy'</span><span class="special">)</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">planet</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span>
 <span class="string">'howdy'</span>
 </pre>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.constructors"></a>Constructors</h3></div></div></div>
 <p>
-        Our previous example didn't have any explicit constructors. Since <tt class="literal">World</tt>
+        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
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">planet</span> <span class="special">=</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">World</span><span class="special">()</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">planet</span> <span class="special">=</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">World</span><span class="special">()</span>
 </pre>
 <p>
         We may wish to wrap a class with a non-default constructor. Let us build
         on our previous example:
       </p>
-<p>
-      </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">World</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">World</span>
 <span class="special">{</span>
-    <span class="identifier">World</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">msg</span><span class="special">):</span> <span class="identifier">msg</span><span class="special">(</span><span class="identifier">msg</span><span class="special">)</span> <span class="special">{}</span> <span class="comment">// added constructor
-</span>    <span class="keyword">void</span> <span class="identifier">set</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">msg</span><span class="special">)</span> <span class="special">{</span> <span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">msg</span> <span class="special">=</span> <span class="identifier">msg</span><span class="special">;</span> <span class="special">}</span>
+    <span class="identifier">World</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">msg</span><span class="special">):</span> <span class="identifier">msg</span><span class="special">(</span><span class="identifier">msg</span><span class="special">)</span> <span class="special">{}</span> <span class="comment">// added constructor</span>
+    <span class="keyword">void</span> <span class="identifier">set</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">msg</span><span class="special">)</span> <span class="special">{</span> <span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">msg</span> <span class="special">=</span> <span class="identifier">msg</span><span class="special">;</span> <span class="special">}</span>
     <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">greet</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">msg</span><span class="special">;</span> <span class="special">}</span>
     <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">msg</span><span class="special">;</span>
 <span class="special">};</span>
 </pre>
 <p>
-        This time <tt class="literal">World</tt> has no default constructor; our previous
+        This time <code class="literal">World</code> has no default constructor; our previous
         wrapping code would fail to compile when the library tried to expose it.
-        We have to tell <tt class="literal">class_&lt;World&gt;</tt> about the constructor
+        We have to tell <code class="literal">class_&lt;World&gt;</code> about the constructor
         we want to expose instead.
       </p>
-<pre class="programlisting">
-<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">;</span>
 
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">hello</span><span class="special">)</span>
@@ -124,17 +114,16 @@
 <span class="special">}</span>
 </pre>
 <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>").
+        <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">"__init__"</code>").
       </p>
 <p>
-        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
+        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
         another World constructor taking in two doubles:
       </p>
-<pre class="programlisting">
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">World</span><span class="special">&gt;(</span><span class="string">"World"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span>
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">World</span><span class="special">&gt;(</span><span class="string">"World"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span>
     <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">init</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;())</span>
     <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"greet"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">World</span><span class="special">::</span><span class="identifier">greet</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"set"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">World</span><span class="special">::</span><span class="identifier">set</span><span class="special">)</span>
@@ -142,27 +131,25 @@
 </pre>
 <p>
         On the other hand, if we do not wish to expose any constructors at all, we
-        may use <tt class="literal">no_init</tt> instead:
+        may use <code class="literal">no_init</code> instead:
       </p>
-<pre class="programlisting">
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Abstract</span><span class="special">&gt;(</span><span class="string">"Abstract"</span><span class="special">,</span> <span class="identifier">no_init</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Abstract</span><span class="special">&gt;(</span><span class="string">"Abstract"</span><span class="special">,</span> <span class="identifier">no_init</span><span class="special">)</span>
 </pre>
 <p>
-        This actually adds an <tt class="literal"><span class="underline">_init</span>_</tt>
-        method which always raises a Python RuntimeError exception.
+        This actually adds an <code class="literal">__init__</code> method which always raises
+        a Python RuntimeError exception.
       </p>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.class_data_members"></a>Class Data Members</h3></div></div></div>
 <p>
         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"><b>read-only</b></span>
-        or <span class="bold"><b>read-write</b></span>. Consider this class <tt class="literal">Var</tt>:
+        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>:
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">Var</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Var</span>
 <span class="special">{</span>
     <span class="identifier">Var</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">name</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">name</span><span class="special">(</span><span class="identifier">name</span><span class="special">),</span> <span class="identifier">value</span><span class="special">()</span> <span class="special">{}</span>
     <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="keyword">const</span> <span class="identifier">name</span><span class="special">;</span>
@@ -170,11 +157,10 @@
 <span class="special">};</span>
 </pre>
 <p>
-        Our C++ <tt class="literal">Var</tt> class and its data members can be exposed
+        Our C++ <code class="literal">Var</code> class and its data members can be exposed
         to Python:
       </p>
-<pre class="programlisting">
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Var</span><span class="special">&gt;(</span><span class="string">"Var"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span>
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Var</span><span class="special">&gt;(</span><span class="string">"Var"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span>
     <span class="special">.</span><span class="identifier">def_readonly</span><span class="special">(</span><span class="string">"name"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Var</span><span class="special">::</span><span class="identifier">name</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">def_readwrite</span><span class="special">(</span><span class="string">"value"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Var</span><span class="special">::</span><span class="identifier">value</span><span class="special">);</span>
 </pre>
@@ -182,26 +168,22 @@
         Then, in Python, assuming we have placed our Var class inside the namespace
         hello as we did before:
       </p>
-<p>
-      </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">Var</span><span class="special">(</span><span class="string">'pi'</span><span class="special">)</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">Var</span><span class="special">(</span><span class="string">'pi'</span><span class="special">)</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">value</span> <span class="special">=</span> <span class="number">3.14</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">name</span><span class="special">,</span> <span class="string">'is around'</span><span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">value</span>
 <span class="identifier">pi</span> <span class="keyword">is</span> <span class="identifier">around</span> <span class="number">3.14</span>
 </pre>
 <p>
-        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>.
+        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>.
       </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
-</span><span class="identifier">Traceback</span> <span class="special">(</span><span class="identifier">most</span> <span class="identifier">recent</span> <span class="identifier">call</span> <span class="identifier">last</span><span class="special">):</span>
-  <span class="identifier">File</span> <span class="string">"&lt;stdin&gt;"</span><span class="special">,</span> <span class="identifier">line</span> <span class="number">1</span><span class="special">,</span> <span class="keyword">in</span> #
-<span class="identifier">AttributeError</span><span class="special">:</span> <span class="identifier">can</span>#<span class="identifier">t</span> <span class="identifier">set</span> <span class="identifier">attribute</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">name</span> <span class="special">=</span> <span class="string">'e'</span> <span class="comment"># can't change name</span>
+<span class="identifier">Traceback</span> <span class="special">(</span><span class="identifier">most</span> <span class="identifier">recent</span> <span class="identifier">call</span> <span class="identifier">last</span><span class="special">):</span>
+  <span class="identifier">File</span> <span class="string">"&lt;stdin&gt;"</span><span class="special">,</span> <span class="identifier">line</span> <span class="number">1</span><span class="special">,</span> <span class="keyword">in</span> <span class="error">?</span>
+<span class="identifier">AttributeError</span><span class="special">:</span> <span class="identifier">can</span><span class="error">'</span><span class="identifier">t</span> <span class="identifier">set</span> <span class="identifier">attribute</span>
 </pre>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.class_properties"></a>Class Properties</h3></div></div></div>
 <p>
@@ -210,10 +192,7 @@
         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>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Num</span>
 <span class="special">{</span>
     <span class="identifier">Num</span><span class="special">();</span>
     <span class="keyword">float</span> <span class="identifier">get</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
@@ -224,38 +203,31 @@
 <p>
         However, in Python attribute access is fine; it doesn't neccessarily break
         encapsulation to let users handle attributes directly, because the attributes
-        can just be a different syntax for a method call. Wrapping our <tt class="literal">Num</tt>
+        can just be a different syntax for a method call. Wrapping our <code class="literal">Num</code>
         class using Boost.Python:
       </p>
-<pre class="programlisting">
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Num</span><span class="special">&gt;(</span><span class="string">"Num"</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Num</span><span class="special">&gt;(</span><span class="string">"Num"</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">add_property</span><span class="special">(</span><span class="string">"rovalue"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">get</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">add_property</span><span class="special">(</span><span class="string">"value"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">get</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">set</span><span class="special">);</span>
 </pre>
 <p>
         And at last, in Python:
       </p>
-<p>
-      </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">Num</span><span class="special">()</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">Num</span><span class="special">()</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">value</span> <span class="special">=</span> <span class="number">3.14</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">value</span><span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">rovalue</span>
 <span class="special">(</span><span class="number">3.14</span><span class="special">,</span> <span class="number">3.14</span><span class="special">)</span>
-<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>
+<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">rovalue</span> <span class="special">=</span> <span class="number">2.17</span> <span class="comment"># error!</span>
+</pre>
 <p>
-        Take note that the class property <tt class="literal">rovalue</tt> is exposed as
-        <span class="bold"><b>read-only</b></span> since the <tt class="literal">rovalue</tt>
+        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>
         setter member function is not passed in:
       </p>
-<p>
-      </p>
-<pre class="programlisting">
-<span class="special">.</span><span class="identifier">add_property</span><span class="special">(</span><span class="string">"rovalue"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">get</span><span class="special">)</span>
+<pre class="programlisting"><span class="special">.</span><span class="identifier">add_property</span><span class="special">(</span><span class="string">"rovalue"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">get</span><span class="special">)</span>
 </pre>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.inheritance"></a>Inheritance</h3></div></div></div>
 <p>
@@ -268,85 +240,78 @@
 <p>
         Consider this trivial inheritance structure:
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">Base</span> <span class="special">{</span> <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">Base</span><span class="special">();</span> <span class="special">};</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Base</span> <span class="special">{</span> <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">Base</span><span class="special">();</span> <span class="special">};</span>
 <span class="keyword">struct</span> <span class="identifier">Derived</span> <span class="special">:</span> <span class="identifier">Base</span> <span class="special">{};</span>
 </pre>
 <p>
-        And a set of C++ functions operating on <tt class="literal">Base</tt> and <tt class="literal">Derived</tt>
+        And a set of C++ functions operating on <code class="literal">Base</code> and <code class="literal">Derived</code>
         object instances:
       </p>
-<pre class="programlisting">
-<span class="keyword">void</span> <span class="identifier">b</span><span class="special">(</span><span class="identifier">Base</span><span class="special">*);</span>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">b</span><span class="special">(</span><span class="identifier">Base</span><span class="special">*);</span>
 <span class="keyword">void</span> <span class="identifier">d</span><span class="special">(</span><span class="identifier">Derived</span><span class="special">*);</span>
 <span class="identifier">Base</span><span class="special">*</span> <span class="identifier">factory</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="keyword">new</span> <span class="identifier">Derived</span><span class="special">;</span> <span class="special">}</span>
 </pre>
 <p>
-        We've seen how we can wrap the base class <tt class="literal">Base</tt>:
+        We've seen how we can wrap the base class <code class="literal">Base</code>:
       </p>
-<pre class="programlisting">
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
     <span class="comment">/*...*/</span>
     <span class="special">;</span>
 </pre>
 <p>
-        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:
+        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:
       </p>
-<pre class="programlisting">
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Derived</span><span class="special">,</span> <span class="identifier">bases</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span> <span class="special">&gt;(</span><span class="string">"Derived"</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Derived</span><span class="special">,</span> <span class="identifier">bases</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span> <span class="special">&gt;(</span><span class="string">"Derived"</span><span class="special">)</span>
     <span class="comment">/*...*/</span>
     <span class="special">;</span>
 </pre>
 <p>
         Doing so, we get some things for free:
       </p>
-<div class="orderedlist"><ol type="1">
-<li>
-          Derived automatically inherits all of Base's Python methods (wrapped C++
-          member functions)
-        </li>
-<li>
-<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
-          <tt class="literal">Base</tt> can be passed where a pointer or reference to
-          <tt class="literal">Derived</tt> is expected.
-        </li>
+<div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+            Derived automatically inherits all of Base's Python methods (wrapped
+            C++ member functions)
+          </li>
+<li class="listitem">
+            <span class="bold"><strong>If</strong></span> Base is polymorphic, <code class="literal">Derived</code>
+            objects which have been passed to Python via a pointer or reference to
+            <code class="literal">Base</code> can be passed where a pointer or reference to
+            <code class="literal">Derived</code> is expected.
+          </li>
 </ol></div>
 <p>
-        Now, we will expose the C++ free functions <tt class="literal">b</tt> and <tt class="literal">d</tt>
-        and <tt class="literal">factory</tt>:
+        Now, we will expose the C++ free functions <code class="literal">b</code> and <code class="literal">d</code>
+        and <code class="literal">factory</code>:
       </p>
-<pre class="programlisting">
-<span class="identifier">def</span><span class="special">(</span><span class="string">"b"</span><span class="special">,</span> <span class="identifier">b</span><span class="special">);</span>
+<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"b"</span><span class="special">,</span> <span class="identifier">b</span><span class="special">);</span>
 <span class="identifier">def</span><span class="special">(</span><span class="string">"d"</span><span class="special">,</span> <span class="identifier">d</span><span class="special">);</span>
 <span class="identifier">def</span><span class="special">(</span><span class="string">"factory"</span><span class="special">,</span> <span class="identifier">factory</span><span class="special">);</span>
 </pre>
 <p>
-        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 will see more of Boost.Python <a href="functions.html#python.call_policies" title="Call Policies">call
+        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
+        is destroyed. We will see more of Boost.Python <a class="link" href="functions.html#python.call_policies" title="Call Policies">call
         policies</a> later.
       </p>
-<pre class="programlisting">
-<span class="comment">// Tell Python to take ownership of factory's result
-</span><span class="identifier">def</span><span class="special">(</span><span class="string">"factory"</span><span class="special">,</span> <span class="identifier">factory</span><span class="special">,</span>
+<pre class="programlisting"><span class="comment">// Tell Python to take ownership of factory's result</span>
+<span class="identifier">def</span><span class="special">(</span><span class="string">"factory"</span><span class="special">,</span> <span class="identifier">factory</span><span class="special">,</span>
     <span class="identifier">return_value_policy</span><span class="special">&lt;</span><span class="identifier">manage_new_object</span><span class="special">&gt;());</span>
 </pre>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.class_virtual_functions"></a>Class Virtual Functions</h3></div></div></div>
 <p>
         In this section, we will learn how to make functions behave polymorphically
         through virtual functions. Continuing our example, let us add a virtual function
-        to our <tt class="literal">Base</tt> class:
+        to our <code class="literal">Base</code> class:
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">Base</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Base</span>
 <span class="special">{</span>
     <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">Base</span><span class="special">()</span> <span class="special">{}</span>
     <span class="keyword">virtual</span> <span class="keyword">int</span> <span class="identifier">f</span><span class="special">()</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
@@ -356,16 +321,15 @@
         One of the goals of Boost.Python is to be minimally intrusive on an existing
         C++ design. In principle, it should be possible to expose the interface for
         a 3rd party library without changing it. It is not ideal to add anything
-        to our class <tt class="computeroutput"><span class="identifier">Base</span></tt>. Yet, when
+        to our class <code class="computeroutput"><span class="identifier">Base</span></code>. Yet, when
         you have a virtual function that's going to be overridden in Python and called
-        polymorphically <span class="bold"><b>from C++</b></span>, we'll need to
+        polymorphically <span class="bold"><strong>from C++</strong></span>, we'll need to
         add some scaffoldings to make things work properly. What we'll do is write
-        a class wrapper that derives from <tt class="computeroutput"><span class="identifier">Base</span></tt>
+        a class wrapper that derives from <code class="computeroutput"><span class="identifier">Base</span></code>
         that will unintrusively hook into the virtual functions so that a Python
         override may be called:
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">BaseWrap</span> <span class="special">:</span> <span class="identifier">Base</span><span class="special">,</span> <span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">BaseWrap</span> <span class="special">:</span> <span class="identifier">Base</span><span class="special">,</span> <span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span>
 <span class="special">{</span>
     <span class="keyword">int</span> <span class="identifier">f</span><span class="special">()</span>
     <span class="special">{</span>
@@ -374,81 +338,79 @@
 <span class="special">};</span>
 </pre>
 <p>
-        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
+        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
         the job of wrapping classes that are meant to overridden in Python, easier.
       </p>
 <div class="sidebar">
+<div class="titlepage"></div>
 <p>
-        <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><b>MSVC6/7 Workaround</b></span>
+        <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><strong>MSVC6/7 Workaround</strong></span>
       </p>
 <p>
-        If you are using Microsoft Visual C++ 6 or 7, you have to write <tt class="computeroutput"><span class="identifier">f</span></tt> as:
+        If you are using Microsoft Visual C++ 6 or 7, you have to write <code class="computeroutput"><span class="identifier">f</span></code> as:
       </p>
 <p>
-        <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>.
+        <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 <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>.
+        BaseWrap's overridden virtual member function <code class="computeroutput"><span class="identifier">f</span></code>
+        in effect calls the corresponding method of the Python object through <code class="computeroutput"><span class="identifier">get_override</span></code>.
       </p>
 <p>
-        Finally, exposing <tt class="computeroutput"><span class="identifier">Base</span></tt>:
+        Finally, exposing <code class="computeroutput"><span class="identifier">Base</span></code>:
       </p>
-<pre class="programlisting">
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">BaseWrap</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">BaseWrap</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">pure_virtual</span><span class="special">(&amp;</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">))</span>
     <span class="special">;</span>
 </pre>
 <p>
-        <tt class="computeroutput"><span class="identifier">pure_virtual</span></tt> signals Boost.Python
-        that the function <tt class="computeroutput"><span class="identifier">f</span></tt> is a
+        <code class="computeroutput"><span class="identifier">pure_virtual</span></code> signals Boost.Python
+        that the function <code class="computeroutput"><span class="identifier">f</span></code> is a
         pure virtual function.
       </p>
 <div class="note"><table border="0" summary="Note">
 <tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/html/images/note.png"></td>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
 <th align="left">Note</th>
 </tr>
-<tr><td colspan="2" align="left" valign="top">
+<tr><td align="left" valign="top">
 <p>
-          <span class="bold"><b>member function and methods</b></span>
+          <span class="bold"><strong>member function and methods</strong></span>
         </p>
 <p>
-          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>
+          Python, like many object oriented languages uses the term <span class="bold"><strong>methods</strong></span>.
+          Methods correspond roughly to C++'s <span class="bold"><strong>member functions</strong></span>
         </p>
 </td></tr>
 </table></div>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.virtual_functions_with_default_implementations"></a>Virtual Functions with Default Implementations</h3></div></div></div>
 <p>
         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"><b>non</b></span>-pure-virtual
+        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.
       </p>
 <p>
-        Recall that in the <a href="exposing.html#python.class_virtual_functions" title="Class Virtual Functions">previous
+        Recall that in the <a class="link" href="exposing.html#python.class_virtual_functions" title="Class Virtual Functions">previous
         section</a>, we wrapped a class with a pure virtual function that we then
         implemented in C++, or Python classes derived from it. Our base class:
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">Base</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Base</span>
 <span class="special">{</span>
     <span class="keyword">virtual</span> <span class="keyword">int</span> <span class="identifier">f</span><span class="special">()</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">};</span>
 </pre>
 <p>
-        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:
+        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:
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">Base</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Base</span>
 <span class="special">{</span>
     <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">Base</span><span class="special">()</span> <span class="special">{}</span>
     <span class="keyword">virtual</span> <span class="keyword">int</span> <span class="identifier">f</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> <span class="special">}</span>
@@ -457,57 +419,53 @@
 <p>
         We wrap it this way:
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">BaseWrap</span> <span class="special">:</span> <span class="identifier">Base</span><span class="special">,</span> <span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">BaseWrap</span> <span class="special">:</span> <span class="identifier">Base</span><span class="special">,</span> <span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span>
 <span class="special">{</span>
     <span class="keyword">int</span> <span class="identifier">f</span><span class="special">()</span>
     <span class="special">{</span>
         <span class="keyword">if</span> <span class="special">(</span><span class="identifier">override</span> <span class="identifier">f</span> <span class="special">=</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="keyword">return</span> <span class="identifier">f</span><span class="special">();</span> <span class="comment">// *note*
-</span>        <span class="keyword">return</span> <span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">();</span>
+            <span class="keyword">return</span> <span class="identifier">f</span><span class="special">();</span> <span class="comment">// *note*</span>
+        <span class="keyword">return</span> <span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">();</span>
     <span class="special">}</span>
 
     <span class="keyword">int</span> <span class="identifier">default_f</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">();</span> <span class="special">}</span>
 <span class="special">};</span>
 </pre>
 <p>
-        Notice how we implemented <tt class="computeroutput"><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">f</span></tt>. Now,
-        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>.
+        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>.
       </p>
 <div class="sidebar">
+<div class="titlepage"></div>
 <p>
-        <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><b>MSVC6/7 Workaround</b></span>
+        <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><strong>MSVC6/7 Workaround</strong></span>
       </p>
 <p>
         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:
+        with the <code class="computeroutput"><span class="special">*</span><span class="identifier">note</span><span class="special">*</span></code> as:
       </p>
 <p>
-        <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>.
+        <code class="computeroutput"><span class="keyword">return</span> <span class="identifier">call</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*&gt;(</span><span class="identifier">f</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">());</span></code>.
       </p>
 </div>
 <p>
         Finally, exposing:
       </p>
-<pre class="programlisting">
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">BaseWrap</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">BaseWrap</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">default_f</span><span class="special">)</span>
     <span class="special">;</span>
 </pre>
 <p>
-        Take note that we expose both <tt class="computeroutput"><span class="special">&amp;</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span></tt> and <tt class="computeroutput"><span class="special">&amp;</span><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">default_f</span></tt>. Boost.Python needs to keep track
-        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.
+        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.
       </p>
 <p>
         In Python, the results would be as expected:
       </p>
-<p>
-      </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">base</span> <span class="special">=</span> <span class="identifier">Base</span><span class="special">()</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">base</span> <span class="special">=</span> <span class="identifier">Base</span><span class="special">()</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="keyword">class</span> <span class="identifier">Derived</span><span class="special">(</span><span class="identifier">Base</span><span class="special">):</span>
 <span class="special">...</span>     <span class="keyword">def</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span>
 <span class="special">...</span>         <span class="keyword">return</span> <span class="number">42</span>
@@ -515,40 +473,35 @@
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">derived</span> <span class="special">=</span> <span class="identifier">Derived</span><span class="special">()</span>
 </pre>
 <p>
-        Calling <tt class="literal">base.f()</tt>:
+        Calling <code class="literal">base.f()</code>:
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">base</span><span class="special">.</span><span class="identifier">f</span><span class="special">()</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">base</span><span class="special">.</span><span class="identifier">f</span><span class="special">()</span>
 <span class="number">0</span>
 </pre>
 <p>
-        Calling <tt class="literal">derived.f()</tt>:
+        Calling <code class="literal">derived.f()</code>:
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">derived</span><span class="special">.</span><span class="identifier">f</span><span class="special">()</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">derived</span><span class="special">.</span><span class="identifier">f</span><span class="special">()</span>
 <span class="number">42</span>
 </pre>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.class_operators_special_functions"></a>Class Operators/Special Functions</h3></div></div></div>
-<a name="class_operators_special_functions.python_operators"></a><h2>
-<a name="id461481"></a>
+<h3>
+<a name="class_operators_special_functions.python_operators"></a>
         Python Operators
-      </h2>
+      </h3>
 <p>
         C is well known for the abundance of operators. C++ extends this to the extremes
         by allowing operator overloading. Boost.Python takes advantage of this and
         makes it easy to wrap C++ operator-powered classes.
       </p>
 <p>
-        Consider a file position class <tt class="literal">FilePos</tt> and a set of operators
+        Consider a file position class <code class="literal">FilePos</code> and a set of operators
         that take on FilePos instances:
       </p>
-<p>
-      </p>
-<pre class="programlisting">
-<span class="keyword">class</span> <span class="identifier">FilePos</span> <span class="special">{</span> <span class="comment">/*...*/</span> <span class="special">};</span>
+<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">FilePos</span> <span class="special">{</span> <span class="comment">/*...*/</span> <span class="special">};</span>
 
 <span class="identifier">FilePos</span>     <span class="keyword">operator</span><span class="special">+(</span><span class="identifier">FilePos</span><span class="special">,</span> <span class="keyword">int</span><span class="special">);</span>
 <span class="identifier">FilePos</span>     <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">FilePos</span><span class="special">);</span>
@@ -562,29 +515,28 @@
         The class and the various operators can be mapped to Python rather easily
         and intuitively:
       </p>
-<pre class="programlisting">
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">FilePos</span><span class="special">&gt;(</span><span class="string">"FilePos"</span><span class="special">)</span>
-    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">+</span> <span class="keyword">int</span><span class="special">())</span>          <span class="comment">// __add__
-</span>    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="keyword">int</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">self</span><span class="special">)</span>          <span class="comment">// __radd__
-</span>    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">-</span> <span class="identifier">self</span><span class="special">)</span>           <span class="comment">// __sub__
-</span>    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">-</span> <span class="keyword">int</span><span class="special">())</span>          <span class="comment">// __sub__
-</span>    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">+=</span> <span class="keyword">int</span><span class="special">())</span>         <span class="comment">// __iadd__
-</span>    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">-=</span> <span class="identifier">other</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;())</span>
-    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">&lt;</span> <span class="identifier">self</span><span class="special">);</span>          <span class="comment">// __lt__
-</span></pre>
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">FilePos</span><span class="special">&gt;(</span><span class="string">"FilePos"</span><span class="special">)</span>
+    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">+</span> <span class="keyword">int</span><span class="special">())</span>          <span class="comment">// __add__</span>
+    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="keyword">int</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">self</span><span class="special">)</span>          <span class="comment">// __radd__</span>
+    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">-</span> <span class="identifier">self</span><span class="special">)</span>           <span class="comment">// __sub__</span>
+    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">-</span> <span class="keyword">int</span><span class="special">())</span>          <span class="comment">// __sub__</span>
+    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">+=</span> <span class="keyword">int</span><span class="special">())</span>         <span class="comment">// __iadd__</span>
+    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">-=</span> <span class="identifier">other</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;())</span>
+    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">&lt;</span> <span class="identifier">self</span><span class="special">);</span>          <span class="comment">// __lt__</span>
+</pre>
 <p>
         The code snippet above is very clear and needs almost no explanation at all.
         It is virtually the same as the operators' signatures. Just take note that
-        <tt class="literal">self</tt> refers to FilePos object. Also, not every class
-        <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
+        <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
         expressions".
       </p>
-<a name="class_operators_special_functions.special_methods"></a><h2>
-<a name="id462238"></a>
+<h3>
+<a name="class_operators_special_functions.special_methods"></a>
         Special Methods
-      </h2>
+      </h3>
 <p>
         Python has a few more <span class="emphasis"><em>Special Methods</em></span>. Boost.Python
         supports all of the standard special method names supported by real Python
@@ -592,8 +544,7 @@
         wrap C++ functions that correspond to these Python <span class="emphasis"><em>special functions</em></span>.
         Example:
       </p>
-<pre class="programlisting">
-<span class="keyword">class</span> <span class="identifier">Rational</span>
+<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">Rational</span>
 <span class="special">{</span> <span class="keyword">public</span><span class="special">:</span> <span class="keyword">operator</span> <span class="keyword">double</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span> <span class="special">};</span>
 
 <span class="identifier">Rational</span> <span class="identifier">pow</span><span class="special">(</span><span class="identifier">Rational</span><span class="special">,</span> <span class="identifier">Rational</span><span class="special">);</span>
@@ -601,30 +552,30 @@
 <span class="identifier">ostream</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">&lt;&lt;(</span><span class="identifier">ostream</span><span class="special">&amp;,</span><span class="identifier">Rational</span><span class="special">);</span>
 
 <span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Rational</span><span class="special">&gt;(</span><span class="string">"Rational"</span><span class="special">)</span>
-    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">float_</span><span class="special">(</span><span class="identifier">self</span><span class="special">))</span>                  <span class="comment">// __float__
-</span>    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">pow</span><span class="special">(</span><span class="identifier">self</span><span class="special">,</span> <span class="identifier">other</span><span class="special">&lt;</span><span class="identifier">Rational</span><span class="special">&gt;))</span>    <span class="comment">// __pow__
-</span>    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">abs</span><span class="special">(</span><span class="identifier">self</span><span class="special">))</span>                     <span class="comment">// __abs__
-</span>    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">str</span><span class="special">(</span><span class="identifier">self</span><span class="special">))</span>                     <span class="comment">// __str__
-</span>    <span class="special">;</span>
+    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">float_</span><span class="special">(</span><span class="identifier">self</span><span class="special">))</span>                  <span class="comment">// __float__</span>
+    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">pow</span><span class="special">(</span><span class="identifier">self</span><span class="special">,</span> <span class="identifier">other</span><span class="special">&lt;</span><span class="identifier">Rational</span><span class="special">&gt;))</span>    <span class="comment">// __pow__</span>
+    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">abs</span><span class="special">(</span><span class="identifier">self</span><span class="special">))</span>                     <span class="comment">// __abs__</span>
+    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">str</span><span class="special">(</span><span class="identifier">self</span><span class="special">))</span>                     <span class="comment">// __str__</span>
+    <span class="special">;</span>
 </pre>
 <p>
         Need we say more?
       </p>
 <div class="note"><table border="0" summary="Note">
 <tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/html/images/note.png"></td>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
 <th align="left">Note</th>
 </tr>
-<tr><td colspan="2" align="left" valign="top"><p>
-          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>.
+<tr><td align="left" valign="top"><p>
+          What is the business of <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code>? Well, the method <code class="computeroutput"><span class="identifier">str</span></code> requires the <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code> to do its work (i.e. <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code>
+          is used by the method defined by <code class="computeroutput"><span class="identifier">def</span><span class="special">(</span><span class="identifier">str</span><span class="special">(</span><span class="identifier">self</span><span class="special">))</span></code>.
         </p></td></tr>
 </table></div>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
       de Guzman, David Abrahams<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
@@ -634,7 +585,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="hello.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="functions.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="hello.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="functions.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

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

@@ -1,28 +1,28 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>Functions</title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
-<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="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
+<link rel="prev" href="exposing.html" title="Exposing Classes">
+<link rel="next" href="object.html" title="Object Interface">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="exposing.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="object.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="exposing.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="object.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="python.functions"></a>Functions</h2></div></div></div>
 <div class="toc"><dl>
@@ -38,18 +38,12 @@
       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
-      <tt class="literal">&gt;&gt;&gt; import this</tt>.
+      <code class="literal">&gt;&gt;&gt; import this</code>.
     </p>
 <pre class="programlisting">&gt;&gt;&gt; import this
 The Zen of Python, by Tim Peters
@@ -68,12 +62,12 @@ In the face of ambiguity, refuse the temptation to guess.
 There should be one-- and preferably only one --obvious way to do it
 Although that way may not be obvious at first unless you're Dutch.
 Now is better than never.
-Although never is often better than <span class="bold"><b>right</b></span> now.
+Although never is often better than <span class="bold"><strong>right</strong></span> now.
 If the implementation is hard to explain, it's a bad idea.
 If the implementation is easy to explain, it may be a good idea.
 Namespaces are one honking great idea -- let's do more of those!
 </pre>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.call_policies"></a>Call Policies</h3></div></div></div>
 <p>
@@ -87,16 +81,14 @@ Namespaces are one honking great idea -- let's do more of those!
         so Boost.Python must deal with them. To do this, it may need your help. Consider
         the following C++ function:
       </p>
-<pre class="programlisting">
-<span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">);</span>
+<pre class="programlisting"><span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">);</span>
 </pre>
 <p>
         How should the library wrap this function? A naive approach builds a Python
         X object around result reference. This strategy might or might not work out.
         Here's an example where it didn't
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="preprocessor"># x</span> <span class="identifier">refers</span> <span class="identifier">to</span> <span class="identifier">some</span> <span class="identifier">C</span><span class="special">++</span> <span class="identifier">X</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="preprocessor"># x</span> <span class="identifier">refers</span> <span class="identifier">to</span> <span class="identifier">some</span> <span class="identifier">C</span><span class="special">++</span> <span class="identifier">X</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">del</span> <span class="identifier">y</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">some_method</span><span class="special">()</span> <span class="preprocessor"># CRASH</span><span class="special">!</span>
 </pre>
@@ -106,8 +98,7 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         Well, what if f() was implemented as shown below:
       </p>
-<pre class="programlisting">
-<span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">)</span>
 <span class="special">{</span>
     <span class="identifier">y</span><span class="special">.</span><span class="identifier">z</span> <span class="special">=</span> <span class="identifier">z</span><span class="special">;</span>
     <span class="keyword">return</span> <span class="identifier">y</span><span class="special">.</span><span class="identifier">x</span><span class="special">;</span>
@@ -124,31 +115,30 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         Here's what's happening:
       </p>
-<div class="orderedlist"><ol type="1">
-<li>
-<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 <tt class="literal">y.x</tt> is returned
-        </li>
-<li>
-<tt class="literal">y</tt> is deleted. <tt class="literal">x</tt> is a dangling reference
-        </li>
-<li>
-<tt class="literal">x.some_method()</tt> is called
-        </li>
-<li><span class="bold"><b>BOOM!</b></span></li>
+<div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+            <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>
+          </li>
+<li class="listitem">
+            A reference to <code class="literal">y.x</code> is returned
+          </li>
+<li class="listitem">
+            <code class="literal">y</code> is deleted. <code class="literal">x</code> is a dangling reference
+          </li>
+<li class="listitem">
+            <code class="literal">x.some_method()</code> is called
+          </li>
+<li class="listitem">
+            <span class="bold"><strong>BOOM!</strong></span>
+          </li>
 </ol></div>
 <p>
         We could copy result into a new object:
       </p>
-<p>
-      </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">).</span><span class="identifier">set</span><span class="special">(</span><span class="number">42</span><span class="special">)</span> <span class="comment"># Result disappears
-</span><span class="special">&gt;&gt;&gt;</span> <span class="identifier">y</span><span class="special">.</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span>       <span class="comment"># No crash, but still bad
-</span><span class="number">3.14</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">).</span><span class="identifier">set</span><span class="special">(</span><span class="number">42</span><span class="special">)</span> <span class="comment"># Result disappears</span>
+<span class="special">&gt;&gt;&gt;</span> <span class="identifier">y</span><span class="special">.</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span>       <span class="comment"># No crash, but still bad</span>
+<span class="number">3.14</span>
 </pre>
 <p>
         This is not really our intent of our C++ interface. We've broken our promise
@@ -158,29 +148,24 @@ 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>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">Y</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Y</span>
 <span class="special">{</span>
     <span class="identifier">X</span> <span class="identifier">x</span><span class="special">;</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">;</span>
     <span class="keyword">int</span> <span class="identifier">z_value</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">z</span><span class="special">-&gt;</span><span class="identifier">value</span><span class="special">();</span> <span class="special">}</span>
 <span class="special">};</span>
 </pre>
 <p>
-        Notice that the data member <tt class="literal">z</tt> is held by class Y using
+        Notice that the data member <code class="literal">z</code> is held by class Y using
         a raw pointer. Now we have a potential dangling pointer problem inside Y:
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="preprocessor"># y</span> <span class="identifier">refers</span> <span class="identifier">to</span> <span class="identifier">z</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="preprocessor"># y</span> <span class="identifier">refers</span> <span class="identifier">to</span> <span class="identifier">z</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">del</span> <span class="identifier">z</span>       <span class="preprocessor"># Kill</span> <span class="identifier">the</span> <span class="identifier">z</span> <span class="identifier">object</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">y</span><span class="special">.</span><span class="identifier">z_value</span><span class="special">()</span> <span class="preprocessor"># CRASH</span><span class="special">!</span>
 </pre>
 <p>
-        For reference, here's the implementation of <tt class="literal">f</tt> again:
+        For reference, here's the implementation of <code class="literal">f</code> again:
       </p>
-<pre class="programlisting">
-<span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">)</span>
 <span class="special">{</span>
     <span class="identifier">y</span><span class="special">.</span><span class="identifier">z</span> <span class="special">=</span> <span class="identifier">z</span><span class="special">;</span>
     <span class="keyword">return</span> <span class="identifier">y</span><span class="special">.</span><span class="identifier">x</span><span class="special">;</span>
@@ -189,71 +174,70 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         Here's what's happening:
       </p>
-<div class="orderedlist"><ol type="1">
-<li>
-<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 <tt class="literal">z</tt> is held by <tt class="literal">y</tt>
-</li>
-<li>
-          A reference to <tt class="literal">y.x</tt> is returned
-        </li>
-<li>
-<tt class="literal">z</tt> is deleted. <tt class="literal">y.z</tt> is a dangling pointer
-        </li>
-<li>
-<tt class="literal">y.z_value()</tt> is called
-        </li>
-<li>
-<tt class="literal">z-&gt;value()</tt> is called
-        </li>
-<li><span class="bold"><b>BOOM!</b></span></li>
+<div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+            <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>
+          </li>
+<li class="listitem">
+            A pointer to <code class="literal">z</code> is held by <code class="literal">y</code>
+          </li>
+<li class="listitem">
+            A reference to <code class="literal">y.x</code> is returned
+          </li>
+<li class="listitem">
+            <code class="literal">z</code> is deleted. <code class="literal">y.z</code> is a dangling
+            pointer
+          </li>
+<li class="listitem">
+            <code class="literal">y.z_value()</code> is called
+          </li>
+<li class="listitem">
+            <code class="literal">z-&gt;value()</code> is called
+          </li>
+<li class="listitem">
+            <span class="bold"><strong>BOOM!</strong></span>
+          </li>
 </ol></div>
-<a name="call_policies.call_policies"></a><h2>
-<a name="id464235"></a>
+<h3>
+<a name="call_policies.call_policies"></a>
         Call Policies
-      </h2>
+      </h3>
 <p>
         Call Policies may be used in situations such as the example detailed above.
-        In our example, <tt class="literal">return_internal_reference</tt> and <tt class="literal">with_custodian_and_ward</tt>
+        In our example, <code class="literal">return_internal_reference</code> and <code class="literal">with_custodian_and_ward</code>
         are our friends:
       </p>
-<pre class="programlisting">
-<span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">,</span>
+<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">,</span>
     <span class="identifier">return_internal_reference</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span>
         <span class="identifier">with_custodian_and_ward</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">&gt;</span> <span class="special">&gt;());</span>
 </pre>
 <p>
-        What are the <tt class="literal">1</tt> and <tt class="literal">2</tt> parameters, you
+        What are the <code class="literal">1</code> and <code class="literal">2</code> parameters, you
         ask?
       </p>
-<pre class="programlisting">
-<span class="identifier">return_internal_reference</span><span class="special">&lt;</span><span class="number">1</span>
+<pre class="programlisting"><span class="identifier">return_internal_reference</span><span class="special">&lt;</span><span class="number">1</span>
 </pre>
 <p>
-        Informs Boost.Python that the first argument, in our case <tt class="literal">Y&amp;
-        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>".
+        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>".
       </p>
-<pre class="programlisting">
-<span class="identifier">with_custodian_and_ward</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">&gt;</span>
+<pre class="programlisting"><span class="identifier">with_custodian_and_ward</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">&gt;</span>
 </pre>
 <p>
         Informs Boost.Python that the lifetime of the argument indicated by ward
-        (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>).
+        (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>).
       </p>
 <p>
         It is also important to note that we have defined two policies above. Two
         or more policies can be composed by chaining. Here's the general syntax:
       </p>
-<pre class="programlisting">
-<span class="identifier">policy1</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...,</span>
+<pre class="programlisting"><span class="identifier">policy1</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...,</span>
     <span class="identifier">policy2</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...,</span>
         <span class="identifier">policy3</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...&gt;</span> <span class="special">&gt;</span> <span class="special">&gt;</span>
 </pre>
@@ -261,42 +245,44 @@ Namespaces are one honking great idea -- let's do more of those!
         Here is the list of predefined call policies. A complete reference detailing
         these can be found <a href="../../../../v2/reference.html#models_of_call_policies" target="_top">here</a>.
       </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
-<span class="bold"><b>with_custodian_and_ward</b></span>: Ties lifetimes
-          of the arguments
-        </li>
-<li>
-<span class="bold"><b>with_custodian_and_ward_postcall</b></span>: Ties
-          lifetimes of the arguments and results
-        </li>
-<li>
-<span class="bold"><b>return_internal_reference</b></span>: Ties lifetime
-          of one argument to that of result
-        </li>
-<li>
-<span class="bold"><b>return_value_policy&lt;T&gt; with T one of:</b></span><div class="itemizedlist"><ul type="circle">
-<li>
-<span class="bold"><b>reference_existing_object</b></span>: naive (dangerous)
-              approach
-            </li>
-<li>
-<span class="bold"><b>copy_const_reference</b></span>: Boost.Python
-              v1 approach
-            </li>
-<li>
-<span class="bold"><b>copy_non_const_reference</b></span>:
-            </li>
-<li>
-<span class="bold"><b>manage_new_object</b></span>: Adopt a pointer
-              and hold the instance
-            </li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            <span class="bold"><strong>with_custodian_and_ward</strong></span>: Ties lifetimes
+            of the arguments
+          </li>
+<li class="listitem">
+            <span class="bold"><strong>with_custodian_and_ward_postcall</strong></span>: Ties
+            lifetimes of the arguments and results
+          </li>
+<li class="listitem">
+            <span class="bold"><strong>return_internal_reference</strong></span>: Ties lifetime
+            of one argument to that of result
+          </li>
+<li class="listitem">
+            <span class="bold"><strong>return_value_policy&lt;T&gt; with T one of:</strong></span>
+            <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                  <span class="bold"><strong>reference_existing_object</strong></span>: naive
+                  (dangerous) approach
+                </li>
+<li class="listitem">
+                  <span class="bold"><strong>copy_const_reference</strong></span>: Boost.Python
+                  v1 approach
+                </li>
+<li class="listitem">
+                  <span class="bold"><strong>copy_non_const_reference</strong></span>:
+                </li>
+<li class="listitem">
+                  <span class="bold"><strong>manage_new_object</strong></span>: Adopt a pointer
+                  and hold the instance
+                </li>
 </ul></div>
-</li>
+          </li>
 </ul></div>
 <div class="sidebar">
+<div class="titlepage"></div>
 <p>
-        <span class="inlinemediaobject"><img src="../images/smiley.png" alt="smiley"></span> <span class="bold"><b>Remember the Zen, Luke:</b></span>
+        <span class="inlinemediaobject"><img src="../images/smiley.png" alt="smiley"></span> <span class="bold"><strong>Remember the Zen, Luke:</strong></span>
       </p>
 <p>
         "Explicit is better than implicit"
@@ -306,7 +292,7 @@ Namespaces are one honking great idea -- let's do more of those!
       </p>
 </div>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.overloading"></a>Overloading</h3></div></div></div>
 <p>
@@ -317,8 +303,7 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         We have here our C++ class:
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">X</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">X</span>
 <span class="special">{</span>
     <span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">)</span>
     <span class="special">{</span>
@@ -345,8 +330,7 @@ Namespaces are one honking great idea -- let's do more of those!
         Class X has 4 overloaded functions. We will start by introducing some member
         function pointer variables:
       </p>
-<pre class="programlisting">
-<span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx1</span><span class="special">)(</span><span class="keyword">int</span><span class="special">)</span>              <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
+<pre class="programlisting"><span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx1</span><span class="special">)(</span><span class="keyword">int</span><span class="special">)</span>              <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
 <span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx2</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">)</span>      <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
 <span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx3</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">char</span><span class="special">)=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
 <span class="keyword">int</span>     <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx4</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)</span>    <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
@@ -354,75 +338,69 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         With these in hand, we can proceed to define and wrap this for Python:
       </p>
-<pre class="programlisting">
-<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx1</span><span class="special">)</span>
+<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx1</span><span class="special">)</span>
 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx2</span><span class="special">)</span>
 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx3</span><span class="special">)</span>
 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx4</span><span class="special">)</span>
 </pre>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.default_arguments"></a>Default Arguments</h3></div></div></div>
 <p>
         Boost.Python wraps (member) function pointers. Unfortunately, C++ function
-        pointers carry no default argument info. Take a function <tt class="literal">f</tt>
+        pointers carry no default argument info. Take a function <code class="literal">f</code>
         with default arguments:
       </p>
-<pre class="programlisting">
-<span class="keyword">int</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span> <span class="special">=</span> <span class="number">3.14</span><span class="special">,</span> <span class="keyword">char</span> <span class="keyword">const</span><span class="special">*</span> <span class="special">=</span> <span class="string">"hello"</span><span class="special">);</span>
+<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span> <span class="special">=</span> <span class="number">3.14</span><span class="special">,</span> <span class="keyword">char</span> <span class="keyword">const</span><span class="special">*</span> <span class="special">=</span> <span class="string">"hello"</span><span class="special">);</span>
 </pre>
 <p>
-        But the type of a pointer to the function <tt class="literal">f</tt> has no information
+        But the type of a pointer to the function <code class="literal">f</code> has no information
         about its default arguments:
       </p>
-<pre class="programlisting">
-<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>
+<pre class="programlisting"><span class="keyword">int</span><span class="special">(*</span><span class="identifier">g</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span><span class="keyword">double</span><span class="special">,</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*)</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">;</span>    <span class="comment">// defaults lost!</span>
+</pre>
 <p>
-        When we pass this function pointer to the <tt class="literal">def</tt> function,
+        When we pass this function pointer to the <code class="literal">def</code> function,
         there is no way to retrieve the default arguments:
       </p>
-<pre class="programlisting">
-<span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">);</span>                            <span class="comment">// defaults lost!
-</span></pre>
+<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">);</span>                            <span class="comment">// defaults lost!</span>
+</pre>
 <p>
         Because of this, when wrapping C++ code, we had to resort to manual wrapping
-        as outlined in the <a href="functions.html#python.overloading" title="Overloading">previous section</a>,
+        as outlined in the <a class="link" href="functions.html#python.overloading" title="Overloading">previous section</a>,
         or writing thin wrappers:
       </p>
-<pre class="programlisting">
-<span class="comment">// write "thin wrappers"
-</span><span class="keyword">int</span> <span class="identifier">f1</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">{</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span> <span class="special">}</span>
-<span class="keyword">int</span> <span class="identifier">f2</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">)</span> <span class="special">{</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">);</span> <span class="special">}</span>
+<pre class="programlisting"><span class="comment">// write "thin wrappers"</span>
+<span class="keyword">int</span> <span class="identifier">f1</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span> <span class="special">}</span>
+<span class="keyword">int</span> <span class="identifier">f2</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">);</span> <span class="special">}</span>
 
 <span class="comment">/*...*/</span>
 
-    <span class="comment">// in module init
-</span>    <span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">);</span>  <span class="comment">// all arguments
-</span>    <span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f2</span><span class="special">);</span> <span class="comment">// two arguments
-</span>    <span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f1</span><span class="special">);</span> <span class="comment">// one argument
-</span></pre>
+    <span class="comment">// in module init</span>
+    <span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">);</span>  <span class="comment">// all arguments</span>
+    <span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f2</span><span class="special">);</span> <span class="comment">// two arguments</span>
+    <span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f1</span><span class="special">);</span> <span class="comment">// one argument</span>
+</pre>
 <p>
         When you want to wrap functions (or member functions) that either:
       </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
-          have default arguments, or
-        </li>
-<li>
-          are overloaded with a common sequence of initial arguments
-        </li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            have default arguments, or
+          </li>
+<li class="listitem">
+            are overloaded with a common sequence of initial arguments
+          </li>
 </ul></div>
-<a name="default_arguments.boost_python_function_overloads"></a><h2>
-<a name="id466276"></a>
+<h3>
+<a name="default_arguments.boost_python_function_overloads"></a>
         BOOST_PYTHON_FUNCTION_OVERLOADS
-      </h2>
+      </h3>
 <p>
         Boost.Python now has a way to make it easier. For instance, given a function:
       </p>
-<pre class="programlisting">
-<span class="keyword">int</span> <span class="identifier">foo</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">char</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">c</span> <span class="special">=</span> <span class="number">2</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="number">3</span><span class="special">)</span>
+<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">char</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">c</span> <span class="special">=</span> <span class="number">2</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="number">3</span><span class="special">)</span>
 <span class="special">{</span>
     <span class="comment">/*...*/</span>
 <span class="special">}</span>
@@ -430,24 +408,22 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         The macro invocation:
       </p>
-<pre class="programlisting">
-<span class="identifier">BOOST_PYTHON_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">foo_overloads</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">4</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">BOOST_PYTHON_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">foo_overloads</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">4</span><span class="special">)</span>
 </pre>
 <p>
         will automatically create the thin wrappers for us. This macro will create
-        a class <tt class="literal">foo_overloads</tt> that can be passed on to <tt class="literal">def(...)</tt>.
+        a class <code class="literal">foo_overloads</code> that can be passed on to <code class="literal">def(...)</code>.
         The third and fourth macro argument are the minimum arguments and maximum
-        arguments, respectively. In our <tt class="literal">foo</tt> function the minimum
-        number of arguments is 1 and the maximum number of arguments is 4. The <tt class="literal">def(...)</tt>
+        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>
         function will automatically add all the foo variants for us:
       </p>
-<pre class="programlisting">
-<span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
+<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
 </pre>
-<a name="default_arguments.boost_python_member_function_overloads"></a><h2>
-<a name="id466594"></a>
+<h3>
+<a name="default_arguments.boost_python_member_function_overloads"></a>
         BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS
-      </h2>
+      </h3>
 <p>
         Objects here, objects there, objects here there everywhere. More frequently
         than anything else, we need to expose member functions of our classes to
@@ -456,12 +432,11 @@ Namespaces are one honking great idea -- let's do more of those!
         play. Another macro is provided to make this a breeze.
       </p>
 <p>
-        Like <tt class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</tt>, <tt class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt>
+        Like <code class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</code>, <code class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</code>
         may be used to automatically create the thin wrappers for wrapping member
         functions. Let's have an example:
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">george</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">george</span>
 <span class="special">{</span>
     <span class="keyword">void</span>
     <span class="identifier">wack_em</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span> <span class="keyword">char</span> <span class="identifier">c</span> <span class="special">=</span> <span class="char">'x'</span><span class="special">)</span>
@@ -473,34 +448,31 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         The macro invocation:
       </p>
-<pre class="programlisting">
-<span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">george_overloads</span><span class="special">,</span> <span class="identifier">wack_em</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">3</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">george_overloads</span><span class="special">,</span> <span class="identifier">wack_em</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">3</span><span class="special">)</span>
 </pre>
 <p>
-        will generate a set of thin wrappers for george's <tt class="literal">wack_em</tt>
+        will generate a set of thin wrappers for george's <code class="literal">wack_em</code>
         member function accepting a minimum of 1 and a maximum of 3 arguments (i.e.
         the third and fourth macro argument). The thin wrappers are all enclosed
-        in a class named <tt class="literal">george_overloads</tt> that can then be used
-        as an argument to <tt class="literal">def(...)</tt>:
+        in a class named <code class="literal">george_overloads</code> that can then be used
+        as an argument to <code class="literal">def(...)</code>:
       </p>
-<pre class="programlisting">
-<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"wack_em"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">george</span><span class="special">::</span><span class="identifier">wack_em</span><span class="special">,</span> <span class="identifier">george_overloads</span><span class="special">());</span>
+<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"wack_em"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">george</span><span class="special">::</span><span class="identifier">wack_em</span><span class="special">,</span> <span class="identifier">george_overloads</span><span class="special">());</span>
 </pre>
 <p>
         See the <a href="../../../../v2/overloads.html#BOOST_PYTHON_FUNCTION_OVERLOADS-spec" target="_top">overloads
         reference</a> for details.
       </p>
-<a name="default_arguments.init_and_optional"></a><h2>
-<a name="id466958"></a>
+<h3>
+<a name="default_arguments.init_and_optional"></a>
         init and optional
-      </h2>
+      </h3>
 <p>
         A similar facility is provided for class constructors, again, with default
-        arguments or a sequence of overloads. Remember <tt class="literal">init&lt;...&gt;</tt>?
+        arguments or a sequence of overloads. Remember <code class="literal">init&lt;...&gt;</code>?
         For example, given a class X with a constructor:
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">X</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">X</span>
 <span class="special">{</span>
     <span class="identifier">X</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">char</span> <span class="identifier">b</span> <span class="special">=</span> <span class="char">'D'</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">c</span> <span class="special">=</span> <span class="string">"constructor"</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">);</span>
     <span class="comment">/*...*/</span>
@@ -509,25 +481,23 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         You can easily add this constructor to Boost.Python in one shot:
       </p>
-<pre class="programlisting">
-<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">init</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;</span> <span class="special">&gt;())</span>
+<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">init</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;</span> <span class="special">&gt;())</span>
 </pre>
 <p>
-        Notice the use of <tt class="literal">init&lt;...&gt;</tt> and <tt class="literal">optional&lt;...&gt;</tt>
+        Notice the use of <code class="literal">init&lt;...&gt;</code> and <code class="literal">optional&lt;...&gt;</code>
         to signify the default (optional arguments).
       </p>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.auto_overloading"></a>Auto-Overloading</h3></div></div></div>
 <p>
-        It 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
+        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:
       </p>
-<pre class="programlisting">
-<span class="keyword">void</span> <span class="identifier">foo</span><span class="special">()</span>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">foo</span><span class="special">()</span>
 <span class="special">{</span>
    <span class="comment">/*...*/</span>
 <span class="special">}</span>
@@ -551,61 +521,56 @@ Namespaces are one honking great idea -- let's do more of those!
         Like in the previous section, we can generate thin wrappers for these overloaded
         functions in one-shot:
       </p>
-<pre class="programlisting">
-<span class="identifier">BOOST_PYTHON_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">foo_overloads</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">3</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">BOOST_PYTHON_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">foo_overloads</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">3</span><span class="special">)</span>
 </pre>
 <p>
         Then...
       </p>
-<pre class="programlisting">
-<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="special">(</span><span class="keyword">void</span><span class="special">(*)(</span><span class="keyword">bool</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">))</span><span class="number">0</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
+<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="special">(</span><span class="keyword">void</span><span class="special">(*)(</span><span class="keyword">bool</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">))</span><span class="number">0</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
 </pre>
 <p>
         Notice though that we have a situation now where we have a minimum of zero
         (0) arguments and a maximum of 3 arguments.
       </p>
-<a name="auto_overloading.manual_wrapping"></a><h2>
-<a name="id467739"></a>
+<h3>
+<a name="auto_overloading.manual_wrapping"></a>
         Manual Wrapping
-      </h2>
+      </h3>
 <p>
-        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,
+        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,
         our scheme above will not work. If this is not the case, we have to wrap
-        our functions <a href="functions.html#python.overloading" title="Overloading">manually</a>.
+        our functions <a class="link" href="functions.html#python.overloading" title="Overloading">manually</a>.
       </p>
 <p>
         Actually, we can mix and match manual wrapping of overloaded functions and
-        automatic wrapping through <tt class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt>
-        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
+        automatic wrapping through <code class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</code>
+        and its sister, <code class="literal">BOOST_PYTHON_FUNCTION_OVERLOADS</code>. Following
+        up on our example presented in the section <a class="link" href="functions.html#python.overloading" title="Overloading">on
         overloading</a>, since the first 4 overload functins have a common sequence
-        of initial arguments, we can use <tt class="literal">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</tt>
-        to automatically wrap the first three of the <tt class="literal">def</tt>s and
+        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
         manually wrap just the last. Here's how we'll do this:
       </p>
-<pre class="programlisting">
-<span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">xf_overloads</span><span class="special">,</span> <span class="identifier">f</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">4</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">xf_overloads</span><span class="special">,</span> <span class="identifier">f</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">4</span><span class="special">)</span>
 </pre>
 <p>
         Create a member function pointers as above for both X::f overloads:
       </p>
-<pre class="programlisting">
-<span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx1</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">char</span><span class="special">)</span>    <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
+<pre class="programlisting"><span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx1</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">char</span><span class="special">)</span>    <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
 <span class="keyword">int</span>     <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx2</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)</span>        <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
 </pre>
 <p>
         Then...
       </p>
-<pre class="programlisting">
-<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx1</span><span class="special">,</span> <span class="identifier">xf_overloads</span><span class="special">());</span>
+<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx1</span><span class="special">,</span> <span class="identifier">xf_overloads</span><span class="special">());</span>
 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx2</span><span class="special">)</span>
 </pre>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
       de Guzman, David Abrahams<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
@@ -615,7 +580,7 @@ Namespaces are one honking great idea -- let's do more of those!
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="exposing.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="object.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="exposing.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="object.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

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

@@ -1,53 +1,53 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Building Hello World</title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
-<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">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Building Hello World</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
+<link rel="prev" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
+<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%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="../index.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="exposing.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="../index.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="exposing.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="python.hello"></a> Building Hello World</h2></div></div></div>
-<a name="hello.from_start_to_finish"></a><h2>
-<a name="id386189"></a>
+<a name="python.hello"></a>Building Hello World</h2></div></div></div>
+<h3>
+<a name="hello.from_start_to_finish"></a>
       From Start To Finish
-    </h2>
+    </h3>
 <p>
       Now the first thing you'd want to do is to build the Hello World module and
       try it for yourself in Python. In this section, we will outline the steps necessary
       to achieve that. We will use the build tool that comes bundled with every boost
-      distribution: <span class="bold"><b>bjam</b></span>.
+      distribution: <span class="bold"><strong>bjam</strong></span>.
     </p>
 <div class="note"><table border="0" summary="Note">
 <tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/html/images/note.png"></td>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
 <th align="left">Note</th>
 </tr>
-<tr><td colspan="2" align="left" valign="top">
+<tr><td align="left" valign="top">
 <p>
-        <span class="bold"><b>Building without bjam</b></span>
+        <span class="bold"><strong>Building without bjam</strong></span>
       </p>
 <p>
         Besides bjam, there are of course other ways to get your module built. What's
         written here should not be taken as "the one and only way". There
-        are of course other build tools apart from <tt class="literal">bjam</tt>.
+        are of course other build tools apart from <code class="literal">bjam</code>.
       </p>
 <p>
         Take note however that the preferred build tool for Boost.Python is bjam.
@@ -65,65 +65,59 @@
       and run a python program using the extension.
     </p>
 <p>
-      The tutorial example can be found in the directory: <tt class="literal">libs/python/example/tutorial</tt>.
+      The tutorial example can be found in the directory: <code class="literal">libs/python/example/tutorial</code>.
       There, you can find:
     </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
-        hello.cpp
-      </li>
-<li>
-        hello.py
-      </li>
-<li>
-        Jamroot
-      </li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+          hello.cpp
+        </li>
+<li class="listitem">
+          hello.py
+        </li>
+<li class="listitem">
+          Jamroot
+        </li>
 </ul></div>
 <p>
-      The <tt class="literal">hello.cpp</tt> file is our C++ hello world example. The
-      <tt class="literal">Jamroot</tt> is a minimalist <span class="emphasis"><em>bjam</em></span> script
-      that builds the DLLs for us. Finally, <tt class="literal">hello.py</tt> is our Python
-      program that uses the extension in <tt class="literal">hello.cpp</tt>.
+      The <code class="literal">hello.cpp</code> file is our C++ hello world example. The
+      <code class="literal">Jamroot</code> is a minimalist <span class="emphasis"><em>bjam</em></span> script
+      that builds the DLLs for us. Finally, <code class="literal">hello.py</code> is our Python
+      program that uses the extension in <code class="literal">hello.cpp</code>.
     </p>
 <p>
       Before anything else, you should have the bjam executable in your boost directory
-      or somewhere in your path such that <tt class="literal">bjam</tt> can be executed
+      or somewhere in your path such that <code class="literal">bjam</code> can be executed
       in the command line. Pre-built Boost.Jam executables are available for most
       platforms. The complete list of Bjam executables can be found <a href="http://sourceforge.net/project/showfiles.php?group_id=7586" target="_top">here</a>.
     </p>
-<a name="hello.let_s_jam_"></a><h2>
-<a name="id386347"></a>
+<h3>
+<a name="hello.let_s_jam_"></a>
       Let's Jam!
-    </h2>
+    </h3>
 <p>
       <span class="inlinemediaobject"><img src="../images/jam.png" alt="jam"></span>
     </p>
 <p>
       <a href="../../../../../example/tutorial/Jamroot" target="_top">Here</a> is our minimalist
-      Jamroot file. Simply copy the file and tweak <tt class="literal">use-project boost</tt>
+      Jamroot file. Simply copy the file and tweak <code class="literal">use-project boost</code>
       to where your boost root directory is and your OK.
     </p>
 <p>
       The comments contained in the Jamrules file above should be sufficient to get
       you going.
     </p>
-<a name="hello.running_bjam"></a><h2>
-<a name="id386404"></a>
+<h3>
+<a name="hello.running_bjam"></a>
       Running bjam
-    </h2>
+    </h3>
 <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>
       A file called user-config.jam in your home directory is used to configure your
       tools. In Windows, your home directory can be found by typing:
@@ -139,25 +133,24 @@
 using msvc : 8.0 ;
 
 #  Python configuration
-using python : 2.4 : C:/dev/tools<span class="emphasis"><em>Python</em></span> ;
+using python : 2.4 : C:<span class="emphasis"><em>dev/tools/Python</em></span> ;
 </pre>
 <p>
       The first rule tells Bjam to use the MSVC 8.0 compiler and associated tools.
       The second rule provides information on Python, its version and where it is
-      located. The above assumes that the Python installation is in <tt class="literal">C:/dev/tools/Python/</tt>.
+      located. The above assumes that the Python installation is in <code class="literal">C:<span class="emphasis"><em>dev/tools\/Python</em></span></code>.
       If you have one fairly "standard" python installation for your platform,
       you might not need to do this.
     </p>
 <p>
-      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">"Jamroot"</tt>
+      Now we are ready... Be sure to <code class="literal">cd</code> to <code class="literal">libs/python/example/tutorial</code>
+      where the tutorial <code class="literal">"hello.cpp"</code> and the <code class="literal">"Jamroot"</code>
       is situated.
     </p>
 <p>
       Finally:
     </p>
-<pre class="programlisting">
-<span class="identifier">bjam</span>
+<pre class="programlisting"><span class="identifier">bjam</span>
 </pre>
 <p>
       It should be building now:
@@ -172,7 +165,7 @@ bjam
       And so on... Finally:
     </p>
 <pre class="programlisting">Creating library <span class="emphasis"><em>path-to-boost_python.dll</em></span>
-   Creating library <span class="emphasis"><em>path-to-'''hello_ext'''.exp</em></span>
+   Creating library /path-to-hello_ext.exp/
 **passed** ... hello.test
 ...updated 35 targets...
 </pre>
@@ -180,29 +173,13 @@ bjam
       Or something similar. If all is well, you should now have built the DLLs and
       run the Python program.
     </p>
-<div class="note"><table border="0" summary="Note">
-<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/html/images/note.png"></td>
-<th align="left">Note</th>
-</tr>
-<tr><td colspan="2" align="left" valign="top"><p>
-        Starting from Boost 1.35, bjam erases the generated executables (e.g. pyd
-        file). To keep bjam from doing that, pass --preserve-test-targets to bjam.
-      </p></td></tr>
-</table></div>
-<div class="blockquote"><blockquote class="blockquote">
-<p>
-        </p>
-<p>
-          <span class="bold"><b>There you go... Have fun!</b></span>
-        </p>
-<p>
-      </p>
-</blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+        <span class="bold"><strong>There you go... Have fun!</strong></span>
+      </p></blockquote></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
       de Guzman, David Abrahams<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
@@ -212,7 +189,7 @@ bjam
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="../index.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="exposing.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="../index.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="exposing.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

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

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

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

@@ -1,69 +1,67 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Object Interface</title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Object Interface</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
 <link rel="prev" href="functions.html" title="Functions">
 <link rel="next" href="embedding.html" title="Embedding">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="functions.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="embedding.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="embedding.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="python.object"></a> Object Interface</h2></div></div></div>
+<a name="python.object"></a>Object Interface</h2></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="object.html#python.basic_interface">Basic Interface</a></span></dt>
 <dt><span class="section"><a href="object.html#python.derived_object_types">Derived Object types</a></span></dt>
 <dt><span class="section"><a href="object.html#python.extracting_c___objects">Extracting C++ objects</a></span></dt>
 <dt><span class="section"><a href="object.html#python.enums">Enums</a></span></dt>
+<dt><span class="section"><a href="object.html#python.creating_python_object">Creating <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">object</span></code> from <code class="computeroutput"><span class="identifier">PyObject</span><span class="special">*</span></code></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 <tt class="literal">object</tt>. We will see in this
+      are just instances of class <code class="literal">object</code>. We will 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++ <tt class="literal">object</tt>s are as close as possible to Python. This should
+      C++ <code class="literal">object</code>s are as close as possible to Python. This should
       minimize the learning curve significantly.
     </p>
 <p>
       <span class="inlinemediaobject"><img src="../images/python.png" alt="python"></span>
     </p>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.basic_interface"></a>Basic Interface</h3></div></div></div>
 <p>
-        Class <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
+        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
         can in fact be explicitly constructed from any C++ object.
       </p>
 <p>
         To illustrate, this Python code snippet:
       </p>
-<p>
-      </p>
-<pre class="programlisting">
-<span class="keyword">def</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">y</span><span class="special">):</span>
+<pre class="programlisting"><span class="keyword">def</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">y</span><span class="special">):</span>
      <span class="keyword">if</span> <span class="special">(</span><span class="identifier">y</span> <span class="special">==</span> <span class="string">'foo'</span><span class="special">):</span>
          <span class="identifier">x</span><span class="special">[</span><span class="number">3</span><span class="special">:</span><span class="number">7</span><span class="special">]</span> <span class="special">=</span> <span class="string">'bar'</span>
      <span class="keyword">else</span><span class="special">:</span>
@@ -76,10 +74,7 @@
 <p>
         Can be rewritten in C++ using Boost.Python facilities this way:
       </p>
-<p>
-      </p>
-<pre class="programlisting">
-<span class="identifier">object</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">object</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">y</span><span class="special">)</span> <span class="special">{</span>
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">object</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">y</span><span class="special">)</span> <span class="special">{</span>
      <span class="keyword">if</span> <span class="special">(</span><span class="identifier">y</span> <span class="special">==</span> <span class="string">"foo"</span><span class="special">)</span>
          <span class="identifier">x</span><span class="special">.</span><span class="identifier">slice</span><span class="special">(</span><span class="number">3</span><span class="special">,</span><span class="number">7</span><span class="special">)</span> <span class="special">=</span> <span class="string">"bar"</span><span class="special">;</span>
      <span class="keyword">else</span>
@@ -95,120 +90,114 @@
         in C++, the look and feel should be immediately apparent to the Python coder.
       </p>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.derived_object_types"></a>Derived Object types</h3></div></div></div>
 <p>
-        Boost.Python comes with a set of derived <tt class="literal">object</tt> types
+        Boost.Python comes with a set of derived <code class="literal">object</code> types
         corresponding to that of Python's:
       </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
-          list
-        </li>
-<li>
-          dict
-        </li>
-<li>
-          tuple
-        </li>
-<li>
-          str
-        </li>
-<li>
-          long_
-        </li>
-<li>
-          enum
-        </li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            list
+          </li>
+<li class="listitem">
+            dict
+          </li>
+<li class="listitem">
+            tuple
+          </li>
+<li class="listitem">
+            str
+          </li>
+<li class="listitem">
+            long_
+          </li>
+<li class="listitem">
+            enum
+          </li>
 </ul></div>
 <p>
-        These derived <tt class="literal">object</tt> types act like real Python types.
+        These derived <code class="literal">object</code> types act like real Python types.
         For instance:
       </p>
-<pre class="programlisting">
-<span class="identifier">str</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">==&gt;</span> <span class="string">"1"</span>
+<pre class="programlisting"><span class="identifier">str</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">==&gt;</span> <span class="string">"1"</span>
 </pre>
 <p>
-        Wherever appropriate, a particular derived <tt class="literal">object</tt> has
-        corresponding Python type's methods. For instance, <tt class="literal">dict</tt>
-        has a <tt class="literal">keys()</tt> method:
+        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:
       </p>
-<pre class="programlisting">
-<span class="identifier">d</span><span class="special">.</span><span class="identifier">keys</span><span class="special">()</span>
+<pre class="programlisting"><span class="identifier">d</span><span class="special">.</span><span class="identifier">keys</span><span class="special">()</span>
 </pre>
 <p>
-        <tt class="literal">make_tuple</tt> is provided for declaring <span class="emphasis"><em>tuple literals</em></span>.
+        <code class="literal">make_tuple</code> is provided for declaring <span class="emphasis"><em>tuple literals</em></span>.
         Example:
       </p>
-<pre class="programlisting">
-<span class="identifier">make_tuple</span><span class="special">(</span><span class="number">123</span><span class="special">,</span> <span class="char">'D'</span><span class="special">,</span> <span class="string">"Hello, World"</span><span class="special">,</span> <span class="number">0.0</span><span class="special">);</span>
+<pre class="programlisting"><span class="identifier">make_tuple</span><span class="special">(</span><span class="number">123</span><span class="special">,</span> <span class="char">'D'</span><span class="special">,</span> <span class="string">"Hello, World"</span><span class="special">,</span> <span class="number">0.0</span><span class="special">);</span>
 </pre>
 <p>
-        In C++, when Boost.Python <tt class="literal">object</tt>s are used as arguments
+        In C++, when Boost.Python <code class="literal">object</code>s are used as arguments
         to functions, subtype matching is required. For example, when a function
-        <tt class="literal">f</tt>, as declared below, is wrapped, it will only accept
-        instances of Python's <tt class="literal">str</tt> type and subtypes.
+        <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.
       </p>
-<pre class="programlisting">
-<span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">name</span><span class="special">)</span>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">name</span><span class="special">)</span>
 <span class="special">{</span>
-    <span class="identifier">object</span> <span class="identifier">n2</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"upper"</span><span class="special">)();</span>   <span class="comment">// NAME = name.upper()
-</span>    <span class="identifier">str</span> <span class="identifier">NAME</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">.</span><span class="identifier">upper</span><span class="special">();</span>            <span class="comment">// better
-</span>    <span class="identifier">object</span> <span class="identifier">msg</span> <span class="special">=</span> <span class="string">"%s is bigger than %s"</span> <span class="special">%</span> <span class="identifier">make_tuple</span><span class="special">(</span><span class="identifier">NAME</span><span class="special">,</span><span class="identifier">name</span><span class="special">);</span>
+    <span class="identifier">object</span> <span class="identifier">n2</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"upper"</span><span class="special">)();</span>   <span class="comment">// NAME = name.upper()</span>
+    <span class="identifier">str</span> <span class="identifier">NAME</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">.</span><span class="identifier">upper</span><span class="special">();</span>            <span class="comment">// better</span>
+    <span class="identifier">object</span> <span class="identifier">msg</span> <span class="special">=</span> <span class="string">"%s is bigger than %s"</span> <span class="special">%</span> <span class="identifier">make_tuple</span><span class="special">(</span><span class="identifier">NAME</span><span class="special">,</span><span class="identifier">name</span><span class="special">);</span>
 <span class="special">}</span>
 </pre>
 <p>
         In finer detail:
       </p>
-<pre class="programlisting">
-<span class="identifier">str</span> <span class="identifier">NAME</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">.</span><span class="identifier">upper</span><span class="special">();</span>
+<pre class="programlisting"><span class="identifier">str</span> <span class="identifier">NAME</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">.</span><span class="identifier">upper</span><span class="special">();</span>
 </pre>
 <p>
         Illustrates that we provide versions of the str type's methods as C++ member
         functions.
       </p>
-<pre class="programlisting">
-<span class="identifier">object</span> <span class="identifier">msg</span> <span class="special">=</span> <span class="string">"%s is bigger than %s"</span> <span class="special">%</span> <span class="identifier">make_tuple</span><span class="special">(</span><span class="identifier">NAME</span><span class="special">,</span><span class="identifier">name</span><span class="special">);</span>
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">msg</span> <span class="special">=</span> <span class="string">"%s is bigger than %s"</span> <span class="special">%</span> <span class="identifier">make_tuple</span><span class="special">(</span><span class="identifier">NAME</span><span class="special">,</span><span class="identifier">name</span><span class="special">);</span>
 </pre>
 <p>
-        Demonstrates that you can write the C++ equivalent of <tt class="literal">"format"
-        % x,y,z</tt> in Python, which is useful since there's no easy way to
+        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
         do that in std C++.
       </p>
-<div class="sidebar"><p>
-        <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><b>Beware</b></span> the common pitfall
+<div class="sidebar">
+<div class="titlepage"></div>
+<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>
+      </p>
+</div>
 <p>
         Python:
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">dict</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">__dict__</span><span class="special">)</span>     <span class="comment"># copies x.__dict__
-</span><span class="special">&gt;&gt;&gt;</span> <span class="identifier">d</span><span class="special">[</span><span class="string">'whatever'</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span>        <span class="comment"># modifies the copy
-</span></pre>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">dict</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">__dict__</span><span class="special">)</span>     <span class="comment"># copies x.__dict__</span>
+<span class="special">&gt;&gt;&gt;</span> <span class="identifier">d</span><span class="special">[</span><span class="string">'whatever'</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span>        <span class="comment"># modifies the copy</span>
+</pre>
 <p>
         C++:
       </p>
-<pre class="programlisting">
-<span class="identifier">dict</span> <span class="identifier">d</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span>  <span class="comment">// copies x.__dict__
-</span><span class="identifier">d</span><span class="special">[</span><span class="char">'whatever'</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>           <span class="comment">// modifies the copy
-</span></pre>
-<a name="derived_object_types.class__lt_t_gt__as_objects"></a><h2>
-<a name="id469744"></a>
+<pre class="programlisting"><span class="identifier">dict</span> <span class="identifier">d</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span>  <span class="comment">// copies x.__dict__</span>
+<span class="identifier">d</span><span class="special">[</span><span class="char">'whatever'</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>           <span class="comment">// modifies the copy</span>
+</pre>
+<h3>
+<a name="derived_object_types.class__lt_t_gt__as_objects"></a>
         class_&lt;T&gt; as objects
-      </h2>
+      </h3>
 <p>
-        Due to the dynamic nature of Boost.Python objects, any <tt class="literal">class_&lt;T&gt;</tt>
+        Due to the dynamic nature of Boost.Python objects, any <code class="literal">class_&lt;T&gt;</code>
         may also be one of these types! The following code snippet wraps the class
         (type) object.
       </p>
 <p>
         We can use this to create wrapped instances. Example:
       </p>
-<pre class="programlisting">
-<span class="identifier">object</span> <span class="identifier">vec345</span> <span class="special">=</span> <span class="special">(</span>
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">vec345</span> <span class="special">=</span> <span class="special">(</span>
     <span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Vec2</span><span class="special">&gt;(</span><span class="string">"Vec2"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;())</span>
         <span class="special">.</span><span class="identifier">def_readonly</span><span class="special">(</span><span class="string">"length"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Point</span><span class="special">::</span><span class="identifier">length</span><span class="special">)</span>
         <span class="special">.</span><span class="identifier">def_readonly</span><span class="special">(</span><span class="string">"angle"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Point</span><span class="special">::</span><span class="identifier">angle</span><span class="special">)</span>
@@ -217,91 +206,85 @@
 <span class="identifier">assert</span><span class="special">(</span><span class="identifier">vec345</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">)</span> <span class="special">==</span> <span class="number">5.0</span><span class="special">);</span>
 </pre>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.extracting_c___objects"></a>Extracting C++ objects</h3></div></div></div>
 <p>
         At 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
+        can be achieved with the <code class="literal">extract&lt;T&gt;</code> 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>
+<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">o</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">);</span> <span class="comment">// compile error</span>
+</pre>
 <p>
-        In the code above, we got a compiler error because Boost.Python <tt class="literal">object</tt>
-        can't be implicitly converted to <tt class="literal">double</tt>s. Instead, what
+        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
         we wanted to do above can be achieved by writing:
       </p>
-<pre class="programlisting">
-<span class="keyword">double</span> <span class="identifier">l</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;(</span><span class="identifier">o</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">));</span>
+<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">l</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;(</span><span class="identifier">o</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">));</span>
 <span class="identifier">Vec2</span><span class="special">&amp;</span> <span class="identifier">v</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">Vec2</span><span class="special">&amp;&gt;(</span><span class="identifier">o</span><span class="special">);</span>
 <span class="identifier">assert</span><span class="special">(</span><span class="identifier">l</span> <span class="special">==</span> <span class="identifier">v</span><span class="special">.</span><span class="identifier">length</span><span class="special">());</span>
 </pre>
 <p>
         The first line attempts to extract the "length" attribute of the
-        Boost.Python <tt class="literal">object</tt>. The second line attempts to <span class="emphasis"><em>extract</em></span>
-        the <tt class="literal">Vec2</tt> object from held by the Boost.Python <tt class="literal">object</tt>.
+        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>.
       </p>
 <p>
         Take note that we said "attempt to" above. What if the Boost.Python
-        <tt class="literal">object</tt> does not really hold a <tt class="literal">Vec2</tt>
+        <code class="literal">object</code> does not really hold a <code class="literal">Vec2</code>
         type? This is certainly a possibility considering the dynamic nature of Python
-        <tt class="literal">object</tt>s. To be on the safe side, if the C++ type can't
+        <code class="literal">object</code>s. To be on the safe side, if the C++ type can't
         be extracted, an appropriate exception is thrown. To avoid an exception,
         we need to test for extractibility:
       </p>
-<pre class="programlisting">
-<span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">Vec2</span><span class="special">&amp;&gt;</span> <span class="identifier">x</span><span class="special">(</span><span class="identifier">o</span><span class="special">);</span>
+<pre class="programlisting"><span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">Vec2</span><span class="special">&amp;&gt;</span> <span class="identifier">x</span><span class="special">(</span><span class="identifier">o</span><span class="special">);</span>
 <span class="keyword">if</span> <span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">check</span><span class="special">())</span> <span class="special">{</span>
     <span class="identifier">Vec2</span><span class="special">&amp;</span> <span class="identifier">v</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">();</span> <span class="special">...</span>
 </pre>
 <p>
-        <span class="inlinemediaobject"><img src="../images/tip.png" alt="tip"></span> The astute reader might have noticed that the <tt class="literal">extract&lt;T&gt;</tt>
+        <span class="inlinemediaobject"><img src="../images/tip.png" alt="tip"></span> The astute reader might have noticed that the <code class="literal">extract&lt;T&gt;</code>
         facility in fact solves the mutable copying problem:
       </p>
-<pre class="programlisting">
-<span class="identifier">dict</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">dict</span><span class="special">&gt;(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span>
-<span class="identifier">d</span><span class="special">[</span><span class="string">"whatever"</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>          <span class="comment">// modifies x.__dict__ !
-</span></pre>
+<pre class="programlisting"><span class="identifier">dict</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">dict</span><span class="special">&gt;(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span>
+<span class="identifier">d</span><span class="special">[</span><span class="string">"whatever"</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>          <span class="comment">// modifies x.__dict__ !</span>
+</pre>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.enums"></a>Enums</h3></div></div></div>
 <p>
         Boost.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
+        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:
       </p>
-<pre class="programlisting">
-<span class="keyword">enum</span> <span class="identifier">choice</span> <span class="special">{</span> <span class="identifier">red</span><span class="special">,</span> <span class="identifier">blue</span> <span class="special">};</span>
+<pre class="programlisting"><span class="keyword">enum</span> <span class="identifier">choice</span> <span class="special">{</span> <span class="identifier">red</span><span class="special">,</span> <span class="identifier">blue</span> <span class="special">};</span>
 </pre>
 <p>
         the construct:
       </p>
-<pre class="programlisting">
-<span class="identifier">enum_</span><span class="special">&lt;</span><span class="identifier">choice</span><span class="special">&gt;(</span><span class="string">"choice"</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">enum_</span><span class="special">&lt;</span><span class="identifier">choice</span><span class="special">&gt;(</span><span class="string">"choice"</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">value</span><span class="special">(</span><span class="string">"red"</span><span class="special">,</span> <span class="identifier">red</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">value</span><span class="special">(</span><span class="string">"blue"</span><span class="special">,</span> <span class="identifier">blue</span><span class="special">)</span>
     <span class="special">;</span>
 </pre>
 <p>
         can be used to expose to Python. The new enum type is created in the current
-        <tt class="literal">scope()</tt>, which is usually the current module. The snippet
-        above creates a Python class derived from Python's <tt class="literal">int</tt>
+        <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>
         type which is associated with the C++ type passed as its first parameter.
       </p>
 <div class="note"><table border="0" summary="Note">
 <tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/html/images/note.png"></td>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
 <th align="left">Note</th>
 </tr>
-<tr><td colspan="2" align="left" valign="top">
+<tr><td align="left" valign="top">
 <p>
-          <span class="bold"><b>what is a scope?</b></span>
+          <span class="bold"><strong>what is a scope?</strong></span>
         </p>
 <p>
           The scope is a class that has an associated global Python object which
@@ -313,35 +296,55 @@
 <p>
         You can access those values in Python as
       </p>
-<p>
-      </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">my_module</span><span class="special">.</span><span class="identifier">choice</span><span class="special">.</span><span class="identifier">red</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">my_module</span><span class="special">.</span><span class="identifier">choice</span><span class="special">.</span><span class="identifier">red</span>
 <span class="identifier">my_module</span><span class="special">.</span><span class="identifier">choice</span><span class="special">.</span><span class="identifier">red</span>
 </pre>
 <p>
         where my_module is the module where the enum is declared. You can also create
         a new scope around a class:
       </p>
-<p>
-      </p>
-<pre class="programlisting">
-<span class="identifier">scope</span> <span class="identifier">in_X</span> <span class="special">=</span> <span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;(</span><span class="string">"X"</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">scope</span> <span class="identifier">in_X</span> <span class="special">=</span> <span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;(</span><span class="string">"X"</span><span class="special">)</span>
                 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span> <span class="special">...</span> <span class="special">)</span>
                 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span> <span class="special">...</span> <span class="special">)</span>
             <span class="special">;</span>
 
-<span class="comment">// Expose X::nested as X.nested
-</span><span class="identifier">enum_</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">nested</span><span class="special">&gt;(</span><span class="string">"nested"</span><span class="special">)</span>
+<span class="comment">// Expose X::nested as X.nested</span>
+<span class="identifier">enum_</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">nested</span><span class="special">&gt;(</span><span class="string">"nested"</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">value</span><span class="special">(</span><span class="string">"red"</span><span class="special">,</span> <span class="identifier">red</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">value</span><span class="special">(</span><span class="string">"blue"</span><span class="special">,</span> <span class="identifier">blue</span><span class="special">)</span>
     <span class="special">;</span>
 </pre>
 </div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="python.creating_python_object"></a>Creating <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">object</span></code> from <code class="computeroutput"><span class="identifier">PyObject</span><span class="special">*</span></code>
+</h3></div></div></div>
+<p>
+        When you want a <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">object</span></code> to manage a pointer to <code class="computeroutput"><span class="identifier">PyObject</span><span class="special">*</span></code>
+        pyobj one does:
+      </p>
+<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">object</span> <span class="identifier">o</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">handle</span><span class="special">&lt;&gt;(</span><span class="identifier">pyobj</span><span class="special">));</span>
+</pre>
+<p>
+        In this case, the <code class="computeroutput"><span class="identifier">o</span></code> object,
+        manages the <code class="computeroutput"><span class="identifier">pyobj</span></code>, it won&#8217;t
+        increase the reference count on construction.
+      </p>
+<p>
+        Otherwise, to use a borrowed reference:
+      </p>
+<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">object</span> <span class="identifier">o</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">handle</span><span class="special">&lt;&gt;(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">borrowed</span><span class="special">(</span><span class="identifier">pyobj</span><span class="special">)));</span>
+</pre>
+<p>
+        In this case, <code class="computeroutput"><span class="identifier">Py_INCREF</span></code> is
+        called, so <code class="computeroutput"><span class="identifier">pyobj</span></code> is not destructed
+        when object o goes out of scope.
+      </p>
+</div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
       de Guzman, David Abrahams<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
@@ -351,7 +354,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="functions.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="embedding.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="embedding.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

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

@@ -1,29 +1,29 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> General Techniques</title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
-<link rel="start" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="up" href="../index.html" title="Chapter 1. python 1.0">
-<link rel="prev" href="exception.html" title=" Exception Translation">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>General Techniques</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;python 2.0">
+<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%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="exception.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a>
+<a accesskey="p" href="exception.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="python.techniques"></a> General Techniques</h2></div></div></div>
+<a name="python.techniques"></a>General Techniques</h2></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="techniques.html#python.creating_packages">Creating Packages</a></span></dt>
 <dt><span class="section"><a href="techniques.html#python.extending_wrapped_objects_in_python">Extending Wrapped Objects in Python</a></span></dt>
@@ -33,7 +33,7 @@
       Here are presented some useful techniques that you can use while wrapping code
       with Boost.Python.
     </p>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.creating_packages"></a>Creating Packages</h3></div></div></div>
 <p>
@@ -50,11 +50,10 @@
 <p>
         We have a C++ library that works with sounds: reading and writing various
         formats, applying filters to the sound data, etc. It is named (conveniently)
-        <tt class="literal">sounds</tt>. Our library already has a neat C++ namespace hierarchy,
+        <code class="literal">sounds</code>. Our library already has a neat C++ namespace hierarchy,
         like so:
       </p>
-<pre class="programlisting">
-<span class="identifier">sounds</span><span class="special">::</span><span class="identifier">core</span>
+<pre class="programlisting"><span class="identifier">sounds</span><span class="special">::</span><span class="identifier">core</span>
 <span class="identifier">sounds</span><span class="special">::</span><span class="identifier">io</span>
 <span class="identifier">sounds</span><span class="special">::</span><span class="identifier">filters</span>
 </pre>
@@ -62,16 +61,14 @@
         We would like to present this same hierarchy to the Python user, allowing
         him to write code like this:
       </p>
-<pre class="programlisting">
-<span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
-<span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo</span><span class="special">(...)</span> <span class="comment"># echo is a C++ function
-</span></pre>
+<pre class="programlisting"><span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
+<span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo</span><span class="special">(...)</span> <span class="comment"># echo is a C++ function</span>
+</pre>
 <p>
         The first step is to write the wrapping code. We have to export each module
         separately with Boost.Python, like this:
       </p>
-<pre class="programlisting">
-<span class="special">/*</span> <span class="identifier">file</span> <span class="identifier">core</span><span class="special">.</span><span class="identifier">cpp</span> <span class="special">*/</span>
+<pre class="programlisting"><span class="special">/*</span> <span class="identifier">file</span> <span class="identifier">core</span><span class="special">.</span><span class="identifier">cpp</span> <span class="special">*/</span>
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">core</span><span class="special">)</span>
 <span class="special">{</span>
     <span class="special">/*</span> <span class="identifier">export</span> <span class="identifier">everything</span> <span class="keyword">in</span> <span class="identifier">the</span> <span class="identifier">sounds</span><span class="special">::</span><span class="identifier">core</span> <span class="identifier">namespace</span> <span class="special">*/</span>
@@ -93,18 +90,18 @@
 <span class="special">}</span>
 </pre>
 <p>
-        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>.
+        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>.
       </p>
 <div class="note"><table border="0" summary="Note">
 <tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/html/images/note.png"></td>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
 <th align="left">Note</th>
 </tr>
-<tr><td colspan="2" align="left" valign="top"><p>
-          The extension <tt class="literal">.pyd</tt> is used for python extension modules,
+<tr><td align="left" valign="top"><p>
+          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
-          <tt class="literal">.so</tt> for Unix and <tt class="literal">.dll</tt> for Windows,
+          <code class="literal">.so</code> for Unix and <code class="literal">.dll</code> for Windows,
           works just as well.
         </p></td></tr>
 </table></div>
@@ -118,19 +115,16 @@
     io.pyd
 </pre>
 <p>
-        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
+        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
         file, but can also perform some magic, that will be shown later.
       </p>
 <p>
-        Now our package is ready. All the user has to do is put <tt class="literal">sounds</tt>
+        Now our package is ready. All the user has to do is put <code class="literal">sounds</code>
         into his <a href="http://www.python.org/doc/current/tut/node8.html#SECTION008110000000000000000" target="_top">PYTHONPATH</a>
         and fire up the interpreter:
       </p>
-<p>
-      </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">io</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">io</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">sound</span> <span class="special">=</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">io</span><span class="special">.</span><span class="identifier">open</span><span class="special">(</span><span class="string">'file.mp3'</span><span class="special">)</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">new_sound</span> <span class="special">=</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo</span><span class="special">(</span><span class="identifier">sound</span><span class="special">,</span> <span class="number">1.0</span><span class="special">)</span>
@@ -150,10 +144,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>
-<pre class="programlisting">
-<span class="comment">/* file core.cpp */</span>
+<pre class="programlisting"><span class="comment">/* file core.cpp */</span>
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">_core</span><span class="special">)</span>
 <span class="special">{</span>
     <span class="special">...</span>
@@ -162,7 +153,7 @@
 </pre>
 <p>
         Note that we added an underscore to the module name. The filename will have
-        to be changed to <tt class="literal">_core.pyd</tt> as well, and we do the same
+        to be changed to <code class="literal">_core.pyd</code> as well, and we do the same
         to the other extension modules. Now, we change our package hierarchy like
         so:
       </p>
@@ -183,77 +174,68 @@
         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>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">_core</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">_core</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">_core</span><span class="special">.</span><span class="identifier">foo</span><span class="special">(...)</span>
 </pre>
 <p>
-        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
+        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
         can be accessed directly by the user. So, all we have to do is bring the
-        entire namespace from <tt class="literal">_core.pyd</tt> to <tt class="literal">core/__init__.py</tt>.
-        So add this line of code to <tt class="literal">sounds<span class="emphasis"><em>core</em></span>__init__.py</tt>:
+        entire namespace from <code class="literal">_core.pyd</code> to <code class="literal">core/__init__.py</code>.
+        So add this line of code to <code class="literal">sounds/core/__init__.py</code>:
       </p>
-<pre class="programlisting">
-<span class="keyword">from</span> <span class="identifier">_core</span> <span class="keyword">import</span> <span class="special">*</span>
+<pre class="programlisting"><span class="keyword">from</span> <span class="identifier">_core</span> <span class="keyword">import</span> <span class="special">*</span>
 </pre>
 <p>
         We do the same for the other packages. Now the user accesses the functions
         and classes in the extension modules like before:
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo</span><span class="special">(...)</span>
 </pre>
 <p>
         with the additional benefit that we can easily add pure Python functions
         to any module, in a way that the user can't tell the difference between a
         C++ function and a Python function. Let's add a <span class="emphasis"><em>pure</em></span>
-        Python function, <tt class="literal">echo_noise</tt>, to the <tt class="literal">filters</tt>
-        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
+        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
         function:
       </p>
-<pre class="programlisting">
-<span class="keyword">import</span> <span class="identifier">_filters</span>
+<pre class="programlisting"><span class="keyword">import</span> <span class="identifier">_filters</span>
 <span class="keyword">def</span> <span class="identifier">echo_noise</span><span class="special">(</span><span class="identifier">sound</span><span class="special">):</span>
     <span class="identifier">s</span> <span class="special">=</span> <span class="identifier">_filters</span><span class="special">.</span><span class="identifier">echo</span><span class="special">(</span><span class="identifier">sound</span><span class="special">)</span>
     <span class="identifier">s</span> <span class="special">=</span> <span class="identifier">_filters</span><span class="special">.</span><span class="identifier">noise</span><span class="special">(</span><span class="identifier">sound</span><span class="special">)</span>
     <span class="keyword">return</span> <span class="identifier">s</span>
 </pre>
 <p>
-        Next, we add this line to <tt class="literal">sounds<span class="emphasis"><em>filters</em></span>__init__.py</tt>:
+        Next, we add this line to <code class="literal">sounds/filters/__init__.py</code>:
       </p>
-<pre class="programlisting">
-<span class="keyword">from</span> <span class="identifier">echo_noise</span> <span class="keyword">import</span> <span class="identifier">echo_noise</span>
+<pre class="programlisting"><span class="keyword">from</span> <span class="identifier">echo_noise</span> <span class="keyword">import</span> <span class="identifier">echo_noise</span>
 </pre>
 <p>
         And that's it. The user now accesses this function like any other function
-        from the <tt class="literal">filters</tt> package:
+        from the <code class="literal">filters</code> package:
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo_noise</span><span class="special">(...)</span>
 </pre>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.extending_wrapped_objects_in_python"></a>Extending Wrapped Objects in Python</h3></div></div></div>
 <p>
         Thanks to Python's flexibility, you can easily add new methods to a class,
         even after it was already created:
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">class</span> <span class="identifier">C</span><span class="special">(</span><span class="identifier">object</span><span class="special">):</span> <span class="keyword">pass</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">class</span> <span class="identifier">C</span><span class="special">(</span><span class="identifier">object</span><span class="special">):</span> <span class="keyword">pass</span>
 <span class="special">&gt;&gt;&gt;</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="comment"># a regular function
-</span><span class="special">&gt;&gt;&gt;</span> <span class="keyword">def</span> <span class="identifier">C_str</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span> <span class="keyword">return</span> <span class="string">'A C instance!'</span>
+<span class="special">&gt;&gt;&gt;</span> <span class="comment"># a regular function</span>
+<span class="special">&gt;&gt;&gt;</span> <span class="keyword">def</span> <span class="identifier">C_str</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span> <span class="keyword">return</span> <span class="string">'A C instance!'</span>
 <span class="special">&gt;&gt;&gt;</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="comment"># now we turn it in a member function
-</span><span class="special">&gt;&gt;&gt;</span> <span class="identifier">C</span><span class="special">.</span><span class="identifier">__str__</span> <span class="special">=</span> <span class="identifier">C_str</span>
+<span class="special">&gt;&gt;&gt;</span> <span class="comment"># now we turn it in a member function</span>
+<span class="special">&gt;&gt;&gt;</span> <span class="identifier">C</span><span class="special">.</span><span class="identifier">__str__</span> <span class="special">=</span> <span class="identifier">C_str</span>
 <span class="special">&gt;&gt;&gt;</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">c</span> <span class="special">=</span> <span class="identifier">C</span><span class="special">()</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">c</span>
@@ -266,12 +248,9 @@
       </p>
 <p>
         We can do the same with classes that were wrapped with Boost.Python. Suppose
-        we have a class <tt class="literal">point</tt> in C++:
+        we have a class <code class="literal">point</code> in C++:
       </p>
-<p>
-      </p>
-<pre class="programlisting">
-<span class="keyword">class</span> <span class="identifier">point</span> <span class="special">{...};</span>
+<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">point</span> <span class="special">{...};</span>
 
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">_geom</span><span class="special">)</span>
 <span class="special">{</span>
@@ -279,48 +258,44 @@
 <span class="special">}</span>
 </pre>
 <p>
-        If we are using the technique from the previous session, <a href="techniques.html#python.creating_packages" title="Creating Packages">Creating
-        Packages</a>, we can code directly into <tt class="literal">geom/__init__.py</tt>:
+        If we are using the technique from the previous session, <a class="link" href="techniques.html#python.creating_packages" title="Creating Packages">Creating
+        Packages</a>, we can code directly into <code class="literal">geom/__init__.py</code>:
       </p>
-<p>
-      </p>
-<pre class="programlisting">
-<span class="keyword">from</span> <span class="identifier">_geom</span> <span class="keyword">import</span> <span class="special">*</span>
+<pre class="programlisting"><span class="keyword">from</span> <span class="identifier">_geom</span> <span class="keyword">import</span> <span class="special">*</span>
 
-<span class="comment"># a regular function
-</span><span class="keyword">def</span> <span class="identifier">point_str</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span>
+<span class="comment"># a regular function</span>
+<span class="keyword">def</span> <span class="identifier">point_str</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span>
     <span class="keyword">return</span> <span class="identifier">str</span><span class="special">((</span><span class="identifier">self</span><span class="special">.</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">self</span><span class="special">.</span><span class="identifier">y</span><span class="special">))</span>
 
-<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>
+<span class="comment"># now we turn it into a member function</span>
+<span class="identifier">point</span><span class="special">.</span><span class="identifier">__str__</span> <span class="special">=</span> <span class="identifier">point_str</span>
 </pre>
 <p>
-        <span class="bold"><b>All</b></span> point instances created from C++ will
+        <span class="bold"><strong>All</strong></span> point instances created from C++ will
         also have this member function! This technique has several advantages:
       </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
-          Cut down compile times to zero for these additional functions
-        </li>
-<li>
-          Reduce the memory footprint to virtually zero
-        </li>
-<li>
-          Minimize the need to recompile
-        </li>
-<li>
-          Rapid prototyping (you can move the code to C++ if required without changing
-          the interface)
-        </li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            Cut down compile times to zero for these additional functions
+          </li>
+<li class="listitem">
+            Reduce the memory footprint to virtually zero
+          </li>
+<li class="listitem">
+            Minimize the need to recompile
+          </li>
+<li class="listitem">
+            Rapid prototyping (you can move the code to C++ if required without changing
+            the interface)
+          </li>
 </ul></div>
 <p>
         You can even add a little syntactic sugar with the use of metaclasses. Let's
         create a special metaclass that "injects" methods in other classes.
       </p>
-<pre class="programlisting">
-<span class="comment"># The one Boost.Python uses for all wrapped classes.
-</span><span class="comment"># You can use here any class exported by Boost instead of "point"
-</span><span class="identifier">BoostPythonMetaclass</span> <span class="special">=</span> <span class="identifier">point</span><span class="special">.</span><span class="identifier">__class__</span>
+<pre class="programlisting"><span class="comment"># The one Boost.Python uses for all wrapped classes.</span>
+<span class="comment"># You can use here any class exported by Boost instead of "point"</span>
+<span class="identifier">BoostPythonMetaclass</span> <span class="special">=</span> <span class="identifier">point</span><span class="special">.</span><span class="identifier">__class__</span>
 
 <span class="keyword">class</span> <span class="identifier">injector</span><span class="special">(</span><span class="identifier">object</span><span class="special">):</span>
     <span class="keyword">class</span> <span class="identifier">__metaclass__</span><span class="special">(</span><span class="identifier">BoostPythonMetaclass</span><span class="special">):</span>
@@ -331,8 +306,8 @@
                         <span class="identifier">setattr</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">k</span><span class="special">,</span><span class="identifier">v</span><span class="special">)</span>
             <span class="keyword">return</span> <span class="identifier">type</span><span class="special">.</span><span class="identifier">__init__</span><span class="special">(</span><span class="identifier">self</span><span class="special">,</span> <span class="identifier">name</span><span class="special">,</span> <span class="identifier">bases</span><span class="special">,</span> <span class="identifier">dict</span><span class="special">)</span>
 
-<span class="comment"># inject some methods in the point foo
-</span><span class="keyword">class</span> <span class="identifier">more_point</span><span class="special">(</span><span class="identifier">injector</span><span class="special">,</span> <span class="identifier">point</span><span class="special">):</span>
+<span class="comment"># inject some methods in the point foo</span>
+<span class="keyword">class</span> <span class="identifier">more_point</span><span class="special">(</span><span class="identifier">injector</span><span class="special">,</span> <span class="identifier">point</span><span class="special">):</span>
     <span class="keyword">def</span> <span class="identifier">__repr__</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span>
         <span class="keyword">return</span> <span class="string">'Point(x=%s, y=%s)'</span> <span class="special">%</span> <span class="special">(</span><span class="identifier">self</span><span class="special">.</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">self</span><span class="special">.</span><span class="identifier">y</span><span class="special">)</span>
     <span class="keyword">def</span> <span class="identifier">foo</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span>
@@ -341,8 +316,7 @@
 <p>
         Now let's see how it got:
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">point</span><span class="special">()</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">point</span><span class="special">()</span>
 <span class="identifier">Point</span><span class="special">(</span><span class="identifier">x</span><span class="special">=</span><span class="number">10</span><span class="special">,</span> <span class="identifier">y</span><span class="special">=</span><span class="number">10</span><span class="special">)</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">point</span><span class="special">().</span><span class="identifier">foo</span><span class="special">()</span>
 <span class="identifier">foo</span><span class="special">!</span>
@@ -350,8 +324,7 @@
 <p>
         Another useful idea is to replace constructors with factory functions:
       </p>
-<pre class="programlisting">
-<span class="identifier">_point</span> <span class="special">=</span> <span class="identifier">point</span>
+<pre class="programlisting"><span class="identifier">_point</span> <span class="special">=</span> <span class="identifier">point</span>
 
 <span class="keyword">def</span> <span class="identifier">point</span><span class="special">(</span><span class="identifier">x</span><span class="special">=</span><span class="number">0</span><span class="special">,</span> <span class="identifier">y</span><span class="special">=</span><span class="number">0</span><span class="special">):</span>
     <span class="keyword">return</span> <span class="identifier">_point</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">y</span><span class="special">)</span>
@@ -363,7 +336,7 @@
         support.
       </p>
 </div>
-<div class="section" lang="en">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.reducing_compiling_time"></a>Reducing Compiling Time</h3></div></div></div>
 <p>
@@ -372,10 +345,7 @@
         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>
+<pre class="programlisting"><span class="comment">/* file point.cpp */</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">point</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
@@ -394,11 +364,10 @@
 <span class="special">}</span>
 </pre>
 <p>
-        Now you create a file <tt class="literal">main.cpp</tt>, which contains the <tt class="literal">BOOST_PYTHON_MODULE</tt>
+        Now you create a file <code class="literal">main.cpp</code>, which contains the <code class="literal">BOOST_PYTHON_MODULE</code>
         macro, and call the various export functions inside it.
       </p>
-<pre class="programlisting">
-<span class="keyword">void</span> <span class="identifier">export_point</span><span class="special">();</span>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">export_point</span><span class="special">();</span>
 <span class="keyword">void</span> <span class="identifier">export_triangle</span><span class="special">();</span>
 
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">_geom</span><span class="special">)</span>
@@ -411,8 +380,7 @@
         Compiling and linking together all this files produces the same result as
         the usual approach:
       </p>
-<pre class="programlisting">
-<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">point</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">triangle</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span>
 
@@ -432,21 +400,21 @@
       </p>
 <div class="note"><table border="0" summary="Note">
 <tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/html/images/note.png"></td>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
 <th align="left">Note</th>
 </tr>
-<tr><td colspan="2" align="left" valign="top"><p>
+<tr><td align="left" valign="top"><p>
           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
+          take a look at the <code class="literal">--multiple</code> option, that generates
           the wrappers in various files as demonstrated here.
         </p></td></tr>
 </table></div>
 <div class="note"><table border="0" summary="Note">
 <tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/html/images/note.png"></td>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
 <th align="left">Note</th>
 </tr>
-<tr><td colspan="2" align="left" valign="top"><p>
+<tr><td align="left" valign="top"><p>
           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>.
@@ -456,7 +424,7 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2005 Joel
       de Guzman, David Abrahams<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
@@ -466,7 +434,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="exception.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a>
+<a accesskey="p" href="exception.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a>
 </div>
 </body>
 </html>

doc/tutorial/doc/tutorial.qbk

@@ -1,5 +1,5 @@
 [library python
-    [version 1.0]
+    [version 2.0]
     [authors [de Guzman, Joel], [Abrahams, David]]
     [copyright 2002 2003 2004 2005 Joel de Guzman, David Abrahams]
     [category inter-language support]
@@ -62,7 +62,7 @@ resulting DLL is now visible to Python. Here's a sample Python session:
 [python]
 
     >>> import hello_ext
-    >>> print hello.greet()
+    >>> print hello_ext.greet()
     hello, world
 
 [c++]
@@ -901,8 +901,8 @@ wrapping as outlined in the [link python.overloading previous section], or
 writing thin wrappers:
 
     // write "thin wrappers"
-    int f1(int x) { f(x); }
-    int f2(int x, double y) { f(x,y); }
+    int f1(int x) { return f(x); }
+    int f2(int x, double y) { return f(x,y); }
 
     /*...*/
 
@@ -1302,6 +1302,23 @@ create a new scope around a class:
 [def PyModule_GetDict       [@http://www.python.org/doc/current/api/moduleObjects.html#l2h-594   PyModule_GetDict]]
 
 [endsect]
+
+[section:creating_python_object Creating `boost::python::object` from `PyObject*`]
+
+When you want a `boost::python::object` to manage a pointer to `PyObject*` pyobj one does:
+
+    boost::python::object o(boost::python::handle<>(pyobj));
+
+In this case, the `o` object, manages the `pyobj`, it won’t increase the reference count on construction.
+
+Otherwise, to use a borrowed reference:
+
+    boost::python::object o(boost::python::handle<>(boost::python::borrowed(pyobj)));
+
+In this case, `Py_INCREF` is called, so `pyobj` is not destructed when object o goes out of scope.
+
+[endsect] [/ creating_python_object ]
+
 [endsect] [/ Object Interface]
 
 [section Embedding]
@@ -1381,10 +1398,10 @@ interpreter. This may be fixed in a future version of boost.python.]
 [section Using the interpreter]
 
 As you probably already know, objects in Python are reference-counted.
-Naturally, the [^PyObject]s of the Python/C API are also reference-counted.
+Naturally, the [^PyObject]s of the Python C API are also reference-counted.
 There is a difference however. While the reference-counting is fully
-automatic in Python, the Python/C API requires you to do it
-[@http://www.python.org/doc/current/api/refcounts.html by hand]. This is
+automatic in Python, the Python C API requires you to do it
+[@http://www.python.org/doc/current/c-api/refcounting.html by hand]. This is
 messy and especially hard to get right in the presence of C++ exceptions.
 Fortunately Boost.Python provides the [@../../../v2/handle.html handle] and
 [@../../../v2/object.html object] class templates to automate the process.
@@ -1466,7 +1483,7 @@ If an exception occurs in the evaluation of the python expression,
 The [^error_already_set] exception class doesn't carry any information in itself.
 To find out more about the Python exception that occurred, you need to use the
 [@http://www.python.org/doc/api/exceptionHandling.html exception handling functions]
-of the Python/C API in your catch-statement. This can be as simple as calling
+of the Python C API in your catch-statement. This can be as simple as calling
 [@http://www.python.org/doc/api/exceptionHandling.html#l2h-70 PyErr_Print()] to
 print the exception's traceback to the console, or comparing the type of the
 exception with those of the [@http://www.python.org/doc/api/standardExceptions.html

doc/tutorial/index.html

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

doc/v2/CallPolicies.html

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

doc/v2/Dereferenceable.html

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

doc/v2/Extractor.html

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

doc/v2/HolderGenerator.html

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

doc/v2/args.html

@@ -101,7 +101,7 @@ namespace boost { namespace python
         struct arg 
         {
           template <class T>
-                  arg &perator = (T const &value);
+                  arg &operator = (T const &value);
           explicit arg (char const *name){elements[0].name = name;}
         };
 

doc/v2/configuration.html

@@ -106,6 +106,33 @@
         function from being treated as an exported symbol on platforms which
         support that distinction in-code</td>
       </tr>
+
+      <tr>
+        <td valign="top"><code>BOOST_PYTHON_ENABLE_CDECL</code></td>
+
+        <td valign="top" align="center"><i>not&nbsp;defined</i></td>
+
+        <td valign="top">If defined, allows functions using the <code>__cdecl
+        </code> calling convention to be wrapped.</td>
+      </tr>
+
+      <tr>
+        <td valign="top"><code>BOOST_PYTHON_ENABLE_STDCALL</code></td>
+
+        <td valign="top" align="center"><i>not&nbsp;defined</i></td>
+
+        <td valign="top">If defined, allows functions using the <code>__stdcall
+        </code> calling convention to be wrapped.</td>
+      </tr>
+
+      <tr>
+        <td valign="top"><code>BOOST_PYTHON_ENABLE_FASTCALL</code></td>
+
+        <td valign="top" align="center"><i>not&nbsp;defined</i></td>
+
+        <td valign="top">If defined, allows functions using the <code>__fastcall
+        </code> calling convention to be wrapped.</td>
+      </tr>
     </table>
 
     <h2><a name="lib-defined-impl"></a>Library Defined Implementation

doc/v2/make_function.html

@@ -96,10 +96,10 @@ template <class F, class Policies, class Keywords, class Signature>
       to <code>f</code>. <ul>
 <li>        If <code>policies</code> are supplied, it
       will be applied to the function as described <a href=
-      "CallPolicies.html">here</a>. 
+      "CallPolicies.html">here</a>.
 <li>If <code>keywords</code> are
       supplied, the keywords will be applied in order to the final
-      arguments of the resulting function.  
+      arguments of the resulting function.
 <li>If <code>Signature</code>
       is supplied, it should be an instance of an <a
       href="../../../mpl/doc/refmanual/front-extensible-sequence.html">MPL front-extensible
@@ -125,36 +125,33 @@ template &lt;class F, class Policies, class Keywords, class Signature&gt;
     </dl>
 
 <pre>
-<a name=
-"make_constructor-spec"></a>template &lt;class T, class ArgList, class Generator&gt;
-<a href="object.html#object-spec">object</a> make_constructor();
- 
-template &lt;class ArgList, class Generator, class Policies&gt;
+<a name="make_constructor-spec">template &lt;class F&gt;</a>
+<a href="object.html#object-spec">object</a> make_constructor(F f)
+
+template &lt;class F, class Policies&gt;
 <a href=
-"object.html#object-spec">object</a> make_constructor(Policies const&amp; policies)
+"object.html#object-spec">object</a> make_constructor(F f, Policies const&amp; policies)
+
+template &lt;class F, class Policies, class KeywordsOrSignature&gt;
+<a href=
+"object.html#object-spec">object</a> make_constructor(F f, Policies const&amp; policies, KeywordsOrSignature const&amp; ks)
+
+template &lt;class F, class Policies, class Keywords, class Signature&gt;
+<a href=
+"object.html#object-spec">object</a> make_constructor(F f, Policies const&amp; policies, Keywords const&amp; kw, Signature const&amp; sig)
 </pre>
 
     <dl class="function-semantics">
-      <dt><b>Requires:</b> <code>T</code> is a class type.
-      <code>Policies</code> is a model of <a href=
-      "CallPolicies.html">CallPolicies</a>. <code>ArgList</code> is an <a
-      href="../../../mpl/doc/refmanual/forward-sequence.html">MPL sequence</a> of C++ argument
-      types (<i>A1,&nbsp;A2,...&nbsp;AN</i>) such that if
-      <code>a1,&nbsp;a2</code>...&nbsp;<code>aN</code> are objects of type
-      <i>A1,&nbsp;A2,...&nbsp;AN</i> respectively, the expression <code>new
-      Generator::apply&lt;T&gt;::type(a1,&nbsp;a2</code>...&nbsp;<code>aN</code>)
-      is valid. Generator is a model of <a href=
-      "HolderGenerator.html">HolderGenerator</a>.</dt>
+      <dt><b>Requires:</b> <code>F</code> is a
+      function pointer type. If <code>policies</code> are supplied, it must
+      be a model of <a href="CallPolicies.html">CallPolicies</a>. If
+      <code>kewords</code> are supplied, it must be the result of a <a href=
+      "args.html#keyword-expression"><em>keyword-expression</em></a>
+      specifying no more arguments than the <a href=
+      "definitions.html#arity">arity</a> of <code>f</code>.</dt>
 
       <dt><b>Effects:</b> Creates a Python callable object which, when called
-      from Python, expects its first argument to be a Boost.Python extension
-      class object. It converts its remaining its arguments to C++ and passes
-      them to the constructor of a dynamically-allocated
-      <code>Generator::apply&lt;T&gt;::type</code> object, which is then
-      installed in the extension class object. In the second form, the
-      <code>policies</code> are applied to the arguments and result (<a href=
-      "http://www.python.org/doc/current/lib/bltin-null-object.html">None</a>)
-      of the Python callable object</dt>
+      from Python, converts its arguments to C++ and calls <code>f</code>.</dt>
 
       <dt><b>Returns:</b> An instance of <a href=
       "object.html#object-spec">object</a> which holds the new Python
@@ -186,7 +183,7 @@ BOOST_PYTHON_MODULE(make_function_test)
     def("choose_function", choose_function);
 }
 </pre>
-    It can be used this way in Python: 
+    It can be used this way in Python:
 <pre>
 &gt;&gt;&gt; from make_function_test import *
 &gt;&gt;&gt; f = choose_function(1)

doc/v2/object.html

@@ -74,6 +74,32 @@
             </dl>
           </dd>
 
+          <dt><a href="#const_objattribute_policies-spec">Class
+          <code>const_objattribute_policies</code></a></dt>
+
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#const_objattribute_policies-spec-synopsis">Class
+              <code>const_objattribute_policies</code> synopsis</a></dt>
+
+              <dt><a href="#const_objattribute_policies-spec-statics">Class
+              <code>const_objattribute_policies</code> static functions</a></dt>
+            </dl>
+          </dd>
+
+          <dt><a href="#objattribute_policies-spec">Class
+          <code>objattribute_policies</code></a></dt>
+
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#objattribute_policies-spec-synopsis">Class
+              <code>objattribute_policies</code> synopsis</a></dt>
+
+              <dt><a href="#objattribute_policies-spec-statics">Class
+              <code>objattribute_policies</code> static functions</a></dt>
+            </dl>
+          </dd>
+
           <dt><a href="#const_item_policies-spec">Class
           <code>const_item_policies</code></a></dt>
 
@@ -328,6 +354,102 @@ static void del(object const&amp;target, char const* key);
     <!-- end -->
     <!-- begin -->
 
+    <h3><a name="const_objattribute_policies-spec"></a>Class
+    <code>const_objattribute_policies</code></h3>
+
+    <p>The policies which are used for proxies representing an attribute
+    access to a <code>const&nbsp;object</code> when the attribute name is
+    given as a <code>const&nbsp;object</code>.</p>
+
+    <h4><a name="const_objattribute_policies-spec-synopsis"></a>Class
+    <code>const_objattribute_policies</code> synopsis</h4>
+<pre>
+namespace boost { namespace python { namespace api
+{
+  struct const_objattribute_policies
+  {
+      typedef object const& key_type;
+      static object get(object const&amp; target, object const& key);
+  };
+}}}
+</pre>
+
+    <h4><a name="const_objattribute_policies-spec-statics"></a>Class
+    <code>const_objattribute_policies</code> static functions</h4>
+<pre>
+static object get(object const&amp; target, object const& key);
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> <code>key</code> is an <code>object</code>
+      holding a string.</dt>
+
+      <dt><b>Effects:</b> accesses the attribute of <code>target</code> named
+      by <code>key</code>.</dt>
+
+      <dt><b>Returns:</b> An <code>object</code> managing the result of the
+      attribute access.</dt>
+
+      <dt><b>Throws:</b> <code><a href=
+      "errors.html#error_already_set-spec">error_already_set</a></code> if a
+      Python exception is raised.</dt>
+    </dl>
+
+    <h3><a name="objattribute_policies-spec"></a>Class
+    <code>objattribute_policies</code></h3>
+
+    <p>The policies which are used for proxies representing an attribute
+    access to a mutable <code>object</code> when the attribute name is
+    given as a <code>const&nbsp;object</code>.</p>
+
+    <h4><a name="objattribute_policies-spec-synopsis"></a>Class
+    <code>objattribute_policies</code> synopsis</h4>
+<pre>
+namespace boost { namespace python { namespace api
+{
+  struct objattribute_policies : const_objattribute_policies
+  {
+      static object const&amp; set(object const&amp; target, object const& key, object const&amp; value);
+      static void del(object const&amp;target, object const& key);
+  };
+}}}
+</pre>
+
+    <h4><a name="objattribute_policies-spec-statics"></a>Class
+    <code>objattribute_policies</code> static functions</h4>
+<pre>
+static object const&amp; set(object const&amp; target, object const& key, object const&amp; value);
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> <code>key</code> is an <code>object</code>
+      holding a string.</dt>
+
+      <dt><b>Effects:</b> sets the attribute of <code>target</code> named by
+      <code>key</code> to <code>value</code>.</dt>
+
+      <dt><b>Throws:</b> <code><a href=
+      "errors.html#error_already_set-spec">error_already_set</a></code> if a
+      Python exception is raised.</dt>
+    </dl>
+<pre>
+static void del(object const&amp;target, object const& key);
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> <code>key</code> is an <code>object</code>
+      holding a string.</dt>
+
+      <dt><b>Effects:</b> deletes the attribute of <code>target</code> named
+      by <code>key</code>.</dt>
+
+      <dt><b>Throws:</b> <code><a href=
+      "errors.html#error_already_set-spec">error_already_set</a></code> if a
+      Python exception is raised.</dt>
+    </dl>
+    <!-- end -->
+    <!-- begin -->
+
     <h3><a name="const_item_policies-spec"></a>Class
     <code>const_item_policies</code></h3>
 
@@ -533,6 +655,11 @@ namespace boost { namespace python { namespace api
       template &lt;class A0, class A1,...class An&gt;
       object operator()(A0 const&amp;, A1 const&amp;,...An const&amp;) const;
 
+      detail::args_proxy operator* () const; 
+      object operator()(detail::args_proxy const &amp;args) const; 
+      object operator()(detail::args_proxy const &amp;args, 
+                        detail::kwds_proxy const &amp;kwds) const; 
+
       // truth value testing
       //
       typedef unspecified bool_type;
@@ -542,6 +669,8 @@ namespace boost { namespace python { namespace api
       //
       proxy&lt;const_object_attribute&gt; attr(char const*) const;
       proxy&lt;object_attribute&gt; attr(char const*);
+      proxy&lt;const_object_objattribute&gt; attr(object const&) const;
+      proxy&lt;object_objattribute&gt; attr(object const&);
 
       // item access
       //
@@ -580,6 +709,25 @@ object operator()(A0 const&amp; a1, A1 const&amp; a2,...An const&amp; aN) const;
       call&lt;object&gt;(object(*static_cast&lt;U*&gt;(this)).ptr(), a1,
       a2,...aN)</dt>
     </dl>
+
+<pre>
+object operator()(detail::args_proxy const &amp;args) const; 
+</pre>
+<dl class="function-semantics">
+  <dt><b>Effects:</b>
+  call object with arguments given by the tuple <varname>args</varname></dt>
+</dl>
+<pre>
+object operator()(detail::args_proxy const &amp;args, 
+                  detail::kwds_proxy const &amp;kwds) const; 
+</pre>
+<dl class="function-semantics">
+  <dt><b>Effects:</b>
+  call object with arguments given by the tuple <varname>args</varname>, and named
+  arguments given by the dictionary <varname>kwds</varname></dt>
+</dl>
+
+
 <pre>
 operator bool_type() const;
 </pre>
@@ -608,6 +756,21 @@ proxy&lt;object_attribute&gt; attr(char const* name);
       <code>name</code> as its key.</dt>
     </dl>
 <pre>
+proxy&lt;const_object_objattribute&gt; attr(const object& name) const;
+proxy&lt;object_objattribute&gt; attr(const object& name);
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> name is a <code>object</code> holding a string.</dt>
+
+      <dt><b>Effects:</b> accesses the named attribute of
+      <code>*this</code>.</dt>
+
+      <dt><b>Returns:</b> a proxy object which binds
+      <code>object(*static_cast&lt;U*&gt;(this))</code> as its target, and
+      <code>name</code> as its key.</dt>
+    </dl>
+<pre>
 template &lt;class T&gt;
 proxy&lt;const_object_item&gt; operator[](T const&amp; key) const;
 template &lt;class T&gt;
@@ -672,6 +835,8 @@ namespace boost { namespace python { namespace api
       object&amp; operator=(object const&amp;); 
 
       PyObject* ptr() const;
+
+      bool is_none() const;
   };
 }}}
 </pre>
@@ -732,6 +897,14 @@ PyObject* ptr() const;
       <dt><b>Returns:</b> a pointer to the internally-held Python
       object.</dt>
     </dl>
+
+<pre>
+bool is_none() const;
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Returns:</b> result of (ptr() == Py_None)</dt>
+    </dl>
     <!-- -->
 
     <h3><a name="proxy-spec"></a>Class template <code>proxy</code></h3>
@@ -938,11 +1111,11 @@ object sum_items(object seq)
 </pre>
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  13 January, 2006
+  15 March, 2010
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2006.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2008.</i></p>
   </body>
 </html>

doc/v2/pickle.html

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

doc/v2/return_internal_reference.html

@@ -167,12 +167,13 @@ PyObject* postcall(PyObject* args, PyObject* result);
 
 class Bar
 {
+ public:
    Bar(int x) : x(x) {}
    int get_x() const { return x; }
    void set_x(int x) { this->x = x; }
  private:
    int x;
-}
+};
 
 class Foo
 {
@@ -189,7 +190,7 @@ class Foo
 using namespace boost::python;
 BOOST_PYTHON_MODULE(internal_refs)
 {
-   class_<Bar>("Bar")
+   class_<Bar>("Bar", init<int>())
       .def("get_x", &Bar::get_x)
       .def("set_x", &Bar::set_x)
       ;

doc/v2/slice.html

@@ -85,7 +85,7 @@ namespace boost { namespace python
       object stop();
       object step();
 
-      // The return type of slice::get_indicies()
+      // The return type of slice::get_indices()
       template <typename RandomAccessIterator>
       struct range
       {
@@ -96,7 +96,7 @@ namespace boost { namespace python
 
       template <typename RandomAccessIterator>
       range<RandomAccessIterator>
-      get_indicies(
+      get_indices(
           RandomAccessIterator const& begin, 
           RandomAccessIterator const& end);
   };
@@ -164,7 +164,7 @@ slice object, but in practice they are usually integers.</dt>
 <pre>
 template &lt;typename RandomAccessIterator&gt;
 slice::range&lt;RandomAccessIterator&gt;
-slice::get_indicies( 
+slice::get_indices( 
     RandomAccessIterator const&amp; begin, 
     RandomAccessIterator const&amp; end) const;
 </pre>
@@ -173,8 +173,8 @@ slice::get_indicies(
 Iterators that form a half-open range.</dt>
   <dt><b>Effects:</b> Create a RandomAccessIterator pair that defines a
 fully-closed range within the [begin,end) range of its arguments.&nbsp;
-This function translates this slice's indicies while accounting for the
-effects of any PyNone or negative indicies, and non-singular step sizes.</dt>
+This function translates this slice's indices while accounting for the
+effects of any PyNone or negative indices, and non-singular step sizes.</dt>
   <dt><b>Returns:</b> a slice::range
 that has been initialized with a non-zero value of step and a pair of
 RandomAccessIterators that point within the range of this functions
@@ -182,7 +182,7 @@ arguments and define a closed interval.</dt>
   <dt><b>Throws:</b> <a href="definitions.html#raise">Raises</a> a Python <code>TypeError</code> exception if any of this slice's arguments
 are neither references to <code>PyNone</code> nor convertible to <code>int</code>.&nbsp; Throws
 <code>std::invalid_argument</code> if the resulting range would be empty.&nbsp; You
-should always wrap calls to <code>slice::get_indicies()</code>
+should always wrap calls to <code>slice::get_indices()</code>
 within <code>try { ...; } catch (std::invalid_argument) {}</code> to
 handle this case and take appropriate action.</dt>
   <dt><b>Rationale</b>: closed-interval: If
@@ -221,7 +221,7 @@ double partial_sum(std::vector&lt;double&gt; const&amp; Foo, const slice index)
 {
     slice::range&lt;std::vector&lt;double&gt;::const_iterator&gt; bounds;
     try {
-        bounds = index.get_indicies&lt;&gt;(Foo.begin(), Foo.end());
+        bounds = index.get_indices&lt;&gt;(Foo.begin(), Foo.end());
     }
     catch (std::invalid_argument) {
         return 0.0;

doc/v2/with_custodian_and_ward.html

@@ -91,7 +91,7 @@
     <hr>
     <h2>
       <a name="introduction">Introduction</a>
-    </h2>This header provides faciliites for establishing a lifetime
+    </h2>This header provides facilities for establishing a lifetime
     dependency between two of a function's Python argument or result objects.
     The <i>ward</i> object will not be destroyed until after the custodian as
     long as the <i>custodian</i> object supports <a href=

example/Jamroot

@@ -11,7 +11,10 @@ use-project boost
 # boost_python library from the project whose global ID is
 # /boost/python.
 project
-  : requirements <library>/boost/python//boost_python ;
+  : requirements <library>/boost/python//boost_python 
+                 <implicit-dependency>/boost//headers 
+  : usage-requirements <implicit-dependency>/boost//headers 
+  ;
 
 # Declare the three extension modules.  You can specify multiple
 # source files after the colon separated by spaces.

example/quickstart/Jamroot

@@ -12,6 +12,8 @@ use-project boost
 # /boost/python.
 project boost-python-quickstart
   : requirements <library>/boost/python//boost_python 
+    		 <implicit-dependency>/boost//headers 
+  : usage-requirements <implicit-dependency>/boost//headers 	 
     ;
 
 # Make the definition of the python-extension rule available

example/tutorial/Jamroot

@@ -2,6 +2,15 @@
 # Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+import python ;
+
+if ! [ python.configured ]
+{
+    ECHO "notice: no Python configured in user-config.jam" ;
+    ECHO "notice: will use default configuration" ;
+    using python ;
+}
+
 # Specify the path to the Boost project.  If you move this project,
 # adjust this path to refer to the Boost root directory.
 use-project boost
@@ -11,12 +20,23 @@ use-project boost
 # boost_python library from the project whose global ID is
 # /boost/python.
 project
-  : requirements <library>/boost/python//boost_python ;
+  : requirements <library>/boost/python//boost_python 
+                 <implicit-dependency>/boost//headers 
+  : usage-requirements <implicit-dependency>/boost//headers 
+  ;
 
 # Declare the three extension modules.  You can specify multiple
 # source files after the colon separated by spaces.
 python-extension hello_ext : hello.cpp ;
 
+# Put the extension and Boost.Python DLL in the current directory, so
+# that running script by hand works.
+install convenient_copy 
+  : hello_ext 
+  : <install-dependencies>on <install-type>SHARED_LIB <install-type>PYTHON_EXTENSION 
+    <location>. 
+  ;
+
 # A little "rule" (function) to clean up the syntax of declaring tests
 # of these extension modules.
 local rule run-test ( test-name : sources + )

include/boost/python/call.hpp

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

include/boost/python/call_method.hpp

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

include/boost/python/class.hpp

@@ -138,7 +138,8 @@ namespace detail
         static void
         must_be_derived_class_member(Default const&)
         {
-            typedef typename assertion<mpl::not_<is_same<Default,Fn> > >::failed test0;
+            // https://svn.boost.org/trac/boost/ticket/5803
+            //typedef typename assertion<mpl::not_<is_same<Default,Fn> > >::failed test0;
 # if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
             typedef typename assertion<is_polymorphic<T> >::failed test1;
 # endif 

include/boost/python/converter/builtin_converters.hpp

@@ -90,6 +90,14 @@ namespace detail
         BOOST_PYTHON_ARG_TO_PYTHON_BY_VALUE(T,expr)
 
 // Specialize converters for signed and unsigned T to Python Int
+#if PY_VERSION_HEX >= 0x03000000
+
+# define BOOST_PYTHON_TO_INT(T)                                         \
+    BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed T, ::PyLong_FromLong(x), &PyLong_Type)      \
+    BOOST_PYTHON_TO_PYTHON_BY_VALUE(unsigned T, ::PyLong_FromUnsignedLong(x), &PyLong_Type)
+
+#else
+
 # define BOOST_PYTHON_TO_INT(T)                                         \
     BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed T, ::PyInt_FromLong(x), &PyInt_Type)      \
     BOOST_PYTHON_TO_PYTHON_BY_VALUE(                                    \
@@ -98,6 +106,7 @@ namespace detail
                 (std::numeric_limits<long>::max)())                     \
         ? ::PyLong_FromUnsignedLong(x)                                  \
         : ::PyInt_FromLong(x), &PyInt_Type)
+#endif
 
 // Bool is not signed.
 #if PY_VERSION_HEX >= 0x02030000
@@ -113,20 +122,48 @@ BOOST_PYTHON_TO_INT(short)
 BOOST_PYTHON_TO_INT(int)
 BOOST_PYTHON_TO_INT(long)
 
-// using Python's macro instead of Boost's - we don't seem to get the
-// config right all the time.
-# ifdef HAVE_LONG_LONG 
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed BOOST_PYTHON_LONG_LONG, ::PyLong_FromLongLong(x), &PyInt_Type)
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(unsigned BOOST_PYTHON_LONG_LONG, ::PyLong_FromUnsignedLongLong(x), &PyInt_Type)
+# if defined(_MSC_VER) && defined(_WIN64) && PY_VERSION_HEX < 0x03000000
+/* Under 64-bit Windows std::size_t is "unsigned long long". To avoid
+   getting a Python long for each std::size_t the value is checked before
+   the conversion. A std::size_t is converted to a simple Python int
+   if possible; a Python long appears only if the value is too small or
+   too large to fit into a simple int. */
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(
+    signed BOOST_PYTHON_LONG_LONG,
+    (   x < static_cast<signed BOOST_PYTHON_LONG_LONG>(
+            (std::numeric_limits<long>::min)())
+     || x > static_cast<signed BOOST_PYTHON_LONG_LONG>(
+            (std::numeric_limits<long>::max)()))
+    ? ::PyLong_FromLongLong(x)
+    : ::PyInt_FromLong(static_cast<long>(x)), &PyInt_Type)
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(
+    unsigned BOOST_PYTHON_LONG_LONG,
+    x > static_cast<unsigned BOOST_PYTHON_LONG_LONG>(
+      (std::numeric_limits<long>::max)())
+    ? ::PyLong_FromUnsignedLongLong(x)
+    : ::PyInt_FromLong(static_cast<long>(x)), &PyInt_Type)
+//
+# elif defined(HAVE_LONG_LONG) // using Python's macro instead of Boost's
+                               // - we don't seem to get the config right
+                               // all the time.
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed BOOST_PYTHON_LONG_LONG, ::PyLong_FromLongLong(x), &PyLong_Type)
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(unsigned BOOST_PYTHON_LONG_LONG, ::PyLong_FromUnsignedLongLong(x), &PyLong_Type)
 # endif
     
 # undef BOOST_TO_PYTHON_INT
 
+#if PY_VERSION_HEX >= 0x03000000
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(char, converter::do_return_to_python(x), &PyUnicode_Type)
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(char const*, converter::do_return_to_python(x), &PyUnicode_Type)
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::string, ::PyUnicode_FromStringAndSize(x.data(),implicit_cast<ssize_t>(x.size())), &PyUnicode_Type)
+#else
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(char, converter::do_return_to_python(x), &PyString_Type)
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(char const*, converter::do_return_to_python(x), &PyString_Type)
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::string, ::PyString_FromStringAndSize(x.data(),implicit_cast<ssize_t>(x.size())), &PyString_Type)
+#endif
+
 #if defined(Py_USING_UNICODE) && !defined(BOOST_NO_STD_WSTRING)
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::wstring, ::PyUnicode_FromWideChar(x.data(),implicit_cast<ssize_t>(x.size())), &PyString_Type)
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::wstring, ::PyUnicode_FromWideChar(x.data(),implicit_cast<ssize_t>(x.size())), &PyUnicode_Type)
 # endif 
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(float, ::PyFloat_FromDouble(x), &PyFloat_Type)
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(double, ::PyFloat_FromDouble(x), &PyFloat_Type)

include/boost/python/converter/pyobject_traits.hpp

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

include/boost/python/converter/registry.hpp

@@ -30,7 +30,7 @@ namespace registry
   BOOST_PYTHON_DECL void insert(to_python_function_t, type_info, PyTypeObject const* (*to_python_target_type)() = 0);
 
   // Insert an lvalue from_python converter
-  BOOST_PYTHON_DECL void insert(void* (*convert)(PyObject*), type_info, PyTypeObject const* (*expected_pytype)() = 0);
+  BOOST_PYTHON_DECL void insert(convertible_function, type_info, PyTypeObject const* (*expected_pytype)() = 0);
 
   // Insert an rvalue from_python converter
   BOOST_PYTHON_DECL void insert(

include/boost/python/converter/rvalue_from_python_data.hpp

@@ -117,9 +117,9 @@ struct rvalue_from_python_data : rvalue_from_python_storage<T>
 // Implementataions
 //
 template <class T>
-inline rvalue_from_python_data<T>::rvalue_from_python_data(rvalue_from_python_stage1_data const& stage1)
+inline rvalue_from_python_data<T>::rvalue_from_python_data(rvalue_from_python_stage1_data const& _stage1)
 {
-    this->stage1 = stage1;
+    this->stage1 = _stage1;
 }
 
 template <class T>

include/boost/python/converter/shared_ptr_from_python.hpp

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

include/boost/python/data_members.hpp

@@ -265,7 +265,8 @@ inline object make_getter(D const& d, Policies const& policies)
 template <class D>
 inline object make_getter(D& x)
 {
-    detail::not_specified policy;
+    detail::not_specified policy
+        = detail::not_specified(); // suppress a SunPro warning
     return detail::make_getter(x, policy, is_member_pointer<D>(), 0L);
 }
 
@@ -273,7 +274,8 @@ inline object make_getter(D& x)
 template <class D>
 inline object make_getter(D const& d)
 {
-    detail::not_specified policy;
+    detail::not_specified policy
+        = detail::not_specified(); // Suppress a SunPro warning
     return detail::make_getter(d, policy, is_member_pointer<D>(), 0L);
 }
 #  endif

include/boost/python/detail/config.hpp

@@ -76,13 +76,13 @@
 
 #  if BOOST_PYTHON_USE_GCC_SYMBOL_VISIBILITY
 #     if defined(BOOST_PYTHON_SOURCE)
-#        define BOOST_PYTHON_DECL __attribute__ ((visibility("default")))
+#        define BOOST_PYTHON_DECL __attribute__ ((__visibility__("default")))
 #        define BOOST_PYTHON_BUILD_DLL
 #     else
 #        define BOOST_PYTHON_DECL
 #     endif
 #     define BOOST_PYTHON_DECL_FORWARD
-#     define BOOST_PYTHON_DECL_EXCEPTION __attribute__ ((visibility("default")))
+#     define BOOST_PYTHON_DECL_EXCEPTION __attribute__ ((__visibility__("default")))
 #  elif (defined(_WIN32) || defined(__CYGWIN__))
 #     if defined(BOOST_PYTHON_SOURCE)
 #        define BOOST_PYTHON_DECL __declspec(dllexport)

include/boost/python/detail/decorated_type_id.hpp

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

include/boost/python/detail/destroy.hpp

@@ -30,7 +30,7 @@ struct value_destroyer<
     template <class T>
     static void execute(T const volatile* p)
     {
-        p->T::~T();
+        p->~T();
     }
 };
 

include/boost/python/detail/make_keyword_range_fn.hpp

@@ -57,7 +57,7 @@ object make_keyword_range_constructor(
     , Holder* = 0                       
     , ArgList* = 0, Arity* = 0)
 {
-#if !defined( BOOST_PYTHON_NO_PY_SIGNATURES) && defined( BOOST_PYTHON_PY_SYGNATURES_PROPER_INIT_SELF_TYPE)
+#if !defined( BOOST_PYTHON_NO_PY_SIGNATURES) && defined( BOOST_PYTHON_PY_SIGNATURES_PROPER_INIT_SELF_TYPE)
     python_class<BOOST_DEDUCED_TYPENAME Holder::value_type>::register_();
 #endif
     return detail::make_keyword_range_function(

include/boost/python/detail/operator_id.hpp

@@ -47,8 +47,15 @@ enum operator_id
     op_ixor,
     op_ior,
     op_complex,
+#if PY_VERSION_HEX >= 0x03000000
+    op_bool,
+#else
     op_nonzero,
+#endif
     op_repr
+#if PY_VERSION_HEX >= 0x03000000
+    ,op_truediv
+#endif
 };
 
 }}} // namespace boost::python::detail

include/boost/python/detail/result.hpp

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

include/boost/python/detail/target.hpp

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

include/boost/python/detail/translate_exception.hpp

@@ -2,13 +2,15 @@
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
-#ifndef TRANSLATE_EXCEPTION_DWA2002810_HPP
-# define TRANSLATE_EXCEPTION_DWA2002810_HPP
+#ifndef TRANSLATE_EXCEPTION_TDS20091020_HPP
+# define TRANSLATE_EXCEPTION_TDS20091020_HPP
 
 # include <boost/python/detail/exception_handler.hpp>
 
 # include <boost/call_traits.hpp>
 # include <boost/type_traits/add_const.hpp>
+# include <boost/type_traits/add_reference.hpp>
+# include <boost/type_traits/remove_reference.hpp>
 
 # include <boost/function/function0.hpp>
 

include/boost/python/detail/wrap_python.hpp

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

include/boost/python/enum.hpp

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

include/boost/python/exception_translator.hpp

@@ -8,6 +8,7 @@
 # include <boost/python/detail/prefix.hpp>
 
 # include <boost/bind.hpp>
+# include <boost/bind/placeholders.hpp>
 # include <boost/type.hpp>
 # include <boost/python/detail/translate_exception.hpp>
 # include <boost/python/detail/exception_handler.hpp>
@@ -18,7 +19,7 @@ template <class ExceptionType, class Translate>
 void register_exception_translator(Translate translate, boost::type<ExceptionType>* = 0)
 {
     detail::register_exception_handler(
-        bind<bool>(detail::translate_exception<ExceptionType,Translate>(), _1, _2, translate)
+        boost::bind<bool>(detail::translate_exception<ExceptionType,Translate>(), _1, _2, translate)
         );
 }
 

include/boost/python/exec.hpp

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

include/boost/python/extract.hpp

@@ -19,7 +19,6 @@
 # include <boost/python/detail/copy_ctor_mutates_rhs.hpp>
 # include <boost/python/detail/void_ptr.hpp>
 # include <boost/python/detail/void_return.hpp>
-# include <boost/utility.hpp>
 # include <boost/call_traits.hpp>
 
 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || BOOST_WORKAROUND(BOOST_INTEL_WIN, <= 900)

include/boost/python/instance_holder.hpp

@@ -7,7 +7,7 @@
 
 # include <boost/python/detail/prefix.hpp>
 
-# include <boost/utility.hpp>
+# include <boost/noncopyable.hpp>
 # include <boost/python/type_id.hpp>
 # include <cstddef>
 

include/boost/python/iterator.hpp

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

include/boost/python/list.hpp

@@ -19,7 +19,7 @@ namespace detail
   {
       void append(object_cref); // append object to end
 
-      long count(object_cref value) const; // return number of occurrences of value
+      ssize_t count(object_cref value) const; // return number of occurrences of value
 
       void extend(object_cref sequence); // extend list by appending sequence elements
     
@@ -37,8 +37,12 @@ namespace detail
       void reverse(); // reverse *IN PLACE*
 
       void sort(); //  sort *IN PLACE*; if given, cmpfunc(x, y) -> -1, 0, 1
+#if PY_VERSION_HEX >= 0x03000000
+      void sort(args_proxy const &args, 
+                 kwds_proxy const &kwds);
+#else
       void sort(object_cref cmpfunc);
-
+#endif
 
    protected:
       list_base(); // new list
@@ -113,13 +117,15 @@ class list : public detail::list_base
         base::remove(object(value));
     }
 
+#if PY_VERSION_HEX <= 0x03000000
     void sort() { base::sort(); }
-    
+
     template <class T>
     void sort(T const& value)
     {
         base::sort(object(value));
     }
+#endif
     
  public: // implementation detail -- for internal use only
     BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(list, base)

include/boost/python/lvalue_from_pytype.hpp

@@ -63,7 +63,7 @@ struct extract_member
 {
     static MemberType& execute(InstanceType& c)
     {
-        (void)c.ob_type; // static assertion
+        (void)Py_TYPE(&c); // static assertion
         return c.*member;
     }
 };
@@ -75,7 +75,7 @@ struct extract_identity
 {
     static InstanceType& execute(InstanceType& c)
     {
-        (void)c.ob_type; // static assertion
+        (void)Py_TYPE(&c); // static assertion
         return c;
     }
 };

include/boost/python/make_constructor.hpp

@@ -105,12 +105,12 @@ namespace detail
       // If the BasePolicy_ supplied a result converter it would be
       // ignored; issue an error if it's not the default.
 #if defined _MSC_VER && _MSC_VER < 1300
-	  typedef is_same<
+      typedef is_same<
               typename BasePolicy_::result_converter
             , default_result_converter
           > same_result_converter;
-	  //see above for explanation
-	  BOOST_STATIC_ASSERT(same_result_converter::value) ;
+      //see above for explanation
+      BOOST_STATIC_ASSERT(same_result_converter::value) ;
 #else
       BOOST_MPL_ASSERT_MSG(
          (is_same<

include/boost/python/module_init.hpp

@@ -6,48 +6,86 @@
 # define MODULE_INIT_DWA20020722_HPP
 
 # include <boost/python/detail/prefix.hpp>
+# include <boost/preprocessor/cat.hpp>
+# include <boost/preprocessor/stringize.hpp>
 
 # ifndef BOOST_PYTHON_MODULE_INIT
 
 namespace boost { namespace python { namespace detail {
 
-BOOST_PYTHON_DECL void init_module(char const* name, void(*)());
+#  if PY_VERSION_HEX >= 0x03000000
+
+BOOST_PYTHON_DECL PyObject* init_module(PyModuleDef&, void(*)());
+
+#else
+
+BOOST_PYTHON_DECL PyObject* init_module(char const* name, void(*)());
+
+#endif
 
 }}}
 
-#  if (defined(_WIN32) || defined(__CYGWIN__)) && !defined(BOOST_PYTHON_STATIC_MODULE)
+#  if PY_VERSION_HEX >= 0x03000000
 
-#   define BOOST_PYTHON_MODULE_INIT(name)               \
-void init_module_##name();                              \
-extern "C" __declspec(dllexport) void init##name()      \
+#   define _BOOST_PYTHON_MODULE_INIT(name) \
+  PyObject* BOOST_PP_CAT(PyInit_, name)()  \
+  { \
+    static PyModuleDef_Base initial_m_base = { \
+        PyObject_HEAD_INIT(NULL) \
+        0, /* m_init */ \
+        0, /* m_index */ \
+        0 /* m_copy */ };  \
+    static PyMethodDef initial_methods[] = { { 0, 0, 0, 0 } }; \
+ \
+    static struct PyModuleDef moduledef = { \
+        initial_m_base, \
+        BOOST_PP_STRINGIZE(name), \
+        0, /* m_doc */ \
+        -1, /* m_size */ \
+        initial_methods, \
+        0,  /* m_reload */ \
+        0, /* m_traverse */ \
+        0, /* m_clear */ \
+        0,  /* m_free */ \
+    }; \
+ \
+    return boost::python::detail::init_module( \
+        moduledef, BOOST_PP_CAT(init_module_, name) ); \
+  } \
+  void BOOST_PP_CAT(init_module_, name)()
+
+#  else
+
+#   define _BOOST_PYTHON_MODULE_INIT(name)              \
+  void BOOST_PP_CAT(init,name)()                        \
 {                                                       \
     boost::python::detail::init_module(                 \
-        #name,&init_module_##name);                     \
+        BOOST_PP_STRINGIZE(name),&BOOST_PP_CAT(init_module_,name)); \
 }                                                       \
-void init_module_##name()
+  void BOOST_PP_CAT(init_module_,name)()
+
+#  endif
+
+#  if (defined(_WIN32) || defined(__CYGWIN__)) && !defined(BOOST_PYTHON_STATIC_MODULE)
+
+#   define BOOST_PYTHON_MODULE_INIT(name)                           \
+  void BOOST_PP_CAT(init_module_,name)();                           \
+extern "C" __declspec(dllexport) _BOOST_PYTHON_MODULE_INIT(name)
 
 #  elif BOOST_PYTHON_USE_GCC_SYMBOL_VISIBILITY
 
 #   define BOOST_PYTHON_MODULE_INIT(name)                               \
-void init_module_##name();                                              \
-extern "C" __attribute__ ((visibility("default"))) void init##name()    \
-{                                                                       \
-    boost::python::detail::init_module(#name, &init_module_##name);     \
-}                                                                       \
-void init_module_##name()
+  void BOOST_PP_CAT(init_module_,name)();                               \
+extern "C" __attribute__ ((__visibility__("default"))) _BOOST_PYTHON_MODULE_INIT(name)
 
 #  else
 
 #   define BOOST_PYTHON_MODULE_INIT(name)                               \
-void init_module_##name();                                              \
-extern "C"  void init##name()                                           \
-{                                                                       \
-    boost::python::detail::init_module(#name, &init_module_##name);     \
-}                                                                       \
-void init_module_##name()
+  void BOOST_PP_CAT(init_module_,name)();                               \
+extern "C" _BOOST_PYTHON_MODULE_INIT(name)
 
 #  endif
 
-# endif 
+# endif
 
 #endif // MODULE_INIT_DWA20020722_HPP

include/boost/python/object/class.hpp

@@ -6,7 +6,6 @@
 # define CLASS_DWA20011214_HPP
 
 # include <boost/python/detail/prefix.hpp>
-# include <boost/utility.hpp>
 # include <boost/python/object_core.hpp>
 # include <boost/python/type_id.hpp>
 # include <cstddef>

include/boost/python/object/class_metadata.hpp

@@ -236,9 +236,9 @@ struct class_metadata
     //
     // Support for converting smart pointers to python
     //
-    inline static void maybe_register_pointer_to_python(void*,void*,void*) {}
+    inline static void maybe_register_pointer_to_python(...) {}
 
-#ifndef BOOST_PYTHON_NO_PY_SYGNATURES
+#ifndef BOOST_PYTHON_NO_PY_SIGNATURES
     inline static void maybe_register_pointer_to_python(void*,void*,mpl::true_*) 
     {
         objects::copy_class_object(python::type_id<T>(), python::type_id<back_reference<T const &> >());
@@ -255,7 +255,7 @@ struct class_metadata
               , make_ptr_instance<T2, pointer_holder<held_type, T2> >
             >()
         );
-#ifndef BOOST_PYTHON_NO_PY_SYGNATURES
+#ifndef BOOST_PYTHON_NO_PY_SIGNATURES
         // explicit qualification of type_id makes msvc6 happy
         objects::copy_class_object(python::type_id<T2>(), python::type_id<held_type>());
 #endif
@@ -270,7 +270,7 @@ struct class_metadata
     inline static void maybe_register_class_to_python(T2*, mpl::false_)
     {
         python::detail::force_instantiate(class_cref_wrapper<T2, make_instance<T2, holder> >());
-#ifndef BOOST_PYTHON_NO_PY_SYGNATURES
+#ifndef BOOST_PYTHON_NO_PY_SIGNATURES
         // explicit qualification of type_id makes msvc6 happy
         objects::copy_class_object(python::type_id<T2>(), python::type_id<held_type>());
 #endif

include/boost/python/object/function.hpp

@@ -39,6 +39,8 @@ struct BOOST_PYTHON_DECL function : PyObject
     void doc(object const& x);
     
     object const& name() const;
+
+    object const& get_namespace() const { return m_namespace; }
     
  private: // helper functions
     object signature(bool show_return_type=false) const;

include/boost/python/object/iterator.hpp

@@ -129,7 +129,11 @@ namespace detail
       return class_<range_>(name, no_init)
           .def("__iter__", identity_function())
           .def(
+#if PY_VERSION_HEX >= 0x03000000
+              "__next__"
+#else
               "next"
+#endif
             , make_function(
                 next_fn()
               , policies

include/boost/python/object/make_holder.hpp

@@ -12,7 +12,7 @@
 
 #  include <boost/python/object/instance.hpp>
 #  include <boost/python/converter/registry.hpp>
-#if !defined( BOOST_PYTHON_NO_PY_SIGNATURES) && defined( BOOST_PYTHON_PY_SYGNATURES_PROPER_INIT_SELF_TYPE)
+#if !defined( BOOST_PYTHON_NO_PY_SIGNATURES) && defined( BOOST_PYTHON_PY_SIGNATURES_PROPER_INIT_SELF_TYPE)
 #  include <boost/python/detail/python_type.hpp>
 #endif
 
@@ -47,7 +47,10 @@ template <int nargs> struct make_holder;
 
 # endif // MAKE_HOLDER_DWA20011215_HPP
 
-#elif BOOST_PP_ITERATION_DEPTH() == 1
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1
 # if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
         && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
 #  line BOOST_PP_LINE(__LINE__, make_holder.hpp)
@@ -78,7 +81,7 @@ struct make_holder<N>
 # endif 
         
         static void execute(
-#if !defined( BOOST_PYTHON_NO_PY_SIGNATURES) && defined( BOOST_PYTHON_PY_SYGNATURES_PROPER_INIT_SELF_TYPE)
+#if !defined( BOOST_PYTHON_NO_PY_SIGNATURES) && defined( BOOST_PYTHON_PY_SIGNATURES_PROPER_INIT_SELF_TYPE)
             boost::python::detail::python_class<BOOST_DEDUCED_TYPENAME Holder::value_type> *p
 #else
             PyObject *p
@@ -102,4 +105,5 @@ struct make_holder<N>
 
 # undef N
 
+#endif // BOOST_PP_ITERATION_DEPTH()
 #endif

include/boost/python/object/make_instance.hpp

@@ -10,6 +10,9 @@
 # include <boost/python/converter/registered.hpp>
 # include <boost/python/detail/decref_guard.hpp>
 # include <boost/python/detail/none.hpp>
+# include <boost/mpl/assert.hpp>
+# include <boost/mpl/or.hpp>
+# include <boost/type_traits/is_union.hpp>
 
 namespace boost { namespace python { namespace objects { 
 
@@ -21,7 +24,7 @@ struct make_instance_impl
     template <class Arg>
     static inline PyObject* execute(Arg& x)
     {
-        BOOST_STATIC_ASSERT(is_class<T>::value);
+        BOOST_MPL_ASSERT((mpl::or_<is_class<T>, is_union<T> >));
 
         PyTypeObject* type = Derived::get_class_object(x);
 
@@ -43,7 +46,7 @@ struct make_instance_impl
               
             // Note the position of the internally-stored Holder,
             // for the sake of destruction
-            instance->ob_size = offsetof(instance_t, storage);
+            Py_SIZE(instance) = offsetof(instance_t, storage);
 
             // Release ownership of the python object
             protect.cancel();

include/boost/python/object/pointer_holder.hpp

@@ -35,6 +35,8 @@
 
 #  include <boost/detail/workaround.hpp>
 
+#  include <boost/type_traits/remove_const.hpp>
+
 namespace boost { namespace python {
 
 template <class T> class wrapper;
@@ -122,19 +124,29 @@ inline pointer_holder_back_reference<Pointer,Value>::pointer_holder_back_referen
 template <class Pointer, class Value>
 void* pointer_holder<Pointer, Value>::holds(type_info dst_t, bool null_ptr_only)
 {
+    typedef typename boost::remove_const< Value >::type non_const_value;
+
     if (dst_t == python::type_id<Pointer>()
         && !(null_ptr_only && get_pointer(this->m_p))
     )
         return &this->m_p;
 
-    Value* p = get_pointer(this->m_p);
+    Value* p0
+#  if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+        = static_cast<Value*>( get_pointer(this->m_p) )
+#  else 
+        = get_pointer(this->m_p)
+#  endif
+        ;
+    non_const_value* p = const_cast<non_const_value*>( p0 );
+
     if (p == 0)
         return 0;
     
     if (void* wrapped = holds_wrapped(dst_t, p, p))
         return wrapped;
     
-    type_info src_t = python::type_id<Value>();
+    type_info src_t = python::type_id<non_const_value>();
     return src_t == dst_t ? p : find_dynamic_type(p, src_t, dst_t);
 }
 
@@ -163,7 +175,10 @@ void* pointer_holder_back_reference<Pointer, Value>::holds(type_info dst_t, bool
 # endif // POINTER_HOLDER_DWA20011215_HPP
 
 /* --------------- pointer_holder --------------- */
-#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == 1
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == 1
 # if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
         && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
 #  line BOOST_PP_LINE(__LINE__, pointer_holder.hpp)
@@ -205,4 +220,5 @@ void* pointer_holder_back_reference<Pointer, Value>::holds(type_info dst_t, bool
 
 # undef N
 
+#endif // BOOST_PP_ITERATION_DEPTH()
 #endif

include/boost/python/object/value_holder.hpp

@@ -117,7 +117,10 @@ void* value_holder_back_reference<Value,Held>::holds(
 
 // --------------- value_holder ---------------
 
-#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == 1
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == 1
 # if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
         && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
 #  line BOOST_PP_LINE(__LINE__, value_holder.hpp(value_holder))
@@ -163,4 +166,5 @@ void* value_holder_back_reference<Value,Held>::holds(
 
 # undef N
 
+#endif // BOOST_PP_ITERATION_DEPTH()
 #endif

include/boost/python/object_attributes.hpp

@@ -17,6 +17,7 @@ struct const_attribute_policies
 {
     typedef char const* key_type;
     static object get(object const& target, char const* key);
+    static object get(object const& target, object const& key);
 };
   
 struct attribute_policies : const_attribute_policies
@@ -25,6 +26,18 @@ struct attribute_policies : const_attribute_policies
     static void del(object const&target, char const* key);
 };
 
+struct const_objattribute_policies
+{
+    typedef object const key_type;
+    static object get(object const& target, object const& key);
+};
+  
+struct objattribute_policies : const_objattribute_policies
+{
+    static object const& set(object const& target, object const& key, object const& value);
+    static void del(object const&target, object const& key);
+};
+
 //
 // implementation
 //
@@ -42,11 +55,30 @@ inline const_object_attribute object_operators<U>::attr(char const* name) const
     return const_object_attribute(x, name);
 }
 
+template <class U>
+inline object_objattribute object_operators<U>::attr(object const& name)
+{
+    object_cref2 x = *static_cast<U*>(this);
+    return object_objattribute(x, name);
+}
+
+template <class U>
+inline const_object_objattribute object_operators<U>::attr(object const& name) const
+{
+    object_cref2 x = *static_cast<U const*>(this);
+    return const_object_objattribute(x, name);
+}
+
 inline object const_attribute_policies::get(object const& target, char const* key)
 {
     return python::getattr(target, key);
 }
 
+inline object const_objattribute_policies::get(object const& target, object const& key)
+{
+    return python::getattr(target, key);
+}
+
 inline object const& attribute_policies::set(
     object const& target
     , char const* key
@@ -56,6 +88,15 @@ inline object const& attribute_policies::set(
     return value;
 }
 
+inline object const& objattribute_policies::set(
+    object const& target
+    , object const& key
+    , object const& value)
+{
+    python::setattr(target, key, value);
+    return value;
+}
+
 inline void attribute_policies::del(
     object const& target
     , char const* key)
@@ -63,6 +104,13 @@ inline void attribute_policies::del(
     python::delattr(target, key);
 }
 
+inline void objattribute_policies::del(
+    object const& target
+    , object const& key)
+{
+    python::delattr(target, key);
+}
+
 }}} // namespace boost::python::api
 
 #endif // OBJECT_ATTRIBUTES_DWA2002615_HPP

include/boost/python/object_core.hpp

@@ -5,6 +5,8 @@
 #ifndef OBJECT_CORE_DWA2002615_HPP
 # define OBJECT_CORE_DWA2002615_HPP
 
+# define BOOST_PYTHON_OBJECT_HAS_IS_NONE // added 2010-03-15 by rwgk
+
 # include <boost/python/detail/prefix.hpp>
 
 # include <boost/type.hpp>
@@ -42,6 +44,12 @@
 
 namespace boost { namespace python { 
 
+namespace detail
+{
+  class kwds_proxy; 
+  class args_proxy; 
+} 
+
 namespace converter
 {
   template <class T> struct arg_to_python;
@@ -59,6 +67,8 @@ namespace api
   
   struct const_attribute_policies;
   struct attribute_policies;
+  struct const_objattribute_policies;
+  struct objattribute_policies;
   struct const_item_policies;
   struct item_policies;
   struct const_slice_policies;
@@ -67,6 +77,8 @@ namespace api
 
   typedef proxy<const_attribute_policies> const_object_attribute;
   typedef proxy<attribute_policies> object_attribute;
+  typedef proxy<const_objattribute_policies> const_object_objattribute;
+  typedef proxy<objattribute_policies> object_objattribute;
   typedef proxy<const_item_policies> const_object_item;
   typedef proxy<item_policies> object_item;
   typedef proxy<const_slice_policies> const_object_slice;
@@ -98,6 +110,11 @@ namespace api
 
 # define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PYTHON_MAX_ARITY, <boost/python/object_call.hpp>))
 # include BOOST_PP_ITERATE()
+    
+      detail::args_proxy operator* () const; 
+      object operator()(detail::args_proxy const &args) const; 
+      object operator()(detail::args_proxy const &args, 
+                        detail::kwds_proxy const &kwds) const; 
 
       // truth value testing
       //
@@ -108,7 +125,13 @@ namespace api
       //
       const_object_attribute attr(char const*) const;
       object_attribute attr(char const*);
+      const_object_objattribute attr(object const&) const;
+      object_objattribute attr(object const&);
 
+      // Wrap 'in' operator (aka. __contains__)
+      template <class T>
+      object contains(T const& key) const;
+      
       // item access
       //
       const_object_item operator[](object_cref) const;
@@ -213,12 +236,14 @@ namespace api
       inline object_base(object_base const&);
       inline object_base(PyObject* ptr);
       
-      object_base& operator=(object_base const& rhs);
-      ~object_base();
+      inline object_base& operator=(object_base const& rhs);
+      inline ~object_base();
         
       // Underlying object access -- returns a borrowed reference
-      PyObject* ptr() const;
-      
+      inline PyObject* ptr() const;
+
+      inline bool is_none() const;
+
    private:
       PyObject* m_ptr;
   };
@@ -323,12 +348,12 @@ namespace api
   // Macros for forwarding constructors in classes derived from
   // object. Derived classes will usually want these as an
   // implementation detail
-# define BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS_(derived, base)       \
-    inline explicit derived(python::detail::borrowed_reference p)       \
-        : base(p) {}                                                    \
-    inline explicit derived(python::detail::new_reference p)            \
-        : base(p) {}                                                    \
-    inline explicit derived(python::detail::new_non_null_reference p)   \
+# define BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS_(derived, base)              \
+    inline explicit derived(::boost::python::detail::borrowed_reference p)     \
+        : base(p) {}                                                           \
+    inline explicit derived(::boost::python::detail::new_reference p)          \
+        : base(p) {}                                                           \
+    inline explicit derived(::boost::python::detail::new_non_null_reference p) \
         : base(p) {}
 
 # if !defined(BOOST_MSVC) || BOOST_MSVC >= 1300
@@ -387,7 +412,7 @@ namespace api
       static PyObject*
       get(T const& x, U)
       {
-          return python::incref(get_managed_object(x, tag));
+          return python::incref(get_managed_object(x, boost::python::tag));
       }
   };
 
@@ -410,6 +435,71 @@ template <class T> struct extract;
 // implementation
 //
 
+namespace detail 
+{
+
+class call_proxy 
+{ 
+public: 
+  call_proxy(object target) : m_target(target) {} 
+  operator object() const { return m_target;} 
+ 
+ private: 
+    object m_target; 
+}; 
+ 
+class kwds_proxy : public call_proxy 
+{ 
+public: 
+  kwds_proxy(object o = object()) : call_proxy(o) {} 
+}; 
+class args_proxy : public call_proxy 
+{ 
+public: 
+  args_proxy(object o) : call_proxy(o) {} 
+  kwds_proxy operator* () const { return kwds_proxy(*this);} 
+}; 
+} 
+ 
+template <typename U> 
+detail::args_proxy api::object_operators<U>::operator* () const 
+{ 
+  object_cref2 x = *static_cast<U const*>(this); 
+  return boost::python::detail::args_proxy(x); 
+} 
+ 
+template <typename U> 
+object api::object_operators<U>::operator()(detail::args_proxy const &args) const 
+{ 
+  U const& self = *static_cast<U const*>(this); 
+  PyObject *result = PyObject_Call(get_managed_object(self, boost::python::tag), 
+                                   args.operator object().ptr(), 
+                                   0); 
+  return object(boost::python::detail::new_reference(result)); 
+ 
+} 
+ 
+template <typename U> 
+object api::object_operators<U>::operator()(detail::args_proxy const &args, 
+                                            detail::kwds_proxy const &kwds) const 
+{ 
+  U const& self = *static_cast<U const*>(this); 
+  PyObject *result = PyObject_Call(get_managed_object(self, boost::python::tag), 
+                                   args.operator object().ptr(), 
+                                   kwds.operator object().ptr()); 
+  return object(boost::python::detail::new_reference(result)); 
+ 
+}  
+
+
+template <typename U>
+template <class T>
+object api::object_operators<U>::contains(T const& key) const
+{
+    return this->attr("__contains__")(object(key));
+}
+
+
 inline object::object()
     : object_base(python::incref(Py_None))
 {}
@@ -453,6 +543,11 @@ inline PyObject* api::object_base::ptr() const
     return m_ptr;
 }
 
+inline bool api::object_base::is_none() const
+{
+    return (m_ptr == Py_None);
+}
+
 //
 // Converter specialization implementations
 //

include/boost/python/object_operators.hpp

@@ -60,7 +60,9 @@ inline
 object_operators<U>::operator bool_type() const
 {
     object_cref2 x = *static_cast<U const*>(this);
-    return PyObject_IsTrue(x.ptr()) ? &object::ptr : 0;
+    int is_true = PyObject_IsTrue(x.ptr());
+    if (is_true < 0) throw_error_already_set();
+    return is_true ? &object::ptr : 0;
 }
 
 template <class U>
@@ -68,7 +70,9 @@ inline bool
 object_operators<U>::operator!() const
 {
     object_cref2 x = *static_cast<U const*>(this);
-    return !PyObject_IsTrue(x.ptr());
+    int is_true = PyObject_IsTrue(x.ptr());
+    if (is_true < 0) throw_error_already_set();
+    return !is_true;
 }
 
 # define BOOST_PYTHON_COMPARE_OP(op, opid)                              \

include/boost/python/object_protocol.hpp

@@ -10,9 +10,11 @@
 # include <boost/python/object_protocol_core.hpp>
 # include <boost/python/object_core.hpp>
 
+# include <boost/detail/workaround.hpp>
+
 namespace boost { namespace python { namespace api {
 
-# if BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580)
+# if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
 // attempt to use SFINAE to prevent functions accepting T const& from
 // coming up as ambiguous with the one taking a char const* when a
 // string literal is passed
@@ -22,45 +24,45 @@ namespace boost { namespace python { namespace api {
 # endif
 
 template <class Target, class Key>
-object getattr(Target const& target, Key const& key BOOST_PYTHON_NO_ARRAY_ARG(key))
+object getattr(Target const& target, Key const& key BOOST_PYTHON_NO_ARRAY_ARG(Key))
 {
     return getattr(object(target), object(key));
 }
 
 template <class Target, class Key, class Default>
-object getattr(Target const& target, Key const& key, Default const& default_ BOOST_PYTHON_NO_ARRAY_ARG(key))
+object getattr(Target const& target, Key const& key, Default const& default_ BOOST_PYTHON_NO_ARRAY_ARG(Key))
 {
     return getattr(object(target), object(key), object(default_));
 }
 
 
 template <class Key, class Value>
-void setattr(object const& target, Key const& key, Value const& value BOOST_PYTHON_NO_ARRAY_ARG(key))
+void setattr(object const& target, Key const& key, Value const& value BOOST_PYTHON_NO_ARRAY_ARG(Key))
 {
     setattr(target, object(key), object(value));
 }
 
 template <class Key>
-void delattr(object const& target, Key const& key BOOST_PYTHON_NO_ARRAY_ARG(key))
+void delattr(object const& target, Key const& key BOOST_PYTHON_NO_ARRAY_ARG(Key))
 {
     delattr(target, object(key));
 }
 
 template <class Target, class Key>
-object getitem(Target const& target, Key const& key BOOST_PYTHON_NO_ARRAY_ARG(key))
+object getitem(Target const& target, Key const& key BOOST_PYTHON_NO_ARRAY_ARG(Key))
 {
     return getitem(object(target), object(key));
 }
 
 
 template <class Key, class Value>
-void setitem(object const& target, Key const& key, Value const& value BOOST_PYTHON_NO_ARRAY_ARG(key))
+void setitem(object const& target, Key const& key, Value const& value BOOST_PYTHON_NO_ARRAY_ARG(Key))
 {
     setitem(target, object(key), object(value));
 }
 
 template <class Key>
-void delitem(object const& target, Key const& key BOOST_PYTHON_NO_ARRAY_ARG(key))
+void delitem(object const& target, Key const& key BOOST_PYTHON_NO_ARRAY_ARG(Key))
 {
     delitem(target, object(key));
 }

include/boost/python/object_slices.hpp

@@ -27,6 +27,12 @@ struct slice_policies : const_slice_policies
     static void del(object const& target, key_type const& key);
 };
 
+template <class T, class U>
+inline slice_policies::key_type slice_key(T x, U y)
+{
+    return slice_policies::key_type(handle<>(x), handle<>(y));
+}
+    
 //
 // implementation
 //
@@ -35,7 +41,7 @@ object_slice
 object_operators<U>::slice(object_cref start, object_cref finish)
 {
     object_cref2 x = *static_cast<U*>(this);
-    return object_slice(x, std::make_pair(borrowed(start.ptr()), borrowed(finish.ptr())));
+    return object_slice(x, api::slice_key(borrowed(start.ptr()), borrowed(finish.ptr())));
 }
 
 template <class U>
@@ -43,7 +49,7 @@ const_object_slice
 object_operators<U>::slice(object_cref start, object_cref finish) const
 {
     object_cref2 x = *static_cast<U const*>(this);
-    return const_object_slice(x, std::make_pair(borrowed(start.ptr()), borrowed(finish.ptr())));
+    return const_object_slice(x, api::slice_key(borrowed(start.ptr()), borrowed(finish.ptr())));
 }
 
 template <class U>
@@ -51,7 +57,7 @@ object_slice
 object_operators<U>::slice(slice_nil, object_cref finish)
 {
     object_cref2 x = *static_cast<U*>(this);
-    return object_slice(x, std::make_pair(allow_null((PyObject*)0), borrowed(finish.ptr())));
+    return object_slice(x, api::slice_key(allow_null((PyObject*)0), borrowed(finish.ptr())));
 }
 
 template <class U>
@@ -59,7 +65,7 @@ const_object_slice
 object_operators<U>::slice(slice_nil, object_cref finish) const
 {
     object_cref2 x = *static_cast<U const*>(this);
-    return const_object_slice(x, std::make_pair(allow_null((PyObject*)0), borrowed(finish.ptr())));
+    return const_object_slice(x, api::slice_key(allow_null((PyObject*)0), borrowed(finish.ptr())));
 }
 
 template <class U>
@@ -67,7 +73,7 @@ object_slice
 object_operators<U>::slice(slice_nil, slice_nil)
 {
     object_cref2 x = *static_cast<U*>(this);
-    return object_slice(x, std::make_pair(allow_null((PyObject*)0), allow_null((PyObject*)0)));
+    return object_slice(x, api::slice_key(allow_null((PyObject*)0), allow_null((PyObject*)0)));
 }
 
 template <class U>
@@ -75,7 +81,7 @@ const_object_slice
 object_operators<U>::slice(slice_nil, slice_nil) const
 {
     object_cref2 x = *static_cast<U const*>(this);
-    return const_object_slice(x, std::make_pair(allow_null((PyObject*)0), allow_null((PyObject*)0)));
+    return const_object_slice(x, api::slice_key(allow_null((PyObject*)0), allow_null((PyObject*)0)));
 }
 
 template <class U>
@@ -83,7 +89,7 @@ object_slice
 object_operators<U>::slice(object_cref start, slice_nil)
 {
     object_cref2 x = *static_cast<U*>(this);
-    return object_slice(x, std::make_pair(borrowed(start.ptr()), allow_null((PyObject*)0)));
+    return object_slice(x, api::slice_key(borrowed(start.ptr()), allow_null((PyObject*)0)));
 }
 
 template <class U>
@@ -91,7 +97,7 @@ const_object_slice
 object_operators<U>::slice(object_cref start, slice_nil) const
 {
     object_cref2 x = *static_cast<U const*>(this);
-    return const_object_slice(x, std::make_pair(borrowed(start.ptr()), allow_null((PyObject*)0)));
+    return const_object_slice(x, api::slice_key(borrowed(start.ptr()), allow_null((PyObject*)0)));
 }
 # if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
 template <class U>

include/boost/python/opaque_pointer_converter.hpp

@@ -121,8 +121,7 @@ opaque<Pointee> opaque<Pointee>::instance;
 template <class Pointee>
 PyTypeObject opaque<Pointee>::type_object =
 {
-    PyObject_HEAD_INIT(0)
-    0,
+    PyVarObject_HEAD_INIT(NULL, 0)
     0,
     sizeof( BOOST_DEDUCED_TYPENAME opaque<Pointee>::python_instance ),
     0,

include/boost/python/operators.hpp

@@ -212,7 +212,11 @@ namespace self_ns                                       \
 BOOST_PYTHON_BINARY_OPERATOR(add, radd, +)
 BOOST_PYTHON_BINARY_OPERATOR(sub, rsub, -)
 BOOST_PYTHON_BINARY_OPERATOR(mul, rmul, *)
-BOOST_PYTHON_BINARY_OPERATOR(div, rdiv, /)
+#if PY_VERSION_HEX >= 0x03000000
+    BOOST_PYTHON_BINARY_OPERATOR(truediv, rtruediv, /)
+#else
+    BOOST_PYTHON_BINARY_OPERATOR(div, rdiv, /)
+#endif
 BOOST_PYTHON_BINARY_OPERATOR(mod, rmod, %)
 BOOST_PYTHON_BINARY_OPERATOR(lshift, rlshift, <<)
 BOOST_PYTHON_BINARY_OPERATOR(rshift, rrshift, >>)
@@ -341,7 +345,11 @@ BOOST_PYTHON_UNARY_OPERATOR(neg, -, operator-)
 BOOST_PYTHON_UNARY_OPERATOR(pos, +, operator+)
 BOOST_PYTHON_UNARY_OPERATOR(abs, abs, abs)
 BOOST_PYTHON_UNARY_OPERATOR(invert, ~, operator~)
+#if PY_VERSION_HEX >= 0x03000000
+BOOST_PYTHON_UNARY_OPERATOR(bool, !!, operator!)
+#else
 BOOST_PYTHON_UNARY_OPERATOR(nonzero, !!, operator!)
+#endif
 BOOST_PYTHON_UNARY_OPERATOR(int, long, int_)
 BOOST_PYTHON_UNARY_OPERATOR(long, PyLong_FromLong, long_)
 BOOST_PYTHON_UNARY_OPERATOR(float, double, float_)

include/boost/python/override.hpp

@@ -77,7 +77,7 @@ namespace detail
       template <class T>
       T unchecked(type<T>* = 0)
       {
-          return extract<T>(m_obj)();
+          return extract<T>(m_obj.get())();
       }
    private:
       mutable handle<> m_obj;

include/boost/python/ptr.hpp

@@ -8,7 +8,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 // Based on boost/ref.hpp, thus:
-//  Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+//  Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //  Copyright (C) 2001 Peter Dimov
 
 # if _MSC_VER+0 >= 1020

include/boost/python/scope.hpp

@@ -8,7 +8,6 @@
 # include <boost/python/detail/prefix.hpp>
 # include <boost/python/object.hpp>
 # include <boost/python/refcount.hpp>
-# include <boost/utility.hpp>
 
 namespace boost { namespace python { 
 

include/boost/python/signature.hpp

@@ -52,16 +52,23 @@ struct most_derived
 //
 //      template <class RT, class T0... class TN>
 //      inline mpl::vector<RT, T0...TN>
-//      get_signature(RT(*)(T0...TN), void* = 0)
+//      get_signature(RT(BOOST_PYTHON_FN_CC *)(T0...TN), void* = 0)
 //      {
 //          return mpl::list<RT, T0...TN>();
 //      }
 //
+//    where BOOST_PYTHON_FN_CC is a calling convention keyword, can be
+//
+//        empty, for default calling convention
+//        __cdecl (if BOOST_PYTHON_ENABLE_CDECL is defined)
+//        __stdcall (if BOOST_PYTHON_ENABLE_STDCALL is defined)
+//        __fastcall (if BOOST_PYTHON_ENABLE_FASTCALL is defined)
+//
 //   And, for an appropriate assortment of cv-qualifications::
 //
 //      template <class RT, class ClassT, class T0... class TN>
 //      inline mpl::vector<RT, ClassT&, T0...TN>
-//      get_signature(RT(ClassT::*)(T0...TN) cv))
+//      get_signature(RT(BOOST_PYTHON_FN_CC ClassT::*)(T0...TN) cv))
 //      {
 //          return mpl::list<RT, ClassT&, T0...TN>();
 //      }
@@ -72,7 +79,7 @@ struct most_derived
 //        , typename most_derived<Target, ClassT>::type&
 //        , T0...TN
 //      >
-//      get_signature(RT(ClassT::*)(T0...TN) cv), Target*)
+//      get_signature(RT(BOOST_PYTHON_FN_CC ClassT::*)(T0...TN) cv), Target*)
 //      {
 //          return mpl::list<RT, ClassT&, T0...TN>();
 //      }
@@ -87,7 +94,8 @@ struct most_derived
 //
 //  These functions extract the return type, class (for member
 //  functions) and arguments of the input signature and stuff them in
-//  an mpl type sequence.  Note that cv-qualification is dropped from
+//  an mpl type sequence (the calling convention is dropped).
+//  Note that cv-qualification is dropped from
 //  the "hidden this" argument of member functions; that is a
 //  necessary sacrifice to ensure that an lvalue from_python converter
 //  is used.  A pointer is not used so that None will be rejected for
@@ -100,10 +108,64 @@ struct most_derived
 //
 // @group {
 
+// 'default' calling convention
+
+#  define BOOST_PYTHON_FN_CC
+
 #  define BOOST_PP_ITERATION_PARAMS_1                                   \
     (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/signature.hpp>))
 
 #  include BOOST_PP_ITERATE()
+
+#  undef BOOST_PYTHON_FN_CC
+
+// __cdecl calling convention
+
+#  if defined(BOOST_PYTHON_ENABLE_CDECL)
+
+#   define BOOST_PYTHON_FN_CC __cdecl
+#   define BOOST_PYTHON_FN_CC_IS_CDECL
+
+#   define BOOST_PP_ITERATION_PARAMS_1                                   \
+     (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/signature.hpp>))
+
+#   include BOOST_PP_ITERATE()
+
+#   undef BOOST_PYTHON_FN_CC
+#   undef BOOST_PYTHON_FN_CC_IS_CDECL
+
+#  endif // defined(BOOST_PYTHON_ENABLE_CDECL)
+
+// __stdcall calling convention
+
+#  if defined(BOOST_PYTHON_ENABLE_STDCALL)
+
+#   define BOOST_PYTHON_FN_CC __stdcall
+
+#   define BOOST_PP_ITERATION_PARAMS_1                                   \
+     (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/signature.hpp>))
+
+#   include BOOST_PP_ITERATE()
+
+#   undef BOOST_PYTHON_FN_CC
+
+#  endif // defined(BOOST_PYTHON_ENABLE_STDCALL)
+
+// __fastcall calling convention
+
+#  if defined(BOOST_PYTHON_ENABLE_FASTCALL)
+
+#   define BOOST_PYTHON_FN_CC __fastcall
+
+#   define BOOST_PP_ITERATION_PARAMS_1                                   \
+     (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/signature.hpp>))
+
+#   include BOOST_PP_ITERATE()
+
+#   undef BOOST_PYTHON_FN_CC
+
+#  endif // defined(BOOST_PYTHON_ENABLE_FASTCALL)
+
 #  undef BOOST_PYTHON_LIST_INC
 
 // }
@@ -113,21 +175,31 @@ struct most_derived
 
 # endif // SIGNATURE_JDG20020813_HPP
 
-#elif BOOST_PP_ITERATION_DEPTH() == 1 // defined(BOOST_PP_IS_ITERATING)
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1 // defined(BOOST_PP_IS_ITERATING)
 
 # define N BOOST_PP_ITERATION()
 
+   // as 'get_signature(RT(*)(T0...TN), void* = 0)' is the same
+   // function as 'get_signature(RT(__cdecl *)(T0...TN), void* = 0)',
+   // we don't define it twice
+#  if !defined(BOOST_PYTHON_FN_CC_IS_CDECL)
+
 template <
     class RT BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class T)>
 inline BOOST_PYTHON_LIST_INC(N)<
     RT BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, T)>
-get_signature(RT(*)(BOOST_PP_ENUM_PARAMS_Z(1, N, T)), void* = 0)
+get_signature(RT(BOOST_PYTHON_FN_CC *)(BOOST_PP_ENUM_PARAMS_Z(1, N, T)), void* = 0)
 {
     return BOOST_PYTHON_LIST_INC(N)<
             RT BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, T)
         >();
 }
 
+#  endif // !defined(BOOST_PYTHON_FN_CC_IS_CDECL)
+
 # undef N
 
 # define BOOST_PP_ITERATION_PARAMS_2 \
@@ -143,7 +215,7 @@ template <
     class RT, class ClassT BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class T)>
 inline BOOST_PYTHON_LIST_INC(BOOST_PP_INC(N))<
     RT, ClassT& BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, T)>
-get_signature(RT(ClassT::*)(BOOST_PP_ENUM_PARAMS_Z(1, N, T)) Q)
+get_signature(RT(BOOST_PYTHON_FN_CC ClassT::*)(BOOST_PP_ENUM_PARAMS_Z(1, N, T)) Q)
 {
     return BOOST_PYTHON_LIST_INC(BOOST_PP_INC(N))<
             RT, ClassT& BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, T)
@@ -162,7 +234,7 @@ inline BOOST_PYTHON_LIST_INC(BOOST_PP_INC(N))<
     BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, T)
 >
 get_signature(
-    RT(ClassT::*)(BOOST_PP_ENUM_PARAMS_Z(1, N, T)) Q
+    RT(BOOST_PYTHON_FN_CC ClassT::*)(BOOST_PP_ENUM_PARAMS_Z(1, N, T)) Q
   , Target*
 )
 {
@@ -176,4 +248,5 @@ get_signature(
 # undef Q
 # undef N
 
+#endif // BOOST_PP_ITERATION_DEPTH()
 #endif // !defined(BOOST_PP_IS_ITERATING)

include/boost/python/slice.hpp

@@ -30,7 +30,7 @@ namespace detail
       // that created this slice, than that parameter is None here, and compares 
       // equal to a default-constructed boost::python::object.
       // If a user-defined type wishes to support slicing, then support for the 
-      // special meaning associated with negative indicies is up to the user.
+      // special meaning associated with negative indices is up to the user.
       object start() const;
       object stop() const;
       object step() const;
@@ -63,7 +63,7 @@ class slice : public detail::slice_base
         
     // The following algorithm is intended to automate the process of 
     // determining a slice range when you want to fully support negative
-    // indicies and non-singular step sizes.  Its functionallity is simmilar to 
+    // indices and non-singular step sizes.  Its functionallity is simmilar to 
     // PySlice_GetIndicesEx() in the Python/C API, but tailored for C++ users.
     // This template returns a slice::range struct that, when used in the 
     // following iterative loop, will traverse a slice of the function's
@@ -110,7 +110,7 @@ class slice : public detail::slice_base
     
     template<typename RandomAccessIterator>
     slice::range<RandomAccessIterator>
-    get_indicies( const RandomAccessIterator& begin, 
+    get_indices( const RandomAccessIterator& begin, 
         const RandomAccessIterator& end) const
     {
         // This is based loosely on PySlice_GetIndicesEx(), but it has been 
@@ -240,6 +240,16 @@ class slice : public detail::slice_base
         
         return ret;
     }
+
+    // Incorrect spelling. DO NOT USE. Only here for backward compatibility.
+    // Corrected 2011-06-14.
+    template<typename RandomAccessIterator>
+    slice::range<RandomAccessIterator>
+    get_indicies( const RandomAccessIterator& begin, 
+        const RandomAccessIterator& end) const
+    {
+        return get_indices(begin, end);
+    }
         
  public:
     // This declaration, in conjunction with the specialization of 

include/boost/python/str.hpp

@@ -37,10 +37,12 @@ namespace detail
     
       long count(object_cref sub, object_cref start, object_cref end) const;
 
+#if PY_VERSION_HEX < 0x03000000
       object decode() const;
       object decode(object_cref encoding) const;
 
       object decode(object_cref encoding, object_cref errors) const;
+#endif
 
       object encode() const;
       object encode(object_cref encoding) const;
@@ -185,6 +187,7 @@ class str : public detail::str_base
         return base::count(object(sub), object(start));
     }
 
+#if PY_VERSION_HEX < 0x03000000
     object decode() const { return base::decode(); }
     
     template<class T>
@@ -198,6 +201,7 @@ class str : public detail::str_base
     {
         return base::decode(object(encoding),object(errors));
     }
+#endif
 
     object encode() const { return base::encode(); }
 
@@ -404,7 +408,11 @@ namespace converter
 {
   template <>
   struct object_manager_traits<str>
+#if PY_VERSION_HEX >= 0x03000000
+      : pytype_object_manager_traits<&PyUnicode_Type,str>
+#else
       : pytype_object_manager_traits<&PyString_Type,str>
+#endif
   {
   };
 }

include/boost/python/suite/indexing/container_utils.hpp

@@ -7,9 +7,12 @@
 #ifndef PY_CONTAINER_UTILS_JDG20038_HPP
 # define PY_CONTAINER_UTILS_JDG20038_HPP
 
+# include <utility>
+# include <boost/foreach.hpp>
 # include <boost/python/object.hpp>
 # include <boost/python/handle.hpp>
 # include <boost/python/extract.hpp>
+# include <boost/python/stl_iterator.hpp>
 
 namespace boost { namespace python { namespace container_utils {
         
@@ -19,11 +22,13 @@ namespace boost { namespace python { namespace container_utils {
     {
         typedef typename Container::value_type data_type;
         
-        //  l must be a list or some container
-
-        for (int i = 0; i < l.attr("__len__")(); i++)
+        //  l must be iterable
+        BOOST_FOREACH(object elem,
+            std::make_pair(
+              boost::python::stl_input_iterator<object>(l),
+              boost::python::stl_input_iterator<object>()
+              ))
         {
-            object elem(l[i]);
             extract<data_type const&> x(elem);
             //  try if elem is an exact data_type type
             if (x.check())

include/boost/python/type_id.hpp

@@ -11,6 +11,7 @@
 # include <boost/operators.hpp>
 # include <typeinfo>
 # include <cstring>
+# include <ostream>
 # include <boost/static_assert.hpp>
 # include <boost/detail/workaround.hpp>
 # include <boost/type_traits/same_traits.hpp>

include/boost/python/with_custodian_and_ward.hpp

@@ -68,8 +68,9 @@ struct with_custodian_and_ward : BasePolicy_
     
         bool result = BasePolicy_::precall(args_);
 
-        if (!result)
+        if (!result) {
             Py_DECREF(life_support);
+        }
     
         return result;
     }

meta/libraries.json

@@ -0,0 +1,15 @@
+{
+    "key": "python",
+    "name": "Python",
+    "authors": [
+        "Dave Abrahams"
+    ],
+    "description": "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.",
+    "category": [
+        "Inter-language"
+    ],
+    "maintainers": [
+        "Ralf Grosse-Kunstleve <rwgrosse-kunstleve -at- lbl.gov>",
+        "Ravi Rajagopal <lists_ravi -at- lavabit.com>"
+    ]
+}

pyste/src/Pyste/GCCXMLParser.py

@@ -4,12 +4,16 @@
 # http://www.boost.org/LICENSE_1_0.txt)
 
 from declarations import *
-# try to use cElementTree if avaiable
 try:
-    from cElementTree import ElementTree    
+    # try to use internal elementtree
+    from xml.etree.cElementTree import ElementTree
 except ImportError:
-    # fall back to the normal elementtree
-    from elementtree.ElementTree import ElementTree
+    # try to use cElementTree if avaiable
+    try:
+        from cElementTree import ElementTree    
+    except ImportError:
+        # fall back to the normal elementtree
+        from elementtree.ElementTree import ElementTree
 from xml.parsers.expat import ExpatError
 from copy import deepcopy
 from utils import enumerate

src/converter/builtin_converters.cpp

@@ -37,12 +37,20 @@ void shared_ptr_deleter::operator()(void const*)
 
 namespace
 {
+
   // An lvalue conversion function which extracts a char const* from a
   // Python String.
+#if PY_VERSION_HEX < 0x03000000
   void* convert_to_cstring(PyObject* obj)
   {
       return PyString_Check(obj) ? PyString_AsString(obj) : 0;
   }
+#else
+  void* convert_to_cstring(PyObject* obj)
+  {
+      return PyUnicode_Check(obj) ? _PyUnicode_AsString(obj) : 0;
+  }
+#endif
 
   // Given a target type and a SlotPolicy describing how to perform a
   // given conversion, registers from_python converters which use the
@@ -90,6 +98,52 @@ namespace
       }
   };
 
+  // identity_unaryfunc/py_object_identity -- manufacture a unaryfunc
+  // "slot" which just returns its argument. 
+  extern "C" PyObject* identity_unaryfunc(PyObject* x)
+  {
+      Py_INCREF(x);
+      return x;
+  }
+  unaryfunc py_object_identity = identity_unaryfunc;
+
+#if PY_VERSION_HEX >= 0x03000000
+  // As in Python 3 there is only one integer type, we can have much
+  // simplified logic.
+  // XXX(bhy) maybe the code will work with 2.6 or even 2.5?
+  struct int_rvalue_from_python_base
+  {
+      static unaryfunc* get_slot(PyObject* obj)
+      {
+          return PyLong_Check(obj) ? &py_object_identity : 0;
+      }
+      static PyTypeObject const* get_pytype() {return &PyLong_Type;}
+  };
+
+  template <class T>
+  struct signed_int_rvalue_from_python : int_rvalue_from_python_base
+  {
+      static T extract(PyObject* intermediate)
+      {
+          long x = PyLong_AsLong(intermediate);
+          if (PyErr_Occurred())
+              throw_error_already_set();
+          return numeric_cast<T>(x);
+      }
+  };
+
+  template <class T>
+  struct unsigned_int_rvalue_from_python : int_rvalue_from_python_base
+  {
+      static T extract(PyObject* intermediate)
+      {
+          unsigned long x = PyLong_AsUnsignedLong(intermediate);
+          if (PyErr_Occurred())
+              throw_error_already_set();
+          return numeric_cast<T>(x);
+      }
+  };
+#else // PY_VERSION_HEX >= 0x03000000
   // A SlotPolicy for extracting signed integer types from Python objects
   struct signed_int_rvalue_from_python_base
   {
@@ -99,8 +153,13 @@ namespace
           if (number_methods == 0)
               return 0;
 
-          return (PyInt_Check(obj) || PyLong_Check(obj))
-              ? &number_methods->nb_int : 0;
+          return (
+#if PY_VERSION_HEX >= 0x02040000 && defined(BOOST_PYTHON_BOOL_INT_STRICT)
+          !PyBool_Check(obj) &&
+#endif
+          (PyInt_Check(obj) || PyLong_Check(obj)))
+
+        ? &number_methods->nb_int : 0;
       }
       static PyTypeObject const* get_pytype() { return &PyInt_Type;}
   };
@@ -116,16 +175,7 @@ namespace
           return numeric_cast<T>(x);
       }
   };
-
-  // identity_unaryfunc/py_object_identity -- manufacture a unaryfunc
-  // "slot" which just returns its argument. 
-  extern "C" PyObject* identity_unaryfunc(PyObject* x)
-  {
-      Py_INCREF(x);
-      return x;
-  }
-  unaryfunc py_object_identity = identity_unaryfunc;
-
+  
   // A SlotPolicy for extracting unsigned integer types from Python objects
   struct unsigned_int_rvalue_from_python_base
   {
@@ -135,7 +185,11 @@ namespace
           if (number_methods == 0)
               return 0;
 
-          return (PyInt_Check(obj) || PyLong_Check(obj))
+          return (
+#if PY_VERSION_HEX >= 0x02040000 && defined(BOOST_PYTHON_BOOL_INT_STRICT)
+          !PyBool_Check(obj) &&
+#endif
+          (PyInt_Check(obj) || PyLong_Check(obj)))
               ? &py_object_identity : 0;
       }
       static PyTypeObject const* get_pytype() { return &PyInt_Type;}
@@ -146,12 +200,30 @@ namespace
   {
       static T extract(PyObject* intermediate)
       {
-          return numeric_cast<T>(
-              PyLong_Check(intermediate)
-              ? PyLong_AsUnsignedLong(intermediate)
-              : PyInt_AS_LONG(intermediate));
+          if (PyLong_Check(intermediate)) {
+              // PyLong_AsUnsignedLong() checks for negative overflow, so no
+              // need to check it here.
+              unsigned long result = PyLong_AsUnsignedLong(intermediate);
+              if (PyErr_Occurred())
+                  throw_error_already_set();
+              return numeric_cast<T>(result);
+          } else {
+              // None of PyInt_AsUnsigned*() functions check for negative
+              // overflow, so use PyInt_AS_LONG instead and check if number is
+              // negative, issuing the exception appropriately.
+              long result = PyInt_AS_LONG(intermediate);
+              if (PyErr_Occurred())
+                  throw_error_already_set();
+              if (result < 0) {
+                  PyErr_SetString(PyExc_OverflowError, "can't convert negative"
+                                  " value to unsigned");
+                  throw_error_already_set();
+              }
+              return numeric_cast<T>(result);
+          }
       }
   };
+#endif // PY_VERSION_HEX >= 0x03000000
 
 // Checking Python's macro instead of Boost's - we don't seem to get
 // the config right all the time. Furthermore, Python's is defined
@@ -164,6 +236,9 @@ namespace
   {
       static unaryfunc* get_slot(PyObject* obj)
       {
+#if PY_VERSION_HEX >= 0x03000000
+          return PyLong_Check(obj) ? &py_object_identity : 0;
+#else
           PyNumberMethods* number_methods = obj->ob_type->tp_as_number;
           if (number_methods == 0)
               return 0;
@@ -176,19 +251,22 @@ namespace
               return &number_methods->nb_long;
           else
               return 0;
+#endif
       }
-      static PyTypeObject const* get_pytype() { return &PyInt_Type;}
+      static PyTypeObject const* get_pytype() { return &PyLong_Type;}
   };
   
   struct long_long_rvalue_from_python : long_long_rvalue_from_python_base
   {
       static BOOST_PYTHON_LONG_LONG extract(PyObject* intermediate)
       {
+#if PY_VERSION_HEX < 0x03000000
           if (PyInt_Check(intermediate))
           {
               return PyInt_AS_LONG(intermediate);
           }
           else
+#endif
           {
               BOOST_PYTHON_LONG_LONG result = PyLong_AsLongLong(intermediate);
               
@@ -204,11 +282,13 @@ namespace
   {
       static unsigned BOOST_PYTHON_LONG_LONG extract(PyObject* intermediate)
       {
+#if PY_VERSION_HEX < 0x03000000
           if (PyInt_Check(intermediate))
           {
               return numeric_cast<unsigned BOOST_PYTHON_LONG_LONG>(PyInt_AS_LONG(intermediate));
           }
           else
+#endif
           {
               unsigned BOOST_PYTHON_LONG_LONG result = PyLong_AsUnsignedLongLong(intermediate);
               
@@ -226,7 +306,13 @@ namespace
   {
       static unaryfunc* get_slot(PyObject* obj)
       {
+#if PY_VERSION_HEX >= 0x03000000
+          return obj == Py_None || PyLong_Check(obj) ? &py_object_identity : 0;
+#elif PY_VERSION_HEX >= 0x02040000 && defined(BOOST_PYTHON_BOOL_INT_STRICT)
+          return obj == Py_None || PyBool_Check(obj) ? &py_object_identity : 0;
+#else
           return obj == Py_None || PyInt_Check(obj) ? &py_object_identity : 0;
+#endif
       }
       
       static bool extract(PyObject* intermediate)
@@ -255,8 +341,10 @@ namespace
 
           // For integer types, return the tp_int conversion slot to avoid
           // creating a new object. We'll handle that below
+#if PY_VERSION_HEX < 0x03000000
           if (PyInt_Check(obj))
               return &number_methods->nb_int;
+#endif
 
           return (PyLong_Check(obj) || PyFloat_Check(obj))
               ? &number_methods->nb_float : 0;
@@ -264,11 +352,13 @@ namespace
       
       static double extract(PyObject* intermediate)
       {
+#if PY_VERSION_HEX < 0x03000000
           if (PyInt_Check(intermediate))
           {
               return PyInt_AS_LONG(intermediate);
           }
           else
+#endif
           {
               return PyFloat_AS_DOUBLE(intermediate);
           }
@@ -276,22 +366,39 @@ namespace
       static PyTypeObject const* get_pytype() { return &PyFloat_Type;}
   };
 
+#if PY_VERSION_HEX >= 0x03000000
+  unaryfunc py_unicode_as_string_unaryfunc = PyUnicode_AsUTF8String;
+#endif
+
   // A SlotPolicy for extracting C++ strings from Python objects.
   struct string_rvalue_from_python
   {
       // If the underlying object is "string-able" this will succeed
       static unaryfunc* get_slot(PyObject* obj)
       {
-          return (PyString_Check(obj))
-              ? &obj->ob_type->tp_str : 0;
+#if PY_VERSION_HEX >= 0x03000000
+          return (PyUnicode_Check(obj)) ? &py_unicode_as_string_unaryfunc : 
+                  PyBytes_Check(obj) ? &py_object_identity : 0;
+#else
+          return (PyString_Check(obj)) ? &obj->ob_type->tp_str : 0;
+
+#endif
       };
 
       // Remember that this will be used to construct the result object 
+#if PY_VERSION_HEX >= 0x03000000
+      static std::string extract(PyObject* intermediate)
+      {
+          return std::string(PyBytes_AsString(intermediate),PyBytes_Size(intermediate));
+      }
+      static PyTypeObject const* get_pytype() { return &PyUnicode_Type;}
+#else
       static std::string extract(PyObject* intermediate)
       {
           return std::string(PyString_AsString(intermediate),PyString_Size(intermediate));
       }
       static PyTypeObject const* get_pytype() { return &PyString_Type;}
+#endif
   };
 
 #if defined(Py_USING_UNICODE) && !defined(BOOST_NO_STD_WSTRING)
@@ -311,7 +418,11 @@ namespace
       {
           return PyUnicode_Check(obj)
               ? &py_object_identity
+#if PY_VERSION_HEX >= 0x03000000
+            : PyBytes_Check(obj)
+#else
             : PyString_Check(obj)
+#endif
               ? &py_encode_string
             : 0;
       };
@@ -323,7 +434,10 @@ namespace
           if (!result.empty())
           {
               int err = PyUnicode_AsWideChar(
-                  (PyUnicodeObject *)intermediate
+#if PY_VERSION_HEX < 0x03020000
+                  (PyUnicodeObject *)
+#endif
+                    intermediate
                 , &result[0]
                 , result.size());
 
@@ -354,10 +468,12 @@ namespace
                   PyComplex_RealAsDouble(intermediate)
                   , PyComplex_ImagAsDouble(intermediate));
           }
+#if PY_VERSION_HEX < 0x03000000
           else if (PyInt_Check(intermediate))
           {
               return PyInt_AS_LONG(intermediate);
           }
+#endif
           else
           {
               return PyFloat_AS_DOUBLE(intermediate);
@@ -369,12 +485,20 @@ namespace
 
 BOOST_PYTHON_DECL PyObject* do_return_to_python(char x)
 {
+#if PY_VERSION_HEX >= 0x03000000
+    return PyUnicode_FromStringAndSize(&x, 1);
+#else
     return PyString_FromStringAndSize(&x, 1);
+#endif
 }
   
 BOOST_PYTHON_DECL PyObject* do_return_to_python(char const* x)
 {
+#if PY_VERSION_HEX >= 0x03000000
+    return x ? PyUnicode_FromString(x) : boost::python::detail::none();
+#else
     return x ? PyString_FromString(x) : boost::python::detail::none();
+#endif
 }
   
 BOOST_PYTHON_DECL PyObject* do_return_to_python(PyObject* x)
@@ -429,13 +553,18 @@ void initialize_builtin_converters()
     slot_rvalue_from_python<std::complex<long double>,complex_rvalue_from_python>();
     
     // Add an lvalue converter for char which gets us char const*
+#if PY_VERSION_HEX < 0x03000000
     registry::insert(convert_to_cstring,type_id<char>(),&converter::wrap_pytype<&PyString_Type>::get_pytype);
+#else
+    registry::insert(convert_to_cstring,type_id<char>(),&converter::wrap_pytype<&PyUnicode_Type>::get_pytype);
+#endif
 
     // Register by-value converters to std::string, std::wstring
 #if defined(Py_USING_UNICODE) && !defined(BOOST_NO_STD_WSTRING)
     slot_rvalue_from_python<std::wstring, wstring_rvalue_from_python>();
 # endif 
     slot_rvalue_from_python<std::string, string_rvalue_from_python>();
+
 }
 
 }}} // namespace boost::python::converter

src/converter/from_python.cpp

@@ -44,11 +44,8 @@ BOOST_PYTHON_DECL rvalue_from_python_stage1_data rvalue_from_python_stage1(
     // First check to see if it's embedded in an extension class
     // instance, as a special case.
     data.convertible = objects::find_instance_impl(source, converters.target_type, converters.is_shared_ptr);
-    if (data.convertible)
-    {
         data.construct = 0;
-    }
-    else
+    if (!data.convertible)
     {
         for (rvalue_from_python_chain const* chain = converters.rvalue_chain;
              chain != 0;
@@ -96,7 +93,12 @@ BOOST_PYTHON_DECL void* rvalue_from_python_stage2(
     if (!data.convertible)
     {
         handle<> msg(
-            ::PyString_FromFormat(
+#if PY_VERSION_HEX >= 0x03000000
+            ::PyUnicode_FromFormat
+#else
+            ::PyString_FromFormat
+#endif
+                (
                 "No registered converter was able to produce a C++ rvalue of type %s from this Python object of type %s"
                 , converters.target_type.name()
                 , source->ob_type->tp_name
@@ -196,7 +198,12 @@ namespace
   void throw_no_lvalue_from_python(PyObject* source, registration const& converters, char const* ref_type)
   {
       handle<> msg(
-          ::PyString_FromFormat(
+#if PY_VERSION_HEX >= 0x03000000
+          ::PyUnicode_FromFormat
+#else
+          ::PyString_FromFormat
+#endif
+              (
               "No registered converter was able to extract a C++ %s to type %s"
               " from this Python object of type %s"
               , ref_type
@@ -218,7 +225,12 @@ namespace
       if (source->ob_refcnt <= 1)
       {
           handle<> msg(
-              ::PyString_FromFormat(
+#if PY_VERSION_HEX >= 0x3000000
+              ::PyUnicode_FromFormat
+#else
+              ::PyString_FromFormat
+#endif
+                  (
                   "Attempt to return dangling %s to object of type: %s"
                   , ref_type
                   , converters.target_type.name()));

src/converter/registry.cpp

@@ -70,7 +70,12 @@ BOOST_PYTHON_DECL PyObject* registration::to_python(void const volatile* source)
     if (this->m_to_python == 0)
     {
         handle<> msg(
-            ::PyString_FromFormat(
+#if PY_VERSION_HEX >= 0x3000000
+            ::PyUnicode_FromFormat
+#else
+            ::PyString_FromFormat
+#endif
+            (
                 "No to_python (by-value) converter found for C++ type: %s"
                 , this->target_type.name()
                 )
@@ -238,7 +243,7 @@ namespace registry
   }
 
   // Insert an rvalue from_python converter
-  void insert(void* (*convertible)(PyObject*)
+  void insert(convertible_function convertible
               , constructor_function construct
               , type_info key
               , PyTypeObject const* (*exp_pytype)())
@@ -256,7 +261,7 @@ namespace registry
   }
 
   // Insert an rvalue from_python converter
-  void push_back(void* (*convertible)(PyObject*)
+  void push_back(convertible_function convertible
               , constructor_function construct
               , type_info key
               , PyTypeObject const* (*exp_pytype)())

src/dict.cpp

@@ -29,7 +29,7 @@ namespace
 detail::new_reference dict_base::call(object const& arg_)
 {
     return (detail::new_reference)PyObject_CallFunction(
-        (PyObject*)&PyDict_Type, "(O)", 
+        (PyObject*)&PyDict_Type, const_cast<char*>("(O)"), 
         arg_.ptr());
 }
 
@@ -84,7 +84,7 @@ object dict_base::get(object_cref k, object_cref d) const
 
 bool dict_base::has_key(object_cref k) const
 {
-    return extract<bool>(this->attr("has_key")(k)); 
+    return extract<bool>(this->contains(k)); 
 }
 
 list dict_base::items() const

src/errors.cpp

@@ -41,6 +41,10 @@ BOOST_PYTHON_DECL bool handle_exception_impl(function0<void> f)
     {
         PyErr_SetString(PyExc_IndexError, x.what());
     }
+    catch(const std::invalid_argument& x)
+    {
+        PyErr_SetString(PyExc_ValueError, x.what());
+    }
     catch(const std::exception& x)
     {
         PyErr_SetString(PyExc_RuntimeError, x.what());

src/exec.cpp

@@ -5,6 +5,7 @@
 
 #include <boost/python/exec.hpp>
 #include <boost/python/borrowed.hpp>
+#include <boost/python/dict.hpp>
 #include <boost/python/extract.hpp>
 #include <boost/python/handle.hpp>
 
@@ -15,6 +16,15 @@ namespace python
 
 object BOOST_PYTHON_DECL eval(str string, object global, object local)
 {
+  // Set suitable default values for global and local dicts.
+  if (global.is_none())
+  {
+    if (PyObject *g = PyEval_GetGlobals())
+      global = object(detail::borrowed_reference(g));
+    else
+      global = dict();
+  }
+  if (local.is_none()) local = global;
   // should be 'char const *' but older python versions don't use 'const' yet.
   char *s = python::extract<char *>(string);
   PyObject* result = PyRun_String(s, Py_eval_input, global.ptr(), local.ptr());
@@ -24,6 +34,15 @@ object BOOST_PYTHON_DECL eval(str string, object global, object local)
 
 object BOOST_PYTHON_DECL exec(str string, object global, object local)
 {
+  // Set suitable default values for global and local dicts.
+  if (global.is_none())
+  {
+    if (PyObject *g = PyEval_GetGlobals())
+      global = object(detail::borrowed_reference(g));
+    else
+      global = dict();
+  }
+  if (local.is_none()) local = global;
   // should be 'char const *' but older python versions don't use 'const' yet.
   char *s = python::extract<char *>(string);
   PyObject* result = PyRun_String(s, Py_file_input, global.ptr(), local.ptr());
@@ -31,21 +50,58 @@ object BOOST_PYTHON_DECL exec(str string, object global, object local)
   return object(detail::new_reference(result));
 }
 
+object BOOST_PYTHON_DECL exec_statement(str string, object global, object local)
+{
+  // Set suitable default values for global and local dicts.
+  if (global.is_none())
+  {
+    if (PyObject *g = PyEval_GetGlobals())
+      global = object(detail::borrowed_reference(g));
+    else
+      global = dict();
+  }
+  if (local.is_none()) local = global;
+  // should be 'char const *' but older python versions don't use 'const' yet.
+  char *s = python::extract<char *>(string);
+  PyObject* result = PyRun_String(s, Py_single_input, global.ptr(), local.ptr());
+  if (!result) throw_error_already_set();
+  return object(detail::new_reference(result));
+}
+
 // Execute python source code from file filename.
 // global and local are the global and local scopes respectively,
 // used during execution.
 object BOOST_PYTHON_DECL exec_file(str filename, object global, object local)
 {
+  // Set suitable default values for global and local dicts.
+  if (global.is_none())
+  {
+    if (PyObject *g = PyEval_GetGlobals())
+      global = object(detail::borrowed_reference(g));
+    else
+      global = dict();
+  }
+  if (local.is_none()) local = global;
   // should be 'char const *' but older python versions don't use 'const' yet.
   char *f = python::extract<char *>(filename);
+
   // Let python open the file to avoid potential binary incompatibilities.
-  PyObject *pyfile = PyFile_FromString(f, "r");
+#if PY_VERSION_HEX >= 0x03000000
+  // See http://www.codeproject.com/Articles/820116/Embedding-Python-program-in-a-C-Cplusplus-code
+  FILE *fs = _Py_fopen(f, "r");
+#else
+  PyObject *pyfile = PyFile_FromString(f, const_cast<char*>("r"));
   if (!pyfile) throw std::invalid_argument(std::string(f) + " : no such file");
   python::handle<> file(pyfile);
-  PyObject* result = PyRun_File(PyFile_AsFile(file.get()),
+  FILE *fs = PyFile_AsFile(file.get());
+#endif
+
+  int closeit = 1;  // Close file before PyRun returns
+  PyObject* result = PyRun_FileEx(fs,
                 f,
                 Py_file_input,
-                global.ptr(), local.ptr());
+                global.ptr(), local.ptr(),
+                closeit);
   if (!result) throw_error_already_set();
   return object(detail::new_reference(result));
 }

src/list.cpp

@@ -13,7 +13,7 @@ detail::new_non_null_reference list_base::call(object const& arg_)
     return (detail::new_non_null_reference)
         (expect_non_null)(
             PyObject_CallFunction(
-                (PyObject*)&PyList_Type, "(O)", 
+                (PyObject*)&PyList_Type, const_cast<char*>("(O)"), 
                 arg_.ptr()));
 }
 
@@ -48,7 +48,11 @@ void list_base::extend(object_cref sequence)
 long list_base::index(object_cref value) const
 {
     object result_obj(this->attr("index")(value));
+#if PY_VERSION_HEX >= 0x03000000
+    ssize_t result = PyLong_AsSsize_t(result_obj.ptr());
+#else
     long result = PyInt_AsLong(result_obj.ptr());
+#endif
     if (result == -1)
         throw_error_already_set();
     return result;
@@ -69,7 +73,11 @@ void list_base::insert(ssize_t index, object_cref item)
 
 void list_base::insert(object const& index, object_cref x)
 {
+#if PY_VERSION_HEX >= 0x03000000
+    ssize_t index_ = PyLong_AsSsize_t(index.ptr());
+#else
     long index_ = PyInt_AsLong(index.ptr());
+#endif
     if (index_ == -1 && PyErr_Occurred())
         throw_error_already_set();
     this->insert(index_, x);
@@ -121,17 +129,29 @@ void list_base::sort()
     }
 }
 
+#if PY_VERSION_HEX >= 0x03000000
+void list_base::sort(args_proxy const &args, 
+                     kwds_proxy const &kwds)
+{
+    this->attr("sort")(args, kwds);
+}
+#else
 void list_base::sort(object_cref cmpfunc)
 {
     this->attr("sort")(cmpfunc);
 }
+#endif
 
 // For some reason, moving this to the end of the TU suppresses an ICE
 // with vc6.
-long list_base::count(object_cref value) const
+ssize_t list_base::count(object_cref value) const
 {
     object result_obj(this->attr("count")(value));
+#if PY_VERSION_HEX >= 0x03000000
+    ssize_t result = PyLong_AsSsize_t(result_obj.ptr());
+#else
     long result = PyInt_AsLong(result_obj.ptr());
+#endif
     if (result == -1)
         throw_error_already_set();
     return result;

src/long.cpp

@@ -9,21 +9,21 @@ namespace boost { namespace python { namespace detail {
 new_non_null_reference long_base::call(object const& arg_)
 {
     return (detail::new_non_null_reference)PyObject_CallFunction(
-        (PyObject*)&PyLong_Type, "(O)", 
+        (PyObject*)&PyLong_Type, const_cast<char*>("(O)"), 
         arg_.ptr());
 }
 
 new_non_null_reference long_base::call(object const& arg_, object const& base)
 {
     return (detail::new_non_null_reference)PyObject_CallFunction(
-        (PyObject*)&PyLong_Type, "(OO)", 
+        (PyObject*)&PyLong_Type, const_cast<char*>("(OO)"), 
         arg_.ptr(), base.ptr());
 }
 
 long_base::long_base()
     : object(
         detail::new_reference(
-            PyObject_CallFunction((PyObject*)&PyLong_Type, "()"))
+            PyObject_CallFunction((PyObject*)&PyLong_Type, const_cast<char*>("()")))
         )
 {}
 

src/module.cpp

@@ -11,6 +11,23 @@
 
 namespace boost { namespace python { namespace detail {
 
+namespace
+{
+    PyObject* init_module_in_scope(PyObject* m, void(*init_function)())
+    {
+        if (m != 0)
+        {
+            // Create the current module scope
+            object m_obj(((borrowed_reference_t*)m));
+            scope current_module(m_obj);
+
+            handle_exception(init_function);
+        }
+
+        return m;
+    }
+}
+
 BOOST_PYTHON_DECL void scope_setattr_doc(char const* name, object const& x, char const* doc)
 {
     // Use function::add_to_namespace to achieve overloading if
@@ -19,27 +36,31 @@ BOOST_PYTHON_DECL void scope_setattr_doc(char const* name, object const& x, char
     objects::add_to_namespace(current, name, x, doc);
 }
 
+#if PY_VERSION_HEX >= 0x03000000
+
+BOOST_PYTHON_DECL PyObject* init_module(PyModuleDef& moduledef, void(*init_function)())
+{
+    return init_module_in_scope(
+        PyModule_Create(&moduledef),
+        init_function);
+}
+
+#else
+
 namespace
 {
-  PyMethodDef initial_methods[] = { { 0, 0, 0, 0 } };
+    PyMethodDef initial_methods[] = { { 0, 0, 0, 0 } };
 }
 
-BOOST_PYTHON_DECL void init_module(char const* name, void(*init_function)())
+BOOST_PYTHON_DECL PyObject* init_module(char const* name, void(*init_function)())
 {
-    
-    PyObject* m
-        = Py_InitModule(const_cast<char*>(name), initial_methods);
-
-    if (m != 0)
-    {
-        // Create the current module scope
-        object m_obj(((borrowed_reference_t*)m));
-        scope current_module(m_obj);
-        
-        handle_exception(init_function);
-    }
+    return init_module_in_scope(
+        Py_InitModule(const_cast<char*>(name), initial_methods),
+        init_function);
 }
 
+#endif
+
 }}} // namespace boost::python::detail
 
 namespace boost { namespace python {

src/object/class.cpp

@@ -67,14 +67,50 @@ extern "C"
       PyObject *prop_set;
       PyObject *prop_del;
       PyObject *prop_doc;
+      int getter_doc;
   } propertyobject;
 
+  // Copied from Python source and removed the part for setting docstring,
+  // since we don't have a setter for __doc__ and trying to set it will
+  // cause the init fail.
+  static int property_init(PyObject *self, PyObject *args, PyObject *kwds)
+  {
+      PyObject *get = NULL, *set = NULL, *del = NULL, *doc = NULL;
+      static const char *kwlist[] = {"fget", "fset", "fdel", "doc", 0};
+      propertyobject *prop = (propertyobject *)self;
+
+      if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOO:property",
+                  const_cast<char **>(kwlist), &get, &set, &del, &doc))
+          return -1;
+
+      if (get == Py_None)
+          get = NULL;
+      if (set == Py_None)
+          set = NULL;
+      if (del == Py_None)
+          del = NULL;
+
+      Py_XINCREF(get);
+      Py_XINCREF(set);
+      Py_XINCREF(del);
+      Py_XINCREF(doc);
+
+      prop->prop_get = get;
+      prop->prop_set = set;
+      prop->prop_del = del;
+      prop->prop_doc = doc;
+      prop->getter_doc = 0;
+
+      return 0;
+  }
+
+ 
   static PyObject *
   static_data_descr_get(PyObject *self, PyObject * /*obj*/, PyObject * /*type*/)
   {
       propertyobject *gs = (propertyobject *)self;
 
-      return PyObject_CallFunction(gs->prop_get, "()");
+      return PyObject_CallFunction(gs->prop_get, const_cast<char*>("()"));
   }
 
   static int
@@ -95,9 +131,9 @@ extern "C"
           return -1;
       }
       if (value == NULL)
-          res = PyObject_CallFunction(func, "()");
+          res = PyObject_CallFunction(func, const_cast<char*>("()"));
       else
-          res = PyObject_CallFunction(func, "(O)", value);
+          res = PyObject_CallFunction(func, const_cast<char*>("(O)"), value);
       if (res == NULL)
           return -1;
       Py_DECREF(res);
@@ -106,10 +142,9 @@ extern "C"
 }
 
 static PyTypeObject static_data_object = {
-    PyObject_HEAD_INIT(0)//&PyType_Type)
-    0,
-    "Boost.Python.StaticProperty",
-    PyType_Type.tp_basicsize,
+    PyVarObject_HEAD_INIT(NULL, 0)
+    const_cast<char*>("Boost.Python.StaticProperty"),
+    sizeof(propertyobject),
     0,
     0,                                      /* tp_dealloc */
     0,                                      /* tp_print */
@@ -143,11 +178,11 @@ static PyTypeObject static_data_object = {
     static_data_descr_get,                                      /* tp_descr_get */
     static_data_descr_set,                                      /* tp_descr_set */
     0,                                      /* tp_dictoffset */
-    0,                                      /* tp_init */
+    property_init,                                      /* tp_init */
     0,                                      /* tp_alloc */
     0, // filled in with type_new           /* tp_new */
     0, // filled in with __PyObject_GC_Del  /* tp_free */
-    (inquiry)type_is_gc,                    /* tp_is_gc */
+    0,                                      /* tp_is_gc */
     0,                                      /* tp_bases */
     0,                                      /* tp_mro */
     0,                                      /* tp_cache */
@@ -160,17 +195,20 @@ static PyTypeObject static_data_object = {
 
 namespace objects
 {
+#if PY_VERSION_HEX < 0x03000000
+  // XXX Not sure why this run into compiling error in Python 3
   extern "C"
   {
       // This declaration needed due to broken Python 2.2 headers
       extern DL_IMPORT(PyTypeObject) PyProperty_Type;
   }
+#endif
 
   BOOST_PYTHON_DECL PyObject* static_data()
   {
       if (static_data_object.tp_dict == 0)
       {
-          static_data_object.ob_type = &PyType_Type;
+          Py_TYPE(&static_data_object) = &PyType_Type;
           static_data_object.tp_base = &PyProperty_Type;
           if (PyType_Ready(&static_data_object))
               return 0;
@@ -203,16 +241,15 @@ extern "C"
         // If we found a static data descriptor, call it directly to
         // force it to set the static data member
         if (a != 0 && PyObject_IsInstance(a, objects::static_data()))
-            return a->ob_type->tp_descr_set(a, obj, value);
+            return Py_TYPE(a)->tp_descr_set(a, obj, value);
         else
             return PyType_Type.tp_setattro(obj, name, value);
     }
 }
 
 static PyTypeObject class_metatype_object = {
-    PyObject_HEAD_INIT(0)//&PyType_Type)
-    0,
-    "Boost.Python.class",
+    PyVarObject_HEAD_INIT(NULL, 0)
+    const_cast<char*>("Boost.Python.class"),
     PyType_Type.tp_basicsize,
     0,
     0,                                      /* tp_dealloc */
@@ -266,7 +303,7 @@ static PyTypeObject class_metatype_object = {
 // object.
 void instance_holder::install(PyObject* self) throw()
 {
-    assert(self->ob_type->ob_type == &class_metatype_object);
+    assert(PyType_IsSubtype(Py_TYPE(Py_TYPE(self)), &class_metatype_object));
     m_next = ((objects::instance<>*)self)->objects;
     ((objects::instance<>*)self)->objects = this;
 }
@@ -279,7 +316,7 @@ namespace objects
   {
       if (class_metatype_object.tp_dict == 0)
       {
-          class_metatype_object.ob_type = &PyType_Type;
+          Py_TYPE(&class_metatype_object) = &PyType_Type;
           class_metatype_object.tp_base = &PyType_Type;
           if (PyType_Ready(&class_metatype_object))
               return type_handle();
@@ -308,7 +345,7 @@ namespace objects
 
           Py_XDECREF(kill_me->dict);
           
-          inst->ob_type->tp_free(inst);
+          Py_TYPE(inst)->tp_free(inst);
       }
 
       static PyObject *
@@ -316,9 +353,14 @@ namespace objects
       {
           // Attempt to find the __instance_size__ attribute. If not present, no problem.
           PyObject* d = type_->tp_dict;
-          PyObject* instance_size_obj = PyObject_GetAttrString(d, "__instance_size__");
+          PyObject* instance_size_obj = PyObject_GetAttrString(d, const_cast<char*>("__instance_size__"));
 
-          long instance_size = instance_size_obj ? PyInt_AsLong(instance_size_obj) : 0;
+          ssize_t instance_size = instance_size_obj ? 
+#if PY_VERSION_HEX >= 0x03000000
+              PyLong_AsSsize_t(instance_size_obj) : 0;
+#else
+              PyInt_AsLong(instance_size_obj) : 0;
+#endif
           
           if (instance_size < 0)
               instance_size = 0;
@@ -332,7 +374,12 @@ namespace objects
               // like, so we'll store the total size of the object
               // there. A negative number indicates that the extra
               // instance memory is not yet allocated to any holders.
-              result->ob_size = -(static_cast<int>(offsetof(instance<>,storage) + instance_size));
+#if PY_VERSION_HEX >= 0x02060000
+              Py_SIZE(result) =
+#else
+              result->ob_size =
+#endif
+                  -(static_cast<int>(offsetof(instance<>,storage) + instance_size));
           }
           return (PyObject*)result;
       }
@@ -357,20 +404,19 @@ namespace objects
 
 
   static PyGetSetDef instance_getsets[] = {
-      {"__dict__",  instance_get_dict,  instance_set_dict, NULL, 0},
+      {const_cast<char*>("__dict__"),  instance_get_dict,  instance_set_dict, NULL, 0},
       {0, 0, 0, 0, 0}
   };
 
   
   static PyMemberDef instance_members[] = {
-      {"__weakref__", T_OBJECT, offsetof(instance<>, weakrefs), 0, 0},
+      {const_cast<char*>("__weakref__"), T_OBJECT, offsetof(instance<>, weakrefs), 0, 0},
       {0, 0, 0, 0, 0}
   };
 
   static PyTypeObject class_type_object = {
-      PyObject_HEAD_INIT(0) //&class_metatype_object)
-      0,
-      "Boost.Python.instance",
+      PyVarObject_HEAD_INIT(NULL, 0)
+      const_cast<char*>("Boost.Python.instance"),
       offsetof(instance<>,storage),           /* tp_basicsize */
       1,                                      /* tp_itemsize */
       instance_dealloc,                       /* tp_dealloc */
@@ -424,7 +470,7 @@ namespace objects
   {
       if (class_type_object.tp_dict == 0)
       {
-          class_type_object.ob_type = incref(class_metatype().get());
+          Py_TYPE(&class_type_object) = incref(class_metatype().get());
           class_type_object.tp_base = &PyBaseObject_Type;
           if (PyType_Ready(&class_type_object))
               return type_handle();
@@ -436,7 +482,8 @@ namespace objects
   BOOST_PYTHON_DECL void*
   find_instance_impl(PyObject* inst, type_info type, bool null_shared_ptr_only)
   {
-      if (inst->ob_type->ob_type != &class_metatype_object)
+      if (!Py_TYPE(Py_TYPE(inst)) ||
+              !PyType_IsSubtype(Py_TYPE(Py_TYPE(inst)), &class_metatype_object))
           return 0;
     
       instance<>* self = reinterpret_cast<instance<>*>(inst);
@@ -506,13 +553,12 @@ namespace objects
       // Build a tuple of the base Python type objects. If no bases
       // were declared, we'll use our class_type() as the single base
       // class.
-      std::size_t const num_bases = (std::max)(num_types - 1, static_cast<std::size_t>(1));
-      assert(num_bases <= ssize_t_max);
-      handle<> bases(PyTuple_New(static_cast<ssize_t>(num_bases)));
+      ssize_t const num_bases = (std::max)(num_types - 1, static_cast<std::size_t>(1));
+      handle<> bases(PyTuple_New(num_bases));
 
-      for (std::size_t i = 1; i <= num_bases; ++i)
+      for (ssize_t i = 1; i <= num_bases; ++i)
       {
-          type_handle c = (i >= num_types) ? class_type() : get_class(types[i]);
+          type_handle c = (i >= static_cast<ssize_t>(num_types)) ? class_type() : get_class(types[i]);
           // PyTuple_SET_ITEM steals this reference
           PyTuple_SET_ITEM(bases.get(), static_cast<ssize_t>(i - 1), upcast<PyObject>(c.release()));
       }
@@ -527,7 +573,7 @@ namespace objects
           d["__doc__"] = doc;
       
       object result = object(class_metatype())(name, bases, d);
-      assert(PyType_IsSubtype(result.ptr()->ob_type, &PyType_Type));
+      assert(PyType_IsSubtype(Py_TYPE(result.ptr()), &PyType_Type));
       
       if (scope().ptr() != Py_None)
           scope().attr(name) = result;
@@ -572,7 +618,7 @@ namespace objects
   {
       object property(
           (python::detail::new_reference)
-              PyObject_CallFunction((PyObject*)&PyProperty_Type, "Osss", fget.ptr(), 0, 0, docstr));
+          PyObject_CallFunction((PyObject*)&PyProperty_Type, const_cast<char*>("Osss"), fget.ptr(), 0, 0, docstr));
       
       this->setattr(name, property);
   }
@@ -582,7 +628,7 @@ namespace objects
   {
       object property(
           (python::detail::new_reference)
-              PyObject_CallFunction((PyObject*)&PyProperty_Type, "OOss", fget.ptr(), fset.ptr(), 0, docstr));
+          PyObject_CallFunction((PyObject*)&PyProperty_Type, const_cast<char*>("OOss"), fget.ptr(), fset.ptr(), 0, docstr));
       
       this->setattr(name, property);
   }
@@ -590,8 +636,9 @@ namespace objects
   void class_base::add_static_property(char const* name, object const& fget)
   {
       object property(
-          (python::detail::new_reference)
-          PyObject_CallFunction(static_data(), "O", fget.ptr()));
+          (python::detail::new_reference) 
+          PyObject_CallFunction(static_data(), const_cast<char*>("O"), fget.ptr())
+          );
       
       this->setattr(name, property);
   }
@@ -600,7 +647,7 @@ namespace objects
   {
       object property(
           (python::detail::new_reference)
-          PyObject_CallFunction(static_data(), "OO", fget.ptr(), fset.ptr()));
+          PyObject_CallFunction(static_data(), const_cast<char*>("OO"), fget.ptr(), fset.ptr()));
       
       this->setattr(name, property);
   }
@@ -615,13 +662,13 @@ namespace objects
   {
     extern "C" PyObject* no_init(PyObject*, PyObject*)
     {
-        ::PyErr_SetString(::PyExc_RuntimeError, "This class cannot be instantiated from Python");
+        ::PyErr_SetString(::PyExc_RuntimeError, const_cast<char*>("This class cannot be instantiated from Python"));
         return NULL;
     }
     static ::PyMethodDef no_init_def = {
-        "__init__", no_init, METH_VARARGS,
-        "Raises an exception\n"
-        "This class cannot be instantiated from Python\n"
+        const_cast<char*>("__init__"), no_init, METH_VARARGS,
+        const_cast<char*>("Raises an exception\n"
+                          "This class cannot be instantiated from Python\n")
     };
   }
   
@@ -650,8 +697,8 @@ namespace objects
 
         ::PyErr_Format(
             PyExc_TypeError
-            , "staticmethod expects callable object; got an object of type %s, which is not callable"
-            , callable->ob_type->tp_name
+          , const_cast<char*>("staticmethod expects callable object; got an object of type %s, which is not callable")
+            , Py_TYPE(callable)->tp_name
             );
         
         throw_error_already_set();
@@ -681,18 +728,18 @@ namespace objects
 
 void* instance_holder::allocate(PyObject* self_, std::size_t holder_offset, std::size_t holder_size)
 {
-    assert(self_->ob_type->ob_type == &class_metatype_object);
+    assert(PyType_IsSubtype(Py_TYPE(Py_TYPE(self_)), &class_metatype_object));
     objects::instance<>* self = (objects::instance<>*)self_;
     
     int total_size_needed = holder_offset + holder_size;
     
-    if (-self->ob_size >= total_size_needed)
+    if (-Py_SIZE(self) >= total_size_needed)
     {
         // holder_offset should at least point into the variable-sized part
         assert(holder_offset >= offsetof(objects::instance<>,storage));
 
         // Record the fact that the storage is occupied, noting where it starts
-        self->ob_size = holder_offset;
+        Py_SIZE(self) = holder_offset;
         return (char*)self + holder_offset;
     }
     else
@@ -706,9 +753,9 @@ void* instance_holder::allocate(PyObject* self_, std::size_t holder_offset, std:
 
 void instance_holder::deallocate(PyObject* self_, void* storage) throw()
 {
-    assert(self_->ob_type->ob_type == &class_metatype_object);
+    assert(PyType_IsSubtype(Py_TYPE(Py_TYPE(self_)), &class_metatype_object));
     objects::instance<>* self = (objects::instance<>*)self_;
-    if (storage != (char*)self + self->ob_size)
+    if (storage != (char*)self + Py_SIZE(self))
     {
         PyMem_Free(storage);
     }

src/object/enum.cpp

@@ -14,16 +14,20 @@
 #include <boost/python/object_protocol.hpp>
 #include <structmember.h>
 
-namespace boost { namespace python { namespace objects { 
+namespace boost { namespace python { namespace objects {
 
 struct enum_object
 {
+#if PY_VERSION_HEX >= 0x03000000
+    PyLongObject base_object;
+#else
     PyIntObject base_object;
+#endif
     PyObject* name;
 };
 
 static PyMemberDef enum_members[] = {
-    {"name", T_OBJECT_EX, offsetof(enum_object,name),READONLY, 0},
+    {const_cast<char*>("name"), T_OBJECT_EX, offsetof(enum_object,name),READONLY, 0},
     {0, 0, 0, 0, 0}
 };
 
@@ -32,19 +36,32 @@ extern "C"
 {
     static PyObject* enum_repr(PyObject* self_)
     {
-        const char *mod = PyString_AsString(PyObject_GetAttrString( self_, "__module__"));
+        // XXX(bhy) Potentional memory leak here since PyObject_GetAttrString returns a new reference
+        // const char *mod = PyString_AsString(PyObject_GetAttrString( self_, const_cast<char*>("__module__")));
+        PyObject *mod = PyObject_GetAttrString( self_, "__module__");
         enum_object* self = downcast<enum_object>(self_);
         if (!self->name)
         {
-            return PyString_FromFormat("%s.%s(%ld)", mod, self_->ob_type->tp_name, PyInt_AS_LONG(self_));
+            return
+#if PY_VERSION_HEX >= 0x03000000
+                PyUnicode_FromFormat("%S.%s(%ld)", mod, self_->ob_type->tp_name, PyLong_AsLong(self_));
+#else
+                PyString_FromFormat("%s.%s(%ld)", PyString_AsString(mod), self_->ob_type->tp_name, PyInt_AS_LONG(self_));
+#endif
         }
         else
         {
-            char* name = PyString_AsString(self->name);
+            PyObject* name = self->name;
             if (name == 0)
                 return 0;
-            
-            return PyString_FromFormat("%s.%s.%s", mod, self_->ob_type->tp_name, name);
+
+            return
+#if PY_VERSION_HEX >= 0x03000000
+                PyUnicode_FromFormat("%S.%s.%S", mod, self_->ob_type->tp_name, name);
+#else
+                PyString_FromFormat("%s.%s.%s", 
+                        PyString_AsString(mod), self_->ob_type->tp_name, PyString_AsString(name));
+#endif
         }
     }
 
@@ -53,7 +70,11 @@ extern "C"
         enum_object* self = downcast<enum_object>(self_);
         if (!self->name)
         {
+#if PY_VERSION_HEX >= 0x03000000
+            return PyLong_Type.tp_str(self_);
+#else
             return PyInt_Type.tp_str(self_);
+#endif
         }
         else
         {
@@ -63,9 +84,8 @@ extern "C"
 }
 
 static PyTypeObject enum_type_object = {
-    PyObject_HEAD_INIT(0) // &PyType_Type
-    0,
-    "Boost.Python.enum",
+    PyVarObject_HEAD_INIT(NULL, 0) // &PyType_Type
+    const_cast<char*>("Boost.Python.enum"),
     sizeof(enum_object),                    /* tp_basicsize */
     0,                                      /* tp_itemsize */
     0,                                      /* tp_dealloc */
@@ -84,7 +104,9 @@ static PyTypeObject enum_type_object = {
     0,                                      /* tp_setattro */
     0,                                      /* tp_as_buffer */
     Py_TPFLAGS_DEFAULT
+#if PY_VERSION_HEX < 0x03000000
     | Py_TPFLAGS_CHECKTYPES
+#endif
     | Py_TPFLAGS_HAVE_GC
     | Py_TPFLAGS_BASETYPE,                  /* tp_flags */
     0,                                      /* tp_doc */
@@ -125,8 +147,12 @@ namespace
   {
       if (enum_type_object.tp_dict == 0)
       {
-          enum_type_object.ob_type = incref(&PyType_Type);
+          Py_TYPE(&enum_type_object) = incref(&PyType_Type);
+#if PY_VERSION_HEX >= 0x03000000
+          enum_type_object.tp_base = &PyLong_Type;
+#else
           enum_type_object.tp_base = &PyInt_Type;
+#endif
           if (PyType_Ready(&enum_type_object))
               throw_error_already_set();
       }
@@ -139,15 +165,16 @@ namespace
       dict d;
       d["__slots__"] = tuple();
       d["values"] = dict();
+      d["names"] = dict();
 
       object module_name = module_prefix();
       if (module_name)
          d["__module__"] = module_name;
       if (doc)
          d["__doc__"] = doc;
-      
+
       object result = (object(metatype))(name, make_tuple(base), d);
-      
+
       scope().attr(name) = result;
 
       return result;
@@ -167,7 +194,7 @@ enum_base::enum_base(
     converter::registration& converters
         = const_cast<converter::registration&>(
             converter::registry::lookup(id));
-            
+
     converters.m_class_object = downcast<PyTypeObject>(this->ptr());
     converter::registry::insert(to_python, id);
     converter::registry::insert(convertible, construct, id);
@@ -186,23 +213,24 @@ void enum_base::add_value(char const* name_, long value)
 
     dict d = extract<dict>(this->attr("values"))();
     d[value] = x;
-    
+
     // Set the name field in the new enum instanec
     enum_object* p = downcast<enum_object>(x.ptr());
     Py_XDECREF(p->name);
     p->name = incref(name.ptr());
+
+    dict names_dict = extract<dict>(this->attr("names"))();
+    names_dict[x.attr("name")] = x;
 }
 
 void enum_base::export_values()
 {
-    dict d = extract<dict>(this->attr("values"))();
-    list values = d.values();
+    dict d = extract<dict>(this->attr("names"))();
+    list items = d.items();
     scope current;
-    
-    for (unsigned i = 0, max = len(values); i < max; ++i)
-    {
-        api::setattr(current, object(values[i].attr("name")), values[i]);
-    }
+
+    for (unsigned i = 0, max = len(items); i < max; ++i)
+        api::setattr(current, items[i][0], items[i][1]);
  }
 
 PyObject* enum_base::to_python(PyTypeObject* type_, long x)