AMK's megapatch:

	* \bcode, \ecode added everywhere
	* \label{module-foo} added everywhere
	* A few \seealso sections added.
	* Indentation fixed inside verbatim in lib*tex files

Doc/lib/libaifc.tex

 \section{Standard Module \sectcode{aifc}}
+\label{module-aifc}
 \stmodindex{aifc}
 
 This module provides support for reading and writing AIFF and AIFF-C

Doc/lib/libal.tex

 \section{Built-in Module \sectcode{al}}
+\label{module-al}
 \bimodindex{al}
 
 This module provides access to the audio facilities of the SGI Indy

Doc/lib/libamoeba.tex

@@ -82,7 +82,7 @@ For example:
 aa:1c:95:52:6a:fa/14(ff)/8e:ba:5b:8:11:1a
 >>> 
 \end{verbatim}\ecode
-
+%
 The following methods are defined for capability objects.
 
 \renewcommand{\indexsubitem}{(capability method)}

Doc/lib/libarray.tex

 \section{Built-in Module \sectcode{array}}
+\label{module-array}
 \bimodindex{array}
 \index{arrays}
 

Doc/lib/libaudioop.tex

 \section{Built-in Module \sectcode{audioop}}
+\label{module-audioop}
 \bimodindex{audioop}
 
 The \code{audioop} module contains some useful operations on sound fragments.
@@ -210,7 +211,7 @@ def mul_stereo(sample, width, lfactor, rfactor):
     rsample = audioop.tostereo(rsample, width, 0, 1)
     return audioop.add(lsample, rsample, width)
 \end{verbatim}\ecode
-
+%
 If you use the ADPCM coder to build network packets and you want your
 protocol to be stateless (i.e.\ to be able to tolerate packet loss)
 you should not only transmit the data but also the state.  Note that

Doc/lib/libbase64.tex

 \section{Standard Module \sectcode{base64}}
+\label{module-base64}
 \stmodindex{base64}
 
 This module perform base-64 encoding and decoding of arbitrary binary

Doc/lib/libbastion.tex

 \section{Standard Module \sectcode{Bastion}}
+\label{module-Bastion}
 \stmodindex{Bastion}
 \renewcommand{\indexsubitem}{(in module Bastion)}
 

Doc/lib/libbinascii.tex

 \section{Standard module \sectcode{binhex}}
+\label{module-binhex}
 \stmodindex{binhex}
 
 This module encodes and decodes files in binhex4 format, a format

Doc/lib/libbltin.tex

 \section{Built-in Module \sectcode{__builtin__}}
+\label{module-builtin}
 \bimodindex{__builtin__}
 
 This module provides direct access to all `built-in' identifiers of

Doc/lib/libcd.tex

 \section{Built-in Module \sectcode{cd}}
+\label{module-cd}
 \bimodindex{cd}
 
 This module provides an interface to the Silicon Graphics CD library.

Doc/lib/libcgi.tex

 \section{Standard Module \sectcode{cgi}}
+\label{module-cgi}
 \stmodindex{cgi}
 \indexii{WWW}{server}
 \indexii{CGI}{protocol}
@@ -39,21 +40,21 @@ by a blank line.  The first section contains a number of headers,
 telling the client what kind of data is following.  Python code to
 generate a minimal header section looks like this:
 
-\begin{verbatim}
-    print "Content-type: text/html"     # HTML is following
-    print                               # blank line, end of headers
-\end{verbatim}
-
+\bcode\begin{verbatim}
+print "Content-type: text/html"     # HTML is following
+print                               # blank line, end of headers
+\end{verbatim}\ecode
+%
 The second section is usually HTML, which allows the client software
 to display nicely formatted text with header, in-line images, etc.
 Here's Python code that prints a simple piece of HTML:
 
-\begin{verbatim}
-    print "<TITLE>CGI script output</TITLE>"
-    print "<H1>This is my first CGI script</H1>"
-    print "Hello, world!"
-\end{verbatim}
-
+\bcode\begin{verbatim}
+print "<TITLE>CGI script output</TITLE>"
+print "<H1>This is my first CGI script</H1>"
+print "Hello, world!"
+\end{verbatim}\ecode
+%
 (It may not be fully legal HTML according to the letter of the
 standard, but any browser will understand it.)
 
@@ -76,19 +77,19 @@ dictionary.  For instance, the following code (which assumes that the
 \code{Content-type} header and blank line have already been printed) checks that 
 the fields \code{name} and \code{addr} are both set to a non-empty string:
 
-\begin{verbatim}
-    form = cgi.FieldStorage()
-    form_ok = 0
-    if form.has_key("name") and form.has_key("addr"):
+\bcode\begin{verbatim}
+form = cgi.FieldStorage()
+form_ok = 0
+if form.has_key("name") and form.has_key("addr"):
     if form["name"].value != "" and form["addr"].value != "":
         form_ok = 1
-    if not form_ok:
+if not form_ok:
     print "<H1>Error</H1>"
     print "Please fill in the name and addr fields."
     return
-    ...further form processing here...
-\end{verbatim}
-
+...further form processing here...
+\end{verbatim}\ecode
+%
 Here the fields, accessed through \code{form[key]}, are themselves instances
 of \code{FieldStorage} (or \code{MiniFieldStorage}, depending on the form encoding).
 
@@ -100,9 +101,9 @@ name), use the \code{type()} function to determine whether you have a single
 instance or a list of instances.  For example, here's code that
 concatenates any number of username fields, separated by commas:
 
-\begin{verbatim}
-    username = form["username"]
-    if type(username) is type([]):
+\bcode\begin{verbatim}
+username = form["username"]
+if type(username) is type([]):
     # Multiple username fields specified
     usernames = ""
     for item in username:
@@ -112,28 +113,28 @@ concatenates any number of username fields, separated by commas:
         else:
             # First item -- don't insert comma
             usernames = item.value
-    else:
+else:
     # Single username field specified
     usernames = username.value
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 If a field represents an uploaded file, the value attribute reads the 
 entire file in memory as a string.  This may not be what you want.  You can 
 test for an uploaded file by testing either the filename attribute or the 
 file attribute.  You can then read the data at leasure from the file 
 attribute:
 
-\begin{verbatim}
-    fileitem = form["userfile"]
-    if fileitem.file:
+\bcode\begin{verbatim}
+fileitem = form["userfile"]
+if fileitem.file:
     # It's an uploaded file; count lines
     linecount = 0
     while 1:
         line = fileitem.file.readline()
         if not line: break
         linecount = linecount + 1
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 The file upload draft standard entertains the possibility of uploading
 multiple files from one field (using a recursive \code{multipart/*}
 encoding).  When this occurs, the item will be a dictionary-like
@@ -251,10 +252,10 @@ Unix file mode should be 755 (use \code{chmod 755 filename}).  Make sure
 that the first line of the script contains \code{\#!} starting in column 1
 followed by the pathname of the Python interpreter, for instance:
 
-\begin{verbatim}
-    #!/usr/local/bin/python
-\end{verbatim}
-
+\bcode\begin{verbatim}
+#!/usr/local/bin/python
+\end{verbatim}\ecode
+%
 Make sure the Python interpreter exists and is executable by ``others''.
 
 Make sure that any files your script needs to read or write are
@@ -273,12 +274,12 @@ If you need to load modules from a directory which is not on Python's
 default module search path, you can change the path in your script,
 before importing other modules, e.g.:
 
-\begin{verbatim}
-    import sys
-    sys.path.insert(0, "/usr/home/joe/lib/python")
-    sys.path.insert(0, "/usr/local/lib/python")
-\end{verbatim}
-
+\bcode\begin{verbatim}
+import sys
+sys.path.insert(0, "/usr/home/joe/lib/python")
+sys.path.insert(0, "/usr/local/lib/python")
+\end{verbatim}\ecode
+%
 (This way, the directory inserted last will be searched first!)
 
 Instructions for non-Unix systems will vary; check your HTTP server's
@@ -311,10 +312,10 @@ Give it the right mode etc, and send it a request.  If it's installed
 in the standard \code{cgi-bin} directory, it should be possible to send it a
 request by entering a URL into your browser of the form:
 
-\begin{verbatim}
-    http://yourhostname/cgi-bin/cgi.py?name=Joe+Blow&addr=At+Home
-\end{verbatim}
-
+\bcode\begin{verbatim}
+http://yourhostname/cgi-bin/cgi.py?name=Joe+Blow&addr=At+Home
+\end{verbatim}\ecode
+%
 If this gives an error of type 404, the server cannot find the script
 -- perhaps you need to install it in a different directory.  If it
 gives another error (e.g.  500), there's an installation problem that
@@ -328,10 +329,10 @@ script, you should now be able to debug it.
 The next step could be to call the \code{cgi} module's test() function from
 your script: replace its main code with the single statement
 
-\begin{verbatim}
-    cgi.test()
-\end{verbatim}
-
+\bcode\begin{verbatim}
+cgi.test()
+\end{verbatim}\ecode
+%
 This should produce the same results as those gotten from installing
 the \code{cgi.py} file itself.
 
@@ -363,19 +364,19 @@ Here are the rules:
 
 For example:
 
-\begin{verbatim}
-    import sys
-    import traceback
-    print "Content-type: text/html"
-    print
-    sys.stderr = sys.stdout
-    try:
+\bcode\begin{verbatim}
+import sys
+import traceback
+print "Content-type: text/html"
+print
+sys.stderr = sys.stdout
+try:
     ...your code here...
-    except:
+except:
     print "\n\n<PRE>"
     traceback.print_exc()
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 Notes: The assignment to \code{sys.stderr} is needed because the traceback
 prints to \code{sys.stderr}.  The \code{print "$\backslash$n$\backslash$n<PRE>"} statement is necessary to
 disable the word wrapping in HTML.
@@ -384,14 +385,14 @@ If you suspect that there may be a problem in importing the traceback
 module, you can use an even more robust approach (which only uses
 built-in modules):
 
-\begin{verbatim}
-    import sys
-    sys.stderr = sys.stdout
-    print "Content-type: text/plain"
-    print
-    ...your code here...
-\end{verbatim}
-
+\bcode\begin{verbatim}
+import sys
+sys.stderr = sys.stdout
+print "Content-type: text/plain"
+print
+...your code here...
+\end{verbatim}\ecode
+%
 This relies on the Python interpreter to print the traceback.  The
 content type of the output is set to plain text, which disables all
 HTML processing.  If your script works, the raw HTML will be displayed

Doc/lib/libcopy.tex

 \section{Standard Module \sectcode{copy}}
+\label{module-copy}
 \stmodindex{copy}
 \renewcommand{\indexsubitem}{(copy function)}
 \ttindex{copy}
@@ -8,13 +9,13 @@ This module provides generic (shallow and deep) copying operations.
 
 Interface summary:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 import copy
 
 x = copy.copy(y)        # make a shallow copy of y
 x = copy.deepcopy(y)    # make a deep copy of y
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 For module specific errors, \code{copy.error} is raised.
 
 The difference between shallow and deep copying is only relevant for

Doc/lib/libcrypt.tex

-\section{Built-in module {\tt crypt}}
+\section{Built-in Module {\tt crypt}}
+\label{module-crypt}
 \bimodindex{crypt}
 
 This module implements an interface to the crypt({\bf 3}) routine,

Doc/lib/libdbm.tex

 \section{Built-in Module \sectcode{dbm}}
+\label{module-dbm}
 \bimodindex{dbm}
 
 The \code{dbm} module provides an interface to the \UNIX{}

Doc/lib/libfcntl.tex

@@ -65,7 +65,7 @@ rv = fcntl(file.fileno(), FCNTL.O_NDELAY, 1)
 lockdata = struct.pack('hhllhh', FCNTL.F_WRLCK, 0, 0, 0, 0, 0)
 rv = fcntl(file.fileno(), FCNTL.F_SETLKW, lockdata)
 \end{verbatim}\ecode
-
+%
 Note that in the first example the return value variable \code{rv} will
 hold an integer value; in the second example it will hold a string
 value.  The structure lay-out for the \var{lockadata} variable is

Doc/lib/libfl.tex

 \section{Built-in Module \sectcode{fl}}
+\label{module-fl}
 \bimodindex{fl}
 
 This module provides an interface to the FORMS Library by Mark
@@ -471,7 +472,7 @@ the defined names.  Suggested use:
 import fl
 from FL import *
 \end{verbatim}\ecode
-
+%
 \section{Standard Module \sectcode{flp}}
 \stmodindex{flp}
 

Doc/lib/libfm.tex

 \section{Built-in Module \sectcode{fm}}
+\label{module-fm}
 \bimodindex{fm}
 
 This module provides access to the IRIS {\em Font Manager} library.

Doc/lib/libfnmatch.tex

 \section{Standard Module \sectcode{fnmatch}}
+\label{module-fnmatch}
 \stmodindex{fnmatch}
 
 This module provides support for Unix shell-style wildcards, which are

Doc/lib/libformatter.tex

 \section{Standard Module \sectcode{formatter}}
+\label{module-formatter}
 \stmodindex{formatter}
 
 \renewcommand{\indexsubitem}{(in module formatter)}

Doc/lib/libftplib.tex

 \section{Standard Module \sectcode{ftplib}}
+\label{module-ftplib}
 \stmodindex{ftplib}
 
 \renewcommand{\indexsubitem}{(in module ftplib)}
@@ -13,7 +14,7 @@ more information on FTP (File Transfer Protocol), see Internet RFC
 
 Here's a sample session using the \code{ftplib} module:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 >>> from ftplib import FTP
 >>> ftp = FTP('ftp.cwi.nl')   # connect to host, default port
 >>> ftp.login()               # user anonymous, passwd user@hostname
@@ -26,8 +27,8 @@ dr-xr-srwt 105 ftp-usr  pdmaint     1536 Mar 21 14:32 ..
  .
  .
 >>> ftp.quit()
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 The module defines the following items:
 
 \begin{funcdesc}{FTP}{\optional{host\optional{\, user\, passwd\, acct}}}

Doc/lib/libfuncs.tex

@@ -119,7 +119,7 @@ be added to the end of the the argument list.
 2
 >>> 
 \end{verbatim}\ecode
-
+%
   This function can also be used to execute arbitrary code objects
   (e.g.\ created by \code{compile()}).  In this case pass a code
   object instead of a string.  The code object must have been compiled

Doc/lib/libgetopt.tex

 \section{Standard Module \sectcode{getopt}}
+\label{module-getopt}
 
 \stmodindex{getopt}
 This module helps scripts to parse the command line arguments in
@@ -56,7 +57,7 @@ An example using only \UNIX{} style options:
 ['a1', 'a2']
 >>> 
 \end{verbatim}\ecode
-
+%
 Using long option names is equally easy:
 
 \bcode\begin{verbatim}
@@ -72,7 +73,7 @@ Using long option names is equally easy:
 ['a1', 'a2']
 >>> 
 \end{verbatim}\ecode
-
+%
 The exception
 \code{getopt.error = 'getopt.error'}
 is raised when an unrecognized option is found in the argument list or

Doc/lib/libgl.tex

 \section{Built-in Module \sectcode{gl}}
+\label{module-gl}
 \bimodindex{gl}
 
 This module provides access to the Silicon Graphics
@@ -43,13 +44,13 @@ For example, the C call
 \bcode\begin{verbatim}
 lmdef(deftype, index, np, props)
 \end{verbatim}\ecode
-
+%
 is translated to Python as
 
 \bcode\begin{verbatim}
 lmdef(deftype, index, props)
 \end{verbatim}\ecode
-
+%
 \item
 Output arguments are omitted from the argument list; they are
 transmitted as function return values instead.
@@ -62,13 +63,13 @@ Examples: the C call
 \bcode\begin{verbatim}
 getmcolor(i, &red, &green, &blue)
 \end{verbatim}\ecode
-
+%
 is translated to Python as
 
 \bcode\begin{verbatim}
 red, green, blue = getmcolor(i)
 \end{verbatim}\ecode
-
+%
 \end{itemize}
 
 The following functions are non-standard or have special argument
@@ -183,7 +184,7 @@ def main():
 
 main()
 \end{verbatim}\ecode
-
+%
 \section{Standard Modules \sectcode{GL} and \sectcode{DEVICE}}
 \nodename{GL and DEVICE}
 \stmodindex{GL}

Doc/lib/libglob.tex

 \section{Standard Module \sectcode{glob}}
+\label{module-glob}
 \stmodindex{glob}
 \renewcommand{\indexsubitem}{(in module glob)}
 
@@ -24,7 +25,7 @@ For example, consider a directory containing only the following files:
 will produce the following results.  Notice how any leading components
 of the path are preserved.
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 >>> import glob
 >>> glob.glob('./[0-9].*')
 ['./1.gif', './2.txt']
@@ -32,4 +33,4 @@ of the path are preserved.
 ['1.gif', 'card.gif']
 >>> glob.glob('?.gif')
 ['1.gif']
-\end{verbatim}
+\end{verbatim}\ecode

Doc/lib/libgopherlib.tex

 \section{Standard Module \sectcode{gopherlib}}
+\label{module-gopherlib}
 \stmodindex{gopherlib}
 
 \renewcommand{\indexsubitem}{(in module gopherlib)}

Doc/lib/libgrp.tex

 \section{Built-in Module \sectcode{grp}}
+\label{module-grp}
 
 \bimodindex{grp}
 This module provides access to the \UNIX{} group database.

Doc/lib/libhtmllib.tex

 \section{Standard Module \sectcode{htmllib}}
+\label{module-htmllib}
 \stmodindex{htmllib}
 \index{HTML}
 \index{hypertext}
@@ -38,11 +39,11 @@ incomplete elements are saved in a buffer.  To force processing of all
 unprocessed data, call the \code{close()} method.
 
 For example, to parse the entire contents of a file, use:
-\begin{verbatim}
+\bcode\begin{verbatim}
 parser.feed(open('myfile.html').read())
 parser.close()
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 \item
 The interface to define semantics for HTML tags is very simple: derive
 a class and define methods called \code{start_\var{tag}()},

Doc/lib/libhttplib.tex

 \section{Standard Module \sectcode{httplib}}
+\label{module-httplib}
 \stmodindex{httplib}
 \index{HTTP}
 
@@ -19,12 +20,12 @@ method should be used to connect to a server.  For example, the
 following calls all create instances that connect to the server at the
 same host and port:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 >>> h1 = httplib.HTTP('www.cwi.nl')
 >>> h2 = httplib.HTTP('www.cwi.nl:80')
 >>> h3 = httplib.HTTP('www.cwi.nl', 80)
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 Once an \code{HTTP} instance has been connected to an HTTP server, it
 should be used as follows:
 
@@ -111,7 +112,7 @@ methods.
 
 Here is an example session:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 >>> import httplib
 >>> h = httplib.HTTP('www.cwi.nl')
 >>> h.putrequest('GET', '/index.html')
@@ -124,4 +125,4 @@ Here is an example session:
 >>> data f.read() # Get the raw HTML
 >>> f.close()
 >>> 
-\end{verbatim}
+\end{verbatim}\ecode

Doc/lib/libimageop.tex

 \section{Built-in Module \sectcode{imageop}}
+\label{module-imageop}
 \bimodindex{imageop}
 
 The \code{imageop} module contains some useful operations on images.

Doc/lib/libimgfile.tex

 \section{Built-in Module \sectcode{imgfile}}
+\label{module-imgfile}
 \bimodindex{imgfile}
 
 The imgfile module allows python programs to access SGI imglib image

Doc/lib/libimghdr.tex

 \section{Standard module \sectcode{imghdr}}
+\label{module-imghdr}
 \stmodindex{imghdr}
 
 The \code{imghdr} module determines the type of image contained in a
@@ -53,8 +54,8 @@ the test succeeded, or \code{None} if it failed.
 
 Example:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 >>> import imghdr
 >>> imghdr.what('/tmp/bass.gif')
 'gif'
-\end{verbatim}
+\end{verbatim}\ecode

Doc/lib/libimp.tex

 \section{Built-in Module \sectcode{imp}}
+\label{module-imp}
 \bimodindex{imp}
 \index{import}
 
@@ -132,7 +133,7 @@ The module was found as dynamically loadable shared library.
 \subsection{Examples}
 The following function emulates the default import statement:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 import imp
 import sys
 
@@ -171,4 +172,4 @@ def __import__(name, globals=None, locals=None, fromlist=None):
     finally:
         # Since we may exit via an exception, close fp explicitly.
         fp.close()
-\end{verbatim}
+\end{verbatim}\ecode

Doc/lib/libjpeg.tex

 \section{Built-in Module \sectcode{jpeg}}
+\label{module-jpeg}
 \bimodindex{jpeg}
 
 The module \code{jpeg} provides access to the jpeg compressor and

Doc/lib/libmailcap.tex

 \section{Standard Module \sectcode{mailcap}}
+\label{module-mailcap}
 \stmodindex{mailcap}
 \renewcommand{\indexsubitem}{(in module mailcap)}
 
@@ -67,9 +68,9 @@ will override settings in the system mailcap files
 \end{funcdesc}
 
 An example usage:
-\begin{verbatim}
+\bcode\begin{verbatim}
 >>> import mailcap
 >>> d=mailcap.getcaps()
 >>> mailcap.findmatch(d, 'video/mpeg', filename='/tmp/tmp1223')
 ('xmpeg /tmp/tmp1223', {'view': 'xmpeg %s'})
-\end{verbatim}
+\end{verbatim}\ecode

Doc/lib/libmain.tex

 \section{Built-in Module \sectcode{__main__}}
-
+\label{module-main}
 \bimodindex{__main__}
 This module represents the (otherwise anonymous) scope in which the
 interpreter's main program executes --- commands read either from

Doc/lib/libmarshal.tex

 \section{Built-in Module \sectcode{marshal}}
+\label{module-marshal}
 
 \bimodindex{marshal}
 This module contains functions that can read and write Python

Doc/lib/libmath.tex

 \section{Built-in Module \sectcode{math}}
+\label{module-math}
 
 \bimodindex{math}
 \renewcommand{\indexsubitem}{(in module math)}
@@ -70,3 +71,7 @@ The module also defines two mathematical constants:
 \else
 \code{pi} and \code{e}.
 \fi
+
+\begin{seealso}
+\seealso{cmath}{versions of these functions that can handle complex numbers}
+\end{seealso}

Doc/lib/libmd5.tex

 \section{Built-in Module \sectcode{md5}}
+\label{module-md5}
 \bimodindex{md5}
 
 This module implements the interface to RSA's MD5 message digest
@@ -21,14 +22,14 @@ the spammish repetition"}:
 >>> m.digest()
 '\273d\234\203\335\036\245\311\331\336\311\241\215\360\377\351'
 \end{verbatim}\ecode
-
+%
 More condensed:
 
 \bcode\begin{verbatim}
 >>> md5.new("Nobody inspects the spammish repetition").digest()
 '\273d\234\203\335\036\245\311\331\336\311\241\215\360\377\351'
 \end{verbatim}\ecode
-
+%
 \renewcommand{\indexsubitem}{(in module md5)}
 
 \begin{funcdesc}{new}{\optional{arg}}

Doc/lib/libmimetools.tex

 \section{Standard Module \sectcode{mimetools}}
+\label{module-mimetools}
 \stmodindex{mimetools}
 
 \renewcommand{\indexsubitem}{(in module mimetools)}

Doc/lib/libmpz.tex

 \section{Built-in Module \sectcode{mpz}}
+\label{module-mpz}
 \bimodindex{mpz}
 
 This is an optional module.  It is only available when Python is

Doc/lib/libnntplib.tex

 \section{Standard Module \sectcode{nntplib}}
+\label{module-nntplib}
 \stmodindex{nntplib}
 
 \renewcommand{\indexsubitem}{(in module nntplib)}
@@ -13,7 +14,7 @@ statistics about a newsgroup and print the subjects of the last 10
 articles:
 
 \small{
-\begin{verbatim}
+\bcode\begin{verbatim}
 >>> s = NNTP('news.cwi.nl')
 >>> resp, count, first, last, name = s.group('comp.lang.python')
 >>> print 'Group', name, 'has', count, 'articles, range', first, 'to', last
@@ -34,13 +35,13 @@ Group comp.lang.python has 59 articles, range 3742 to 3803
 >>> s.quit()
 '205 news.cwi.nl closing connection.  Goodbye.'
 >>> 
-\end{verbatim}
+\end{verbatim}\ecode
 }
 
 To post an article from a file (this assumes that the article has
 valid headers):
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 >>> s = NNTP('news.cwi.nl')
 >>> f = open('/tmp/article')
 >>> s.post(f)
@@ -48,8 +49,8 @@ valid headers):
 >>> s.quit()
 '205 news.cwi.nl closing connection.  Goodbye.'
 >>> 
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 The module itself defines the following items:
 
 \begin{funcdesc}{NNTP}{host\optional{\, port}}

Doc/lib/liboperator.tex

@@ -184,10 +184,10 @@ Delete the slice of a from index b to index c-1.
 Example: Build a dictionary that maps the ordinals from 0 to 256 to their
 character equivalents.
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 >>> import operator
 >>> d = {}
 >>> keys = range(256)
 >>> vals = map(chr, keys)
 >>> map(operator.setitem, [d]*len(keys), keys, vals)
-\end{verbatim}
+\end{verbatim}\ecode

Doc/lib/libos.tex

 \section{Standard Module \sectcode{os}}
+\label{module-os}
 
 \stmodindex{os}
 This module provides a more portable way of using operating system

Doc/lib/libpanel.tex

 \section{Standard Module \sectcode{panel}}
+\label{module-panel}
 \stmodindex{panel}
 
 \strong{Please note:} The FORMS library, to which the \code{fl} module described

Doc/lib/libparser.tex

@@ -288,30 +288,30 @@ bytecode generation, the simplest operation is to do nothing.  For
 this purpose, using the \code{parser} module to produce an
 intermediate data structure is equivelent to the code
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 >>> code = compile('a + 5', 'eval')
 >>> a = 5
 >>> eval(code)
 10
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 The equivelent operation using the \code{parser} module is somewhat
 longer, and allows the intermediate internal parse tree to be retained
 as an AST object:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 >>> import parser
 >>> ast = parser.expr('a + 5')
 >>> code = parser.compileast(ast)
 >>> a = 5
 >>> eval(code)
 10
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 An application which needs both AST and code objects can package this
 code into readily available functions:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 import parser
 
 def load_suite(source_string):
@@ -323,8 +323,8 @@ def load_expression(source_string):
     ast = parser.expr(source_string)
     code = parser.compileast(ast)
     return ast, code
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 \subsubsection{Information Discovery}
 
 Some applications benefit from direct access to the parse tree.  The
@@ -366,16 +366,16 @@ Consider the simplest case of interest when searching for docstrings:
 a module consisting of a docstring and nothing else.  (See file
 \file{docstring.py}.)
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 """Some documentation.
 """
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 Using the interpreter to take a look at the parse tree, we find a
 bewildering mass of numbers and parentheses, with the documentation
 buried deep in nested tuples.
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 >>> import parser
 >>> import pprint
 >>> ast = parser.suite(open('docstring.py').read())
@@ -403,8 +403,8 @@ buried deep in nested tuples.
    (4, ''))),
  (4, ''),
  (0, ''))
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 The numbers at the first element of each node in the tree are the node
 types; they map directly to terminal and non-terminal symbols in the
 grammar.  Unfortunately, they are represented as integers in the
@@ -442,7 +442,7 @@ form, allowing a simple variable representation to be
 the pattern matching, returning a boolean and a dictionary of variable
 name to value mappings.  (See file \file{example.py}.)
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 from types import ListType, TupleType
 
 def match(pattern, data, vars=None):
@@ -460,13 +460,13 @@ def match(pattern, data, vars=None):
         if not same:
             break
     return same, vars
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 Using this simple representation for syntactic variables and the symbolic
 node types, the pattern for the candidate docstring subtrees becomes
 fairly readable.  (See file \file{example.py}.)
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 import symbol
 import token
 
@@ -493,19 +493,19 @@ DOCSTRING_STMT_PATTERN = (
                      )))))))))))))))),
      (token.NEWLINE, '')
      ))
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 Using the \code{match()} function with this pattern, extracting the
 module docstring from the parse tree created previously is easy:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 >>> found, vars = match(DOCSTRING_STMT_PATTERN, tup[1])
 >>> found
 1
 >>> vars
 {'docstring': '"""Some documentation.\012"""'}
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 Once specific data can be extracted from a location where it is
 expected, the question of where information can be expected
 needs to be answered.  When dealing with docstrings, the answer is
@@ -567,7 +567,7 @@ grammar, but the method which recursively creates new information
 objects requires further examination.  Here is the relevant part of
 the \code{SuiteInfoBase} definition from \file{example.py}:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 class SuiteInfoBase:
     _docstring = ''
     _name = ''
@@ -597,8 +597,8 @@ class SuiteInfoBase:
                 elif cstmt[0] == symbol.classdef:
                     name = cstmt[2][1]
                     self._class_info[name] = ClassInfo(cstmt)
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 After initializing some internal state, the constructor calls the
 \code{_extract_info()} method.  This method performs the bulk of the
 information extraction which takes place in the entire example.  The
@@ -611,21 +611,21 @@ the ``short form'' or the ``long form.''  The short form is used when
 the code block is on the same line as the definition of the code
 block, as in
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 def square(x): "Square an argument."; return x ** 2
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 while the long form uses an indented block and allows nested
 definitions:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 def make_power(exp):
     "Make a function that raises an argument to the exponent `exp'."
     def raiser(x, y=exp):
         return x ** y
     return raiser
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 When the short form is used, the code block may contain a docstring as
 the first, and possibly only, \code{small_stmt} element.  The
 extraction of such a docstring is slightly different and requires only
@@ -660,7 +660,7 @@ the real extraction algorithm remains common to all forms of code
 blocks.  A high-level function can be used to extract the complete set
 of information from a source file.  (See file \file{example.py}.)
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 def get_docs(fileName):
     source = open(fileName).read()
     import os
@@ -669,8 +669,8 @@ def get_docs(fileName):
     ast = parser.suite(source)
     tup = parser.ast2tuple(ast)
     return ModuleInfo(tup, basename)
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 This provides an easy-to-use interface to the documentation of a
 module.  If information is required which is not extracted by the code
 of this example, the code may be extended at clearly defined points to

Doc/lib/libpdb.tex

@@ -29,7 +29,7 @@ specific modules).
 The debugger's prompt is ``\code{(Pdb) }''.
 Typical usage to run a program under control of the debugger is:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 >>> import pdb
 >>> import mymodule
 >>> pdb.run('mymodule.test()')
@@ -40,15 +40,15 @@ Typical usage to run a program under control of the debugger is:
 NameError: 'spam'
 > <string>(1)?()
 (Pdb) 
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 \code{pdb.py} can also be invoked as
 a script to debug other scripts.  For example:
 \code{python /usr/local/lib/python1.4/pdb.py myscript.py}
 
 Typical usage to inspect a crashed program is:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 >>> import pdb
 >>> import mymodule
 >>> mymodule.test()
@@ -63,8 +63,8 @@ NameError: spam
 > ./mymodule.py(3)test2()
 -> print spam
 (Pdb) 
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 The module defines the following functions; each enters the debugger
 in a slightly different way:
 
@@ -224,11 +224,11 @@ The exclamation point can be omitted unless the first word
 of the statement resembles a debugger command.
 To set a global variable, you can prefix the assignment
 command with a ``\code{global}'' command on the same line, e.g.:
-\begin{verbatim}
+\bcode\begin{verbatim}
 (Pdb) global list_options; list_options = ['-l']
 (Pdb)
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 \item[q(uit)]
 
 Quit from the debugger.

Doc/lib/libpickle.tex

 \section{Standard Module \sectcode{pickle}}
+\label{module-pickle}
 \stmodindex{pickle}
 \index{persistency}
 \indexii{persistent}{objects}
@@ -133,30 +134,30 @@ The interface can be summarized as follows.
 
 To pickle an object \code{x} onto a file \code{f}, open for writing:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 p = pickle.Pickler(f)
 p.dump(x)
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 A shorthand for this is:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 pickle.dump(x, f)
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 To unpickle an object \code{x} from a file \code{f}, open for reading:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 u = pickle.Unpickler(f)
 x = u.load()
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 A shorthand is:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 x = pickle.load(f)
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 The \code{Pickler} class only calls the method \code{f.write} with a
 string argument.  The \code{Unpickler} calls the methods \code{f.read}
 (with an integer argument) and \code{f.readline} (without argument),

Doc/lib/libposix.tex

 \section{Built-in Module \sectcode{posix}}
+\label{module-posix}
 \bimodindex{posix}
 
 This module provides access to operating system functionality that is

Doc/lib/libppath.tex

 \section{Standard Module \sectcode{posixpath}}
+\label{module-posixpath}
 \stmodindex{posixpath}
 
 This module implements some useful functions on POSIX pathnames.

Doc/lib/libpwd.tex

 \section{Built-in Module \sectcode{pwd}}
+\label{module-pwd}
 
 \bimodindex{pwd}
 This module provides access to the \UNIX{} password database.

Doc/lib/libquopri.tex

 \section{Standard Module \sectcode{quopri}}
+\label{module-quopri}
 \stmodindex{quopri}
 
 This module performs quoted-printable transport encoding and decoding,

Doc/lib/librand.tex

 \section{Standard Module \sectcode{rand}}
+\label{module-rand}
 \stmodindex{rand}
 
 The \code{rand} module simulates the C library's \code{rand()}
@@ -20,3 +21,7 @@ Set a starting seed value for the random number generator; \var{seed}
 can be an arbitrary integer. 
 \end{funcdesc}
 
+\begin{seealso}
+\seemodule{whrandom}{the standard Python random number generator}
+\end{seealso}
+

Doc/lib/librandom.tex

 \section{Standard Module \sectcode{random}}
+\label{module-random}
 \stmodindex{random}
 
 This module implements pseudo-random number generators for various
@@ -69,3 +70,8 @@ then or equal to zero.  If \var{kappa} is equal to zero, this
 distribution reduces to a uniform random angle over the range 0 to
 \code{2*pi}.
 \end{funcdesc}
+
+
+\begin{seealso}
+\seemodule{whrandom}{the standard Python random number generator}
+\end{seealso}

Doc/lib/libregex.tex

 \section{Built-in Module \sectcode{regex}}
+\label{module-regex}
 
 \bimodindex{regex}
 This module provides regular expression matching operations similar to
@@ -204,13 +205,13 @@ The module defines these functions, and an exception:
 prog = regex.compile(pat)
 result = prog.match(str)
 \end{verbatim}\ecode
-
+%
 is equivalent to
 
 \bcode\begin{verbatim}
 result = regex.match(pat, str)
 \end{verbatim}\ecode
-
+%
 but the version using \code{compile()} is more efficient when multiple
 regular expressions are used concurrently in a single program.  (The
 compiled version of the last pattern passed to \code{regex.match()} or

Doc/lib/libregsub.tex

 \section{Standard Module \sectcode{regsub}}
+\label{module-regsub}
 
 \stmodindex{regsub}
 This module defines a number of functions useful for working with

Doc/lib/libresource.tex

 \section{Built-in Module \sectcode{resource}}
+\label{module-resource}
 
 \bimodindex{resource}
 This module provides basic mechanisms for measuring and controlling

Doc/lib/librexec.tex

 \section{Standard Module \sectcode{rexec}}
+\label{module-rexec}
 \stmodindex{rexec}
 \renewcommand{\indexsubitem}{(in module rexec)}
 
@@ -206,7 +207,7 @@ class TmpWriterRExec(rexec.RExec):
         else: raise IOError, "Illegal open() mode"
         return open(file, mode, buf)
 \end{verbatim}\ecode
-
+%
 Notice that the above code will occasionally forbid a perfectly valid
 filename; for example, code in the restricted environment won't be
 able to open a file called \file{/tmp/foo/../bar}.  To fix this, the

Doc/lib/librfc822.tex

 \section{Standard Module \sectcode{rfc822}}
+\label{module-rfc822}
 \stmodindex{rfc822}
 
 \renewcommand{\indexsubitem}{(in module rfc822)}

Doc/lib/librgbimg.tex

 \section{Built-in Module \sectcode{rgbimg}}
+\label{module-rgbimg}
 \bimodindex{rgbimg}
 
 The rgbimg module allows python programs to access SGI imglib image

Doc/lib/librotor.tex

 \section{Built-in Module \sectcode{rotor}}
+\label{module-rotor}
 \bimodindex{rotor}
 
 This module implements a rotor-based encryption algorithm, contributed by
@@ -79,7 +80,7 @@ An example usage:
 'l(\315'
 >>> del rt
 \end{verbatim}\ecode
-
+%
 The module's code is not an exact simulation of the original Enigma device;
 it implements the rotor encryption scheme differently from the original. The
 most important difference is that in the original Enigma, there were only 5

Doc/lib/libselect.tex

 \section{Built-in Module \sectcode{select}}
+\label{module-select}
 \bimodindex{select}
 
 This module provides access to the function \code{select} available in

Doc/lib/libsgmllib.tex

 \section{Standard Module \sectcode{sgmllib}}
+\label{module-sgmllib}
 \stmodindex{sgmllib}
 \index{SGML}
 

Doc/lib/libshelve.tex

 \section{Standard Module \sectcode{shelve}}
+\label{module-shelve}
 \stmodindex{shelve}
 \stmodindex{pickle}
 \bimodindex{dbm}
@@ -14,7 +15,7 @@ sub-objects.  The keys are ordinary strings.
 To summarize the interface (\code{key} is a string, \code{data} is an
 arbitrary object):
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 import shelve
 
 d = shelve.open(filename) # open, with (g)dbm filename -- no suffix
@@ -29,8 +30,8 @@ flag = d.has_key(key)   # true if the key exists
 list = d.keys() # a list of all existing keys (slow!)
 
 d.close()       # close it
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 Restrictions:
 
 \begin{itemize}

Doc/lib/libsignal.tex

 \section{Built-in Module \sectcode{signal}}
+\label{module-signal}
 
 \bimodindex{signal}
 This module provides mechanisms to use signal handlers in Python.

Doc/lib/libsite.tex

 \section{Standard Module \sectcode{site}}
+\label{module-site}
 \stmodindex{site}
 
 Scripts or modules that need to use site-specific modules should

Doc/lib/libsocket.tex

 \section{Built-in Module \sectcode{socket}}
+\label{module-socket}
 
 \bimodindex{socket}
 This module provides access to the BSD {\em socket} interface.
@@ -336,7 +337,7 @@ while 1:
     conn.send(data)
 conn.close()
 \end{verbatim}\ecode
-
+%
 \bcode\begin{verbatim}
 # Echo client program
 from socket import *
@@ -349,3 +350,7 @@ data = s.recv(1024)
 s.close()
 print 'Received', `data`
 \end{verbatim}\ecode
+%
+\begin{seealso}
+\seemodule{SocketServer}{classes that simplify writing network servers}
+\end{seealso}

Doc/lib/libsoundex.tex

 \section{Standard Module \sectcode{soundex}}
+\label{module-soundex}
 \stmodindex{soundex}
 
 \renewcommand{\indexsubitem}{(in module soundex)}

Doc/lib/libstat.tex

@@ -81,7 +81,7 @@ Time of creation.
 
 Example:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 import os, sys
 from stat import *
 
@@ -103,4 +103,4 @@ def f(file):
     print 'frobbed', file
 
 if __name__ == '__main__': process(sys.argv[1], f)
-\end{verbatim}
+\end{verbatim}\ecode

Doc/lib/libstdwin.tex

@@ -774,7 +774,7 @@ def main():
 
 main()
 \end{verbatim}\ecode
-
+%
 \section{Standard Module \sectcode{stdwinevents}}
 \stmodindex{stdwinevents}
 
@@ -788,7 +788,7 @@ Suggested usage is
 >>> from stdwinevents import *
 >>> 
 \end{verbatim}\ecode
-
+%
 \section{Standard Module \sectcode{rect}}
 \stmodindex{rect}
 
@@ -801,7 +801,7 @@ For example, the rectangle
 \bcode\begin{verbatim}
 (10, 20), (90, 80)
 \end{verbatim}\ecode
-
+%
 is a rectangle whose left, top, right and bottom edges are 10, 20, 90
 and 80, respectively.
 Note that the positive vertical axis points down (as in

Doc/lib/libstring.tex

 \section{Standard Module \sectcode{string}}
+\label{module-string}
 
 \stmodindex{string}
 

Doc/lib/libstruct.tex

 \section{Built-in Module \sectcode{struct}}
+\label{module-struct}
 \bimodindex{struct}
 \indexii{C}{structures}
 
@@ -126,7 +127,7 @@ big-endian machine):
 8
 >>> 
 \end{verbatim}\ecode
-
+%
 Hint: to align the end of a structure to the alignment requirement of
 a particular type, end the format with the code for that type with a
 repeat count of zero, e.g.\ the format \code{'llh0l'} specifies two

Doc/lib/libsys.tex

 \section{Built-in Module \sectcode{sys}}
+\label{module-sys}
 
 \bimodindex{sys}
 This module provides access to some variables used or maintained by the

Doc/lib/libsyslog.tex

 \section{Built-in Module \sectcode{syslog}}
+\label{module-syslog}
 \bimodindex{syslog}
 
 This module provides an interface to the Unix \code{syslog} library

Doc/lib/libtempfile.tex

 \section{Standard Module \sectcode{tempfile}}
+\label{module-tempfile}
 \stmodindex{tempfile}
 \indexii{temporary}{file name}
 \indexii{temporary}{file}

Doc/lib/libtemplate.tex

@@ -96,13 +96,13 @@ failure.
 
 Example:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 >>> import spam
 >>> can = spam.open('/etc/passwd')
 >>> can.empty()
 >>> can.close()
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 % ==== 5. ====
 % If your module defines new object types (for a built-in module) or
 % classes (for a module written in Python), you should list the

Doc/lib/libtermios.tex

 \section{Built-in Module \sectcode{termios}}
+\label{module-termios}
 \bimodindex{termios}
 \indexii{Posix}{I/O control}
 \indexii{tty}{I/O control}
@@ -76,7 +77,7 @@ Note the technique using a separate \code{termios.tcgetattr()} call
 and a \code{try \ldots{} finally} statement to ensure that the old tty
 attributes are restored exactly no matter what happens:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 def getpass(prompt = "Password: "):
     import termios, TERMIOS, sys
     fd = sys.stdin.fileno()
@@ -89,9 +90,8 @@ def getpass(prompt = "Password: "):
     finally:
         termios.tcsetattr(fd, TERMIOS.TCSADRAIN, old)
     return passwd
-\end{verbatim}
-
-
+\end{verbatim}\ecode
+%
 \section{Standard Module \sectcode{TERMIOS}}
 \stmodindex{TERMIOS}
 \indexii{Posix}{I/O control}

Doc/lib/libthread.tex

 \section{Built-in Module \sectcode{thread}}
+\label{module-thread}
 \bimodindex{thread}
 
 This module provides low-level primitives for working with multiple

Doc/lib/libtime.tex

 \section{Built-in Module \sectcode{time}}
+\label{module-time}
 
 \bimodindex{time}
 This module provides various time-related functions.

Doc/lib/libtraceback.tex

 \section{Standard Module \sectcode{traceback}}
+\label{module-traceback}
 \stmodindex{traceback}
 
 \renewcommand{\indexsubitem}{(in module traceback)}

Doc/lib/libtypes2.tex

 \section{Standard Module \sectcode{types}}
+\label{module-types}
 \stmodindex{types}
 
 \renewcommand{\indexsubitem}{(in module types)}
@@ -13,15 +14,15 @@ all end in \code{Type}.
 Typical use is for functions that do different things depending on
 their argument types, like the following:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 from types import *
 def delete(list, item):
     if type(item) is IntType:
        del list[item]
     else:
        list.remove(item)
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 The module defines the following names:
 
 \begin{datadesc}{NoneType}

Doc/lib/liburllib.tex

 \section{Standard Module \sectcode{urllib}}
+\label{module-urllib}
 \stmodindex{urllib}
 \index{WWW}
 \index{World-Wide Web}

Doc/lib/liburlparse.tex

 \section{Standard Module \sectcode{urlparse}}
+\label{module-urlparse}
 \stmodindex{urlparse}
 \index{WWW}
 \index{World-Wide Web}
@@ -34,16 +35,16 @@ retained if present.
 
 Example:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 urlparse('http://www.cwi.nl:80/%7Eguido/Python.html')
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 yields the tuple
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 ('http', 'www.cwi.nl:80', '/%7Eguido/Python.html', '', '', '')
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 If the \var{default_scheme} argument is specified, it gives the
 default addressing scheme, to be used only if the URL string does not
 specify one.  The default value for this argument is the empty string.
@@ -69,16 +70,16 @@ components in the relative URL.
 
 Example:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 urljoin('http://www.cwi.nl/%7Eguido/Python.html', 'FAQ.html')
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 yields the string
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 'http://www.cwi.nl/%7Eguido/FAQ.html'
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 The \var{allow_fragments} argument has the same meaning as for
 \code{urlparse}.
 \end{funcdesc}

Doc/lib/libwhichdb.tex

 \section{Standard Module \sectcode{whichdb}}
+\label{module-whichdb}
 \stmodindex{whichdb}
 
 The single function in this module attempts to guess which of the

Doc/lib/libwhrandom.tex

 \section{Standard Module \sectcode{whrandom}}
+\label{module-whrandom}
 \stmodindex{whrandom}
 
 This module implements a Wichmann-Hill pseudo-random number generator
@@ -36,7 +37,14 @@ When imported, the \code{whrandom} module also creates an instance of
 the \code{whrandom} class, and makes the methods of that instance
 available at the module level.  Therefore one can write either 
 \code{N = whrandom.random()} or:
-\begin{verbatim}
+\bcode\begin{verbatim}
 generator = whrandom.whrandom()
 N = generator.random()
-\end{verbatim}
+\end{verbatim}\ecode
+%
+\begin{seealso}
+\seemodule{random}{generators for various random distributions}
+\seetext{Wichmann, B. A. \& Hill, I. D., ``Algorithm AS 183: 
+An efficient and portable pseudo-random number generator'', 
+Applied Statistics 31 (1982) 188-190}
+\end{seealso}

Doc/lib/libxdrlib.tex

 \section{Standard module \sectcode{xdrlib}}
+\label{module-xdrlib}
 \stmodindex{xdrlib}
 \index{XDR}
 
@@ -221,15 +222,15 @@ variables.
 
 Here is an example of how you would catch one of these exceptions:
 
-\begin{verbatim}
+\bcode\begin{verbatim}
 import xdrlib
 p = xdrlib.Packer()
 try:
     p.pack_double(8.01)
 except xdrlib.ConversionError, instance:
     print 'packing the double failed:', instance.msg
-\end{verbatim}
-
+\end{verbatim}\ecode
+%
 \subsection{Supporting Floating Point Data}
 
 Packing and unpacking floating point data,

Doc/lib/libzlib.tex

 \section{Built-in Module \sectcode{zlib}}
+\label{module-zlib}
 \bimodindex{zlib}
 
 For applications that require data compression, the functions in this
@@ -95,5 +96,8 @@ uncompressed output is returned.  After calling \code{flush()}, the
 action is to delete the object.
 \end{funcdesc}
 
+\begin{seealso}
+\seemodule{gzip}{reading and writing \file{gzip}-format files}
+\end{seealso}
 
 

Doc/libaifc.tex

 \section{Standard Module \sectcode{aifc}}
+\label{module-aifc}
 \stmodindex{aifc}
 
 This module provides support for reading and writing AIFF and AIFF-C

Doc/libal.tex

 \section{Built-in Module \sectcode{al}}
+\label{module-al}
 \bimodindex{al}
 
 This module provides access to the audio facilities of the SGI Indy

Doc/libamoeba.tex

@@ -82,7 +82,7 @@ For example:
 aa:1c:95:52:6a:fa/14(ff)/8e:ba:5b:8:11:1a
 >>> 
 \end{verbatim}\ecode
-
+%
 The following methods are defined for capability objects.
 
 \renewcommand{\indexsubitem}{(capability method)}

Doc/libarray.tex

 \section{Built-in Module \sectcode{array}}
+\label{module-array}
 \bimodindex{array}
 \index{arrays}
 

Doc/libaudio.tex

 \section{Built-in Module \sectcode{audio}}
+\label{module-audio}
 \bimodindex{audio}
 
 \strong{Note:} This module is obsolete, since the hardware to which it

Doc/libaudioop.tex

 \section{Built-in Module \sectcode{audioop}}
+\label{module-audioop}
 \bimodindex{audioop}
 
 The \code{audioop} module contains some useful operations on sound fragments.
@@ -210,7 +211,7 @@ def mul_stereo(sample, width, lfactor, rfactor):
     rsample = audioop.tostereo(rsample, width, 0, 1)
     return audioop.add(lsample, rsample, width)
 \end{verbatim}\ecode
-
+%
 If you use the ADPCM coder to build network packets and you want your
 protocol to be stateless (i.e.\ to be able to tolerate packet loss)
 you should not only transmit the data but also the state.  Note that

Doc/libbase64.tex

 \section{Standard Module \sectcode{base64}}
+\label{module-base64}
 \stmodindex{base64}
 
 This module perform base-64 encoding and decoding of arbitrary binary

Doc/libbastion.tex

 \section{Standard Module \sectcode{Bastion}}
+\label{module-Bastion}
 \stmodindex{Bastion}
 \renewcommand{\indexsubitem}{(in module Bastion)}
 

Doc/libbinascii.tex

 \section{Standard module \sectcode{binhex}}
+\label{module-binhex}
 \stmodindex{binhex}
 
 This module encodes and decodes files in binhex4 format, a format

Doc/libbltin.tex

 \section{Built-in Module \sectcode{__builtin__}}
+\label{module-builtin}
 \bimodindex{__builtin__}
 
 This module provides direct access to all `built-in' identifiers of

Doc/libcd.tex

 \section{Built-in Module \sectcode{cd}}
+\label{module-cd}
 \bimodindex{cd}
 
 This module provides an interface to the Silicon Graphics CD library.