minor updates

[SVN r24135]

doc/tutorial/doc/quickstart.txt

@@ -1458,10 +1458,10 @@ The former returns a reference to an already imported module, the latter
 retrieves a module's namespace dictionary. Let's use them to retrieve the
 namespace of the [^__main__] module:
 
-    object main_module(
-        handle<>(borrowed(PyImport_AddModule("__main__"))));
-    object main_namespace = main_module.attr("__dict__");
+    object main_module((
+        handle<>(borrowed(PyImport_AddModule("__main__")))));
 
+    object main_namespace = main_module.attr("__dict__");
 
 For a function returning a ['new reference] we can just create a [^handle]
 out of the raw [^PyObject*] without wrapping it in a call to borrowed. One
@@ -1510,12 +1510,12 @@ For most intents and purposes you can use the namespace dictionary of the
 We have already seen how to get the [^__main__] module's namespace so let's
 run some Python code in it:
 
-    object main_module(
-        handle<>(borrowed(PyImport_AddModule("__main__"))));
+    object main_module((
+        handle<>(borrowed(PyImport_AddModule("__main__")))));
 
     object main_namespace = main_module.attr("__dict__");
 
-    handle<>(PyRun_String(
+    handle<> ignored((PyRun_String(
 
         "hello = file('hello.txt', 'w')\n"
         "hello.write('Hello world!')\n"
@@ -1524,7 +1524,7 @@ run some Python code in it:
       , Py_file_input
       , main_namespace.ptr()
       , main_namespace.ptr())
-    );
+    ));
 
 Because the Python/C API doesn't know anything about [^object]s, we used
 the object's [^ptr] member function to retrieve the [^PyObject*].
@@ -1547,33 +1547,34 @@ named [^object] class and it's derivatives. We've already seen that they
 can be constructed from a [^handle]. The following examples should further
 illustrate this fact:
 
-    object main_module(
-        handle<>(borrowed(PyImport_AddModule("__main__"))));
+    object main_module((
+         handle<>(borrowed(PyImport_AddModule("__main__")))));
 
     object main_namespace = main_module.attr("__dict__");
 
-    handle<>(PyRun_String(
+    handle<> ignored((PyRun_String(
 
         "result = 5 ** 2"
 
         , Py_file_input
         , main_namespace.ptr()
         , main_namespace.ptr())
-    );
+    ));
 
-    int five_squared = extract<int>(main_namespace["result"] );
+    int five_squared = extract<int>(main_namespace["result"]);
 
 Here we create a dictionary object for the [^__main__] module's namespace.
 Then we assign 5 squared to the result variable and read this variable from
 the dictionary. Another way to achieve the same result is to let
 PyRun_String return the result directly with Py_eval_input:
 
-    object result(handle<>(PyRun_String(
-        "5 ** 2"
-      , Py_eval_input
-      , main_namespace.ptr()
-      , main_namespace.ptr()))
-    );
+    object result((handle<>(
+        PyRun_String("5 ** 2"
+            , Py_eval_input
+            , main_namespace.ptr()
+            , main_namespace.ptr()))
+    ));
+
     int five_squared = extract<int>(result);
 
 __note__ [*Note] that [^object]'s member function to return the wrapped
@@ -1587,12 +1588,12 @@ If an exception occurs in the execution of some Python code, the PyRun_String fu
 
     try
     {
-        object result(handle<>(PyRun_String(
+        object result((handle<>(PyRun_String(
             "5/0"
           , Py_eval_input
           , main_namespace.ptr()
           , main_namespace.ptr()))
-        );
+        ));
 
         // execution will never get here:
         int five_divided_by_zero = extract<int>(result);
@@ -1621,11 +1622,11 @@ The [^error_already_set] exception class doesn't carry any information in itself
 
 If you'd rather not have [^handle] throw a C++ exception when it is constructed, you can use the [@../../v2/handle.html#allow_null-spec allow_null] function in the same way you'd use borrowed:
 
-    handle<> result(allow_null(PyRun_String(
+    handle<> result((allow_null(PyRun_String(
         "5/0"
        , Py_eval_input
        , main_namespace.ptr()
-       , main_namespace.ptr())));
+       , main_namespace.ptr()))));
 
     if (!result)
         // Python exception occurred

doc/tutorial/doc/using_the_interpreter.html

@@ -54,8 +54,9 @@ The former returns a reference to an already imported module, the latter
 retrieves a module's namespace dictionary. Let's use them to retrieve the
 namespace of the <tt>__main__</tt> module:</p>
 <code><pre>
-    <span class=identifier>object </span><span class=identifier>main_module</span><span class=special>(
-        </span><span class=identifier>handle</span><span class=special>&lt;&gt;(</span><span class=identifier>borrowed</span><span class=special>(</span><span class=identifier>PyImport_AddModule</span><span class=special>(</span><span class=string>&quot;__main__&quot;</span><span class=special>))));
+    <span class=identifier>object </span><span class=identifier>main_module</span><span class=special>((
+        </span><span class=identifier>handle</span><span class=special>&lt;&gt;(</span><span class=identifier>borrowed</span><span class=special>(</span><span class=identifier>PyImport_AddModule</span><span class=special>(</span><span class=string>&quot;__main__&quot;</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>&quot;__dict__&quot;</span><span class=special>);
 </span></pre></code>
 <p>
@@ -117,12 +118,12 @@ For most intents and purposes you can use the namespace dictionary of the
 We have already seen how to get the <tt>__main__</tt> module's namespace so let's
 run some Python code in it:</p>
 <code><pre>
-    <span class=identifier>object </span><span class=identifier>main_module</span><span class=special>(
-        </span><span class=identifier>handle</span><span class=special>&lt;&gt;(</span><span class=identifier>borrowed</span><span class=special>(</span><span class=identifier>PyImport_AddModule</span><span class=special>(</span><span class=string>&quot;__main__&quot;</span><span class=special>))));
+    <span class=identifier>object </span><span class=identifier>main_module</span><span class=special>((
+        </span><span class=identifier>handle</span><span class=special>&lt;&gt;(</span><span class=identifier>borrowed</span><span class=special>(</span><span class=identifier>PyImport_AddModule</span><span class=special>(</span><span class=string>&quot;__main__&quot;</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>&quot;__dict__&quot;</span><span class=special>);
 
-    </span><span class=identifier>handle</span><span class=special>&lt;&gt;(</span><span class=identifier>PyRun_String</span><span class=special>(
+    </span><span class=identifier>handle</span><span class=special>&lt;&gt; </span><span class=identifier>ignored</span><span class=special>((</span><span class=identifier>PyRun_String</span><span class=special>(
 
         </span><span class=string>&quot;hello = file('hello.txt', 'w')\n&quot;
         </span><span class=string>&quot;hello.write('Hello world!')\n&quot;
@@ -131,7 +132,7 @@ run some Python code in it:</p>
       </span><span class=special>, </span><span class=identifier>Py_file_input
       </span><span class=special>, </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>ptr</span><span class=special>()
       , </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>ptr</span><span class=special>())
-    );
+    ));
 </span></pre></code>
 <p>
 Because the Python/C API doesn't know anything about <tt>object</tt>s, we used
@@ -155,21 +156,21 @@ named <tt>object</tt> class and it's derivatives. We've already seen that they
 can be constructed from a <tt>handle</tt>. The following examples should further
 illustrate this fact:</p>
 <code><pre>
-    <span class=identifier>object </span><span class=identifier>main_module</span><span class=special>(
-        </span><span class=identifier>handle</span><span class=special>&lt;&gt;(</span><span class=identifier>borrowed</span><span class=special>(</span><span class=identifier>PyImport_AddModule</span><span class=special>(</span><span class=string>&quot;__main__&quot;</span><span class=special>))));
+    <span class=identifier>object </span><span class=identifier>main_module</span><span class=special>((
+         </span><span class=identifier>handle</span><span class=special>&lt;&gt;(</span><span class=identifier>borrowed</span><span class=special>(</span><span class=identifier>PyImport_AddModule</span><span class=special>(</span><span class=string>&quot;__main__&quot;</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>&quot;__dict__&quot;</span><span class=special>);
 
-    </span><span class=identifier>handle</span><span class=special>&lt;&gt;(</span><span class=identifier>PyRun_String</span><span class=special>(
+    </span><span class=identifier>handle</span><span class=special>&lt;&gt; </span><span class=identifier>ignored</span><span class=special>((</span><span class=identifier>PyRun_String</span><span class=special>(
 
         </span><span class=string>&quot;result = 5 ** 2&quot;
 
         </span><span class=special>, </span><span class=identifier>Py_file_input
         </span><span class=special>, </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>ptr</span><span class=special>()
         , </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>ptr</span><span class=special>())
-    );
+    ));
 
-    </span><span class=keyword>int </span><span class=identifier>five_squared </span><span class=special>= </span><span class=identifier>extract</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;(</span><span class=identifier>main_namespace</span><span class=special>[</span><span class=string>&quot;result&quot;</span><span class=special>] );
+    </span><span class=keyword>int </span><span class=identifier>five_squared </span><span class=special>= </span><span class=identifier>extract</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;(</span><span class=identifier>main_namespace</span><span class=special>[</span><span class=string>&quot;result&quot;</span><span class=special>]);
 </span></pre></code>
 <p>
 Here we create a dictionary object for the <tt>__main__</tt> module's namespace.
@@ -179,12 +180,13 @@ the dictionary. Another way to achieve the same result is to let
 PyRun_String</a> return the result directly with <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-58">
 Py_eval_input</a>:</p>
 <code><pre>
-    <span class=identifier>object </span><span class=identifier>result</span><span class=special>(</span><span class=identifier>handle</span><span class=special>&lt;&gt;(</span><span class=identifier>PyRun_String</span><span class=special>(
-        </span><span class=string>&quot;5 ** 2&quot;
-      </span><span class=special>, </span><span class=identifier>Py_eval_input
-      </span><span class=special>, </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>ptr</span><span class=special>()
-      , </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>ptr</span><span class=special>()))
-    );
+    <span class=identifier>object </span><span class=identifier>result</span><span class=special>((</span><span class=identifier>handle</span><span class=special>&lt;&gt;(
+        </span><span class=identifier>PyRun_String</span><span class=special>(</span><span class=string>&quot;5 ** 2&quot;
+            </span><span class=special>, </span><span class=identifier>Py_eval_input
+            </span><span class=special>, </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>ptr</span><span class=special>()
+            , </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>ptr</span><span class=special>()))
+    ));
+
     </span><span class=keyword>int </span><span class=identifier>five_squared </span><span class=special>= </span><span class=identifier>extract</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;(</span><span class=identifier>result</span><span class=special>);
 </span></pre></code>
 <p>
@@ -199,12 +201,12 @@ error_already_set</a>, so basically, the Python exception is automatically trans
 <code><pre>
     <span class=keyword>try
     </span><span class=special>{
-        </span><span class=identifier>object </span><span class=identifier>result</span><span class=special>(</span><span class=identifier>handle</span><span class=special>&lt;&gt;(</span><span class=identifier>PyRun_String</span><span class=special>(
+        </span><span class=identifier>object </span><span class=identifier>result</span><span class=special>((</span><span class=identifier>handle</span><span class=special>&lt;&gt;(</span><span class=identifier>PyRun_String</span><span class=special>(
             </span><span class=string>&quot;5/0&quot;
           </span><span class=special>, </span><span class=identifier>Py_eval_input
           </span><span class=special>, </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>ptr</span><span class=special>()
           , </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>ptr</span><span class=special>()))
-        );
+        ));
 
         // </span><span class=identifier>execution </span><span class=identifier>will </span><span class=identifier>never </span><span class=identifier>get </span><span class=identifier>here</span><span class=special>:
         </span><span class=keyword>int </span><span class=identifier>five_divided_by_zero </span><span class=special>= </span><span class=identifier>extract</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;(</span><span class=identifier>result</span><span class=special>);
@@ -240,11 +242,11 @@ here</a>.)</p>
 If you'd rather not have <tt>handle</tt> throw a C++ exception when it is constructed, you can use the <a href="../../v2/handle.html#allow_null-spec">
 allow_null</a> function in the same way you'd use borrowed:</p>
 <code><pre>
-    <span class=identifier>handle</span><span class=special>&lt;&gt; </span><span class=identifier>result</span><span class=special>(</span><span class=identifier>allow_null</span><span class=special>(</span><span class=identifier>PyRun_String</span><span class=special>(
+    <span class=identifier>handle</span><span class=special>&lt;&gt; </span><span class=identifier>result</span><span class=special>((</span><span class=identifier>allow_null</span><span class=special>(</span><span class=identifier>PyRun_String</span><span class=special>(
         </span><span class=string>&quot;5/0&quot;
        </span><span class=special>, </span><span class=identifier>Py_eval_input
        </span><span class=special>, </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>ptr</span><span class=special>()
-       , </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>ptr</span><span class=special>())));
+       , </span><span class=identifier>main_namespace</span><span class=special>.</span><span class=identifier>ptr</span><span class=special>()))));
 
     </span><span class=keyword>if </span><span class=special>(!</span><span class=identifier>result</span><span class=special>)
         // </span><span class=identifier>Python </span><span class=identifier>exception </span><span class=identifier>occurred

doc/tutorial/doc/virtual_functions_with_default_implementations.html

@@ -22,7 +22,7 @@
     <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
     <td width="30"><a href="deriving_a_python_class.html"><img src="theme/l_arr.gif" border="0"></a></td>
     <td width="20"><a href="class_operators_special_functions.html"><img src="theme/r_arr.gif" border="0"></a></td>
-  </tr>
+   </tr>
 </table>
 <p>
 Recall that in the <a href="class_virtual_functions.html">
@@ -63,12 +63,10 @@ Then, Boost.Python needs to keep track of 1) the dispatch function <tt>f</tt> an
 2) the forwarding function to its default implementation <tt>default_f</tt>.
 There's a special <tt>def</tt> function for this purpose. Here's how it is
 applied to our example above:</p>
-<code>
-<pre>
-    <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>Base</span><span class=special>, </span><span class=identifier>BaseWrap</span><span class=special>, </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>noncopyable</span><span class=special>&gt;(</span><span class=string>&quot;Base&quot;</span><span class=special>)
+<code><pre>
+    <span class=identifier>class_</span><span class=special>&lt;</span><span class=identifier>Base</span><span class=special>, </span><span class=identifier>BaseWrap</span><span class=special>, </span><span class=identifier>BaseWrap</span><span class=special>, </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>noncopyable</span><span class=special>&gt;(</span><span class=string>&quot;Base&quot;</span><span class=special>)
         .</span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;f&quot;</span><span class=special>, &amp;</span><span class=identifier>Base</span><span class=special>::</span><span class=identifier>f</span><span class=special>, &amp;</span><span class=identifier>BaseWrap</span><span class=special>::</span><span class=identifier>default_f</span><span class=special>)
-</span></pre>
-</code>
+</span></pre></code>
 <p>
 Note that we are allowing <tt>Base</tt> objects to be instantiated this time,
 unlike before where we specifically defined the <tt>class_&lt;Base&gt;</tt> with
@@ -112,7 +110,7 @@ Calling <tt>call_f</tt>, passing in a <tt>derived</tt> object:</p>
     <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
     <td width="30"><a href="deriving_a_python_class.html"><img src="theme/l_arr.gif" border="0"></a></td>
     <td width="20"><a href="class_operators_special_functions.html"><img src="theme/r_arr.gif" border="0"></a></td>
-  </tr>
+   </tr>
 </table>
 <br>
 <hr size="1"><p class="copyright">Copyright &copy; 2002-2003 David Abrahams<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>