--- rest25/distutils/apiref.rst	2008-12-19 16:58:05.000000000 +0900
+++ rest262/distutils/apiref.rst	2009-04-07 00:06:52.000000000 +0900
@@ -17,102 +17,106 @@
 setup script). Indirectly provides the  :class:`distutils.dist.Distribution` and
 :class:`distutils.cmd.Command` class.
 
 
 .. function:: setup(arguments)
 
    The basic do-everything function that does most everything you could ever ask
    for from a Distutils method. See XXXXX
 
    The setup function takes a large number of arguments. These are laid out in the
    following table.
 
-   +--------------------+--------------------------------+------------------------------------------------------------------+
-   | argument name      | value                          | type                                                             |
-   +====================+================================+==================================================================+
+   +--------------------+--------------------------------+-------------------------------------------------------------+
+   | argument name      | value                          | type                                                        |
+   +====================+================================+=============================================================+
-   | *name*             | The name of the package        | a string                                                         |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *name*             | The name of the package        | a string                                                    |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *version*          | The version number of the      | See :mod:`distutils.version`                                     |
-   |                    | package                        |                                                                  |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *version*          | The version number of the      | See :mod:`distutils.version`                                |
+   |                    | package                        |                                                             |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *description*      | A single line describing the   | a string                                                         |
-   |                    | package                        |                                                                  |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *description*      | A single line describing the   | a string                                                    |
+   |                    | package                        |                                                             |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *long_description* | Longer description of the      | a string                                                         |
-   |                    | package                        |                                                                  |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *long_description* | Longer description of the      | a string                                                    |
+   |                    | package                        |                                                             |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *author*           | The name of the package author | a string                                                         |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *author*           | The name of the package author | a string                                                    |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *author_email*     | The email address of the       | a string                                                         |
-   |                    | package author                 |                                                                  |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *author_email*     | The email address of the       | a string                                                    |
+   |                    | package author                 |                                                             |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *maintainer*       | The name of the current        | a string                                                         |
-   |                    | maintainer, if different from  |                                                                  |
-   |                    | the author                     |                                                                  |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *maintainer*       | The name of the current        | a string                                                    |
+   |                    | maintainer, if different from  |                                                             |
+   |                    | the author                     |                                                             |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *maintainer_email* | The email address of the       |                                                                  |
-   |                    | current maintainer, if         |                                                                  |
-   |                    | different from the author      |                                                                  |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *maintainer_email* | The email address of the       |                                                             |
+   |                    | current maintainer, if         |                                                             |
+   |                    | different from the author      |                                                             |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *url*              | A URL for the package          | a URL                                                            |
-   |                    | (homepage)                     |                                                                  |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *url*              | A URL for the package          | a URL                                                       |
+   |                    | (homepage)                     |                                                             |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *download_url*     | A URL to download the package  | a URL                                                            |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *download_url*     | A URL to download the package  | a URL                                                       |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *packages*         | A list of Python packages that | a list of strings                                                |
-   |                    | distutils will manipulate      |                                                                  |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *packages*         | A list of Python packages that | a list of strings                                           |
+   |                    | distutils will manipulate      |                                                             |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *py_modules*       | A list of Python modules that  | a list of strings                                                |
-   |                    | distutils will manipulate      |                                                                  |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *py_modules*       | A list of Python modules that  | a list of strings                                           |
+   |                    | distutils will manipulate      |                                                             |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *scripts*          | A list of standalone script    | a list of strings                                                |
-   |                    | files to be built and          |                                                                  |
-   |                    | installed                      |                                                                  |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *scripts*          | A list of standalone script    | a list of strings                                           |
+   |                    | files to be built and          |                                                             |
+   |                    | installed                      |                                                             |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *ext_modules*      | A list of Python extensions to | A list of  instances of                                          |
-   |                    | be built                       | :class:`distutils.core.Extension`                                |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *ext_modules*      | A list of Python extensions to | A list of  instances of                                     |
+   |                    | be built                       | :class:`distutils.core.Extension`                           |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *classifiers*      | A list of categories for the   | The list of available                                            |
-   |                    | package                        | categorizations is at                                            |
-   |                    |                                | `<http://cheeseshop.python.org/pypi?:action=list_classifiers>`_. |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *classifiers*      | A list of categories for the   | The list of available                                       |
+   |                    | package                        | categorizations is at                                       |
+   |                    |                                | http://pypi.python.org/pypi?:action=list_classifiers.       |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *distclass*        | the :class:`Distribution`      | A subclass of                                                    |
-   |                    | class to use                   | :class:`distutils.core.Distribution`                             |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *distclass*        | the :class:`Distribution`      | A subclass of                                               |
+   |                    | class to use                   | :class:`distutils.core.Distribution`                        |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *script_name*      | The name of the setup.py       | a string                                                         |
-   |                    | script - defaults to           |                                                                  |
-   |                    | ``sys.argv[0]``                |                                                                  |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *script_name*      | The name of the setup.py       | a string                                                    |
+   |                    | script - defaults to           |                                                             |
+   |                    | ``sys.argv[0]``                |                                                             |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *script_args*      | Arguments to supply to the     | a list of strings                                                |
-   |                    | setup script                   |                                                                  |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *script_args*      | Arguments to supply to the     | a list of strings                                           |
+   |                    | setup script                   |                                                             |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *options*          | default options for the setup  | a string                                                         |
-   |                    | script                         |                                                                  |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *options*          | default options for the setup  | a string                                                    |
+   |                    | script                         |                                                             |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *license*          | The license for the package    |                                                                  |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *license*          | The license for the package    | a string                                                    |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *keywords*         | Descriptive meta-data. See     |                                                                  |
-   |                    | :pep:`314`                     |                                                                  |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *keywords*         | Descriptive meta-data, see     |                                                             |
+   |                    | :pep:`314`                     |                                                             |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *platforms*        |                                |                                                                  |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *platforms*        |                                |                                                             |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
-   | *cmdclass*         | A mapping of command names to  | a dictionary                                                     |
-   |                    | :class:`Command` subclasses    |                                                                  |
-   +--------------------+--------------------------------+------------------------------------------------------------------+
+   | *cmdclass*         | A mapping of command names to  | a dictionary                                                |
+   |                    | :class:`Command` subclasses    |                                                             |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
+   | *data_files*       | A list of data files to        | a list                                                      |
+   |                    | install                        |                                                             |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
+   | *package_dir*      | A mapping of package to        | a dictionary                                                |
+   |                    | directory names                |                                                             |
+   +--------------------+--------------------------------+-------------------------------------------------------------+
 
-   The list of available categorizations is at
-   `<http://cheeseshop.python.org/pypi?:action=list_classifiers>`_.
 
 
-.. function:: run_setup(script_name[, script_args=``None``, stop_after=``'run'``])
+.. function:: run_setup(script_name[, script_args=None, stop_after='run'])
 
    Run a setup script in a somewhat controlled environment, and return  the
    :class:`distutils.dist.Distribution` instance that drives things.   This is
    useful if you need to find out the distribution meta-data  (passed as keyword
    args from *script* to :func:`setup`), or  the contents of the config files or
    command-line.
 
    *script_name* is a file that will be run with :func:`execfile` ``sys.argv[0]``
    will be replaced with *script* for the duration of the call.  *script_args* is a
    list of strings; if supplied, ``sys.argv[1:]`` will be replaced by *script_args*
    for the duration  of the call.
 
@@ -175,27 +179,28 @@
    |                        | Source files may be C, C++,    |                           |
    |                        | SWIG (.i), platform-specific   |                           |
    |                        | resource files, or whatever    |                           |
    |                        | else is recognized by the      |                           |
    |                        | :command:`build_ext` command   |                           |
    |                        | as source for a Python         |                           |
    |                        | extension.                     |                           |
    +------------------------+--------------------------------+---------------------------+
    | *include_dirs*         | list of directories to search  | string                    |
    |                        | for C/C++ header files (in     |                           |
    |                        | Unix form for portability)     |                           |
    +------------------------+--------------------------------+---------------------------+
-   | *define_macros*        | list of macros to define; each | (string,string)  tuple or |
-   |                        | macro is defined using a       | (name,``None``)           |
-   |                        | 2-tuple, where 'value' is      |                           |
+   | *define_macros*        | list of macros to define; each | (string, string) tuple or |
+   |                        | macro is defined using a       | (name, ``None``)          |
+   |                        | 2-tuple ``(name, value)``,     |                           |
+   |                        | where *value* is               |                           |
    |                        | either the string to define it |                           |
    |                        | to or ``None`` to define it    |                           |
    |                        | without a particular value     |                           |
    |                        | (equivalent of ``#define FOO`` |                           |
    |                        | in source or :option:`-DFOO`   |                           |
    |                        | on Unix C compiler command     |                           |
    |                        | line)                          |                           |
    +------------------------+--------------------------------+---------------------------+
    | *undef_macros*         | list of macros to undefine     | string                    |
    |                        | explicitly                     |                           |
    +------------------------+--------------------------------+---------------------------+
    | *library_dirs*         | list of directories to search  | string                    |
@@ -320,40 +325,40 @@
 
    The default values are ``os.name`` and ``sys.platform`` in case the parameters
    are not given.
 
 
 .. function:: new_compiler(plat=None, compiler=None, verbose=0, dry_run=0, force=0)
 
    Factory function to generate an instance of some CCompiler subclass for the
    supplied platform/compiler combination. *plat* defaults to ``os.name`` (eg.
    ``'posix'``, ``'nt'``), and *compiler*  defaults to the default compiler for
    that platform. Currently only ``'posix'`` and ``'nt'`` are supported, and the
    default compilers are "traditional Unix interface" (:class:`UnixCCompiler`
-   class) and Visual C++(:class:`MSVCCompiler` class).  Note that it's perfectly
+   class) and Visual C++ (:class:`MSVCCompiler` class).  Note that it's perfectly
    possible to ask for a Unix compiler object under Windows, and a Microsoft
    compiler object under Unix---if you supply a value for *compiler*, *plat* is
    ignored.
 
    .. % Is the posix/nt only thing still true? Mac OS X seems to work, and
    .. % returns a UnixCCompiler instance. How to document this... hmm.
 
 
 .. function:: show_compilers()
 
    Print list of available compilers (used by the :option:`--help-compiler` options
    to :command:`build`, :command:`build_ext`, :command:`build_clib`).
 
 
-.. class:: CCompiler([verbose=``0``, dry_run=``0``, force=``0``])
+.. class:: CCompiler([verbose=0, dry_run=0, force=0])
 
    The abstract base class :class:`CCompiler` defines the interface that  must be
    implemented by real compiler classes.  The class also has  some utility methods
    used by several compiler classes.
 
    The basic idea behind a compiler abstraction class is that each instance can be
    used for all the compile/link steps in building a single project.  Thus,
    attributes common to all of those compile and link steps --- include
    directories, macros to define, libraries to link against, etc. --- are
    attributes of the compiler instance.  To allow for variability in how individual
    files are treated, most of those attributes may be varied on a per-compilation
    or per-link basis.
@@ -425,40 +430,40 @@
 
       Add *dir* to the list of directories that will be searched for shared libraries
       at runtime.
 
 
    .. method:: CCompiler.set_runtime_library_dirs(dirs)
 
       Set the list of directories to search for shared libraries at runtime to *dirs*
       (a list of strings).  This does not affect any standard search path that the
       runtime linker may search by default.
 
 
-   .. method:: CCompiler.define_macro(name[, value=``None``])
+   .. method:: CCompiler.define_macro(name[, value=None])
 
       Define a preprocessor macro for all compilations driven by this compiler object.
       The optional parameter *value* should be a string; if it is not supplied, then
       the macro will be defined without an explicit value and the exact outcome
       depends on the compiler used (XXX true? does ANSI say anything about this?)
 
 
    .. method:: CCompiler.undefine_macro(name)
 
       Undefine a preprocessor macro for all compilations driven by this compiler
-      object.  If the same macro is defined by :meth:`define_macro` and undefined by
-      :meth:`undefine_macro`  the last call takes precedence (including multiple
-      redefinitions or undefinitions).  If the macro is redefined/undefined on a per-
-      compilation basis (ie. in the call to :meth:`compile`), then that takes
-      precedence.
+      object.  If the same macro is defined by :meth:`define_macro` and
+      undefined by :meth:`undefine_macro` the last call takes precedence
+      (including multiple redefinitions or undefinitions).  If the macro is
+      redefined/undefined on a per-compilation basis (ie. in the call to
+      :meth:`compile`), then that takes precedence.
 
 
    .. method:: CCompiler.add_link_object(object)
 
       Add *object* to the list of object files (or analogues, such as explicitly named
       library files or the output of "resource compilers") to be included in every
       link driven by this compiler object.
 
 
    .. method:: CCompiler.set_link_objects(objects)
 
       Set the list of object files (or analogues) to be included in every link to
@@ -467,33 +472,33 @@
 
    The following methods implement methods for autodetection of compiler  options,
    providing some functionality similar to GNU :program:`autoconf`.
 
 
    .. method:: CCompiler.detect_language(sources)
 
       Detect the language of a given file, or list of files. Uses the  instance
       attributes :attr:`language_map` (a dictionary), and  :attr:`language_order` (a
       list) to do the job.
 
 
-   .. method:: CCompiler.find_library_file(dirs, lib[, debug=``0``])
+   .. method:: CCompiler.find_library_file(dirs, lib[, debug=0])
 
       Search the specified list of directories for a static or shared library file
       *lib* and return the full path to that file.  If *debug* is true, look for a
       debugging version (if that makes sense on the current platform).  Return
       ``None`` if *lib* wasn't found in any of the specified directories.
 
 
-   .. method:: CCompiler.has_function(funcname [, includes=``None``, include_dirs=``None``, libraries=``None``, library_dirs=``None``])
+   .. method:: CCompiler.has_function(funcname [, includes=None, include_dirs=None, libraries=None, library_dirs=None])
 
       Return a boolean indicating whether *funcname* is supported on the current
       platform.  The optional arguments can be used to augment the compilation
       environment by providing additional include files and paths and libraries and
       paths.
 
 
    .. method:: CCompiler.library_dir_option(dir)
 
       Return the compiler option to add *dir* to the list of directories searched for
       libraries.
 
@@ -530,25 +535,25 @@
       | *archiver*   | static library creator                   |
       +--------------+------------------------------------------+
 
       On platforms with a command-line (Unix, DOS/Windows), each of these is a string
       that will be split into executable name and (optional) list of arguments.
       (Splitting the string is done similarly to how Unix shells operate: words are
       delimited by spaces, but quotes and backslashes can override this.  See
       :func:`distutils.util.split_quoted`.)
 
    The following methods invoke stages in the build process.
 
 
-   .. method:: CCompiler.compile(sources[, output_dir=``None``, macros=``None``, include_dirs=``None``, debug=``0``, extra_preargs=``None``, extra_postargs=``None``, depends=``None``])
+   .. method:: CCompiler.compile(sources[, output_dir=None, macros=None, include_dirs=None, debug=0, extra_preargs=None, extra_postargs=None, depends=None])
 
       Compile one or more source files. Generates object files (e.g.  transforms a
       :file:`.c` file to a :file:`.o` file.)
 
       *sources* must be a list of filenames, most likely C/C++ files, but in reality
       anything that can be handled by a particular compiler and compiler class (eg.
       :class:`MSVCCompiler` can handle resource files in *sources*).  Return a list of
       object filenames, one per source filename in *sources*.  Depending on the
       implementation, not all source files will necessarily be compiled, but all
       corresponding object filenames will be returned.
 
       If *output_dir* is given, object files will be put under it, while retaining
@@ -574,47 +579,47 @@
       compiler command line.  On other platforms, consult the implementation class
       documentation.  In any event, they are intended as an escape hatch for those
       occasions when the abstract compiler framework doesn't cut the mustard.
 
       *depends*, if given, is a list of filenames that all targets depend on.  If a
       source file is older than any file in depends, then the source file will be
       recompiled.  This supports dependency tracking, but only at a coarse
       granularity.
 
       Raises :exc:`CompileError` on failure.
 
 
-   .. method:: CCompiler.create_static_lib(objects, output_libname[, output_dir=``None``, debug=``0``, target_lang=``None``])
+   .. method:: CCompiler.create_static_lib(objects, output_libname[, output_dir=None, debug=0, target_lang=None])
 
       Link a bunch of stuff together to create a static library file. The "bunch of
       stuff" consists of the list of object files supplied as *objects*, the extra
       object files supplied to :meth:`add_link_object` and/or
       :meth:`set_link_objects`, the libraries supplied to :meth:`add_library` and/or
       :meth:`set_libraries`, and the libraries supplied as *libraries* (if any).
 
       *output_libname* should be a library name, not a filename; the filename will be
       inferred from the library name.  *output_dir* is the directory where the library
       file will be put. XXX defaults to what?
 
       *debug* is a boolean; if true, debugging information will be included in the
       library (note that on most platforms, it is the compile step where this matters:
       the *debug* flag is included here just for consistency).
 
       *target_lang* is the target language for which the given objects are being
       compiled. This allows specific linkage time treatment of certain languages.
 
       Raises :exc:`LibError` on failure.
 
 
-   .. method:: CCompiler.link(target_desc, objects, output_filename[, output_dir=``None``, libraries=``None``, library_dirs=``None``, runtime_library_dirs=``None``, export_symbols=``None``, debug=``0``, extra_preargs=``None``, extra_postargs=``None``, build_temp=``None``, target_lang=``None``])
+   .. method:: CCompiler.link(target_desc, objects, output_filename[, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, target_lang=None])
 
       Link a bunch of stuff together to create an executable or shared library file.
 
       The "bunch of stuff" consists of the list of object files supplied as *objects*.
       *output_filename* should be a filename.  If *output_dir* is supplied,
       *output_filename* is relative to it (i.e. *output_filename* can provide
       directory components if needed).
 
       *libraries* is a list of libraries to link against.  These are library names,
       not filenames, since they're translated into filenames in a platform-specific
       way (eg. *foo* becomes :file:`libfoo.a` on Unix and :file:`foo.lib` on
       DOS/Windows).  However, they can include a directory component, which means the
@@ -638,128 +643,128 @@
       sake).
 
       *extra_preargs* and *extra_postargs* are as for :meth:`compile`  (except of
       course that they supply command-line arguments for the particular linker being
       used).
 
       *target_lang* is the target language for which the given objects are being
       compiled. This allows specific linkage time treatment of certain languages.
 
       Raises :exc:`LinkError` on failure.
 
 
-   .. method:: CCompiler.link_executable(objects, output_progname[, output_dir=``None``, libraries=``None``, library_dirs=``None``, runtime_library_dirs=``None``, debug=``0``, extra_preargs=``None``, extra_postargs=``None``, target_lang=``None``])
+   .. method:: CCompiler.link_executable(objects, output_progname[, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, debug=0, extra_preargs=None, extra_postargs=None, target_lang=None])
 
       Link an executable.  *output_progname* is the name of the file executable, while
       *objects* are a list of object filenames to link in. Other arguments  are as for
       the :meth:`link` method.
 
 
-   .. method:: CCompiler.link_shared_lib(objects, output_libname[, output_dir=``None``, libraries=``None``, library_dirs=``None``, runtime_library_dirs=``None``, export_symbols=``None``, debug=``0``, extra_preargs=``None``, extra_postargs=``None``, build_temp=``None``, target_lang=``None``])
+   .. method:: CCompiler.link_shared_lib(objects, output_libname[, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, target_lang=None])
 
       Link a shared library. *output_libname* is the name of the output  library,
       while *objects* is a list of object filenames to link in.  Other arguments are
       as for the :meth:`link` method.
 
 
-   .. method:: CCompiler.link_shared_object(objects, output_filename[, output_dir=``None``, libraries=``None``, library_dirs=``None``, runtime_library_dirs=``None``, export_symbols=``None``, debug=``0``, extra_preargs=``None``, extra_postargs=``None``, build_temp=``None``, target_lang=``None``])
+   .. method:: CCompiler.link_shared_object(objects, output_filename[, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, target_lang=None])
 
       Link a shared object. *output_filename* is the name of the shared object that
       will be created, while *objects* is a list of object filenames  to link in.
       Other arguments are as for the :meth:`link` method.
 
 
-   .. method:: CCompiler.preprocess(source[, output_file=``None``, macros=``None``, include_dirs=``None``, extra_preargs=``None``, extra_postargs=``None``])
+   .. method:: CCompiler.preprocess(source[, output_file=None, macros=None, include_dirs=None, extra_preargs=None, extra_postargs=None])
 
       Preprocess a single C/C++ source file, named in *source*. Output will be written
       to file named *output_file*, or *stdout* if *output_file* not supplied.
       *macros* is a list of macro definitions as for :meth:`compile`, which will
       augment the macros set with :meth:`define_macro` and :meth:`undefine_macro`.
       *include_dirs* is a list of directory names that will be added to the  default
       list, in the same way as :meth:`add_include_dir`.
 
       Raises :exc:`PreprocessError` on failure.
 
    The following utility methods are defined by the :class:`CCompiler` class, for
    use by the various concrete subclasses.
 
 
-   .. method:: CCompiler.executable_filename(basename[, strip_dir=``0``, output_dir=``''``])
+   .. method:: CCompiler.executable_filename(basename[, strip_dir=0, output_dir=''])
 
       Returns the filename of the executable for the given *basename*.  Typically for
       non-Windows platforms this is the same as the basename,  while Windows will get
       a :file:`.exe` added.
 
 
-   .. method:: CCompiler.library_filename(libname[, lib_type=``'static'``, strip_dir=``0``, output_dir=``''``])
+   .. method:: CCompiler.library_filename(libname[, lib_type='static', strip_dir=0, output_dir=''])
 
       Returns the filename for the given library name on the current platform. On Unix
       a library with *lib_type* of ``'static'`` will typically  be of the form
       :file:`liblibname.a`, while a *lib_type* of ``'dynamic'``  will be of the form
       :file:`liblibname.so`.
 
 
-   .. method:: CCompiler.object_filenames(source_filenames[, strip_dir=``0``, output_dir=``''``])
+   .. method:: CCompiler.object_filenames(source_filenames[, strip_dir=0, output_dir=''])
 
       Returns the name of the object files for the given source files.
       *source_filenames* should be a list of filenames.
 
 
-   .. method:: CCompiler.shared_object_filename(basename[, strip_dir=``0``, output_dir=``''``])
+   .. method:: CCompiler.shared_object_filename(basename[, strip_dir=0, output_dir=''])
 
       Returns the name of a shared object file for the given file name *basename*.
 
 
-   .. method:: CCompiler.execute(func, args[, msg=``None``, level=``1``])
+   .. method:: CCompiler.execute(func, args[, msg=None, level=1])
 
       Invokes :func:`distutils.util.execute` This method invokes a  Python function
       *func* with the given arguments *args*, after  logging and taking into account
       the *dry_run* flag. XXX see also.
 
 
    .. method:: CCompiler.spawn(cmd)
 
       Invokes :func:`distutils.util.spawn`. This invokes an external  process to run
       the given command. XXX see also.
 
 
-   .. method:: CCompiler.mkpath(name[, mode=``511``])
+   .. method:: CCompiler.mkpath(name[, mode=511])
 
       Invokes :func:`distutils.dir_util.mkpath`. This creates a directory  and any
       missing ancestor directories. XXX see also.
 
 
    .. method:: CCompiler.move_file(src, dst)
 
       Invokes :meth:`distutils.file_util.move_file`. Renames *src* to  *dst*.  XXX see
       also.
 
 
-   .. method:: CCompiler.announce(msg[, level=``1``])
+   .. method:: CCompiler.announce(msg[, level=1])
 
       Write a message using :func:`distutils.log.debug`. XXX see also.
 
 
    .. method:: CCompiler.warn(msg)
 
       Write a warning message *msg* to standard error.
 
 
    .. method:: CCompiler.debug_print(msg)
 
       If the *debug* flag is set on this :class:`CCompiler` instance, print  *msg* to
       standard output, otherwise do nothing.
 
 .. % \subsection{Compiler-specific modules}
-.. % 
+.. %
 .. % The following modules implement concrete subclasses of the abstract
 .. % \class{CCompiler} class. They should not be instantiated directly, but should
 .. % be created using \function{distutils.ccompiler.new_compiler()} factory
 .. % function.
 
 
 :mod:`distutils.unixccompiler` --- Unix C Compiler
 ==================================================
 
 .. module:: distutils.unixccompiler
    :synopsis: UNIX C Compiler
 
@@ -845,72 +850,72 @@
 :mod:`distutils.mwerkscompiler` --- Metrowerks CodeWarrior support
 ==================================================================
 
 .. module:: distutils.mwerkscompiler
    :synopsis: Metrowerks CodeWarrior support
 
 
 Contains :class:`MWerksCompiler`, an implementation of the abstract
 :class:`CCompiler` class for MetroWerks CodeWarrior on the pre-Mac OS X
 Macintosh. Needs work to support CW on Windows or Mac OS X.
 
 .. % \subsection{Utility modules}
-.. % 
+.. %
 .. % The following modules all provide general utility functions. They haven't
 .. % all been documented yet.
 
 
 :mod:`distutils.archive_util` ---  Archiving utilities
 ======================================================
 
 .. module:: distutils.archive_util
    :synopsis: Utility functions for creating archive files (tarballs, zip files, ...)
 
 
 This module provides a few functions for creating archive files, such as
 tarballs or zipfiles.
 
 
-.. function:: make_archive(base_name, format[, root_dir=``None``, base_dir=``None``, verbose=``0``, dry_run=``0``])
+.. function:: make_archive(base_name, format[, root_dir=None, base_dir=None, verbose=0, dry_run=0])
 
    Create an archive file (eg. ``zip`` or ``tar``).  *base_name*  is the name of
    the file to create, minus any format-specific extension;  *format* is the
    archive format: one of ``zip``, ``tar``,  ``ztar``, or ``gztar``. *root_dir* is
    a directory that will be the root directory of the archive; ie. we typically
    ``chdir`` into *root_dir* before  creating the archive.  *base_dir* is the
    directory where we start  archiving from; ie. *base_dir* will be the common
    prefix of all files and directories in the archive.  *root_dir* and *base_dir*
    both default to the current directory.  Returns the name of the archive file.
 
    .. warning::
 
       This should be changed to support bz2 files
 
 
-.. function:: make_tarball(base_name, base_dir[, compress=``'gzip'``, verbose=``0``, dry_run=``0``])
+.. function:: make_tarball(base_name, base_dir[, compress='gzip', verbose=0, dry_run=0])
 
    'Create an (optional compressed) archive as a tar file from all files in and
    under *base_dir*. *compress* must be ``'gzip'`` (the default),  ``'compress'``,
    ``'bzip2'``, or ``None``.  Both :program:`tar` and the compression utility named
    by *compress* must be on the  default program search path, so this is probably
    Unix-specific.  The  output tar file will be named :file:`base_dir.tar`,
    possibly plus the appropriate compression extension (:file:`.gz`, :file:`.bz2`
    or :file:`.Z`).  Return the output filename.
 
    .. warning::
 
       This should be replaced with calls to the :mod:`tarfile` module.
 
 
-.. function:: make_zipfile(base_name, base_dir[, verbose=``0``, dry_run=``0``])
+.. function:: make_zipfile(base_name, base_dir[, verbose=0, dry_run=0])
 
    Create a zip file from all files in and under *base_dir*.  The output zip file
    will be named *base_dir* + :file:`.zip`.  Uses either the  :mod:`zipfile` Python
    module (if available) or the InfoZIP :file:`zip`  utility (if installed and
    found on the default search path).  If neither  tool is available, raises
    :exc:`DistutilsExecError`.   Returns the name of the output zip file.
 
 
 :mod:`distutils.dep_util` --- Dependency checking
 =================================================
 
 .. module:: distutils.dep_util
@@ -930,149 +935,149 @@
    *source* does not exist.
 
 
 .. function:: newer_pairwise(sources, targets)
 
    Walk two filename lists in parallel, testing if each source is newer than its
    corresponding target.  Return a pair of lists (*sources*, *targets*) where
    source is newer than target, according to the semantics of :func:`newer`
 
    .. % % equivalent to a listcomp...
 
 
-.. function:: newer_group(sources, target[, missing=``'error'``])
+.. function:: newer_group(sources, target[, missing='error'])
 
    Return true if *target* is out-of-date with respect to any file listed in
    *sources*  In other words, if *target* exists and is newer than every file in
    *sources*, return false; otherwise return true. *missing* controls what we do
    when a source file is missing; the default (``'error'``) is to blow up with an
    :exc:`OSError` from  inside :func:`os.stat`; if it is ``'ignore'``, we silently
    drop any missing source files; if it is ``'newer'``, any missing source files
    make us assume that *target* is out-of-date (this is handy in "dry-run" mode:
    it'll make you pretend to carry out commands that wouldn't work because inputs
    are missing, but that doesn't matter because you're not actually going to run
    the commands).
 
 
 :mod:`distutils.dir_util` --- Directory tree operations
 =======================================================
 
 .. module:: distutils.dir_util
    :synopsis: Utility functions for operating on directories and directory trees
 
 
 This module provides functions for operating on directories and trees of
 directories.
 
 
-.. function:: mkpath(name[, mode=``0777``, verbose=``0``, dry_run=``0``])
+.. function:: mkpath(name[, mode=0777, verbose=0, dry_run=0])
 
    Create a directory and any missing ancestor directories.  If the directory
    already exists (or if *name* is the empty string, which means the current
    directory, which of course exists), then do nothing.  Raise
    :exc:`DistutilsFileError` if unable to create some directory along the way (eg.
    some sub-path exists, but is a file rather than a directory).  If *verbose* is
    true, print a one-line summary of each mkdir to stdout.  Return the list of
    directories actually created.
 
 
-.. function:: create_tree(base_dir, files[, mode=``0777``, verbose=``0``, dry_run=``0``])
+.. function:: create_tree(base_dir, files[, mode=0777, verbose=0, dry_run=0])
 
    Create all the empty directories under *base_dir* needed to put *files* there.
    *base_dir* is just the a name of a directory which doesn't necessarily exist
    yet; *files* is a list of filenames to be interpreted relative to *base_dir*.
    *base_dir* + the directory portion of every file in *files* will be created if
    it doesn't already exist.  *mode*, *verbose* and *dry_run* flags  are as for
    :func:`mkpath`.
 
 
-.. function:: copy_tree(src, dst[preserve_mode=``1``, preserve_times=``1``, preserve_symlinks=``0``, update=``0``, verbose=``0``, dry_run=``0``])
+.. function:: copy_tree(src, dst[, preserve_mode=1, preserve_times=1, preserve_symlinks=0, update=0, verbose=0, dry_run=0])
 
    Copy an entire directory tree *src* to a new location *dst*.  Both *src* and
    *dst* must be directory names.  If *src* is not a directory, raise
    :exc:`DistutilsFileError`.  If *dst* does  not exist, it is created with
    :func:`mkpath`.  The end result of the  copy is that every file in *src* is
    copied to *dst*, and  directories under *src* are recursively copied to *dst*.
    Return the list of files that were copied or might have been copied, using their
    output name. The return value is unaffected by *update* or *dry_run*: it is
    simply the list of all files under *src*, with the names changed to be under
    *dst*.
 
    *preserve_mode* and *preserve_times* are the same as for :func:`copy_file` in
    :mod:`distutils.file_util`; note that they only apply to regular files, not to
    directories.  If *preserve_symlinks* is true, symlinks will be copied as
    symlinks (on platforms that support them!); otherwise (the default), the
    destination of the symlink will be copied.  *update* and *verbose* are the same
    as for :func:`copy_file`.
 
 
-.. function:: remove_tree(directory[verbose=``0``, dry_run=``0``])
+.. function:: remove_tree(directory[, verbose=0, dry_run=0])
 
    Recursively remove *directory* and all files and directories underneath it. Any
    errors are ignored (apart from being reported to ``sys.stdout`` if *verbose* is
    true).
 
 **\*\*** Some of this could be replaced with the shutil module? **\*\***
 
 
 :mod:`distutils.file_util` --- Single file operations
 =====================================================
 
 .. module:: distutils.file_util
    :synopsis: Utility functions for operating on single files
 
 
 This module contains some utility functions for operating on individual files.
 
 
-.. function:: copy_file(src, dst[preserve_mode=``1``, preserve_times=``1``, update=``0``, link=``None``, verbose=``0``, dry_run=``0``])
+.. function:: copy_file(src, dst[, preserve_mode=1, preserve_times=1, update=0, link=None, verbose=0, dry_run=0])
 
    Copy file *src* to *dst*. If *dst* is a directory, then *src* is copied there
    with the same name; otherwise, it must be a filename. (If the file exists, it
    will be ruthlessly clobbered.) If *preserve_mode* is true (the default), the
-   file's mode (type and permission bits, or whatever is analogous on the current
+   file's mode (type and permission bits, or whatever is analogous on the
-   platform) is copied. If *preserve_times* is true (the default), the last-
+   current platform) is copied. If *preserve_times* is true (the default), the
-   modified and last-access times are copied as well. If *update* is true, *src*
+   last-modified and last-access times are copied as well. If *update* is true,
-   will only be copied if *dst* does not exist, or if *dst* does exist but is older
+   *src* will only be copied if *dst* does not exist, or if *dst* does exist but
-   than *src*.
+   is older than *src*.
 
    *link* allows you to make hard links (using :func:`os.link`) or symbolic links
    (using :func:`os.symlink`) instead of copying: set it to ``'hard'`` or
    ``'sym'``; if it is ``None`` (the default), files are copied. Don't set *link*
    on systems that don't support it: :func:`copy_file` doesn't check if hard or
    symbolic linking is available.  It uses :func:`_copy_file_contents` to copy file
    contents.
 
    Return a tuple ``(dest_name, copied)``: *dest_name* is the actual  name of the
    output file, and *copied* is true if the file was copied  (or would have been
    copied, if *dry_run* true).
 
    .. % XXX if the destination file already exists, we clobber it if
    .. % copying, but blow up if linking.  Hmmm.  And I don't know what
    .. % macostools.copyfile() does.  Should definitely be consistent, and
    .. % should probably blow up if destination exists and we would be
    .. % changing it (ie. it's not already a hard/soft link to src OR
    .. % (not update) and (src newer than dst)).
 
 
-.. function:: move_file(src, dst[verbose, dry_run])
+.. function:: move_file(src, dst[, verbose, dry_run])
 
    Move file *src* to *dst*. If *dst* is a directory, the file will be moved into
    it with the same name; otherwise, *src* is just renamed to *dst*.  Returns the
    new full name of the file.
 
    .. warning::
 
-      Handles cross-device moves on Unix using :func:`copy_file`.   What about other
-      systems???
+      Handles cross-device moves on Unix using :func:`copy_file`.  What about
+      other systems?
 
 
 .. function:: write_file(filename, contents)
 
    Create a file called *filename* and write *contents* (a sequence of strings
    without line terminators) to it.
 
 
 :mod:`distutils.util` --- Miscellaneous other utility functions
 ===============================================================
 
 .. module:: distutils.util
@@ -1086,35 +1091,49 @@
 .. function:: get_platform()
 
    Return a string that identifies the current platform.  This is used mainly to
    distinguish platform-specific build directories and platform-specific built
    distributions.  Typically includes the OS name and version and the architecture
    (as supplied by 'os.uname()'), although the exact information included depends
    on the OS; eg. for IRIX the architecture isn't particularly important (IRIX only
    runs on SGI hardware), but for Linux the kernel version isn't particularly
    important.
 
    Examples of returned values:
 
-* ``linux-i586``
-* ``linux-alpha``
-* ``solaris-2.6-sun4u``
-* ``irix-5.3``
-* ``irix64-6.2``
+   * ``linux-i586``
+   * ``linux-alpha``
+   * ``solaris-2.6-sun4u``
+   * ``irix-5.3``
+   * ``irix64-6.2``
 
-   For non-POSIX platforms, currently just returns ``sys.platform``.
+   For non-POSIX platforms, currently just returns ``sys.platform``.
 
+   For Mac OS X systems the OS version reflects the minimal version on which
+   binaries will run (that is, the value of ``MACOSX_DEPLOYMENT_TARGET``
+   during the build of Python), not the OS version of the current system.
 
+   For universal binary builds on Mac OS X the architecture value reflects
+   the univeral binary status instead of the architecture of the current
+   processor. For 32-bit universal binaries the architecture is ``fat``,
+   for 64-bit universal binaries the architecture is ``fat64``, and
+   for 4-way universal binaries the architecture is ``universal``.
 
+   Examples of returned values on Mac OS X:
 
+   * ``macosx-10.3-ppc``
+
+   * ``macosx-10.3-fat``
+
+   * ``macosx-10.5-universal``
 
    .. % XXX isn't this also provided by some other non-distutils module?
 
 
 .. function:: convert_path(pathname)
 
    Return 'pathname' as a name that will work on the native filesystem, i.e. split
    it on '/' and put it back together again using the current directory separator.
    Needed because filenames in the setup script are always supplied in Unix style,
    and have to be converted to the local convention before we can actually use them
    in the filesystem.  Raises :exc:`ValueError` on non-Unix-ish systems if
    *pathname* either  starts or ends with a slash.
@@ -1124,101 +1143,98 @@
 
    Return *pathname* with *new_root* prepended.  If *pathname* is relative, this is
    equivalent to ``os.path.join(new_root,pathname)`` Otherwise, it requires making
    *pathname* relative and then joining the two, which is tricky on DOS/Windows.
 
 
 .. function:: check_environ()
 
    Ensure that 'os.environ' has all the environment variables we guarantee that
    users can use in config files, command-line options, etc.  Currently this
    includes:
 
-* :envvar:`HOME` - user's home directory (Unix only)
-
-* :envvar:`PLAT` - description of the current platform, including hardware and
+   * :envvar:`HOME` - user's home directory (Unix only)
+   * :envvar:`PLAT` - description of the current platform, including hardware and
      OS (see :func:`get_platform`)
 
 
 .. function:: subst_vars(s, local_vars)
 
    Perform shell/Perl-style variable substitution on *s*.  Every occurrence of
    ``$`` followed by a name is considered a variable, and variable is substituted
    by the value found in the *local_vars* dictionary, or in ``os.environ`` if it's
    not in *local_vars*. *os.environ* is first checked/augmented to guarantee that
    it contains certain values: see :func:`check_environ`.  Raise :exc:`ValueError`
    for any variables not found in either *local_vars* or ``os.environ``.
 
    Note that this is not a fully-fledged string interpolation function. A valid
    ``$variable`` can consist only of upper and lower case letters, numbers and an
    underscore. No { } or ( ) style quoting is available.
 
 
-.. function:: grok_environment_error(exc[, prefix=``'error: '``])
+.. function:: grok_environment_error(exc[, prefix='error: '])
 
    Generate a useful error message from an :exc:`EnvironmentError`  (:exc:`IOError`
    or :exc:`OSError`) exception object.   Handles Python 1.5.1 and later styles,
    and does what it can to deal with  exception objects that don't have a filename
    (which happens when the error  is due to a two-file operation, such as
    :func:`rename` or  :func:`link`).  Returns the error message as a string
    prefixed  with *prefix*.
 
 
 .. function:: split_quoted(s)
 
    Split a string up according to Unix shell-like rules for quotes and backslashes.
    In short: words are delimited by spaces, as long as those spaces are not escaped
    by a backslash, or inside a quoted string. Single and double quotes are
    equivalent, and the quote characters can be backslash-escaped.  The backslash is
    stripped from any two-character escape sequence, leaving only the escaped
    character.  The quote characters are stripped from any quoted string.  Returns a
    list of words.
 
    .. % Should probably be moved into the standard library.
 
 
-.. function:: execute(func, args[, msg=``None``, verbose=``0``, dry_run=``0``])
+.. function:: execute(func, args[, msg=None, verbose=0, dry_run=0])
 
    Perform some action that affects the outside world (for instance, writing to the
    filesystem).  Such actions are special because they are disabled by the
    *dry_run* flag.  This method takes  care of all that bureaucracy for you; all
    you have to do is supply the function to call and an argument tuple for it (to
    embody the "external action" being performed), and an optional message to print.
 
 
 .. function:: strtobool(val)
 
    Convert a string representation of truth to true (1) or false (0).
 
    True values are ``y``, ``yes``, ``t``, ``true``, ``on``  and ``1``; false values
    are ``n``, ``no``, ``f``, ``false``,  ``off`` and ``0``.  Raises
    :exc:`ValueError` if *val*  is anything else.
 
 
-.. function:: byte_compile(py_files[, optimize=``0``, force=``0``, prefix=``None``, base_dir=``None``, verbose=``1``, dry_run=``0``, direct=``None``])
+.. function:: byte_compile(py_files[, optimize=0, force=0, prefix=None, base_dir=None, verbose=1, dry_run=0, direct=None])
 
    Byte-compile a collection of Python source files to either :file:`.pyc` or
    :file:`.pyo` files in the same directory.  *py_files* is a list of files to
    compile; any files that don't end in :file:`.py` are silently skipped.
    *optimize* must be one of the following:
 
-* ``0`` - don't optimize (generate :file:`.pyc`)
-
-* ``1`` - normal optimization (like ``python -O``)
-
-* ``2`` - extra optimization (like ``python -OO``)
+   * ``0`` - don't optimize (generate :file:`.pyc`)
+   * ``1`` - normal optimization (like ``python -O``)
+   * ``2`` - extra optimization (like ``python -OO``)
 
    If *force* is true, all files are recompiled regardless of timestamps.
 
-   The source filename encoded in each bytecode file defaults to the filenames
+   The source filename encoded in each :term:`bytecode` file defaults to the filenames
    listed in *py_files*; you can modify these with *prefix* and *basedir*.
    *prefix* is a string that will be stripped off of each source filename, and
    *base_dir* is a directory name that will be prepended (after *prefix* is
    stripped).  You can supply either or both (or neither) of *prefix* and
    *base_dir*, as you wish.
 
    If *dry_run* is true, doesn't actually do anything that would affect the
    filesystem.
 
    Byte-compilation is either done directly in this interpreter process with the
    standard :mod:`py_compile` module, or indirectly by writing a temporary script
    and executing it.  Normally, you should let :func:`byte_compile` figure out to
@@ -1327,59 +1343,59 @@
 
 
 .. function:: wrap_text(text, width)
 
    Wraps *text* to less than *width* wide.
 
    .. warning::
 
       Should be replaced with :mod:`textwrap` (which is available  in Python 2.3 and
       later).
 
 
-.. class:: FancyGetopt([option_table=``None``])
+.. class:: FancyGetopt([option_table=None])
 
    The option_table is a list of 3-tuples: ``(long_option, short_option,
    help_string)``
 
    If an option takes an argument, its *long_option* should have ``'='`` appended;
    *short_option* should just be a single character, no ``':'`` in any case.
    *short_option* should be ``None`` if a *long_option*  doesn't have a
    corresponding *short_option*. All option tuples must have long options.
 
 The :class:`FancyGetopt` class provides the following methods:
 
 
-.. method:: FancyGetopt.getopt([args=``None``, object=``None``])
+.. method:: FancyGetopt.getopt([args=None, object=None])
 
    Parse command-line options in args. Store as attributes on *object*.
 
    If *args* is ``None`` or not supplied, uses ``sys.argv[1:]``.  If *object* is
    ``None`` or not supplied, creates a new :class:`OptionDummy` instance, stores
    option values there, and returns a tuple ``(args, object)``.  If *object* is
    supplied, it is modified in place and :func:`getopt` just returns *args*; in
    both cases, the returned *args* is a modified copy of the passed-in *args* list,
    which is left untouched.
 
    .. % and args returned are?
 
 
 .. method:: FancyGetopt.get_option_order()
 
    Returns the list of ``(option, value)`` tuples processed by the previous run of
    :meth:`getopt`  Raises :exc:`RuntimeError` if :meth:`getopt` hasn't been called
    yet.
 
 
-.. method:: FancyGetopt.generate_help([header=``None``])
+.. method:: FancyGetopt.generate_help([header=None])
 
    Generate help text (a list of strings, one per suggested line of output) from
    the option table for this :class:`FancyGetopt` object.
 
    If supplied, prints the supplied *header* at the top of the help.
 
 
 :mod:`distutils.filelist` --- The FileList class
 ================================================
 
 .. module:: distutils.filelist
    :synopsis: The FileList class, used for poking about the file system and building lists of
@@ -1409,39 +1425,150 @@
 :mod:`distutils.spawn` --- Spawn a sub-process
 ==============================================
 
 .. module:: distutils.spawn
    :synopsis: Provides the spawn() function
 
 
 This module provides the :func:`spawn` function, a front-end to  various
 platform-specific functions for launching another program in a  sub-process.
 Also provides :func:`find_executable` to search the path for a given executable
 name.
 
-XXX: input{sysconfig} :XXX
+
+:mod:`distutils.sysconfig` --- System configuration information
+===============================================================
+
+.. module:: distutils.sysconfig
+   :synopsis: Low-level access to configuration information of the Python interpreter.
+.. moduleauthor:: Fred L. Drake, Jr. <fdrake@acm.org>
+.. moduleauthor:: Greg Ward <gward@python.net>
+.. sectionauthor:: Fred L. Drake, Jr. <fdrake@acm.org>
+
+
+The :mod:`distutils.sysconfig` module provides access to Python's low-level
+configuration information.  The specific configuration variables available
+depend heavily on the platform and configuration. The specific variables depend
+on the build process for the specific version of Python being run; the variables
+are those found in the :file:`Makefile` and configuration header that are
+installed with Python on Unix systems.  The configuration header is called
+:file:`pyconfig.h` for Python versions starting with 2.2, and :file:`config.h`
+for earlier versions of Python.
+
+Some additional functions are provided which perform some useful manipulations
+for other parts of the :mod:`distutils` package.
+
+
+.. data:: PREFIX
+
+   The result of ``os.path.normpath(sys.prefix)``.
+
+
+.. data:: EXEC_PREFIX
+
+   The result of ``os.path.normpath(sys.exec_prefix)``.
+
+
+.. function:: get_config_var(name)
+
+   Return the value of a single variable.  This is equivalent to
+   ``get_config_vars().get(name)``.
+
+
+.. function:: get_config_vars(...)
+
+   Return a set of variable definitions.  If there are no arguments, this returns a
+   dictionary mapping names of configuration variables to values.  If arguments are
+   provided, they should be strings, and the return value will be a sequence giving
+   the associated values. If a given name does not have a corresponding value,
+   ``None`` will be included for that variable.
+
+
+.. function:: get_config_h_filename()
+
+   Return the full path name of the configuration header.  For Unix, this will be
+   the header generated by the :program:`configure` script; for other platforms the
+   header will have been supplied directly by the Python source distribution.  The
+   file is a platform-specific text file.
+
+
+.. function:: get_makefile_filename()
+
+   Return the full path name of the :file:`Makefile` used to build Python.  For
+   Unix, this will be a file generated by the :program:`configure` script; the
+   meaning for other platforms will vary.  The file is a platform-specific text
+   file, if it exists. This function is only useful on POSIX platforms.
+
+
+.. function:: get_python_inc([plat_specific[, prefix]])
+
+   Return the directory for either the general or platform-dependent C include
+   files.  If *plat_specific* is true, the platform-dependent include directory is
+   returned; if false or omitted, the platform-independent directory is returned.
+   If *prefix* is given, it is used as either the prefix instead of
+   :const:`PREFIX`, or as the exec-prefix instead of :const:`EXEC_PREFIX` if
+   *plat_specific* is true.
+
+
+.. function:: get_python_lib([plat_specific[, standard_lib[, prefix]]])
+
+   Return the directory for either the general or platform-dependent library
+   installation.  If *plat_specific* is true, the platform-dependent include
+   directory is returned; if false or omitted, the platform-independent directory
+   is returned.  If *prefix* is given, it is used as either the prefix instead of
+   :const:`PREFIX`, or as the exec-prefix instead of :const:`EXEC_PREFIX` if
+   *plat_specific* is true.  If *standard_lib* is true, the directory for the
+   standard library is returned rather than the directory for the installation of
+   third-party extensions.
+
+The following function is only intended for use within the :mod:`distutils`
+package.
+
+
+.. function:: customize_compiler(compiler)
+
+   Do any platform-specific customization of a
+   :class:`distutils.ccompiler.CCompiler` instance.
+
+   This function is only needed on Unix at this time, but should be called
+   consistently to support forward-compatibility.  It inserts the information that
+   varies across Unix flavors and is stored in Python's :file:`Makefile`.  This
+   information includes the selected compiler, compiler and linker options, and the
+   extension used by the linker for shared objects.
+
+This function is even more special-purpose, and should only be used from
+Python's own build procedures.
+
+
+.. function:: set_python_build()
+
+   Inform the :mod:`distutils.sysconfig` module that it is being used as part of
+   the build process for Python.  This changes a lot of relative locations for
+   files, allowing them to be located in the build area rather than in an installed
+   Python.
+
 
 :mod:`distutils.text_file` --- The TextFile class
 =================================================
 
 .. module:: distutils.text_file
    :synopsis: provides the TextFile class, a simple interface to text files
 
 
 This module provides the :class:`TextFile` class, which gives an interface  to
 text files that (optionally) takes care of stripping comments, ignoring  blank
 lines, and joining lines with backslashes.
 
 
-.. class:: TextFile([filename=``None``, file=``None``, **options])
+.. class:: TextFile([filename=None, file=None, **options])
 
    This class provides a file-like object that takes care of all  the things you
    commonly want to do when processing a text file  that has some line-by-line
    syntax: strip comments (as long as ``#``  is your comment character), skip blank
    lines, join adjacent lines by escaping the newline (ie. backslash at end of
    line), strip leading and/or trailing whitespace.  All of these are optional and
    independently controllable.
 
    The class provides a :meth:`warn` method so you can generate  warning messages
    that report physical line number, even if the  logical line in question spans
    multiple physical lines.  Also  provides :meth:`unreadline` for implementing
    line-at-a-time lookahead.
@@ -1511,25 +1638,25 @@
    .. method:: TextFile.open(filename)
 
       Open a new file *filename*. This overrides any *file* or  *filename* constructor
       arguments.
 
 
    .. method:: TextFile.close()
 
       Close the current file and forget everything we know about it (including the
       filename and the current line number).
 
 
-   .. method:: TextFile.warn(msg[,line=``None``])
+   .. method:: TextFile.warn(msg[,line=None])
 
       Print (to stderr) a warning message tied to the current logical line in the
       current file.  If the current logical line in the file spans multiple physical
       lines, the warning refers to the whole range, such as ``"lines 3-5"``.  If
       *line* is supplied,  it overrides the current line number; it may be a list or
       tuple  to indicate a range of physical lines, or an integer for a  single
       physical line.
 
 
    .. method:: TextFile.readline()
 
       Read and return a single logical line from the current file (or from an internal
@@ -1557,25 +1684,25 @@
       to :meth:`readline`, the lines will be returned most in most recent first order.
 
 
 :mod:`distutils.version` --- Version number classes
 ===================================================
 
 .. module:: distutils.version
    :synopsis: implements classes that represent module version numbers.
 
 
 .. % todo
 .. % \section{Distutils Commands}
-.. % 
+.. %
 .. % This part of Distutils implements the various Distutils commands, such
 .. % as \code{build}, \code{install} \&c. Each command is implemented as a
 .. % separate module, with the command name as the name of the module.
 
 
 :mod:`distutils.cmd` --- Abstract base class for Distutils commands
 ===================================================================
 
 .. module:: distutils.cmd
    :synopsis: This module provides the abstract base class Command. This class is subclassed
               by the modules in the distutils.command  subpackage.
 
@@ -1633,24 +1760,42 @@
 
 
 :mod:`distutils.command.bdist_dumb` --- Build a "dumb" installer
 ================================================================
 
 .. module:: distutils.command.bdist_dumb
    :synopsis: Build a "dumb" installer - a simple archive of files
 
 
 .. % todo
 
 
+:mod:`distutils.command.bdist_msi` --- Build a Microsoft Installer binary package
+=================================================================================
+
+.. module:: distutils.command.bdist_msi
+   :synopsis: Build a binary distribution as a Windows MSI file
+
+.. class:: bdist_msi(Command)
+
+   Builds a `Windows Installer`_ (.msi) binary package.
+
+   .. _Windows Installer: http://msdn.microsoft.com/en-us/library/cc185688(VS.85).aspx
+
+   In most cases, the ``bdist_msi`` installer is a better choice than the
+   ``bdist_wininst`` installer, because it provides better support for
+   Win64 platforms, allows administrators to perform non-interactive
+   installations, and allows installation through group policies.
+
+
 :mod:`distutils.command.bdist_rpm` --- Build a binary distribution as a Redhat RPM and SRPM
 ===========================================================================================
 
 .. module:: distutils.command.bdist_rpm
    :synopsis: Build a binary distribution as a Redhat RPM and SRPM
 
 
 .. % todo
 
 
 :mod:`distutils.command.bdist_wininst` --- Build a Windows installer
 ====================================================================
@@ -1814,69 +1959,52 @@
 is a sample template in that directory called  :file:`command_template`. Copy
 this file to a new module with the same name as the new command you're
 implementing. This module should implement a class with the same name as the
 module (and the command). So, for instance, to create the command
 ``peel_banana`` (so that users can run ``setup.py peel_banana``), you'd copy
 :file:`command_template`  to :file:`distutils/command/peel_banana.py`, then edit
 it so that it's implementing the class :class:`peel_banana`, a subclass of
 :class:`distutils.cmd.Command`.
 
 Subclasses of :class:`Command` must define the following methods.
 
 
-.. method:: XXX Class.initialize_options()(S)
+.. method:: Command.initialize_options()(S)
 
    et default values for all the options that this command supports.  Note that
    these defaults may be overridden by other commands, by the setup script, by
    config files, or by the command-line.  Thus, this is not the place to code
    dependencies between options; generally, :meth:`initialize_options`
    implementations are just a bunch of ``self.foo = None`` assignments.
 
 
-.. method:: XXX Class.finalize_options()
+.. method:: Command.finalize_options()
 
-   Set final values for all the options that this command supports. This is always
+   Set final values for all the options that this command supports. This is
-   called as late as possible, ie.  after any option assignments from the command-
+   always called as late as possible, ie.  after any option assignments from the
-   line or from other commands have been done.  Thus, this is the place to to code
+   command-line or from other commands have been done.  Thus, this is the place
-   option dependencies: if *foo* depends on *bar*, then it is safe to set *foo*
+   to to code option dependencies: if *foo* depends on *bar*, then it is safe to
-   from  *bar* as long as *foo* still has the same value it was assigned in
+   set *foo* from *bar* as long as *foo* still has the same value it was
-   :meth:`initialize_options`.
+   assigned in :meth:`initialize_options`.
 
 
-.. method:: XXX Class.run()
+.. method:: Command.run()
 
    A command's raison d'etre: carry out the action it exists to perform, controlled
    by the options initialized in :meth:`initialize_options`, customized by other
    commands, the setup script, the command-line, and config files, and finalized in
    :meth:`finalize_options`.  All terminal output and filesystem interaction should
    be done by :meth:`run`.
 
 *sub_commands* formalizes the notion of a "family" of commands, eg. ``install``
 as the parent with sub-commands ``install_lib``, ``install_headers``, etc.  The
 parent of a family of commands defines *sub_commands* as a class attribute; it's
 a list of 2-tuples ``(command_name, predicate)``, with *command_name* a string
 and *predicate* an unbound method, a string or None. *predicate* is a method of
 the parent command that determines whether the corresponding command is
 applicable in the current situation.  (Eg. we ``install_headers`` is only
 applicable if we have any C header files to install.)  If *predicate* is None,
 that command is always applicable.
 
 *sub_commands* is usually defined at the \*end\* of a class, because predicates
 can be unbound methods, so they must already have been defined.  The canonical
 example is the :command:`install` command.
-
-.. % 
-.. % The ugly "%begin{latexonly}" pseudo-environments are really just to
-.. % keep LaTeX2HTML quiet during the \renewcommand{} macros; they're
-.. % not really valuable.
-.. % 
-.. % begin{latexonly}
-.. % end{latexonly}
-
-XXX: input{moddist.ind} :XXX
-.. % Module Index
-.. % begin{latexonly}
-.. % end{latexonly}
-
-XXX: input{dist.ind} :XXX
-.. % Index
-
