Index: Doc/c-api/arg.rst
===================================================================
--- Doc/c-api/arg.rst	(révision 81840)
+++ Doc/c-api/arg.rst	(copie de travail)
@@ -32,11 +32,11 @@
 
 These formats do not expect you to provide raw storage for the returned string
 or bytes.  Also, you won't have to release any memory yourself, except with
-the ``es``, ``es#``, ``et`` and ``et#`` formats.
+the ``"es"``, ``"es#"``, ``"et"`` and ``"et#"`` formats.
 
 However, when a :ctype:`Py_buffer` structure gets filled, the underlying
 buffer is locked so that the caller can subsequently use the buffer even
-inside a ``Py_BEGIN_ALLOW_THREADS`` block without the risk of mutable data
+inside a :ctype:`Py_BEGIN_ALLOW_THREADS` block without the risk of mutable data
 being resized or destroyed.  As a result, **you have to call**
 :cfunc:`PyBuffer_Release` after you have finished processing the data (or
 in any early abort case).
@@ -44,16 +44,16 @@
 Unless otherwise stated, buffers are not NUL-terminated.
 
 .. note::
-   For all ``#`` variants of formats (``s#``, ``y#``, etc.), the type of
-   the length argument (int or :ctype:`Py_ssize_t`) is controlled by
+   For all ``#`` variants of formats (``"s#"``, ``"y#"``, etc.), the type of
+   the length argument (:ctype:`int` or :ctype:`Py_ssize_t`) is controlled by
    defining the macro :cmacro:`PY_SSIZE_T_CLEAN` before including
    :file:`Python.h`.  If the macro was defined, length is a
-   :ctype:`Py_ssize_t` rather than an int.  This behavior will change
+   :ctype:`Py_ssize_t` rather than an :ctype:`int`.  This behavior will change
    in a future Python version to only support :ctype:`Py_ssize_t` and
-   drop int support.  It is best to always define :cmacro:`PY_SSIZE_T_CLEAN`.
+   drop :ctype:`int` support.  It is best to always define :cmacro:`PY_SSIZE_T_CLEAN`.
 
 
-``s`` (:class:`str`) [const char \*]
+``"s"`` (:ctype:`PyUnicodeObject\*`) [:ctype:`const char\*`]
    Convert a Unicode object to a C pointer to a character string.
    A pointer to an existing string is stored in the character pointer
    variable whose address you pass.  The C string is NUL-terminated.
@@ -65,61 +65,61 @@
    .. note::
       This format does not accept bytes-like objects.  If you want to accept
       filesystem paths and convert them to C character strings, it is
-      preferrable to use the ``O&`` format with :cfunc:`PyUnicode_FSConverter`
+      preferrable to use the ``"O&"`` format with :cfunc:`PyUnicode_FSConverter`
       as *converter*.
 
-``s*`` (:class:`str`, :class:`bytes`, :class:`bytearray` or buffer compatible object) [Py_buffer]
+``"s*"`` (:ctype:`PyUnicodeObject\*`, :ctype:`PyBytesObject\*`, :ctype:`PyByteArrayObject\*` or buffer compatible object) [:ctype:`Py_buffer`]
    This format accepts Unicode objects as well as objects supporting the
    buffer protocol.
    It fills a :ctype:`Py_buffer` structure provided by the caller.
    In this case the resulting C string may contain embedded NUL bytes.
    Unicode objects are converted to C strings using ``'utf-8'`` encoding.
 
-``s#`` (:class:`str`, :class:`bytes` or read-only buffer compatible object) [const char \*, int or :ctype:`Py_ssize_t`]
-   Like ``s*``, except that it doesn't accept mutable buffer-like objects
-   such as :class:`bytearray`.  The result is stored into two C variables,
+``"s#"`` (:ctype:`PyUnicodeObject\*`, :ctype:`PyBytesObject\*` or read-only buffer compatible object) [:ctype:`const char\*`, :ctype:`int` or :ctype:`Py_ssize_t`]
+   Like ``"s*"``, except that it doesn't accept mutable buffer-like objects
+   such as :ctype:`PyByteArrayObject\*`.  The result is stored into two C variables,
    the first one a pointer to a C string, the second one its length.
    The string may contain embedded null bytes. Unicode objects are converted
    to C strings using ``'utf-8'`` encoding.
 
-``z`` (:class:`str` or ``None``) [const char \*]
-   Like ``s``, but the Python object may also be ``None``, in which case the C
+``"z"`` (:ctype:`PyUnicodeObject\*` or :ctype:`Py_None`) [:ctype:`const char\*`]
+   Like ``"s"``, but the Python object may also be :ctype:`Py_None`, in which case the C
    pointer is set to *NULL*.
 
-``z*`` (:class:`str`, :class:`bytes`, :class:`bytearray`, buffer compatible object or ``None``) [Py_buffer]
-   Like ``s*``, but the Python object may also be ``None``, in which case the
+``"z*"`` (:ctype:`PyUnicodeObject\*`, :ctype:`PyBytesObject\*`, :ctype:`PyByteArrayObject\*`, buffer compatible object or :ctype:`Py_None`) [:ctype:`Py_buffer`]
+   Like ``"s*"``, but the Python object may also be :ctype:`Py_None`, in which case the
    ``buf`` member of the :ctype:`Py_buffer` structure is set to *NULL*.
 
-``z#`` (:class:`str`, :class:`bytes`, read-only buffer compatible object or ``None``) [const char \*, int]
-   Like ``s#``, but the Python object may also be ``None``, in which case the C
+``"z#"`` (:ctype:`PyUnicodeObject\*`, :ctype:`PyBytesObject\*`, read-only buffer compatible object or :ctype:`Py_None`) [:ctype:`const char\*`, :ctype:`int`]
+   Like ``"s#"``, but the Python object may also be :ctype:`Py_None`, in which case the C
    pointer is set to *NULL*.
 
-``y`` (:class:`bytes`) [const char \*]
+``"y"`` (:ctype:`PyBytesObject\*`) [:ctype:`const char\*`]
    This format converts a bytes-like object to a C pointer to a character
    string; it does not accept Unicode objects.  The bytes buffer must not
    contain embedded NUL bytes; if it does, a :exc:`TypeError`
    exception is raised.
 
-``y*`` (:class:`bytes`, :class:`bytearray` or buffer compatible object) [Py_buffer \*]
-   This variant on ``s*`` doesn't accept Unicode objects, only objects
+``"y*"`` (:ctype:`PyBytesObject\*`, :ctype:`PyByteArrayObject\*` or buffer compatible object) [:ctype:`Py_buffer\*`]
+   This variant on ``"s*"`` doesn't accept Unicode objects, only objects
    supporting the buffer protocol.  **This is the recommended way to accept
    binary data.**
 
-``y#`` (:class:`bytes`) [const char \*, int]
-   This variant on ``s#`` doesn't accept Unicode objects, only bytes-like
+``"y#"`` (:ctype:`PyBytesObject\*`) [:ctype:`const char\*`, :ctype:`int`]
+   This variant on ``"s#"`` doesn't accept Unicode objects, only bytes-like
    objects.
 
-``S`` (:class:`bytes`) [PyBytesObject \*]
-   Requires that the Python object is a :class:`bytes` object, without
+``"S"`` (:ctype:`PyBytesObject\*`) [:ctype:`PyBytesObject\*`]
+   Requires that the Python object is a :ctype:`PyBytesObject\*` object, without
    attempting any conversion.  Raises :exc:`TypeError` if the object is not
    a bytes object.  The C variable may also be declared as :ctype:`PyObject\*`.
 
-``Y`` (:class:`bytearray`) [PyByteArrayObject \*]
-   Requires that the Python object is a :class:`bytearray` object, without
+``"Y"`` (:ctype:`PyByteArrayObject\*`) [:ctype:`PyByteArrayObject\*`]
+   Requires that the Python object is a :ctype:`PyByteArrayObject\*` object, without
    attempting any conversion.  Raises :exc:`TypeError` if the object is not
-   a :class:`bytearray` object. The C variable may also be declared as :ctype:`PyObject\*`.
+   a :ctype:`PyByteArrayObject\*` object. The C variable may also be declared as :ctype:`PyObject\*`.
 
-``u`` (:class:`str`) [Py_UNICODE \*]
+``"u"`` (:ctype:`PyUnicodeObject\*`) [:ctype:`Py_UNICODE\*`]
    Convert a Python Unicode object to a C pointer to a NUL-terminated buffer of
    Unicode characters.  You must pass the address of a :ctype:`Py_UNICODE`
    pointer variable, which will be filled with the pointer to an existing
@@ -127,84 +127,82 @@
    character depends on compilation options (it is either 16 or 32 bits).
 
    .. note::
-      Since ``u`` doesn't give you back the length of the string, and it
-      may contain embedded NUL characters, it is recommended to use ``u#``
-      or ``U`` instead.
+      Since ``"u"`` doesn't give you back the length of the string, and it
+      may contain embedded NUL characters, it is recommended to use ``"u#"``
+      or ``"U"`` instead.
 
-``u#`` (:class:`str`) [Py_UNICODE \*, int]
-   This variant on ``u`` stores into two C variables, the first one a pointer to a
-   Unicode data buffer, the second one its length. Non-Unicode objects are handled
-   by interpreting their read-buffer pointer as pointer to a :ctype:`Py_UNICODE`
-   array.
+``"u#"`` (:ctype:`PyUnicodeObject\*`) [:ctype:`Py_UNICODE\*`, :ctype:`int`]
+   This variant on ``"u"`` stores into two C variables, the first one a pointer to a
+   Unicode data buffer, the second one its length.
 
-``Z`` (:class:`str` or ``None``) [Py_UNICODE \*]
-   Like ``u``, but the Python object may also be ``None``, in which case the
+``"Z"`` (:ctype:`PyUnicodeObject\*` or :ctype:`Py_None`) [:ctype:`Py_UNICODE\*`]
+   Like ``"u"``, but the Python object may also be :ctype:`Py_None`, in which case the
    :ctype:`Py_UNICODE` pointer is set to *NULL*.
 
-``Z#`` (:class:`str` or ``None``) [Py_UNICODE \*, int]
-   Like ``u#``, but the Python object may also be ``None``, in which case the
+``"Z#"`` (:ctype:`PyUnicodeObject\*` or :ctype:`Py_None`) [:ctype:`Py_UNICODE\*`, :ctype:`int`]
+   Like ``"u#"``, but the Python object may also be :ctype:`Py_None`, in which case the
    :ctype:`Py_UNICODE` pointer is set to *NULL*.
 
-``U`` (:class:`str`) [PyUnicodeObject \*]
+``"U"`` (:ctype:`PyUnicodeObject\*`) [:ctype:`PyUnicodeObject\*`]
    Requires that the Python object is a Unicode object, without attempting
    any conversion.  Raises :exc:`TypeError` if the object is not a Unicode
    object.  The C variable may also be declared as :ctype:`PyObject\*`.
 
-``t#`` (:class:`bytes`, :class:`bytearray` or read-only character buffer) [char \*, int]
-   Like ``s#``, but accepts any object which implements the read-only buffer
+``"t#"`` (:ctype:`PyBytesObject\*`, :ctype:`PyByteArrayObject\*` or read-only character buffer) [:ctype:`char\*`, :ctype:`int`]
+   Like ``"s#"``, but accepts any object which implements the read-only buffer
    interface.  The :ctype:`char\*` variable is set to point to the first byte of
    the buffer, and the :ctype:`int` is set to the length of the buffer.  Only
    single-segment buffer objects are accepted; :exc:`TypeError` is raised for all
    others.
 
-``w`` (:class:`bytearray` or read-write character buffer) [char \*]
-   Similar to ``s``, but accepts any object which implements the read-write buffer
+``"w"`` (:ctype:`PyByteArrayObject\*` or read-write character buffer) [:ctype:`char\*`]
+   Similar to ``"y"``, but accepts any object which implements the read-write buffer
    interface.  The caller must determine the length of the buffer by other means,
-   or use ``w#`` instead.  Only single-segment buffer objects are accepted;
+   or use ``"w#"`` instead.  Only single-segment buffer objects are accepted;
    :exc:`TypeError` is raised for all others.
 
-``w*`` (:class:`bytearray` or read-write byte-oriented buffer) [Py_buffer]
-   This is to ``w`` what ``s*`` is to ``s``.
+``"w*"`` (:ctype:`PyByteArrayObject\*` or read-write byte-oriented buffer) [:ctype:`Py_buffer`]
+   This is to ``"w"`` what ``"y*"`` is to ``"y"``.
 
-``w#`` (:class:`bytearray` or read-write character buffer) [char \*, int]
-   Like ``s#``, but accepts any object which implements the read-write buffer
-   interface.  The :ctype:`char \*` variable is set to point to the first byte
+``"w#"`` (:ctype:`PyByteArrayObject\*` or read-write character buffer) [:ctype:`char\*`, :ctype:`int`]
+   Like ``"y#"``, but accepts any object which implements the read-write buffer
+   interface.  The :ctype:`char\*` variable is set to point to the first byte
    of the buffer, and the :ctype:`int` is set to the length of the buffer.
    Only single-segment buffer objects are accepted; :exc:`TypeError` is raised
    for all others.
 
-``es`` (:class:`str`) [const char \*encoding, char \*\*buffer]
-   This variant on ``s`` is used for encoding Unicode and objects convertible to
-   Unicode into a character buffer. It only works for encoded data without embedded
+``"es"`` (:ctype:`PyUnicodeObject\*`) [:ctype:`const char \*encoding`, :ctype:`char \*\*buffer`]
+   This variant on ``"s"`` is used for encoding Unicode
+   into a character buffer. It only works for encoded data without embedded
    NUL bytes.
 
    This format requires two arguments.  The first is only used as input, and
    must be a :ctype:`const char\*` which points to the name of an encoding as a
-   NUL-terminated string, or *NULL*, in which case the default encoding is used.
-   An exception is raised if the named encoding is not known to Python.  The
+   NUL-terminated string, or *NULL*, in which case ``'utf-8'`` encoding is used.
+   :ctype:`PyExc_LookupError` is raised if the named encoding is not known to Python. The
    second argument must be a :ctype:`char\*\*`; the value of the pointer it
    references will be set to a buffer with the contents of the argument text.
    The text will be encoded in the encoding specified by the first argument.
 
    :cfunc:`PyArg_ParseTuple` will allocate a buffer of the needed size, copy the
-   encoded data into this buffer and adjust *\*buffer* to reference the newly
+   encoded data into this buffer and adjust ``*buffer`` to reference the newly
    allocated storage.  The caller is responsible for calling :cfunc:`PyMem_Free` to
    free the allocated buffer after use.
 
-``et`` (:class:`str`, :class:`bytes` or :class:`bytearray`) [const char \*encoding, char \*\*buffer]
-   Same as ``es`` except that byte string objects are passed through without
+``"et"`` (:ctype:`PyUnicodeObject\*`, :ctype:`PyBytesObject\*` or :ctype:`PyByteArrayObject\*`) [:ctype:`const char \*encoding`, :ctype:`char \*\*buffer`]
+   Same as ``"es"`` except that byte string objects are passed through without
    recoding them.  Instead, the implementation assumes that the byte string object uses
    the encoding passed in as parameter.
 
-``es#`` (:class:`str`) [const char \*encoding, char \*\*buffer, int \*buffer_length]
-   This variant on ``s#`` is used for encoding Unicode and objects convertible to
-   Unicode into a character buffer.  Unlike the ``es`` format, this variant allows
+``"es#"`` (:ctype:`PyUnicodeObject\*`) [:ctype:`const char \*encoding`, :ctype:`char \*\*buffer`, :ctype:`int \*buffer_length`]
+   This variant on ``"s#"`` is used for encoding Unicode
+   into a character buffer.  Unlike the ``"es"`` format, this variant allows
    input data which contains NUL characters.
 
    It requires three arguments.  The first is only used as input, and must be a
    :ctype:`const char\*` which points to the name of an encoding as a
-   NUL-terminated string, or *NULL*, in which case the default encoding is used.
-   An exception is raised if the named encoding is not known to Python.  The
+   NUL-terminated string, or *NULL*, in which case ``'utf-8'`` encoding is used.
+   :ctype:`PyExc_LookupError` is raised if the named encoding is not known to Python.  The
    second argument must be a :ctype:`char\*\*`; the value of the pointer it
    references will be set to a buffer with the contents of the argument text.
    The text will be encoded in the encoding specified by the first argument.
@@ -213,113 +211,112 @@
 
    There are two modes of operation:
 
-   If *\*buffer* points a *NULL* pointer, the function will allocate a buffer of
-   the needed size, copy the encoded data into this buffer and set *\*buffer* to
-   reference the newly allocated storage.  The caller is responsible for calling
-   :cfunc:`PyMem_Free` to free the allocated buffer after usage.
+   * If ``*buffer`` points a *NULL* pointer, the function will allocate a buffer of
+     the needed size, copy the encoded data into this buffer and set ``*buffer`` to
+     reference the newly allocated storage. The caller is responsible for calling
+     :cfunc:`PyMem_Free` to free the allocated buffer after usage.
+   * If ``*buffer`` points to a non-*NULL* pointer (an already allocated buffer),
+     :cfunc:`PyArg_ParseTuple` will use this location as the buffer and
+     interpret the initial value of ``*buffer_length`` as the buffer size. It
+     will then copy the encoded data into the buffer and NUL-terminate it. If
+     the buffer is not large enough, a :exc:`ValueError` will be set.
 
-   If *\*buffer* points to a non-*NULL* pointer (an already allocated buffer),
-   :cfunc:`PyArg_ParseTuple` will use this location as the buffer and interpret the
-   initial value of *\*buffer_length* as the buffer size.  It will then copy the
-   encoded data into the buffer and NUL-terminate it.  If the buffer is not large
-   enough, a :exc:`ValueError` will be set.
-
-   In both cases, *\*buffer_length* is set to the length of the encoded data
+   In both cases, ``*buffer_length`` is set to the length of the encoded data
    without the trailing NUL byte.
 
-``et#`` (:class:`str`, :class:`bytes` or :class:`bytearray`) [const char \*encoding, char \*\*buffer, int \*buffer_length]
-   Same as ``es#`` except that byte string objects are passed through without recoding
+``"et#"`` (:ctype:`PyUnicodeObject\*`, :ctype:`PyBytesObject\*` or :ctype:`PyByteArrayObject\*`) [:ctype:`const char \*encoding`, :ctype:`char \*\*buffer`, :ctype:`int \*buffer_length`]
+   Same as ``"es#"`` except that byte string objects are passed through without recoding
    them. Instead, the implementation assumes that the byte string object uses the
    encoding passed in as parameter.
 
 Numbers
 -------
 
-``b`` (:class:`int`) [unsigned char]
+``"b"`` (:ctype:`PyLongObject\*`) [:ctype:`unsigned char`]
    Convert a nonnegative Python integer to an unsigned tiny int, stored in a C
    :ctype:`unsigned char`.
 
-``B`` (:class:`int`) [unsigned char]
+``"B"`` (:ctype:`PyLongObject\*`) [:ctype:`unsigned char`]
    Convert a Python integer to a tiny int without overflow checking, stored in a C
    :ctype:`unsigned char`.
 
-``h`` (:class:`int`) [short int]
+``"h"`` (:ctype:`PyLongObject\*`) [:ctype:`short int`]
    Convert a Python integer to a C :ctype:`short int`.
 
-``H`` (:class:`int`) [unsigned short int]
+``"H"`` (:ctype:`PyLongObject\*`) [:ctype:`unsigned short int`]
    Convert a Python integer to a C :ctype:`unsigned short int`, without overflow
    checking.
 
-``i`` (:class:`int`) [int]
+``"i"`` (:ctype:`PyLongObject\*`) [:ctype:`int`]
    Convert a Python integer to a plain C :ctype:`int`.
 
-``I`` (:class:`int`) [unsigned int]
+``"I"`` (:ctype:`PyLongObject\*`) [:ctype:`unsigned int`]
    Convert a Python integer to a C :ctype:`unsigned int`, without overflow
    checking.
 
-``l`` (:class:`int`) [long int]
+``"l"`` (:ctype:`PyLongObject\*`) [:ctype:`long int`]
    Convert a Python integer to a C :ctype:`long int`.
 
-``k`` (:class:`int`) [unsigned long]
+``"k"`` (:ctype:`PyLongObject\*`) [:ctype:`unsigned long`]
    Convert a Python integer to a C :ctype:`unsigned long` without
    overflow checking.
 
-``L`` (:class:`int`) [PY_LONG_LONG]
+``"L"`` (:ctype:`PyLongObject\*`) [:ctype:`PY_LONG_LONG`]
    Convert a Python integer to a C :ctype:`long long`.  This format is only
    available on platforms that support :ctype:`long long` (or :ctype:`_int64` on
    Windows).
 
-``K`` (:class:`int`) [unsigned PY_LONG_LONG]
+``"K"`` (:ctype:`PyLongObject\*`) [:ctype:`unsigned PY_LONG_LONG`]
    Convert a Python integer to a C :ctype:`unsigned long long`
    without overflow checking.  This format is only available on platforms that
    support :ctype:`unsigned long long` (or :ctype:`unsigned _int64` on Windows).
 
-``n`` (:class:`int`) [Py_ssize_t]
+``"n"`` (:ctype:`PyLongObject\*`) [:ctype:`Py_ssize_t`]
    Convert a Python integer to a C :ctype:`Py_ssize_t`.
 
-``c`` (:class:`bytes` of length 1) [char]
-   Convert a Python byte, represented as a :class:`bytes` object of length 1,
+``"c"`` (:ctype:`PyBytesObject\*` of length 1) [:ctype:`char`]
+   Convert a Python byte, represented as a :ctype:`PyBytesObject\*` object of length 1,
    to a C :ctype:`char`.
 
-``C`` (:class:`str` of length 1) [int]
-   Convert a Python character, represented as a :class:`str` object of
+``"C"`` (:ctype:`PyUnicodeObject\*` of length 1) [:ctype:`int`]
+   Convert a Python character, represented as a :ctype:`PyUnicodeObject\*` object of
    length 1, to a C :ctype:`int`.
 
-``f`` (:class:`float`) [float]
+``"f"`` (:ctype:`PyFloatObject\*`) [:ctype:`float`]
    Convert a Python floating point number to a C :ctype:`float`.
 
-``d`` (:class:`float`) [double]
+``"d"`` (:ctype:`PyFloatObject\*`) [:ctype:`double`]
    Convert a Python floating point number to a C :ctype:`double`.
 
-``D`` (:class:`complex`) [Py_complex]
+``"D"`` (:ctype:`PyComplexObject\*`) [:ctype:`Py_complex`]
    Convert a Python complex number to a C :ctype:`Py_complex` structure.
 
 Other objects
 -------------
 
-``O`` (object) [PyObject \*]
+``"O"`` (:ctype:`PyObject\*`) [:ctype:`PyObject\*`]
    Store a Python object (without any conversion) in a C object pointer.  The C
    program thus receives the actual object that was passed.  The object's reference
    count is not increased.  The pointer stored is not *NULL*.
 
-``O!`` (object) [*typeobject*, PyObject \*]
-   Store a Python object in a C object pointer.  This is similar to ``O``, but
+``"O!"`` (:ctype:`PyObject\*`) [:ctype:`PyTypeObject\*`, :ctype:`PyObject\*`]
+   Store a Python object in a C object pointer.  This is similar to ``"O"``, but
    takes two C arguments: the first is the address of a Python type object, the
    second is the address of the C variable (of type :ctype:`PyObject\*`) into which
    the object pointer is stored.  If the Python object does not have the required
    type, :exc:`TypeError` is raised.
 
-``O&`` (object) [*converter*, *anything*]
+``"O&"`` (:ctype:`PyObject\*`) [*converter*, *anything*]
    Convert a Python object to a C variable through a *converter* function.  This
    takes two arguments: the first is a function, the second is the address of a C
-   variable (of arbitrary type), converted to :ctype:`void \*`.  The *converter*
+   variable (of arbitrary type), converted to :ctype:`void\*`.  The *converter*
    function in turn is called as follows::
 
       status = converter(object, address);
 
    where *object* is the Python object to be converted and *address* is the
    :ctype:`void\*` argument that was passed to the :cfunc:`PyArg_Parse\*` function.
-   The returned *status* should be ``1`` for a successful conversion and ``0`` if
+   The returned *status* should be 1 for a successful conversion and 0 if
    the conversion has failed.  When the conversion fails, the *converter* function
    should raise an exception and leave the content of *address* unmodified.
 
@@ -331,7 +328,7 @@
    .. versionchanged:: 3.1
       Py_CLEANUP_SUPPORTED was added.
 
-``(items)`` (:class:`tuple`) [*matching-items*]
+``"(items)"`` (:ctype:`PyTupleObject\*`) [*matching-items*]
    The object must be a Python sequence whose length is the number of format units
    in *items*.  The C arguments must correspond to the individual format units in
    *items*.  Format units for sequences may be nested.
@@ -373,8 +370,8 @@
 
 For the conversion to succeed, the *arg* object must match the format
 and the format must be exhausted.  On success, the
-:cfunc:`PyArg_Parse\*` functions return true, otherwise they return
-false and raise an appropriate exception. When the
+:cfunc:`PyArg_Parse\*` functions return 1, otherwise they return
+0 and raise an appropriate exception. When the
 :cfunc:`PyArg_Parse\*` functions fail due to conversion failure in one
 of the format units, the variables at the addresses corresponding to that
 and the following format units are left untouched.
@@ -385,7 +382,7 @@
 .. cfunction:: int PyArg_ParseTuple(PyObject *args, const char *format, ...)
 
    Parse the parameters of a function that takes only positional parameters into
-   local variables.  Returns true on success; on failure, it returns false and
+   local variables.  Returns 1 on success; on failure, it returns 0 and
    raises the appropriate exception.
 
 
@@ -398,8 +395,8 @@
 .. cfunction:: int PyArg_ParseTupleAndKeywords(PyObject *args, PyObject *kw, const char *format, char *keywords[], ...)
 
    Parse the parameters of a function that takes both positional and keyword
-   parameters into local variables.  Returns true on success; on failure, it
-   returns false and raises the appropriate exception.
+   parameters into local variables.  Returns 1 on success; on failure, it
+   returns 0 and raises the appropriate exception.
 
 
 .. cfunction:: int PyArg_VaParseTupleAndKeywords(PyObject *args, PyObject *kw, const char *format, char *keywords[], va_list vargs)
@@ -440,7 +437,7 @@
    :ctype:`PyObject\*` variable; these will be filled in with the values from
    *args*; they will contain borrowed references.  The variables which correspond
    to optional parameters not given by *args* will not be filled in; these should
-   be initialized by the caller. This function returns true on success and false if
+   be initialized by the caller. This function returns 1 on success and 0 if
    *args* is not a tuple or contains the wrong number of elements; an exception
    will be set if there was a failure.
 
@@ -479,12 +476,12 @@
 
    :cfunc:`Py_BuildValue` does not always build a tuple.  It builds a tuple only if
    its format string contains two or more format units.  If the format string is
-   empty, it returns ``None``; if it contains exactly one format unit, it returns
+   empty, it returns :ctype:`Py_None`; if it contains exactly one format unit, it returns
    whatever object is described by that format unit.  To force it to return a tuple
    of size 0 or one, parenthesize the format string.
 
    When memory buffers are passed as parameters to supply data to build objects, as
-   for the ``s`` and ``s#`` formats, the required data is copied.  Buffers provided
+   for the ``"s"`` and ``"s#"`` formats, the required data is copied.  Buffers provided
    by the caller are never referenced by the objects created by
    :cfunc:`Py_BuildValue`.  In other words, if your code invokes :cfunc:`malloc`
    and passes the allocated memory to :cfunc:`Py_BuildValue`, your code is
@@ -496,100 +493,102 @@
    and the entry in [square] brackets is the type of the C value(s) to be passed.
 
    The characters space, tab, colon and comma are ignored in format strings (but
-   not within format units such as ``s#``).  This can be used to make long format
+   not within format units such as ``"s#"``).  This can be used to make long format
    strings a tad more readable.
 
-   ``s`` (:class:`str` or ``None``) [char \*]
-      Convert a null-terminated C string to a Python object using ``'utf-8'``
-      encoding. If the C string pointer is *NULL*, ``None`` is used.
+   ``"s"`` (:ctype:`PyUnicodeObject\*` or :ctype:`Py_None`) [:ctype:`char\*`]
+      Convert a null-terminated C string to a Python :class:`str` object using ``'utf-8'``
+      encoding. If the C string pointer is *NULL*, :ctype:`Py_None` is used.
 
-   ``s#`` (:class:`str` or ``None``) [char \*, int]
-      Convert a C string and its length to a Python object using ``'utf-8'``
+   ``"s#"`` (:ctype:`PyUnicodeObject\*` or :ctype:`Py_None`) [:ctype:`char\*`, :ctype:`int`]
+      Convert a C string and its length to a Python :class:`str` object using ``'utf-8'``
       encoding. If the C string pointer is *NULL*, the length is ignored and
-      ``None`` is returned.
+      :ctype:`Py_None` is returned.
 
-   ``y`` (:class:`bytes`) [char \*]
-      This converts a C string to a Python :func:`bytes` object.  If the C
-      string pointer is *NULL*, ``None`` is returned.
+   ``"y"`` (:ctype:`PyBytesObject\*` or :ctype:`Py_None`) [:ctype:`char\*`]
+      This converts a C string to a Python :class:`bytes` object.  If the C
+      string pointer is *NULL*, :ctype:`Py_None` is returned.
 
-   ``y#`` (:class:`bytes`) [char \*, int]
-      This converts a C string and its lengths to a Python object.  If the C
-      string pointer is *NULL*, ``None`` is returned.
+   ``"y#"`` (:ctype:`PyBytesObject\*` or :ctype:`Py_None`) [:ctype:`char\*`, :ctype:`int`]
+      This converts a C string and its lengths to a Python :class:`bytes` object. If the C
+      string pointer is *NULL*, :ctype:`Py_None` is returned.
 
-   ``z`` (:class:`str` or ``None``) [char \*]
-      Same as ``s``.
+   ``"z"`` (:ctype:`PyUnicodeObject\*` or :ctype:`Py_None`) [:ctype:`char\*`]
+      Same as ``"s"``.
 
-   ``z#`` (:class:`str` or ``None``) [char \*, int]
-      Same as ``s#``.
+   ``"z#"`` (:ctype:`PyUnicodeObject\*` or :ctype:`Py_None`) [:ctype:`char\*`, :ctype:`int`]
+      Same as ``"s#"``.
 
-   ``u`` (:class:`str`) [Py_UNICODE \*]
+   ``"u"`` (:ctype:`PyUnicodeObject\*` or :ctype:`Py_None`) [:ctype:`Py_UNICODE\*`]
       Convert a null-terminated buffer of Unicode (UCS-2 or UCS-4) data to a Python
-      Unicode object.  If the Unicode buffer pointer is *NULL*, ``None`` is returned.
+      Unicode object.  If the Unicode buffer pointer is *NULL*, :ctype:`Py_None` is returned.
 
-   ``u#`` (:class:`str`) [Py_UNICODE \*, int]
+   ``"u#"`` (:ctype:`PyUnicodeObject\*` or :ctype:`Py_None`) [:ctype:`Py_UNICODE\*`, :ctype:`int`]
       Convert a Unicode (UCS-2 or UCS-4) data buffer and its length to a Python
       Unicode object.   If the Unicode buffer pointer is *NULL*, the length is ignored
-      and ``None`` is returned.
+      and :ctype:`Py_None` is returned.
 
-   ``U`` (:class:`str` or ``None``) [char \*]
-      Same as ``s``.
+   ``"U"`` (:ctype:`PyUnicodeObject\*` or :ctype:`Py_None`) [:ctype:`char\*`]
+      Same as ``"s"``.
 
-   ``U#`` (:class:`str` or ``None``) [char \*, int]
-      Same as ``s#``.
+   ``"U#"`` (:ctype:`PyUnicodeObject\*` or :ctype:`Py_None`) [:ctype:`char\*`, :ctype:`int`]
+      Same as ``"s#"``.
 
-   ``i`` (:class:`int`) [int]
+   ``"i"`` (:ctype:`PyLongObject\*`) [:ctype:`int`]
       Convert a plain C :ctype:`int` to a Python integer object.
 
-   ``b`` (:class:`int`) [char]
+   ``"b"`` (:ctype:`PyLongObject\*`) [:ctype:`char`]
       Convert a plain C :ctype:`char` to a Python integer object.
 
-   ``h`` (:class:`int`) [short int]
+   ``"h"`` (:ctype:`PyLongObject\*`) [:ctype:`short int`]
       Convert a plain C :ctype:`short int` to a Python integer object.
 
-   ``l`` (:class:`int`) [long int]
+   ``"l"`` (:ctype:`PyLongObject\*`) [:ctype:`long int`]
       Convert a C :ctype:`long int` to a Python integer object.
 
-   ``B`` (:class:`int`) [unsigned char]
+   ``"B"`` (:ctype:`PyLongObject\*`) [:ctype:`unsigned char`]
       Convert a C :ctype:`unsigned char` to a Python integer object.
 
-   ``H`` (:class:`int`) [unsigned short int]
+   ``"H"`` (:ctype:`PyLongObject\*`) [:ctype:`unsigned short int`]
       Convert a C :ctype:`unsigned short int` to a Python integer object.
 
-   ``I`` (:class:`int`) [unsigned int]
+   ``"I"`` (:ctype:`PyLongObject\*`) [:ctype:`unsigned int`]
       Convert a C :ctype:`unsigned int` to a Python integer object.
 
-   ``k`` (:class:`int`) [unsigned long]
+   ``"k"`` (:ctype:`PyLongObject\*`) [:ctype:`unsigned long`]
       Convert a C :ctype:`unsigned long` to a Python integer object.
 
-   ``L`` (:class:`int`) [PY_LONG_LONG]
+   ``"L"`` (:ctype:`PyLongObject\*`) [:ctype:`PY_LONG_LONG`]
       Convert a C :ctype:`long long` to a Python integer object. Only available
-      on platforms that support :ctype:`long long`.
+      on platforms that support :ctype:`long long` (or :ctype:`_int64` on
+      Windows).
 
-   ``K`` (:class:`int`) [unsigned PY_LONG_LONG]
+   ``"K"`` (:ctype:`PyLongObject\*`) [:ctype:`unsigned PY_LONG_LONG`]
       Convert a C :ctype:`unsigned long long` to a Python integer object. Only
-      available on platforms that support :ctype:`unsigned long long`.
+      available on platforms that support :ctype:`unsigned long long` (or
+      :ctype:`unsigned _int64` on Windows).
 
-   ``n`` (:class:`int`) [Py_ssize_t]
+   ``"n"`` (:ctype:`PyLongObject\*`) [:ctype:`Py_ssize_t`]
       Convert a C :ctype:`Py_ssize_t` to a Python integer.
 
-   ``c`` (:class:`bytes` of length 1) [char]
-      Convert a C :ctype:`int` representing a byte to a Python :class:`bytes` object of
+   ``"c"`` (:ctype:`PyBytesObject\*` of length 1) [:ctype:`char`]
+      Convert a C :ctype:`int` representing a byte to a Python :ctype:`PyBytesObject\*` object of
       length 1.
 
-   ``C`` (:class:`str` of length 1) [int]
-      Convert a C :ctype:`int` representing a character to Python :class:`str`
+   ``"C"`` (:ctype:`PyUnicodeObject\*` of length 1) [:ctype:`int`]
+      Convert a C :ctype:`int` representing a character to Python :ctype:`PyUnicodeObject\*`
       object of length 1.
 
-   ``d`` (:class:`float`) [double]
+   ``"d"`` (:ctype:`PyFloatObject\*`) [:ctype:`double`]
       Convert a C :ctype:`double` to a Python floating point number.
 
-   ``f`` (:class:`float`) [float]
+   ``"f"`` (:ctype:`PyFloatObject\*`) [:ctype:`float`]
       Convert a C :ctype:`float` to a Python floating point number.
 
-   ``D`` (:class:`complex`) [Py_complex \*]
+   ``"D"`` (:ctype:`PyComplexObject\*`) [:ctype:`Py_complex\*`]
       Convert a C :ctype:`Py_complex` structure to a Python complex number.
 
-   ``O`` (object) [PyObject \*]
+   ``"O"`` (:ctype:`PyObject\*`) [:ctype:`PyObject\*`]
       Pass a Python object untouched (except for its reference count, which is
       incremented by one).  If the object passed in is a *NULL* pointer, it is assumed
       that this was caused because the call producing the argument found an error and
@@ -597,27 +596,27 @@
       raise an exception.  If no exception has been raised yet, :exc:`SystemError` is
       set.
 
-   ``S`` (object) [PyObject \*]
-      Same as ``O``.
+   ``"S"`` (:ctype:`PyObject\*`) [:ctype:`PyObject\*`]
+      Same as ``"O"``.
 
-   ``N`` (object) [PyObject \*]
-      Same as ``O``, except it doesn't increment the reference count on the object.
+   ``"N"`` (:ctype:`PyObject\*`) [:ctype:`PyObject\*`]
+      Same as ``"O"``, except it doesn't increment the reference count on the object.
       Useful when the object is created by a call to an object constructor in the
       argument list.
 
-   ``O&`` (object) [*converter*, *anything*]
+   ``"O&"`` (:ctype:`PyObject\*`) [*converter*, *anything*]
       Convert *anything* to a Python object through a *converter* function.  The
-      function is called with *anything* (which should be compatible with :ctype:`void
-      \*`) as its argument and should return a "new" Python object, or *NULL* if an
+      function is called with *anything* (which should be compatible with :ctype:`void\*`)
+      as its argument and should return a "new" Python object, or *NULL* if an
       error occurred.
 
-   ``(items)`` (:class:`tuple`) [*matching-items*]
+   ``"(items)"`` (:ctype:`PyTupleObject\*`) [*matching-items*]
       Convert a sequence of C values to a Python tuple with the same number of items.
 
-   ``[items]`` (:class:`list`) [*matching-items*]
+   ``"[items]"`` (:ctype:`PyListObject\*`) [*matching-items*]
       Convert a sequence of C values to a Python list with the same number of items.
 
-   ``{items}`` (:class:`dict`) [*matching-items*]
+   ``"{items}"`` (:ctype:`PyDictObject\*`) [*matching-items*]
       Convert a sequence of C values to a Python dictionary.  Each pair of consecutive
       C values adds one item to the dictionary, serving as key and value,
       respectively.