Changeset 388 for python/vendor/current/Doc/c-api

python/vendor/current/Doc/c-api/abstract.rst

r2	r388
14	14
15	15	It is not possible to use these functions on objects that are not properly
16		initialized, such as a list object that has been created by :cfunc:`PyList_New`,
	16	initialized, such as a list object that has been created by :c:func:`PyList_New`,
17	17	but whose items have not been set to some non-\ ``NULL`` value yet.
18	18

python/vendor/current/Doc/c-api/allocation.rst

-              r2
+              r388
 .. cfunction:: PyObject* _PyObject_New(PyTypeObject *type)
+.. c:function:: PyObject* _PyObject_New(PyTypeObject *type)
 .. cfunction:: PyVarObject* _PyObject_NewVar(PyTypeObject *type, Py_ssize_t size)
+.. c:function:: PyVarObject* _PyObject_NewVar(PyTypeObject *type, Py_ssize_t size)
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
+      This function used an :c:type:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: void _PyObject_Del(PyObject *op)
+.. c:function:: void _PyObject_Del(PyObject *op)
 .. cfunction:: PyObject* PyObject_Init(PyObject *op, PyTypeObject *type)
+.. c:function:: PyObject* PyObject_Init(PyObject *op, PyTypeObject *type)
    Initialize a newly-allocated object *op* with its type and initial
 …
 .. cfunction:: PyVarObject* PyObject_InitVar(PyVarObject *op, PyTypeObject *type, Py_ssize_t size)
+.. c:function:: PyVarObject* PyObject_InitVar(PyVarObject *op, PyTypeObject *type, Py_ssize_t size)
    This does everything :cfunc:`PyObject_Init` does, and also initializes the
+   This does everything :c:func:`PyObject_Init` does, and also initializes the
    length information for a variable-size object.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
+      This function used an :c:type:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: TYPE* PyObject_New(TYPE, PyTypeObject *type)
+.. c:function:: TYPE* PyObject_New(TYPE, PyTypeObject *type)
    Allocate a new Python object using the C structure type *TYPE* and the
    Python type object *type*.  Fields not defined by the Python object header
    are not initialized; the object's reference count will be one.  The size of
    the memory allocation is determined from the :attr:`tp_basicsize` field of
+   the memory allocation is determined from the :c:member:`~PyTypeObject.tp_basicsize` field of
    the type object.
 .. cfunction:: TYPE* PyObject_NewVar(TYPE, PyTypeObject *type, Py_ssize_t size)
+.. c:function:: TYPE* PyObject_NewVar(TYPE, PyTypeObject *type, Py_ssize_t size)
    Allocate a new Python object using the C structure type *TYPE* and the
    Python type object *type*.  Fields not defined by the Python object header
    are not initialized.  The allocated memory allows for the *TYPE* structure
    plus *size* fields of the size given by the :attr:`tp_itemsize` field of
+   plus *size* fields of the size given by the :c:member:`~PyTypeObject.tp_itemsize` field of
    *type*.  This is useful for implementing objects like tuples, which are
    able to determine their size at construction time.  Embedding the array of
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
+      This function used an :c:type:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: void PyObject_Del(PyObject *op)
+.. c:function:: void PyObject_Del(PyObject *op)
    Releases memory allocated to an object using :cfunc:`PyObject_New` or
    :cfunc:`PyObject_NewVar`.  This is normally called from the
    :attr:`tp_dealloc` handler specified in the object's type.  The fields of
+   Releases memory allocated to an object using :c:func:`PyObject_New` or
+   :c:func:`PyObject_NewVar`.  This is normally called from the
+   :c:member:`~PyTypeObject.tp_dealloc` handler specified in the object's type.  The fields of
    the object should not be accessed after this call as the memory is no
    longer a valid Python object.
 .. cfunction:: PyObject* Py_InitModule(char *name, PyMethodDef *methods)
+.. c:function:: PyObject* Py_InitModule(char *name, PyMethodDef *methods)
    Create a new module object based on a name and table of functions,
 …
 .. cfunction:: PyObject* Py_InitModule3(char *name, PyMethodDef *methods, char *doc)
+.. c:function:: PyObject* Py_InitModule3(char *name, PyMethodDef *methods, char *doc)
    Create a new module object based on a name and table of functions,
 …
 .. cfunction:: PyObject* Py_InitModule4(char *name, PyMethodDef *methods, char *doc, PyObject *self, int apiver)
+.. c:function:: PyObject* Py_InitModule4(char *name, PyMethodDef *methods, char *doc, PyObject *self, int apiver)
    Create a new module object based on a name and table of functions,
 …
       Most uses of this function should probably be using the
       :cfunc:`Py_InitModule3` instead; only use this if you are sure you need
+      :c:func:`Py_InitModule3` instead; only use this if you are sure you need
       it.
 …
 .. cvar:: PyObject _Py_NoneStruct
+.. c:var:: PyObject _Py_NoneStruct
    Object which is visible in Python as ``None``.  This should only be

python/vendor/current/Doc/c-api/arg.rst

-              r2
+              r388
 :ref:`extending-index`.
 The first three of these functions described, :cfunc:`PyArg_ParseTuple`,
 :cfunc:`PyArg_ParseTupleAndKeywords`, and :cfunc:`PyArg_Parse`, all use
+The first three of these functions described, :c:func:`PyArg_ParseTuple`,
+:c:func:`PyArg_ParseTupleAndKeywords`, and :c:func:`PyArg_Parse`, all use
 *format strings* which are used to tell the function about the expected
 arguments.  The format strings use the same syntax for each of these
 …
 of the C variable(s) whose address should be passed.
+``s`` (string or Unicode object) [const char \*]
+These formats allow to access an object as a contiguous chunk of memory.
+You don't have to provide raw storage for the returned unicode or bytes
+area.  Also, you won't have to release any memory yourself, except with the
+``es``, ``es#``, ``et`` and ``et#`` formats.
+``s`` (string or Unicode) [const char \*]
    Convert a Python string or Unicode object to a C pointer to a character
    string.  You must not provide storage for the string itself; a pointer to
 …
    encoding.  If this conversion fails, a :exc:`UnicodeError` is raised.
 ``s#`` (string, Unicode or any read buffer compatible object) [const char \*, int (or :ctype:`Py_ssize_t`, see below)]
+``s#`` (string, Unicode or any read buffer compatible object) [const char \*, int (or :c:type:`Py_ssize_t`, see below)]
    This variant on ``s`` stores into two C variables, the first one a pointer
    to a character string, the second one its length.  In this case the Python
 …
    Starting with Python 2.5 the type of the length argument can be controlled
    by defining the macro :cmacro:`PY_SSIZE_T_CLEAN` before including
    :file:`Python.h`.  If the macro is defined, length is a :ctype:`Py_ssize_t`
+   by defining the macro :c:macro:`PY_SSIZE_T_CLEAN` before including
+   :file:`Python.h`.  If the macro is defined, length is a :c:type:`Py_ssize_t`
    rather than an int.
 …
    .. versionadded:: 2.6
 ``z`` (string or ``None``) [const char \*]
+``z`` (string, Unicode  or ``None``) [const char \*]
    Like ``s``, but the Python object may also be ``None``, in which case the C
    pointer is set to *NULL*.
 ``z#`` (string or ``None`` or any read buffer compatible object) [const char \*, int]
+``z#`` (string, Unicode, ``None`` or any read buffer compatible object) [const char \*, int]
    This is to ``s#`` as ``z`` is to ``s``.
 ``z*`` (string or ``None`` or any buffer compatible object) [Py_buffer]
+``z*`` (string, Unicode, ``None`` or any buffer compatible object) [Py_buffer]
    This is to ``s*`` as ``z`` is to ``s``.
    .. versionadded:: 2.6
 ``u`` (Unicode object) [Py_UNICODE \*]
+``u`` (Unicode) [Py_UNICODE \*]
    Convert a Python Unicode object to a C pointer to a NUL-terminated buffer
    of 16-bit Unicode (UTF-16) data.  As with ``s``, there is no need to
    provide storage for the Unicode data buffer; a pointer to the existing
    Unicode data is stored into the :ctype:`Py_UNICODE` pointer variable whose
+   Unicode data is stored into the :c:type:`Py_UNICODE` pointer variable whose
    address you pass.
 ``u#`` (Unicode object) [Py_UNICODE \*, int]
+``u#`` (Unicode) [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.
 ``es`` (string, Unicode object or character buffer compatible object) [const char \*encoding, char \*\*buffer]
+   :c:type:`Py_UNICODE` array.
+``es`` (string, Unicode or character buffer compatible object) [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
 …
    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
+   must be a :c:type:`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 second argument must be a :ctype:`char\*\*`; the value of the pointer
+   The second argument must be a :c:type:`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
+   :c:func:`PyArg_ParseTuple` will allocate a buffer of the needed size, copy
    the 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`` (string, Unicode object or character buffer compatible object) [const char \*encoding, char \*\*buffer]
+   :c:func:`PyMem_Free` to free the allocated buffer after use.
+``et`` (string, Unicode or character buffer compatible object) [const char \*encoding, char \*\*buffer]
    Same as ``es`` except that 8-bit string objects are passed through without
    recoding them.  Instead, the implementation assumes that the string object
    uses the encoding passed in as parameter.
 ``es#`` (string, Unicode object or character buffer compatible object) [const char \*encoding, char \*\*buffer, int \*buffer_length]
+``es#`` (string, Unicode or character buffer compatible object) [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
 …
    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
+   a :c:type:`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 second argument must be a :ctype:`char\*\*`; the value of the pointer
+   The second argument must be a :c:type:`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
 …
    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
+   responsible for calling :c:func:`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
+   :c:func:`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
 …
    without the trailing NUL byte.
 ``et#`` (string, Unicode object or character buffer compatible object) [const char \*encoding, char \*\*buffer, int \*buffer_length]
+``et#`` (string, Unicode or character buffer compatible object) [const char \*encoding, char \*\*buffer, int \*buffer_length]
    Same as ``es#`` except that string objects are passed through without
    recoding them. Instead, the implementation assumes that the string object
 …
 ``b`` (integer) [unsigned char]
    Convert a nonnegative Python integer to an unsigned tiny int, stored in a C
    :ctype:`unsigned char`.
+   :c:type:`unsigned char`.
 ``B`` (integer) [unsigned char]
    Convert a Python integer to a tiny int without overflow checking, stored in
    a C :ctype:`unsigned char`.
+   a C :c:type:`unsigned char`.
    .. versionadded:: 2.3
 ``h`` (integer) [short int]
    Convert a Python integer to a C :ctype:`short int`.
+   Convert a Python integer to a C :c:type:`short int`.
 ``H`` (integer) [unsigned short int]
    Convert a Python integer to a C :ctype:`unsigned short int`, without
+   Convert a Python integer to a C :c:type:`unsigned short int`, without
    overflow checking.
 …
 ``i`` (integer) [int]
    Convert a Python integer to a plain C :ctype:`int`.
+   Convert a Python integer to a plain C :c:type:`int`.
 ``I`` (integer) [unsigned int]
    Convert a Python integer to a C :ctype:`unsigned int`, without overflow
+   Convert a Python integer to a C :c:type:`unsigned int`, without overflow
    checking.
 …
 ``l`` (integer) [long int]
    Convert a Python integer to a C :ctype:`long int`.
+   Convert a Python integer to a C :c:type:`long int`.
 ``k`` (integer) [unsigned long]
    Convert a Python integer or long integer to a C :ctype:`unsigned long`
+   Convert a Python integer or long integer to a C :c:type:`unsigned long`
    without overflow checking.
 …
 ``L`` (integer) [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`
+   Convert a Python integer to a C :c:type:`long long`.  This format is only
+   available on platforms that support :c:type:`long long` (or :c:type:`_int64`
    on Windows).
 ``K`` (integer) [unsigned PY_LONG_LONG]
    Convert a Python integer or long integer to a C :ctype:`unsigned long long`
+   Convert a Python integer or long integer to a C :c:type:`unsigned long long`
    without overflow checking.  This format is only available on platforms that
    support :ctype:`unsigned long long` (or :ctype:`unsigned _int64` on
+   support :c:type:`unsigned long long` (or :c:type:`unsigned _int64` on
    Windows).
 …
 ``n`` (integer) [Py_ssize_t]
    Convert a Python integer or long integer to a C :ctype:`Py_ssize_t`.
+   Convert a Python integer or long integer to a C :c:type:`Py_ssize_t`.
    .. versionadded:: 2.5
 …
 ``c`` (string of length 1) [char]
    Convert a Python character, represented as a string of length 1, to a C
    :ctype:`char`.
+   :c:type:`char`.
 ``f`` (float) [float]
    Convert a Python floating point number to a C :ctype:`float`.
+   Convert a Python floating point number to a C :c:type:`float`.
 ``d`` (float) [double]
    Convert a Python floating point number to a C :ctype:`double`.
+   Convert a Python floating point number to a C :c:type:`double`.
 ``D`` (complex) [Py_complex]
    Convert a Python complex number to a C :ctype:`Py_complex` structure.
+   Convert a Python complex number to a C :c:type:`Py_complex` structure.
 ``O`` (object) [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\*`)
+   the second is the address of the C variable (of type :c:type:`PyObject\*`)
    into which the object pointer is stored.  If the Python object does not
    have the required type, :exc:`TypeError` is raised.
 …
    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 \*`.
+   address of a C variable (of arbitrary type), converted to :c:type:`void \*`.
    The *converter* function in turn is called as follows::
 …
    where *object* is the Python object to be converted and *address* is the
    :ctype:`void\*` argument that was passed to the :cfunc:`PyArg_Parse\*`
+   :c:type:`void\*` argument that was passed to the :c:func:`PyArg_Parse\*`
    function.  The returned *status* should be ``1`` for a successful
    conversion and ``0`` if the conversion has failed.  When the conversion
 …
    Like ``O`` but requires that the Python object is a string object.  Raises
    :exc:`TypeError` if the object is not a string object.  The C variable may
    also be declared as :ctype:`PyObject\*`.
+   also be declared as :c:type:`PyObject\*`.
 ``U`` (Unicode string) [PyUnicodeObject \*]
    Like ``O`` but requires that the Python object is a Unicode object.  Raises
    :exc:`TypeError` if the object is not a Unicode object.  The C variable may
    also be declared as :ctype:`PyObject\*`.
+   also be declared as :c:type:`PyObject\*`.
 ``t#`` (read-only character buffer) [char \*, 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.
+   interface.  The :c:type:`char\*` variable is set to point to the first byte
+   of the buffer, and the :c:type:`int` is set to the length of the buffer.
    Only single-segment buffer objects are accepted; :exc:`TypeError` is raised
    for all others.
 …
 ``w#`` (read-write character buffer) [char \*, Py_ssize_t]
    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
    of the buffer, and the :ctype:`Py_ssize_t` is set to the length of the
+   interface.  The :c:type:`char \*` variable is set to point to the first byte
+   of the buffer, and the :c:type:`Py_ssize_t` is set to the length of the
    buffer.  Only single-segment buffer objects are accepted; :exc:`TypeError`
    is raised for all others.
 …
    optional.  The C variables corresponding to optional arguments should be
    initialized to their default value --- when an optional argument is not
    specified, :cfunc:`PyArg_ParseTuple` does not touch the contents of the
+   specified, :c:func:`PyArg_ParseTuple` does not touch the contents of the
    corresponding C variable(s).
 …
    The list of format units ends here; the string after the colon is used as
    the function name in error messages (the "associated value" of the
    exception that :cfunc:`PyArg_ParseTuple` raises).
+   exception that :c:func:`PyArg_ParseTuple` raises).
 ``;``
 …
 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
+format must be exhausted.  On success, the :c:func:`PyArg_Parse\*` functions
 return true, otherwise they return false and raise an appropriate exception.
 When the :cfunc:`PyArg_Parse\*` functions fail due to conversion failure in
+When the :c:func:`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.
 .. cfunction:: int PyArg_ParseTuple(PyObject *args, const char *format, ...)
+.. c:function:: int PyArg_ParseTuple(PyObject *args, const char *format, ...)
    Parse the parameters of a function that takes only positional parameters
 …
 .. cfunction:: int PyArg_VaParse(PyObject *args, const char *format, va_list vargs)
    Identical to :cfunc:`PyArg_ParseTuple`, except that it accepts a va_list
+.. c:function:: int PyArg_VaParse(PyObject *args, const char *format, va_list vargs)
+   Identical to :c:func:`PyArg_ParseTuple`, except that it accepts a va_list
    rather than a variable number of arguments.
 .. cfunction:: int PyArg_ParseTupleAndKeywords(PyObject *args, PyObject *kw, const char *format, char *keywords[], ...)
+.. c:function:: int PyArg_ParseTupleAndKeywords(PyObject *args, PyObject *kw, const char *format, char *keywords[], ...)
    Parse the parameters of a function that takes both positional and keyword
 …
 .. cfunction:: int PyArg_VaParseTupleAndKeywords(PyObject *args, PyObject *kw, const char *format, char *keywords[], va_list vargs)
    Identical to :cfunc:`PyArg_ParseTupleAndKeywords`, except that it accepts a
+.. c:function:: int PyArg_VaParseTupleAndKeywords(PyObject *args, PyObject *kw, const char *format, char *keywords[], va_list vargs)
+   Identical to :c:func:`PyArg_ParseTupleAndKeywords`, except that it accepts a
    va_list rather than a variable number of arguments.
 .. cfunction:: int PyArg_Parse(PyObject *args, const char *format, ...)
+.. c:function:: int PyArg_Parse(PyObject *args, const char *format, ...)
    Function used to deconstruct the argument lists of "old-style" functions
 …
 .. cfunction:: int PyArg_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, ...)
+.. c:function:: int PyArg_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, ...)
    A simpler form of parameter retrieval which does not use a format string to
 …
    tuple must be at least *min* and no more than *max*; *min* and *max* may be
    equal.  Additional arguments must be passed to the function, each of which
    should be a pointer to a :ctype:`PyObject\*` variable; these will be filled
+   should be a pointer to a :c:type:`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
 …
+      }
    The call to :cfunc:`PyArg_UnpackTuple` in this example is entirely
    equivalent to this call to :cfunc:`PyArg_ParseTuple`::
+   The call to :c:func:`PyArg_UnpackTuple` in this example is entirely
+   equivalent to this call to :c:func:`PyArg_ParseTuple`::
       PyArg_ParseTuple(args, "O|O:ref", &object, &callback)
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *min* and *max*. This might
+      This function used an :c:type:`int` type for *min* and *max*. This might
       require changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* Py_BuildValue(const char *format, ...)
+.. c:function:: PyObject* Py_BuildValue(const char *format, ...)
    Create a new value based on a format string similar to those accepted by
    the :cfunc:`PyArg_Parse\*` family of functions and a sequence of values.
+   the :c:func:`PyArg_Parse\*` family of functions and a sequence of values.
    Returns the value or *NULL* in the case of an error; an exception will be
    raised if *NULL* is returned.
    :cfunc:`Py_BuildValue` does not always build a tuple.  It builds a tuple
+   :c:func:`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
 …
    objects, as 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 responsible for calling :cfunc:`free` for that memory once
    :cfunc:`Py_BuildValue` returns.
+   by :c:func:`Py_BuildValue`.  In other words, if your code invokes
+   :c:func:`malloc` and passes the allocated memory to :c:func:`Py_BuildValue`,
+   your code is responsible for calling :c:func:`free` for that memory once
+   :c:func:`Py_BuildValue` returns.
    In the following description, the quoted form is the format unit; the entry
 …
    ``i`` (integer) [int]
       Convert a plain C :ctype:`int` to a Python integer object.
+      Convert a plain C :c:type:`int` to a Python integer object.
    ``b`` (integer) [char]
       Convert a plain C :ctype:`char` to a Python integer object.
+      Convert a plain C :c:type:`char` to a Python integer object.
    ``h`` (integer) [short int]
       Convert a plain C :ctype:`short int` to a Python integer object.
+      Convert a plain C :c:type:`short int` to a Python integer object.
    ``l`` (integer) [long int]
       Convert a C :ctype:`long int` to a Python integer object.
+      Convert a C :c:type:`long int` to a Python integer object.
    ``B`` (integer) [unsigned char]
       Convert a C :ctype:`unsigned char` to a Python integer object.
+      Convert a C :c:type:`unsigned char` to a Python integer object.
    ``H`` (integer) [unsigned short int]
       Convert a C :ctype:`unsigned short int` to a Python integer object.
+      Convert a C :c:type:`unsigned short int` to a Python integer object.
    ``I`` (integer/long) [unsigned int]
       Convert a C :ctype:`unsigned int` to a Python integer object or a Python
+      Convert a C :c:type:`unsigned int` to a Python integer object or a Python
       long integer object, if it is larger than ``sys.maxint``.
    ``k`` (integer/long) [unsigned long]
       Convert a C :ctype:`unsigned long` to a Python integer object or a
+      Convert a C :c:type:`unsigned long` to a Python integer object or a
       Python long integer object, if it is larger than ``sys.maxint``.
    ``L`` (long) [PY_LONG_LONG]
       Convert a C :ctype:`long long` to a Python long integer object. Only
       available on platforms that support :ctype:`long long`.
+      Convert a C :c:type:`long long` to a Python long integer object. Only
+      available on platforms that support :c:type:`long long`.
    ``K`` (long) [unsigned PY_LONG_LONG]
       Convert a C :ctype:`unsigned long long` to a Python long integer object.
       Only available on platforms that support :ctype:`unsigned long long`.
+      Convert a C :c:type:`unsigned long long` to a Python long integer object.
+      Only available on platforms that support :c:type:`unsigned long long`.
    ``n`` (int) [Py_ssize_t]
       Convert a C :ctype:`Py_ssize_t` to a Python integer or long integer.
+      Convert a C :c:type:`Py_ssize_t` to a Python integer or long integer.
       .. versionadded:: 2.5
    ``c`` (string of length 1) [char]
       Convert a C :ctype:`int` representing a character to a Python string of
+      Convert a C :c:type:`int` representing a character to a Python string of
       length 1.
    ``d`` (float) [double]
       Convert a C :ctype:`double` to a Python floating point number.
+      Convert a C :c:type:`double` to a Python floating point number.
    ``f`` (float) [float]
 …
    ``D`` (complex) [Py_complex \*]
       Convert a C :ctype:`Py_complex` structure to a Python complex number.
+      Convert a C :c:type:`Py_complex` structure to a Python complex number.
    ``O`` (object) [PyObject \*]
 …
       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 set an exception. Therefore, :cfunc:`Py_BuildValue`
+      found an error and set an exception. Therefore, :c:func:`Py_BuildValue`
       will return *NULL* but won't raise an exception.  If no exception has
       been raised yet, :exc:`SystemError` is set.
 …
       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
+      :c:type:`void \*`) as its argument and should return a "new" Python
       object, or *NULL* if an error occurred.
 …
    is set and *NULL* returned.
 .. cfunction:: PyObject* Py_VaBuildValue(const char *format, va_list vargs)
    Identical to :cfunc:`Py_BuildValue`, except that it accepts a va_list
+.. c:function:: PyObject* Py_VaBuildValue(const char *format, va_list vargs)
+   Identical to :c:func:`Py_BuildValue`, except that it accepts a va_list
    rather than a variable number of arguments.

python/vendor/current/Doc/c-api/bool.rst

-              r2
+              r388
 .. cfunction:: int PyBool_Check(PyObject *o)
+.. c:function:: int PyBool_Check(PyObject *o)
    Return true if *o* is of type :cdata:`PyBool_Type`.
+   Return true if *o* is of type :c:data:`PyBool_Type`.
    .. versionadded:: 2.3
 .. cvar:: PyObject* Py_False
+.. c:var:: PyObject* Py_False
    The Python ``False`` object.  This object has no methods.  It needs to be
 …
 .. cvar:: PyObject* Py_True
+.. c:var:: PyObject* Py_True
    The Python ``True`` object.  This object has no methods.  It needs to be treated
 …
 .. cmacro:: Py_RETURN_FALSE
+.. c:macro:: Py_RETURN_FALSE
    Return :const:`Py_False` from a function, properly incrementing its reference
 …
 .. cmacro:: Py_RETURN_TRUE
+.. c:macro:: Py_RETURN_TRUE
    Return :const:`Py_True` from a function, properly incrementing its reference
 …
 .. cfunction:: PyObject* PyBool_FromLong(long v)
+.. c:function:: PyObject* PyBool_FromLong(long v)
    Return a new reference to :const:`Py_True` or :const:`Py_False` depending on the

python/vendor/current/Doc/c-api/buffer.rst

-              r2
+              r388
 .. _bufferobjects:
 Buffer Objects
 --------------
+Buffers and Memoryview Objects
+------------------------------
 .. sectionauthor:: Greg Stein <gstein@lyra.org>
+.. sectionauthor:: Benjamin Peterson
 …
 method. Any object that can export a series of bytes through the buffer
 interface can be written to a file. There are a number of format codes to
 :cfunc:`PyArg_ParseTuple` that operate against an object's buffer interface,
+:c:func:`PyArg_ParseTuple` that operate against an object's buffer interface,
 returning data from the target object.
 …
 objects and a C-level buffer API so that any built-in or used-defined type can
 expose its characteristics. Both, however, have been deprecated because of
 various shortcomings, and have been officially removed in Python 3.0 in favour
+various shortcomings, and have been officially removed in Python 3 in favour
 of a new C-level buffer API and a new Python-level object named
 :class:`memoryview`.
 …
 .. ctype:: Py_buffer
    .. cmember:: void *buf
+.. c:type:: Py_buffer
+   .. c:member:: void *buf
       A pointer to the start of the memory for the object.
    .. cmember:: Py_ssize_t len
+   .. c:member:: Py_ssize_t len
       :noindex:
       The total length of the memory in bytes.
    .. cmember:: int readonly
+   .. c:member:: int readonly
       An indicator of whether the buffer is read only.
    .. cmember:: const char *format
+   .. c:member:: const char *format
       :noindex:
 …
       *NULL*, ``"B"`` (unsigned bytes) is assumed.
    .. cmember:: int ndim
+   .. c:member:: int ndim
       The number of dimensions the memory represents as a multi-dimensional
       array.  If it is 0, :cdata:`strides` and :cdata:`suboffsets` must be
+      array.  If it is 0, :c:data:`strides` and :c:data:`suboffsets` must be
       *NULL*.
    .. cmember:: Py_ssize_t *shape
       An array of :ctype:`Py_ssize_t`\s the length of :cdata:`ndim` giving the
+   .. c:member:: Py_ssize_t *shape
+      An array of :c:type:`Py_ssize_t`\s the length of :c:data:`ndim` giving the
       shape of the memory as a multi-dimensional array.  Note that
       ``((*shape)[0] * ... * (*shape)[ndims-1])*itemsize`` should be equal to
       :cdata:`len`.
    .. cmember:: Py_ssize_t *strides
       An array of :ctype:`Py_ssize_t`\s the length of :cdata:`ndim` giving the
+      :c:data:`len`.
+   .. c:member:: Py_ssize_t *strides
+      An array of :c:type:`Py_ssize_t`\s the length of :c:data:`ndim` giving the
       number of bytes to skip to get to a new element in each dimension.
    .. cmember:: Py_ssize_t *suboffsets
       An array of :ctype:`Py_ssize_t`\s the length of :cdata:`ndim`.  If these
+   .. c:member:: Py_ssize_t *suboffsets
+      An array of :c:type:`Py_ssize_t`\s the length of :c:data:`ndim`.  If these
       suboffset numbers are greater than or equal to 0, then the value stored
       along the indicated dimension is a pointer and the suboffset value
 …
    .. cmember:: Py_ssize_t itemsize
+   .. c:member:: Py_ssize_t itemsize
       This is a storage for the itemsize (in bytes) of each element of the
       shared memory. It is technically un-necessary as it can be obtained
       using :cfunc:`PyBuffer_SizeFromFormat`, however an exporter may know
+      using :c:func:`PyBuffer_SizeFromFormat`, however an exporter may know
       this information without parsing the format string and it is necessary
       to know the itemsize for proper interpretation of striding. Therefore,
       storing it is more convenient and faster.
    .. cmember:: void *internal
+   .. c:member:: void *internal
       This is for use internally by the exporting object. For example, this
 …
 .. cfunction:: int PyObject_CheckBuffer(PyObject *obj)
+.. c:function:: int PyObject_CheckBuffer(PyObject *obj)
    Return 1 if *obj* supports the buffer interface otherwise 0.
 .. cfunction:: int PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags)
       Export *obj* into a :ctype:`Py_buffer`, *view*.  These arguments must
+.. c:function:: int PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags)
+      Export *obj* into a :c:type:`Py_buffer`, *view*.  These arguments must
       never be *NULL*.  The *flags* argument is a bit field indicating what
       kind of buffer the caller is prepared to deal with and therefore what
 …
       there is another error that is actually causing the problem. The
       exporter can use flags information to simplify how much of the
       :cdata:`Py_buffer` structure is filled in with non-default values and/or
+      :c:data:`Py_buffer` structure is filled in with non-default values and/or
       raise an error if the object can't support a simpler view of its memory.
 …
       The following table gives possible values to the *flags* arguments.
       +------------------------------+---------------------------------------------------+
       | Flag                         | Description                                       |
       +==============================+===================================================+
       | :cmacro:`PyBUF_SIMPLE`       | This is the default flag state.  The returned     |
       |                              | buffer may or may not have writable memory.  The  |
       |                              | format of the data will be assumed to be unsigned |
       |                              | bytes.  This is a "stand-alone" flag constant. It |
       |                              | never needs to be '|'d to the others. The exporter|
       |                              | will raise an error if it cannot provide such a   |
       |                              | contiguous buffer of bytes.                       |
       |                              |                                                   |
       +------------------------------+---------------------------------------------------+
       | :cmacro:`PyBUF_WRITABLE`     | The returned buffer must be writable.  If it is   |
       |                              | not writable, then raise an error.                |
       +------------------------------+---------------------------------------------------+
       | :cmacro:`PyBUF_STRIDES`      | This implies :cmacro:`PyBUF_ND`. The returned     |
       |                              | buffer must provide strides information (i.e. the |
       |                              | strides cannot be NULL). This would be used when  |
       |                              | the consumer can handle strided, discontiguous    |
       |                              | arrays.  Handling strides automatically assumes   |
       |                              | you can handle shape.  The exporter can raise an  |
       |                              | error if a strided representation of the data is  |
       |                              | not possible (i.e. without the suboffsets).       |
       |                              |                                                   |
       +------------------------------+---------------------------------------------------+
       | :cmacro:`PyBUF_ND`           | The returned buffer must provide shape            |
       |                              | information. The memory will be assumed C-style   |
       |                              | contiguous (last dimension varies the             |
       |                              | fastest). The exporter may raise an error if it   |
       |                              | cannot provide this kind of contiguous buffer. If |
       |                              | this is not given then shape will be *NULL*.      |
       |                              |                                                   |
       |                              |                                                   |
       |                              |                                                   |
       +------------------------------+---------------------------------------------------+
       |:cmacro:`PyBUF_C_CONTIGUOUS`  | These flags indicate that the contiguity returned |
       |:cmacro:`PyBUF_F_CONTIGUOUS`  | buffer must be respectively, C-contiguous (last   |
       |:cmacro:`PyBUF_ANY_CONTIGUOUS`| dimension varies the fastest), Fortran contiguous |
       |                              | (first dimension varies the fastest) or either    |
       |                              | one.  All of these flags imply                    |
       |                              | :cmacro:`PyBUF_STRIDES` and guarantee that the    |
       |                              | strides buffer info structure will be filled in   |
       |                              | correctly.                                        |
       |                              |                                                   |
       +------------------------------+---------------------------------------------------+
       | :cmacro:`PyBUF_INDIRECT`     | This flag indicates the returned buffer must have |
       |                              | suboffsets information (which can be NULL if no   |
       |                              | suboffsets are needed).  This can be used when    |
       |                              | the consumer can handle indirect array            |
       |                              | referencing implied by these suboffsets. This     |
       |                              | implies :cmacro:`PyBUF_STRIDES`.                  |
       |                              |                                                   |
       |                              |                                                   |
       |                              |                                                   |
       +------------------------------+---------------------------------------------------+
       | :cmacro:`PyBUF_FORMAT`       | The returned buffer must have true format         |
       |                              | information if this flag is provided. This would  |
       |                              | be used when the consumer is going to be checking |
       |                              | for what 'kind' of data is actually stored. An    |
       |                              | exporter should always be able to provide this    |
       |                              | information if requested. If format is not        |
       |                              | explicitly requested then the format must be      |
       |                              | returned as *NULL* (which means ``'B'``, or       |
       |                              | unsigned bytes)                                   |
       +------------------------------+---------------------------------------------------+
       | :cmacro:`PyBUF_STRIDED`      | This is equivalent to ``(PyBUF_STRIDES |          |
       |                              | PyBUF_WRITABLE)``.                                |
       +------------------------------+---------------------------------------------------+
       | :cmacro:`PyBUF_STRIDED_RO`   | This is equivalent to ``(PyBUF_STRIDES)``.        |
       |                              |                                                   |
       +------------------------------+---------------------------------------------------+
       | :cmacro:`PyBUF_RECORDS`      | This is equivalent to ``(PyBUF_STRIDES |          |
       |                              | PyBUF_FORMAT | PyBUF_WRITABLE)``.                 |
       +------------------------------+---------------------------------------------------+
       | :cmacro:`PyBUF_RECORDS_RO`   | This is equivalent to ``(PyBUF_STRIDES |          |
       |                              | PyBUF_FORMAT)``.                                  |
       +------------------------------+---------------------------------------------------+
       | :cmacro:`PyBUF_FULL`         | This is equivalent to ``(PyBUF_INDIRECT |         |
       |                              | PyBUF_FORMAT | PyBUF_WRITABLE)``.                 |
       +------------------------------+---------------------------------------------------+
       | :cmacro:`PyBUF_FULL_RO`      | This is equivalent to ``(PyBUF_INDIRECT |         |
       |                              | PyBUF_FORMAT)``.                                  |
       +------------------------------+---------------------------------------------------+
       | :cmacro:`PyBUF_CONTIG`       | This is equivalent to ``(PyBUF_ND |               |
       |                              | PyBUF_WRITABLE)``.                                |
       +------------------------------+---------------------------------------------------+
       | :cmacro:`PyBUF_CONTIG_RO`    | This is equivalent to ``(PyBUF_ND)``.             |
       |                              |                                                   |
       +------------------------------+---------------------------------------------------+
 .. cfunction:: void PyBuffer_Release(Py_buffer *view)
+      +-------------------------------+---------------------------------------------------+
+      | Flag                          | Description                                       |
+      +===============================+===================================================+
+      | :c:macro:`PyBUF_SIMPLE`       | This is the default flag state.  The returned     |
+      |                               | buffer may or may not have writable memory.  The  |
+      |                               | format of the data will be assumed to be unsigned |
+      |                               | bytes.  This is a "stand-alone" flag constant. It |
+      |                               | never needs to be '|'d to the others. The exporter|
+      |                               | will raise an error if it cannot provide such a   |
+      |                               | contiguous buffer of bytes.                       |
+      |                               |                                                   |
+      +-------------------------------+---------------------------------------------------+
+      | :c:macro:`PyBUF_WRITABLE`     | The returned buffer must be writable.  If it is   |
+      |                               | not writable, then raise an error.                |
+      +-------------------------------+---------------------------------------------------+
+      | :c:macro:`PyBUF_STRIDES`      | This implies :c:macro:`PyBUF_ND`. The returned    |
+      |                               | buffer must provide strides information (i.e. the |
+      |                               | strides cannot be NULL). This would be used when  |
+      |                               | the consumer can handle strided, discontiguous    |
+      |                               | arrays.  Handling strides automatically assumes   |
+      |                               | you can handle shape.  The exporter can raise an  |
+      |                               | error if a strided representation of the data is  |
+      |                               | not possible (i.e. without the suboffsets).       |
+      |                               |                                                   |
+      +-------------------------------+---------------------------------------------------+
+      | :c:macro:`PyBUF_ND`           | The returned buffer must provide shape            |
+      |                               | information. The memory will be assumed C-style   |
+      |                               | contiguous (last dimension varies the             |
+      |                               | fastest). The exporter may raise an error if it   |
+      |                               | cannot provide this kind of contiguous buffer. If |
+      |                               | this is not given then shape will be *NULL*.      |
+      |                               |                                                   |
+      |                               |                                                   |
+      |                               |                                                   |
+      +-------------------------------+---------------------------------------------------+
+      |:c:macro:`PyBUF_C_CONTIGUOUS`  | These flags indicate that the contiguity returned |
+      |:c:macro:`PyBUF_F_CONTIGUOUS`  | buffer must be respectively, C-contiguous (last   |
+      |:c:macro:`PyBUF_ANY_CONTIGUOUS`| dimension varies the fastest), Fortran contiguous |
+      |                               | (first dimension varies the fastest) or either    |
+      |                               | one.  All of these flags imply                    |
+      |                               | :c:macro:`PyBUF_STRIDES` and guarantee that the   |
+      |                               | strides buffer info structure will be filled in   |
+      |                               | correctly.                                        |
+      |                               |                                                   |
+      +-------------------------------+---------------------------------------------------+
+      | :c:macro:`PyBUF_INDIRECT`     | This flag indicates the returned buffer must have |
+      |                               | suboffsets information (which can be NULL if no   |
+      |                               | suboffsets are needed).  This can be used when    |
+      |                               | the consumer can handle indirect array            |
+      |                               | referencing implied by these suboffsets. This     |
+      |                               | implies :c:macro:`PyBUF_STRIDES`.                 |
+      |                               |                                                   |
+      |                               |                                                   |
+      |                               |                                                   |
+      +-------------------------------+---------------------------------------------------+
+      | :c:macro:`PyBUF_FORMAT`       | The returned buffer must have true format         |
+      |                               | information if this flag is provided. This would  |
+      |                               | be used when the consumer is going to be checking |
+      |                               | for what 'kind' of data is actually stored. An    |
+      |                               | exporter should always be able to provide this    |
+      |                               | information if requested. If format is not        |
+      |                               | explicitly requested then the format must be      |
+      |                               | returned as *NULL* (which means ``'B'``, or       |
+      |                               | unsigned bytes)                                   |
+      +-------------------------------+---------------------------------------------------+
+      | :c:macro:`PyBUF_STRIDED`      | This is equivalent to ``(PyBUF_STRIDES |          |
+      |                               | PyBUF_WRITABLE)``.                                |
+      +-------------------------------+---------------------------------------------------+
+      | :c:macro:`PyBUF_STRIDED_RO`   | This is equivalent to ``(PyBUF_STRIDES)``.        |
+      |                               |                                                   |
+      +-------------------------------+---------------------------------------------------+
+      | :c:macro:`PyBUF_RECORDS`      | This is equivalent to ``(PyBUF_STRIDES |          |
+      |                               | PyBUF_FORMAT | PyBUF_WRITABLE)``.                 |
+      +-------------------------------+---------------------------------------------------+
+      | :c:macro:`PyBUF_RECORDS_RO`   | This is equivalent to ``(PyBUF_STRIDES |          |
+      |                               | PyBUF_FORMAT)``.                                  |
+      +-------------------------------+---------------------------------------------------+
+      | :c:macro:`PyBUF_FULL`         | This is equivalent to ``(PyBUF_INDIRECT |         |
+      |                               | PyBUF_FORMAT | PyBUF_WRITABLE)``.                 |
+      +-------------------------------+---------------------------------------------------+
+      | :c:macro:`PyBUF_FULL_RO`      | This is equivalent to ``(PyBUF_INDIRECT |         |
+      |                               | PyBUF_FORMAT)``.                                  |
+      +-------------------------------+---------------------------------------------------+
+      | :c:macro:`PyBUF_CONTIG`       | This is equivalent to ``(PyBUF_ND |               |
+      |                               | PyBUF_WRITABLE)``.                                |
+      +-------------------------------+---------------------------------------------------+
+      | :c:macro:`PyBUF_CONTIG_RO`    | This is equivalent to ``(PyBUF_ND)``.             |
+      |                               |                                                   |
+      +-------------------------------+---------------------------------------------------+
+.. c:function:: void PyBuffer_Release(Py_buffer *view)
    Release the buffer *view*.  This should be called when the buffer
 …
+.. cfunction:: Py_ssize_t PyBuffer_SizeFromFormat(const char *)
+   Return the implied :cdata:`~Py_buffer.itemsize` from the struct-stype
+   :cdata:`~Py_buffer.format`.
+.. cfunction:: int PyObject_CopyToObject(PyObject *obj, void *buf, Py_ssize_t len, char fortran)
+   Copy *len* bytes of data pointed to by the contiguous chunk of memory
+   pointed to by *buf* into the buffer exported by obj.  The buffer must of
+   course be writable.  Return 0 on success and return -1 and raise an error
+   on failure.  If the object does not have a writable buffer, then an error
+   is raised.  If *fortran* is ``'F'``, then if the object is
+   multi-dimensional, then the data will be copied into the array in
+   Fortran-style (first dimension varies the fastest).  If *fortran* is
+   ``'C'``, then the data will be copied into the array in C-style (last
+   dimension varies the fastest).  If *fortran* is ``'A'``, then it does not
+   matter and the copy will be made in whatever way is more efficient.
+.. cfunction:: int PyBuffer_IsContiguous(Py_buffer *view, char fortran)
+.. c:function:: Py_ssize_t PyBuffer_SizeFromFormat(const char *)
+   Return the implied :c:data:`~Py_buffer.itemsize` from the struct-stype
+   :c:data:`~Py_buffer.format`.
+.. c:function:: int PyBuffer_IsContiguous(Py_buffer *view, char fortran)
    Return 1 if the memory defined by the *view* is C-style (*fortran* is
 …
 .. cfunction:: void PyBuffer_FillContiguousStrides(int ndim, Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t itemsize, char fortran)
+.. c:function:: void PyBuffer_FillContiguousStrides(int ndim, Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t itemsize, char fortran)
    Fill the *strides* array with byte-strides of a contiguous (C-style if
    *fortran* is ``'C'`` or Fortran-style if *fortran* is ``'F'`` array of the
+   *fortran* is ``'C'`` or Fortran-style if *fortran* is ``'F'``) array of the
    given shape with the given number of bytes per element.
 .. cfunction:: int PyBuffer_FillInfo(Py_buffer *view, void *buf, Py_ssize_t len, int readonly, int infoflags)
+.. c:function:: int PyBuffer_FillInfo(Py_buffer *view, PyObject *obj, void *buf, Py_ssize_t len, int readonly, int infoflags)
    Fill in a buffer-info structure, *view*, correctly for an exporter that can
 …
+MemoryView objects
+==================
+.. versionadded:: 2.7
+A :class:`memoryview` object exposes the new C level buffer interface as a
+Python object which can then be passed around like any other object.
+.. c:function:: PyObject *PyMemoryView_FromObject(PyObject *obj)
+   Create a memoryview object from an object that defines the new buffer
+   interface.
+.. c:function:: PyObject *PyMemoryView_FromBuffer(Py_buffer *view)
+   Create a memoryview object wrapping the given buffer-info structure *view*.
+   The memoryview object then owns the buffer, which means you shouldn't
+   try to release it yourself: it will be released on deallocation of the
+   memoryview object.
+.. c:function:: PyObject *PyMemoryView_GetContiguous(PyObject *obj, int buffertype, char order)
+   Create a memoryview object to a contiguous chunk of memory (in either
+   'C' or 'F'ortran *order*) from an object that defines the buffer
+   interface. If memory is contiguous, the memoryview object points to the
+   original memory. Otherwise copy is made and the memoryview points to a
+   new bytes object.
+.. c:function:: int PyMemoryView_Check(PyObject *obj)
+   Return true if the object *obj* is a memoryview object.  It is not
+   currently allowed to create subclasses of :class:`memoryview`.
+.. c:function:: Py_buffer *PyMemoryView_GET_BUFFER(PyObject *obj)
+   Return a pointer to the buffer-info structure wrapped by the given
+   object.  The object **must** be a memoryview instance; this macro doesn't
+   check its type, you must do it yourself or you will risk crashes.
 Old-style buffer objects
 ========================
 …
 .. index:: single: PyBufferProcs
 More information on the buffer interface is provided in the section
 :ref:`buffer-structs`, under the description for :ctype:`PyBufferProcs`.
+More information on the old buffer interface is provided in the section
+:ref:`buffer-structs`, under the description for :c:type:`PyBufferProcs`.
 A "buffer object" is defined in the :file:`bufferobject.h` header (included by
 …
 .. ctype:: PyBufferObject
    This subtype of :ctype:`PyObject` represents a buffer object.
 .. cvar:: PyTypeObject PyBuffer_Type
+.. c:type:: PyBufferObject
+   This subtype of :c:type:`PyObject` represents a buffer object.
+.. c:var:: PyTypeObject PyBuffer_Type
    .. index:: single: BufferType (in module types)
    The instance of :ctype:`PyTypeObject` which represents the Python buffer type;
+   The instance of :c:type:`PyTypeObject` which represents the Python buffer type;
    it is the same object as ``buffer`` and  ``types.BufferType`` in the Python
    layer. .
 .. cvar:: int Py_END_OF_BUFFER
+.. c:var:: int Py_END_OF_BUFFER
    This constant may be passed as the *size* parameter to
    :cfunc:`PyBuffer_FromObject` or :cfunc:`PyBuffer_FromReadWriteObject`.  It
    indicates that the new :ctype:`PyBufferObject` should refer to *base*
+   :c:func:`PyBuffer_FromObject` or :c:func:`PyBuffer_FromReadWriteObject`.  It
+   indicates that the new :c:type:`PyBufferObject` should refer to *base*
    object from the specified *offset* to the end of its exported buffer.
    Using this enables the caller to avoid querying the *base* object for its
 …
 .. cfunction:: int PyBuffer_Check(PyObject *p)
    Return true if the argument has type :cdata:`PyBuffer_Type`.
 .. cfunction:: PyObject* PyBuffer_FromObject(PyObject *base, Py_ssize_t offset, Py_ssize_t size)
+.. c:function:: int PyBuffer_Check(PyObject *p)
+   Return true if the argument has type :c:data:`PyBuffer_Type`.
+.. c:function:: PyObject* PyBuffer_FromObject(PyObject *base, Py_ssize_t offset, Py_ssize_t size)
    Return a new read-only buffer object.  This raises :exc:`TypeError` if
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *offset* and *size*. This
+      This function used an :c:type:`int` type for *offset* and *size*. This
       might require changes in your code for properly supporting 64-bit
       systems.
 .. cfunction:: PyObject* PyBuffer_FromReadWriteObject(PyObject *base, Py_ssize_t offset, Py_ssize_t size)
+.. c:function:: PyObject* PyBuffer_FromReadWriteObject(PyObject *base, Py_ssize_t offset, Py_ssize_t size)
    Return a new writable buffer object.  Parameters and exceptions are similar
    to those for :cfunc:`PyBuffer_FromObject`.  If the *base* object does not
+   to those for :c:func:`PyBuffer_FromObject`.  If the *base* object does not
    export the writeable buffer protocol, then :exc:`TypeError` is raised.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *offset* and *size*. This
+      This function used an :c:type:`int` type for *offset* and *size*. This
       might require changes in your code for properly supporting 64-bit
       systems.
 .. cfunction:: PyObject* PyBuffer_FromMemory(void *ptr, Py_ssize_t size)
+.. c:function:: PyObject* PyBuffer_FromMemory(void *ptr, Py_ssize_t size)
    Return a new read-only buffer object that reads from a specified location
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
+      This function used an :c:type:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyBuffer_FromReadWriteMemory(void *ptr, Py_ssize_t size)
    Similar to :cfunc:`PyBuffer_FromMemory`, but the returned buffer is
+.. c:function:: PyObject* PyBuffer_FromReadWriteMemory(void *ptr, Py_ssize_t size)
+   Similar to :c:func:`PyBuffer_FromMemory`, but the returned buffer is
    writable.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
+      This function used an :c:type:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyBuffer_New(Py_ssize_t size)
+.. c:function:: PyObject* PyBuffer_New(Py_ssize_t size)
    Return a new writable buffer object that maintains its own memory buffer of
    *size* bytes.  :exc:`ValueError` is returned if *size* is not zero or
    positive.  Note that the memory buffer (as returned by
    :cfunc:`PyObject_AsWriteBuffer`) is not specifically aligned.
+   :c:func:`PyObject_AsWriteBuffer`) is not specifically aligned.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
+      This function used an :c:type:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.

python/vendor/current/Doc/c-api/bytearray.rst

-              r2
+              r388
 .. ctype:: PyByteArrayObject
+.. c:type:: PyByteArrayObject
    This subtype of :ctype:`PyObject` represents a Python bytearray object.
+   This subtype of :c:type:`PyObject` represents a Python bytearray object.
 .. cvar:: PyTypeObject PyByteArray_Type
+.. c:var:: PyTypeObject PyByteArray_Type
    This instance of :ctype:`PyTypeObject` represents the Python bytearray type;
+   This instance of :c:type:`PyTypeObject` represents the Python bytearray type;
    it is the same object as ``bytearray`` in the Python layer.
 …
 ^^^^^^^^^^^^^^^^^
 .. cfunction:: int PyByteArray_Check(PyObject *o)
+.. c:function:: int PyByteArray_Check(PyObject *o)
    Return true if the object *o* is a bytearray object or an instance of a
 …
 .. cfunction:: int PyByteArray_CheckExact(PyObject *o)
+.. c:function:: int PyByteArray_CheckExact(PyObject *o)
    Return true if the object *o* is a bytearray object, but not an instance of a
 …
 ^^^^^^^^^^^^^^^^^^^^
 .. cfunction:: PyObject* PyByteArray_FromObject(PyObject *o)
+.. c:function:: PyObject* PyByteArray_FromObject(PyObject *o)
    Return a new bytearray object from any object, *o*, that implements the
 …
 .. cfunction:: PyObject* PyByteArray_FromStringAndSize(const char *string, Py_ssize_t len)
+.. c:function:: PyObject* PyByteArray_FromStringAndSize(const char *string, Py_ssize_t len)
    Create a new bytearray object from *string* and its length, *len*.  On
 …
 .. cfunction:: PyObject* PyByteArray_Concat(PyObject *a, PyObject *b)
+.. c:function:: PyObject* PyByteArray_Concat(PyObject *a, PyObject *b)
    Concat bytearrays *a* and *b* and return a new bytearray with the result.
 .. cfunction:: Py_ssize_t PyByteArray_Size(PyObject *bytearray)
+.. c:function:: Py_ssize_t PyByteArray_Size(PyObject *bytearray)
    Return the size of *bytearray* after checking for a *NULL* pointer.
 .. cfunction:: char* PyByteArray_AsString(PyObject *bytearray)
+.. c:function:: char* PyByteArray_AsString(PyObject *bytearray)
    Return the contents of *bytearray* as a char array after checking for a
 …
 .. cfunction:: int PyByteArray_Resize(PyObject *bytearray, Py_ssize_t len)
+.. c:function:: int PyByteArray_Resize(PyObject *bytearray, Py_ssize_t len)
    Resize the internal buffer of *bytearray* to *len*.
 …
 These macros trade safety for speed and they don't check pointers.
 .. cfunction:: char* PyByteArray_AS_STRING(PyObject *bytearray)
+.. c:function:: char* PyByteArray_AS_STRING(PyObject *bytearray)
    Macro version of :cfunc:`PyByteArray_AsString`.
+   Macro version of :c:func:`PyByteArray_AsString`.
 .. cfunction:: Py_ssize_t PyByteArray_GET_SIZE(PyObject *bytearray)
+.. c:function:: Py_ssize_t PyByteArray_GET_SIZE(PyObject *bytearray)
    Macro version of :cfunc:`PyByteArray_Size`.
+   Macro version of :c:func:`PyByteArray_Size`.

python/vendor/current/Doc/c-api/cell.rst

-              r2
+              r388
 .. ctype:: PyCellObject
+.. c:type:: PyCellObject
    The C structure used for cell objects.
 .. cvar:: PyTypeObject PyCell_Type
+.. c:var:: PyTypeObject PyCell_Type
    The type object corresponding to cell objects.
 .. cfunction:: int PyCell_Check(ob)
+.. c:function:: int PyCell_Check(ob)
    Return true if *ob* is a cell object; *ob* must not be *NULL*.
 .. cfunction:: PyObject* PyCell_New(PyObject *ob)
+.. c:function:: PyObject* PyCell_New(PyObject *ob)
    Create and return a new cell object containing the value *ob*. The parameter may
 …
 .. cfunction:: PyObject* PyCell_Get(PyObject *cell)
+.. c:function:: PyObject* PyCell_Get(PyObject *cell)
    Return the contents of the cell *cell*.
 .. cfunction:: PyObject* PyCell_GET(PyObject *cell)
+.. c:function:: PyObject* PyCell_GET(PyObject *cell)
    Return the contents of the cell *cell*, but without checking that *cell* is
 …
 .. cfunction:: int PyCell_Set(PyObject *cell, PyObject *value)
+.. c:function:: int PyCell_Set(PyObject *cell, PyObject *value)
    Set the contents of the cell object *cell* to *value*.  This releases the
 …
 .. cfunction:: void PyCell_SET(PyObject *cell, PyObject *value)
+.. c:function:: void PyCell_SET(PyObject *cell, PyObject *value)
    Sets the value of the cell object *cell* to *value*.  No reference counts are

python/vendor/current/Doc/c-api/class.rst

-              r2
+              r388
 .. ctype:: PyClassObject
+.. c:type:: PyClassObject
    The C structure of the objects used to describe built-in classes.
 .. cvar:: PyObject* PyClass_Type
+.. c:var:: PyObject* PyClass_Type
    .. index:: single: ClassType (in module types)
 …
 .. cfunction:: int PyClass_Check(PyObject *o)
+.. c:function:: int PyClass_Check(PyObject *o)
    Return true if the object *o* is a class object, including instances of types
 …
 .. cfunction:: int PyClass_IsSubclass(PyObject *klass, PyObject *base)
+.. c:function:: int PyClass_IsSubclass(PyObject *klass, PyObject *base)
    Return true if *klass* is a subclass of *base*. Return false in all other cases.
 …
 .. cvar:: PyTypeObject PyInstance_Type
+.. c:var:: PyTypeObject PyInstance_Type
    Type object for class instances.
 .. cfunction:: int PyInstance_Check(PyObject *obj)
+.. c:function:: int PyInstance_Check(PyObject *obj)
    Return true if *obj* is an instance.
 .. cfunction:: PyObject* PyInstance_New(PyObject *class, PyObject *arg, PyObject *kw)
+.. c:function:: PyObject* PyInstance_New(PyObject *class, PyObject *arg, PyObject *kw)
    Create a new instance of a specific class.  The parameters *arg* and *kw* are
 …
 .. cfunction:: PyObject* PyInstance_NewRaw(PyObject *class, PyObject *dict)
+.. c:function:: PyObject* PyInstance_NewRaw(PyObject *class, PyObject *dict)
    Create a new instance of a specific class without calling its constructor.

python/vendor/current/Doc/c-api/cobject.rst

-              r2
+              r388
 .. index:: object: CObject
-Refer to :ref:`using-cobjects` for more information on using these objects.
+.. warning::
+.. ctype:: PyCObject
+   The CObject API is deprecated as of Python 2.7.  Please switch to the new
+   :ref:`capsules` API.
+   This subtype of :ctype:`PyObject` represents an opaque value, useful for C
+   extension modules who need to pass an opaque value (as a :ctype:`void\*`
+.. c:type:: PyCObject
+   This subtype of :c:type:`PyObject` represents an opaque value, useful for C
+   extension modules who need to pass an opaque value (as a :c:type:`void\*`
    pointer) through Python code to other C code.  It is often used to make a C
    function pointer defined in one module available to other modules, so the
 …
 .. cfunction:: int PyCObject_Check(PyObject *p)
+.. c:function:: int PyCObject_Check(PyObject *p)
    Return true if its argument is a :ctype:`PyCObject`.
+   Return true if its argument is a :c:type:`PyCObject`.
 .. cfunction:: PyObject* PyCObject_FromVoidPtr(void* cobj, void (*destr)(void *))
+.. c:function:: PyObject* PyCObject_FromVoidPtr(void* cobj, void (*destr)(void *))
    Create a :ctype:`PyCObject` from the ``void *`` *cobj*.  The *destr* function
+   Create a :c:type:`PyCObject` from the ``void *`` *cobj*.  The *destr* function
    will be called when the object is reclaimed, unless it is *NULL*.
 .. cfunction:: PyObject* PyCObject_FromVoidPtrAndDesc(void* cobj, void* desc, void (*destr)(void *, void *))
+.. c:function:: PyObject* PyCObject_FromVoidPtrAndDesc(void* cobj, void* desc, void (*destr)(void *, void *))
    Create a :ctype:`PyCObject` from the :ctype:`void \*` *cobj*.  The *destr*
+   Create a :c:type:`PyCObject` from the :c:type:`void \*` *cobj*.  The *destr*
    function will be called when the object is reclaimed. The *desc* argument can
    be used to pass extra callback data for the destructor function.
 .. cfunction:: void* PyCObject_AsVoidPtr(PyObject* self)
+.. c:function:: void* PyCObject_AsVoidPtr(PyObject* self)
    Return the object :ctype:`void \*` that the :ctype:`PyCObject` *self* was
+   Return the object :c:type:`void \*` that the :c:type:`PyCObject` *self* was
    created with.
 .. cfunction:: void* PyCObject_GetDesc(PyObject* self)
+.. c:function:: void* PyCObject_GetDesc(PyObject* self)
    Return the description :ctype:`void \*` that the :ctype:`PyCObject` *self* was
+   Return the description :c:type:`void \*` that the :c:type:`PyCObject` *self* was
    created with.
 .. cfunction:: int PyCObject_SetVoidPtr(PyObject* self, void* cobj)
+.. c:function:: int PyCObject_SetVoidPtr(PyObject* self, void* cobj)
    Set the void pointer inside *self* to *cobj*. The :ctype:`PyCObject` must not
+   Set the void pointer inside *self* to *cobj*. The :c:type:`PyCObject` must not
    have an associated destructor. Return true on success, false on failure.

python/vendor/current/Doc/c-api/complex.rst

-              r2
+              r388
 .. ctype:: Py_complex
+.. c:type:: Py_complex
    The C structure which corresponds to the value portion of a Python complex
 …
 .. cfunction:: Py_complex _Py_c_sum(Py_complex left, Py_complex right)
+.. c:function:: Py_complex _Py_c_sum(Py_complex left, Py_complex right)
    Return the sum of two complex numbers, using the C :ctype:`Py_complex`
+   Return the sum of two complex numbers, using the C :c:type:`Py_complex`
    representation.
 .. cfunction:: Py_complex _Py_c_diff(Py_complex left, Py_complex right)
+.. c:function:: Py_complex _Py_c_diff(Py_complex left, Py_complex right)
    Return the difference between two complex numbers, using the C
    :ctype:`Py_complex` representation.
+   :c:type:`Py_complex` representation.
 .. cfunction:: Py_complex _Py_c_neg(Py_complex complex)
+.. c:function:: Py_complex _Py_c_neg(Py_complex complex)
    Return the negation of the complex number *complex*, using the C
    :ctype:`Py_complex` representation.
+   :c:type:`Py_complex` representation.
 .. cfunction:: Py_complex _Py_c_prod(Py_complex left, Py_complex right)
+.. c:function:: Py_complex _Py_c_prod(Py_complex left, Py_complex right)
    Return the product of two complex numbers, using the C :ctype:`Py_complex`
+   Return the product of two complex numbers, using the C :c:type:`Py_complex`
    representation.
 .. cfunction:: Py_complex _Py_c_quot(Py_complex dividend, Py_complex divisor)
+.. c:function:: Py_complex _Py_c_quot(Py_complex dividend, Py_complex divisor)
    Return the quotient of two complex numbers, using the C :ctype:`Py_complex`
+   Return the quotient of two complex numbers, using the C :c:type:`Py_complex`
    representation.
+   If *divisor* is null, this method returns zero and sets
+   :c:data:`errno` to :c:data:`EDOM`.
-.. cfunction:: Py_complex _Py_c_pow(Py_complex num, Py_complex exp)
+   Return the exponentiation of *num* by *exp*, using the C :ctype:`Py_complex`
+.. c:function:: Py_complex _Py_c_pow(Py_complex num, Py_complex exp)
+   Return the exponentiation of *num* by *exp*, using the C :c:type:`Py_complex`
    representation.
+   If *num* is null and *exp* is not a positive real number,
+   this method returns zero and sets :c:data:`errno` to :c:data:`EDOM`.
 …
 .. ctype:: PyComplexObject
+.. c:type:: PyComplexObject
    This subtype of :ctype:`PyObject` represents a Python complex number object.
+   This subtype of :c:type:`PyObject` represents a Python complex number object.
 .. cvar:: PyTypeObject PyComplex_Type
+.. c:var:: PyTypeObject PyComplex_Type
    This instance of :ctype:`PyTypeObject` represents the Python complex number
+   This instance of :c:type:`PyTypeObject` represents the Python complex number
    type. It is the same object as ``complex`` and ``types.ComplexType``.
 .. cfunction:: int PyComplex_Check(PyObject *p)
+.. c:function:: int PyComplex_Check(PyObject *p)
    Return true if its argument is a :ctype:`PyComplexObject` or a subtype of
    :ctype:`PyComplexObject`.
+   Return true if its argument is a :c:type:`PyComplexObject` or a subtype of
+   :c:type:`PyComplexObject`.
    .. versionchanged:: 2.2
 …
 .. cfunction:: int PyComplex_CheckExact(PyObject *p)
+.. c:function:: int PyComplex_CheckExact(PyObject *p)
    Return true if its argument is a :ctype:`PyComplexObject`, but not a subtype of
    :ctype:`PyComplexObject`.
+   Return true if its argument is a :c:type:`PyComplexObject`, but not a subtype of
+   :c:type:`PyComplexObject`.
    .. versionadded:: 2.2
 .. cfunction:: PyObject* PyComplex_FromCComplex(Py_complex v)
+.. c:function:: PyObject* PyComplex_FromCComplex(Py_complex v)
    Create a new Python complex number object from a C :ctype:`Py_complex` value.
+   Create a new Python complex number object from a C :c:type:`Py_complex` value.
 .. cfunction:: PyObject* PyComplex_FromDoubles(double real, double imag)
+.. c:function:: PyObject* PyComplex_FromDoubles(double real, double imag)
    Return a new :ctype:`PyComplexObject` object from *real* and *imag*.
+   Return a new :c:type:`PyComplexObject` object from *real* and *imag*.
 .. cfunction:: double PyComplex_RealAsDouble(PyObject *op)
+.. c:function:: double PyComplex_RealAsDouble(PyObject *op)
    Return the real part of *op* as a C :ctype:`double`.
+   Return the real part of *op* as a C :c:type:`double`.
 .. cfunction:: double PyComplex_ImagAsDouble(PyObject *op)
+.. c:function:: double PyComplex_ImagAsDouble(PyObject *op)
    Return the imaginary part of *op* as a C :ctype:`double`.
+   Return the imaginary part of *op* as a C :c:type:`double`.
 .. cfunction:: Py_complex PyComplex_AsCComplex(PyObject *op)
+.. c:function:: Py_complex PyComplex_AsCComplex(PyObject *op)
+   Return the :ctype:`Py_complex` value of the complex number *op*.
+   Return the :c:type:`Py_complex` value of the complex number *op*.
+   Upon failure, this method returns ``-1.0`` as a real value.
    .. versionchanged:: 2.6

python/vendor/current/Doc/c-api/concrete.rst

-              r2
+              r388
 object from a Python program and you are not sure that it has the right type,
 you must perform a type check first; for example, to check that an object is a
 dictionary, use :cfunc:`PyDict_Check`.  The chapter is structured like the
+dictionary, use :c:func:`PyDict_Check`.  The chapter is structured like the
 "family tree" of Python object types.
 …
    slice.rst
    weakref.rst
+   capsule.rst
    cobject.rst
    cell.rst
 …
    datetime.rst
    set.rst
+   code.rst

python/vendor/current/Doc/c-api/conversion.rst

-              r2
+              r388
 .. cfunction:: int PyOS_snprintf(char *str, size_t size,  const char *format, ...)
+.. c:function:: int PyOS_snprintf(char *str, size_t size,  const char *format, ...)
    Output not more than *size* bytes to *str* according to the format string
 …
 .. cfunction:: int PyOS_vsnprintf(char *str, size_t size, const char *format, va_list va)
+.. c:function:: int PyOS_vsnprintf(char *str, size_t size, const char *format, va_list va)
    Output not more than *size* bytes to *str* according to the format string
 …
    :manpage:`vsnprintf(2)`.
 :cfunc:`PyOS_snprintf` and :cfunc:`PyOS_vsnprintf` wrap the Standard C library
 functions :cfunc:`snprintf` and :cfunc:`vsnprintf`. Their purpose is to
+:c:func:`PyOS_snprintf` and :c:func:`PyOS_vsnprintf` wrap the Standard C library
+functions :c:func:`snprintf` and :c:func:`vsnprintf`. Their purpose is to
 guarantee consistent behavior in corner cases, which the Standard C functions do
 not.
 …
 NULL``.
 If the platform doesn't have :cfunc:`vsnprintf` and the buffer size needed to
+If the platform doesn't have :c:func:`vsnprintf` and the buffer size needed to
 avoid truncation exceeds *size* by more than 512 bytes, Python aborts with a
 *Py_FatalError*.
 …
 .. cfunction:: double PyOS_ascii_strtod(const char *nptr, char **endptr)
+.. c:function:: double PyOS_string_to_double(const char *s, char **endptr, PyObject *overflow_exception)
+   Convert a string to a :ctype:`double`. This function behaves like the Standard C
+   function :cfunc:`strtod` does in the C locale. It does this without changing the
+   Convert a string ``s`` to a :c:type:`double`, raising a Python
+   exception on failure.  The set of accepted strings corresponds to
+   the set of strings accepted by Python's :func:`float` constructor,
+   except that ``s`` must not have leading or trailing whitespace.
+   The conversion is independent of the current locale.
+   If ``endptr`` is ``NULL``, convert the whole string.  Raise
+   ValueError and return ``-1.0`` if the string is not a valid
+   representation of a floating-point number.
+   If endptr is not ``NULL``, convert as much of the string as
+   possible and set ``*endptr`` to point to the first unconverted
+   character.  If no initial segment of the string is the valid
+   representation of a floating-point number, set ``*endptr`` to point
+   to the beginning of the string, raise ValueError, and return
+   ``-1.0``.
+   If ``s`` represents a value that is too large to store in a float
+   (for example, ``"1e500"`` is such a string on many platforms) then
+   if ``overflow_exception`` is ``NULL`` return ``Py_HUGE_VAL`` (with
+   an appropriate sign) and don't set any exception.  Otherwise,
+   ``overflow_exception`` must point to a Python exception object;
+   raise that exception and return ``-1.0``.  In both cases, set
+   ``*endptr`` to point to the first character after the converted value.
+   If any other error occurs during the conversion (for example an
+   out-of-memory error), set the appropriate Python exception and
+   return ``-1.0``.
+   .. versionadded:: 2.7
+.. c:function:: double PyOS_ascii_strtod(const char *nptr, char **endptr)
+   Convert a string to a :c:type:`double`. This function behaves like the Standard C
+   function :c:func:`strtod` does in the C locale. It does this without changing the
    current locale, since that would not be thread-safe.
    :cfunc:`PyOS_ascii_strtod` should typically be used for reading configuration
+   :c:func:`PyOS_ascii_strtod` should typically be used for reading configuration
    files or other non-user input that should be locale independent.
+   See the Unix man page :manpage:`strtod(2)` for details.
    .. versionadded:: 2.4
+   See the Unix man page :manpage:`strtod(2)` for details.
+   .. deprecated:: 2.7
+      Use :c:func:`PyOS_string_to_double` instead.
-.. cfunction:: char * PyOS_ascii_formatd(char *buffer, size_t buf_len, const char *format, double d)
+   Convert a :ctype:`double` to a string using the ``'.'`` as the decimal
+   separator. *format* is a :cfunc:`printf`\ -style format string specifying the
+.. c:function:: char* PyOS_ascii_formatd(char *buffer, size_t buf_len, const char *format, double d)
+   Convert a :c:type:`double` to a string using the ``'.'`` as the decimal
+   separator. *format* is a :c:func:`printf`\ -style format string specifying the
    number format. Allowed conversion characters are ``'e'``, ``'E'``, ``'f'``,
    ``'F'``, ``'g'`` and ``'G'``.
 …
    .. versionadded:: 2.4
+   .. deprecated:: 2.7
+      This function is removed in Python 2.7 and 3.1.  Use :func:`PyOS_double_to_string`
+      instead.
 .. cfunction:: double PyOS_ascii_atof(const char *nptr)
+.. c:function:: char* PyOS_double_to_string(double val, char format_code, int precision, int flags, int *ptype)
+   Convert a string to a :ctype:`double` in a locale-independent way.
+   Convert a :c:type:`double` *val* to a string using supplied
+   *format_code*, *precision*, and *flags*.
+   *format_code* must be one of ``'e'``, ``'E'``, ``'f'``, ``'F'``,
+   ``'g'``, ``'G'`` or ``'r'``.  For ``'r'``, the supplied *precision*
+   must be 0 and is ignored.  The ``'r'`` format code specifies the
+   standard :func:`repr` format.
+   *flags* can be zero or more of the values *Py_DTSF_SIGN*,
+   *Py_DTSF_ADD_DOT_0*, or *Py_DTSF_ALT*, or-ed together:
+   * *Py_DTSF_SIGN* means to always precede the returned string with a sign
+     character, even if *val* is non-negative.
+   * *Py_DTSF_ADD_DOT_0* means to ensure that the returned string will not look
+     like an integer.
+   * *Py_DTSF_ALT* means to apply "alternate" formatting rules.  See the
+     documentation for the :c:func:`PyOS_snprintf` ``'#'`` specifier for
+     details.
+   If *ptype* is non-NULL, then the value it points to will be set to one of
+   *Py_DTST_FINITE*, *Py_DTST_INFINITE*, or *Py_DTST_NAN*, signifying that
+   *val* is a finite number, an infinite number, or not a number, respectively.
+   The return value is a pointer to *buffer* with the converted string or
+   *NULL* if the conversion failed. The caller is responsible for freeing the
+   returned string by calling :c:func:`PyMem_Free`.
+   .. versionadded:: 2.7
+.. c:function:: double PyOS_ascii_atof(const char *nptr)
+   Convert a string to a :c:type:`double` in a locale-independent way.
+   See the Unix man page :manpage:`atof(2)` for details.
    .. versionadded:: 2.4
+   See the Unix man page :manpage:`atof(2)` for details.
+   .. deprecated:: 3.1
+      Use :c:func:`PyOS_string_to_double` instead.
 .. cfunction:: char * PyOS_stricmp(char *s1, char *s2)
+.. c:function:: char* PyOS_stricmp(char *s1, char *s2)
    Case insensitive comparison of strings. The function works almost
    identically to :cfunc:`strcmp` except that it ignores the case.
+   identically to :c:func:`strcmp` except that it ignores the case.
    .. versionadded:: 2.6
 .. cfunction:: char * PyOS_strnicmp(char *s1, char *s2, Py_ssize_t  size)
+.. c:function:: char* PyOS_strnicmp(char *s1, char *s2, Py_ssize_t  size)
    Case insensitive comparison of strings. The function works almost
    identically to :cfunc:`strncmp` except that it ignores the case.
+   identically to :c:func:`strncmp` except that it ignores the case.
    .. versionadded:: 2.6

python/vendor/current/Doc/c-api/datetime.rst

-              r2
+              r388
 Before using any of these functions, the header file :file:`datetime.h` must be
 included in your source (note that this is not included by :file:`Python.h`),
+and the macro :cfunc:`PyDateTime_IMPORT` must be invoked.  The macro puts a
+pointer to a C structure into a static variable,  ``PyDateTimeAPI``, that is
+used by the following macros.
+and the macro :c:macro:`PyDateTime_IMPORT` must be invoked, usually as part of
+the module initialisation function.  The macro puts a pointer to a C structure
+into a static variable, :c:data:`PyDateTimeAPI`, that is used by the following
+macros.
 Type-check macros:
 .. cfunction:: int PyDate_Check(PyObject *ob)
    Return true if *ob* is of type :cdata:`PyDateTime_DateType` or a subtype of
    :cdata:`PyDateTime_DateType`.  *ob* must not be *NULL*.
    .. versionadded:: 2.4
 .. cfunction:: int PyDate_CheckExact(PyObject *ob)
    Return true if *ob* is of type :cdata:`PyDateTime_DateType`. *ob* must not be
    *NULL*.
    .. versionadded:: 2.4
 .. cfunction:: int PyDateTime_Check(PyObject *ob)
    Return true if *ob* is of type :cdata:`PyDateTime_DateTimeType` or a subtype of
    :cdata:`PyDateTime_DateTimeType`.  *ob* must not be *NULL*.
    .. versionadded:: 2.4
 .. cfunction:: int PyDateTime_CheckExact(PyObject *ob)
    Return true if *ob* is of type :cdata:`PyDateTime_DateTimeType`. *ob* must not
+.. c:function:: int PyDate_Check(PyObject *ob)
+   Return true if *ob* is of type :c:data:`PyDateTime_DateType` or a subtype of
+   :c:data:`PyDateTime_DateType`.  *ob* must not be *NULL*.
+   .. versionadded:: 2.4
+.. c:function:: int PyDate_CheckExact(PyObject *ob)
+   Return true if *ob* is of type :c:data:`PyDateTime_DateType`. *ob* must not be
+   *NULL*.
+   .. versionadded:: 2.4
+.. c:function:: int PyDateTime_Check(PyObject *ob)
+   Return true if *ob* is of type :c:data:`PyDateTime_DateTimeType` or a subtype of
+   :c:data:`PyDateTime_DateTimeType`.  *ob* must not be *NULL*.
+   .. versionadded:: 2.4
+.. c:function:: int PyDateTime_CheckExact(PyObject *ob)
+   Return true if *ob* is of type :c:data:`PyDateTime_DateTimeType`. *ob* must not
    be *NULL*.
 …
 .. cfunction:: int PyTime_Check(PyObject *ob)
    Return true if *ob* is of type :cdata:`PyDateTime_TimeType` or a subtype of
    :cdata:`PyDateTime_TimeType`.  *ob* must not be *NULL*.
    .. versionadded:: 2.4
 .. cfunction:: int PyTime_CheckExact(PyObject *ob)
    Return true if *ob* is of type :cdata:`PyDateTime_TimeType`. *ob* must not be
    *NULL*.
    .. versionadded:: 2.4
 .. cfunction:: int PyDelta_Check(PyObject *ob)
    Return true if *ob* is of type :cdata:`PyDateTime_DeltaType` or a subtype of
    :cdata:`PyDateTime_DeltaType`.  *ob* must not be *NULL*.
    .. versionadded:: 2.4
 .. cfunction:: int PyDelta_CheckExact(PyObject *ob)
    Return true if *ob* is of type :cdata:`PyDateTime_DeltaType`. *ob* must not be
    *NULL*.
    .. versionadded:: 2.4
 .. cfunction:: int PyTZInfo_Check(PyObject *ob)
    Return true if *ob* is of type :cdata:`PyDateTime_TZInfoType` or a subtype of
    :cdata:`PyDateTime_TZInfoType`.  *ob* must not be *NULL*.
    .. versionadded:: 2.4
 .. cfunction:: int PyTZInfo_CheckExact(PyObject *ob)
    Return true if *ob* is of type :cdata:`PyDateTime_TZInfoType`. *ob* must not be
+.. c:function:: int PyTime_Check(PyObject *ob)
+   Return true if *ob* is of type :c:data:`PyDateTime_TimeType` or a subtype of
+   :c:data:`PyDateTime_TimeType`.  *ob* must not be *NULL*.
+   .. versionadded:: 2.4
+.. c:function:: int PyTime_CheckExact(PyObject *ob)
+   Return true if *ob* is of type :c:data:`PyDateTime_TimeType`. *ob* must not be
+   *NULL*.
+   .. versionadded:: 2.4
+.. c:function:: int PyDelta_Check(PyObject *ob)
+   Return true if *ob* is of type :c:data:`PyDateTime_DeltaType` or a subtype of
+   :c:data:`PyDateTime_DeltaType`.  *ob* must not be *NULL*.
+   .. versionadded:: 2.4
+.. c:function:: int PyDelta_CheckExact(PyObject *ob)
+   Return true if *ob* is of type :c:data:`PyDateTime_DeltaType`. *ob* must not be
+   *NULL*.
+   .. versionadded:: 2.4
+.. c:function:: int PyTZInfo_Check(PyObject *ob)
+   Return true if *ob* is of type :c:data:`PyDateTime_TZInfoType` or a subtype of
+   :c:data:`PyDateTime_TZInfoType`.  *ob* must not be *NULL*.
+   .. versionadded:: 2.4
+.. c:function:: int PyTZInfo_CheckExact(PyObject *ob)
+   Return true if *ob* is of type :c:data:`PyDateTime_TZInfoType`. *ob* must not be
    *NULL*.
 …
 .. cfunction:: PyObject* PyDate_FromDate(int year, int month, int day)
+.. c:function:: PyObject* PyDate_FromDate(int year, int month, int day)
    Return a ``datetime.date`` object with the specified year, month and day.
 …
 .. cfunction:: PyObject* PyDateTime_FromDateAndTime(int year, int month, int day, int hour, int minute, int second, int usecond)
+.. c:function:: PyObject* PyDateTime_FromDateAndTime(int year, int month, int day, int hour, int minute, int second, int usecond)
    Return a ``datetime.datetime`` object with the specified year, month, day, hour,
 …
 .. cfunction:: PyObject* PyTime_FromTime(int hour, int minute, int second, int usecond)
+.. c:function:: PyObject* PyTime_FromTime(int hour, int minute, int second, int usecond)
    Return a ``datetime.time`` object with the specified hour, minute, second and
 …
 .. cfunction:: PyObject* PyDelta_FromDSU(int days, int seconds, int useconds)
+.. c:function:: PyObject* PyDelta_FromDSU(int days, int seconds, int useconds)
    Return a ``datetime.timedelta`` object representing the given number of days,
 …
 Macros to extract fields from date objects.  The argument must be an instance of
 :cdata:`PyDateTime_Date`, including subclasses (such as
 :cdata:`PyDateTime_DateTime`).  The argument must not be *NULL*, and the type is
+:c:data:`PyDateTime_Date`, including subclasses (such as
+:c:data:`PyDateTime_DateTime`).  The argument must not be *NULL*, and the type is
 not checked:
 .. cfunction:: int PyDateTime_GET_YEAR(PyDateTime_Date *o)
+.. c:function:: int PyDateTime_GET_YEAR(PyDateTime_Date *o)
    Return the year, as a positive int.
 …
 .. cfunction:: int PyDateTime_GET_MONTH(PyDateTime_Date *o)
+.. c:function:: int PyDateTime_GET_MONTH(PyDateTime_Date *o)
    Return the month, as an int from 1 through 12.
 …
 .. cfunction:: int PyDateTime_GET_DAY(PyDateTime_Date *o)
+.. c:function:: int PyDateTime_GET_DAY(PyDateTime_Date *o)
    Return the day, as an int from 1 through 31.
 …
 Macros to extract fields from datetime objects.  The argument must be an
 instance of :cdata:`PyDateTime_DateTime`, including subclasses. The argument
+instance of :c:data:`PyDateTime_DateTime`, including subclasses. The argument
 must not be *NULL*, and the type is not checked:
 .. cfunction:: int PyDateTime_DATE_GET_HOUR(PyDateTime_DateTime *o)
+.. c:function:: int PyDateTime_DATE_GET_HOUR(PyDateTime_DateTime *o)
    Return the hour, as an int from 0 through 23.
 …
 .. cfunction:: int PyDateTime_DATE_GET_MINUTE(PyDateTime_DateTime *o)
+.. c:function:: int PyDateTime_DATE_GET_MINUTE(PyDateTime_DateTime *o)
    Return the minute, as an int from 0 through 59.
 …
 .. cfunction:: int PyDateTime_DATE_GET_SECOND(PyDateTime_DateTime *o)
+.. c:function:: int PyDateTime_DATE_GET_SECOND(PyDateTime_DateTime *o)
    Return the second, as an int from 0 through 59.
 …
 .. cfunction:: int PyDateTime_DATE_GET_MICROSECOND(PyDateTime_DateTime *o)
+.. c:function:: int PyDateTime_DATE_GET_MICROSECOND(PyDateTime_DateTime *o)
    Return the microsecond, as an int from 0 through 999999.
 …
 Macros to extract fields from time objects.  The argument must be an instance of
 :cdata:`PyDateTime_Time`, including subclasses. The argument must not be *NULL*,
+:c:data:`PyDateTime_Time`, including subclasses. The argument must not be *NULL*,
 and the type is not checked:
 .. cfunction:: int PyDateTime_TIME_GET_HOUR(PyDateTime_Time *o)
+.. c:function:: int PyDateTime_TIME_GET_HOUR(PyDateTime_Time *o)
    Return the hour, as an int from 0 through 23.
 …
 .. cfunction:: int PyDateTime_TIME_GET_MINUTE(PyDateTime_Time *o)
+.. c:function:: int PyDateTime_TIME_GET_MINUTE(PyDateTime_Time *o)
    Return the minute, as an int from 0 through 59.
 …
 .. cfunction:: int PyDateTime_TIME_GET_SECOND(PyDateTime_Time *o)
+.. c:function:: int PyDateTime_TIME_GET_SECOND(PyDateTime_Time *o)
    Return the second, as an int from 0 through 59.
 …
 .. cfunction:: int PyDateTime_TIME_GET_MICROSECOND(PyDateTime_Time *o)
+.. c:function:: int PyDateTime_TIME_GET_MICROSECOND(PyDateTime_Time *o)
    Return the microsecond, as an int from 0 through 999999.
 …
 .. cfunction:: PyObject* PyDateTime_FromTimestamp(PyObject *args)
+.. c:function:: PyObject* PyDateTime_FromTimestamp(PyObject *args)
    Create and return a new ``datetime.datetime`` object given an argument tuple
 …
 .. cfunction:: PyObject* PyDate_FromTimestamp(PyObject *args)
+.. c:function:: PyObject* PyDate_FromTimestamp(PyObject *args)
    Create and return a new ``datetime.date`` object given an argument tuple

python/vendor/current/Doc/c-api/descriptor.rst

-              r2
+              r388
 .. cvar:: PyTypeObject PyProperty_Type
+.. c:var:: PyTypeObject PyProperty_Type
    The type object for the built-in descriptor types.
 …
 .. cfunction:: PyObject* PyDescr_NewGetSet(PyTypeObject *type, struct PyGetSetDef *getset)
+.. c:function:: PyObject* PyDescr_NewGetSet(PyTypeObject *type, struct PyGetSetDef *getset)
    .. versionadded:: 2.2
 .. cfunction:: PyObject* PyDescr_NewMember(PyTypeObject *type, struct PyMemberDef *meth)
+.. c:function:: PyObject* PyDescr_NewMember(PyTypeObject *type, struct PyMemberDef *meth)
    .. versionadded:: 2.2
 .. cfunction:: PyObject* PyDescr_NewMethod(PyTypeObject *type, struct PyMethodDef *meth)
+.. c:function:: PyObject* PyDescr_NewMethod(PyTypeObject *type, struct PyMethodDef *meth)
    .. versionadded:: 2.2
 .. cfunction:: PyObject* PyDescr_NewWrapper(PyTypeObject *type, struct wrapperbase *wrapper, void *wrapped)
+.. c:function:: PyObject* PyDescr_NewWrapper(PyTypeObject *type, struct wrapperbase *wrapper, void *wrapped)
    .. versionadded:: 2.2
 .. cfunction:: PyObject* PyDescr_NewClassMethod(PyTypeObject *type, PyMethodDef *method)
+.. c:function:: PyObject* PyDescr_NewClassMethod(PyTypeObject *type, PyMethodDef *method)
    .. versionadded:: 2.3
 .. cfunction:: int PyDescr_IsData(PyObject *descr)
+.. c:function:: int PyDescr_IsData(PyObject *descr)
    Return true if the descriptor objects *descr* describes a data attribute, or
 …
 .. cfunction:: PyObject* PyWrapper_New(PyObject *, PyObject *)
+.. c:function:: PyObject* PyWrapper_New(PyObject *, PyObject *)
    .. versionadded:: 2.2

python/vendor/current/Doc/c-api/dict.rst

-              r2
+              r388
 .. ctype:: PyDictObject
    This subtype of :ctype:`PyObject` represents a Python dictionary object.
 .. cvar:: PyTypeObject PyDict_Type
+.. c:type:: PyDictObject
+   This subtype of :c:type:`PyObject` represents a Python dictionary object.
+.. c:var:: PyTypeObject PyDict_Type
    .. index::
 …
       single: DictionaryType (in module types)
    This instance of :ctype:`PyTypeObject` represents the Python dictionary
+   This instance of :c:type:`PyTypeObject` represents the Python dictionary
    type.  This is exposed to Python programs as ``dict`` and
    ``types.DictType``.
 .. cfunction:: int PyDict_Check(PyObject *p)
+.. c:function:: int PyDict_Check(PyObject *p)
    Return true if *p* is a dict object or an instance of a subtype of the dict
 …
 .. cfunction:: int PyDict_CheckExact(PyObject *p)
+.. c:function:: int PyDict_CheckExact(PyObject *p)
    Return true if *p* is a dict object, but not an instance of a subtype of
 …
 .. cfunction:: PyObject* PyDict_New()
+.. c:function:: PyObject* PyDict_New()
    Return a new empty dictionary, or *NULL* on failure.
 .. cfunction:: PyObject* PyDictProxy_New(PyObject *dict)
+.. c:function:: PyObject* PyDictProxy_New(PyObject *dict)
    Return a proxy object for a mapping which enforces read-only behavior.
 …
 .. cfunction:: void PyDict_Clear(PyObject *p)
+.. c:function:: void PyDict_Clear(PyObject *p)
    Empty an existing dictionary of all key-value pairs.
 .. cfunction:: int PyDict_Contains(PyObject *p, PyObject *key)
+.. c:function:: int PyDict_Contains(PyObject *p, PyObject *key)
    Determine if dictionary *p* contains *key*.  If an item in *p* is matches
 …
 .. cfunction:: PyObject* PyDict_Copy(PyObject *p)
+.. c:function:: PyObject* PyDict_Copy(PyObject *p)
    Return a new dictionary that contains the same key-value pairs as *p*.
 …
 .. cfunction:: int PyDict_SetItem(PyObject *p, PyObject *key, PyObject *val)
+.. c:function:: int PyDict_SetItem(PyObject *p, PyObject *key, PyObject *val)
    Insert *value* into the dictionary *p* with a key of *key*.  *key* must be
 …
 .. cfunction:: int PyDict_SetItemString(PyObject *p, const char *key, PyObject *val)
+.. c:function:: int PyDict_SetItemString(PyObject *p, const char *key, PyObject *val)
    .. index:: single: PyString_FromString()
    Insert *value* into the dictionary *p* using *key* as a key. *key* should
    be a :ctype:`char\*`.  The key object is created using
+   be a :c:type:`char\*`.  The key object is created using
    ``PyString_FromString(key)``.  Return ``0`` on success or ``-1`` on
    failure.
 .. cfunction:: int PyDict_DelItem(PyObject *p, PyObject *key)
+.. c:function:: int PyDict_DelItem(PyObject *p, PyObject *key)
    Remove the entry in dictionary *p* with key *key*. *key* must be hashable;
 …
 .. cfunction:: int PyDict_DelItemString(PyObject *p, char *key)
+.. c:function:: int PyDict_DelItemString(PyObject *p, char *key)
    Remove the entry in dictionary *p* which has a key specified by the string
 …
 .. cfunction:: PyObject* PyDict_GetItem(PyObject *p, PyObject *key)
+.. c:function:: PyObject* PyDict_GetItem(PyObject *p, PyObject *key)
    Return the object from dictionary *p* which has a key *key*.  Return *NULL*
 …
 .. cfunction:: PyObject* PyDict_GetItemString(PyObject *p, const char *key)
    This is the same as :cfunc:`PyDict_GetItem`, but *key* is specified as a
    :ctype:`char\*`, rather than a :ctype:`PyObject\*`.
 .. cfunction:: PyObject* PyDict_Items(PyObject *p)
    Return a :ctype:`PyListObject` containing all the items from the
+.. c:function:: PyObject* PyDict_GetItemString(PyObject *p, const char *key)
+   This is the same as :c:func:`PyDict_GetItem`, but *key* is specified as a
+   :c:type:`char\*`, rather than a :c:type:`PyObject\*`.
+.. c:function:: PyObject* PyDict_Items(PyObject *p)
+   Return a :c:type:`PyListObject` containing all the items from the
    dictionary, as in the dictionary method :meth:`dict.items`.
 .. cfunction:: PyObject* PyDict_Keys(PyObject *p)
    Return a :ctype:`PyListObject` containing all the keys from the dictionary,
+.. c:function:: PyObject* PyDict_Keys(PyObject *p)
+   Return a :c:type:`PyListObject` containing all the keys from the dictionary,
    as in the dictionary method :meth:`dict.keys`.
 .. cfunction:: PyObject* PyDict_Values(PyObject *p)
    Return a :ctype:`PyListObject` containing all the values from the
+.. c:function:: PyObject* PyDict_Values(PyObject *p)
+   Return a :c:type:`PyListObject` containing all the values from the
    dictionary *p*, as in the dictionary method :meth:`dict.values`.
 .. cfunction:: Py_ssize_t PyDict_Size(PyObject *p)
+.. c:function:: Py_ssize_t PyDict_Size(PyObject *p)
    .. index:: builtin: len
 …
    .. versionchanged:: 2.5
       This function returned an :ctype:`int` type.  This might require changes
+      This function returned an :c:type:`int` type.  This might require changes
       in your code for properly supporting 64-bit systems.
 .. cfunction:: int PyDict_Next(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue)
+.. c:function:: int PyDict_Next(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue)
    Iterate over all key-value pairs in the dictionary *p*.  The
    :ctype:`Py_ssize_t` referred to by *ppos* must be initialized to ``0``
+   :c:type:`Py_ssize_t` referred to by *ppos* must be initialized to ``0``
    prior to the first call to this function to start the iteration; the
    function returns true for each pair in the dictionary, and false once all
    pairs have been reported.  The parameters *pkey* and *pvalue* should either
    point to :ctype:`PyObject\*` variables that will be filled in with each key
+   point to :c:type:`PyObject\*` variables that will be filled in with each key
    and value, respectively, or may be *NULL*.  Any references returned through
    them are borrowed.  *ppos* should not be altered during iteration. Its
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int *` type for *ppos*. This might require
+      This function used an :c:type:`int *` type for *ppos*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: int PyDict_Merge(PyObject *a, PyObject *b, int override)
+.. c:function:: int PyDict_Merge(PyObject *a, PyObject *b, int override)
    Iterate over mapping object *b* adding key-value pairs to dictionary *a*.
    *b* may be a dictionary, or any object supporting :func:`PyMapping_Keys`
    and :func:`PyObject_GetItem`. If *override* is true, existing pairs in *a*
+   *b* may be a dictionary, or any object supporting :c:func:`PyMapping_Keys`
+   and :c:func:`PyObject_GetItem`. If *override* is true, existing pairs in *a*
    will be replaced if a matching key is found in *b*, otherwise pairs will
    only be added if there is not a matching key in *a*. Return ``0`` on
 …
 .. cfunction:: int PyDict_Update(PyObject *a, PyObject *b)
+.. c:function:: int PyDict_Update(PyObject *a, PyObject *b)
    This is the same as ``PyDict_Merge(a, b, 1)`` in C, or ``a.update(b)`` in
 …
 .. cfunction:: int PyDict_MergeFromSeq2(PyObject *a, PyObject *seq2, int override)
+.. c:function:: int PyDict_MergeFromSeq2(PyObject *a, PyObject *seq2, int override)
    Update or merge into dictionary *a*, from the key-value pairs in *seq2*.

python/vendor/current/Doc/c-api/exceptions.rst

-              r2
+              r388
 The functions described in this chapter will let you handle and raise Python
 exceptions.  It is important to understand some of the basics of Python
 exception handling.  It works somewhat like the Unix :cdata:`errno` variable:
+exception handling.  It works somewhat like the Unix :c:data:`errno` variable:
 there is a global indicator (per thread) of the last error that occurred.  Most
 functions don't clear this on success, but will set it to indicate the cause of
 the error on failure.  Most functions also return an error indicator, usually
 *NULL* if they are supposed to return a pointer, or ``-1`` if they return an
 integer (exception: the :cfunc:`PyArg_\*` functions return ``1`` for success and
+integer (exception: the :c:func:`PyArg_\*` functions return ``1`` for success and
 ``0`` for failure).
 …
 .. cfunction:: void PyErr_PrintEx(int set_sys_last_vars)
+.. c:function:: void PyErr_PrintEx(int set_sys_last_vars)
    Print a standard traceback to ``sys.stderr`` and clear the error indicator.
 …
 .. cfunction:: void PyErr_Print()
+.. c:function:: void PyErr_Print()
    Alias for ``PyErr_PrintEx(1)``.
 .. cfunction:: PyObject* PyErr_Occurred()
+.. c:function:: PyObject* PyErr_Occurred()
    Test whether the error indicator is set.  If set, return the exception *type*
    (the first argument to the last call to one of the :cfunc:`PyErr_Set\*`
    functions or to :cfunc:`PyErr_Restore`).  If not set, return *NULL*.  You do not
    own a reference to the return value, so you do not need to :cfunc:`Py_DECREF`
+   (the first argument to the last call to one of the :c:func:`PyErr_Set\*`
+   functions or to :c:func:`PyErr_Restore`).  If not set, return *NULL*.  You do not
+   own a reference to the return value, so you do not need to :c:func:`Py_DECREF`
    it.
 …
       Do not compare the return value to a specific exception; use
       :cfunc:`PyErr_ExceptionMatches` instead, shown below.  (The comparison could
+      :c:func:`PyErr_ExceptionMatches` instead, shown below.  (The comparison could
       easily fail since the exception may be an instance instead of a class, in the
       case of a class exception, or it may the a subclass of the expected exception.)
 .. cfunction:: int PyErr_ExceptionMatches(PyObject *exc)
+.. c:function:: int PyErr_ExceptionMatches(PyObject *exc)
    Equivalent to ``PyErr_GivenExceptionMatches(PyErr_Occurred(), exc)``.  This
 …
 .. cfunction:: int PyErr_GivenExceptionMatches(PyObject *given, PyObject *exc)
+.. c:function:: int PyErr_GivenExceptionMatches(PyObject *given, PyObject *exc)
    Return true if the *given* exception matches the exception in *exc*.  If
 …
 .. cfunction:: void PyErr_NormalizeException(PyObject**exc, PyObject**val, PyObject**tb)
    Under certain circumstances, the values returned by :cfunc:`PyErr_Fetch` below
+.. c:function:: void PyErr_NormalizeException(PyObject**exc, PyObject**val, PyObject**tb)
+   Under certain circumstances, the values returned by :c:func:`PyErr_Fetch` below
    can be "unnormalized", meaning that ``*exc`` is a class object but ``*val`` is
    not an instance of the  same class.  This function can be used to instantiate
 …
 .. cfunction:: void PyErr_Clear()
+.. c:function:: void PyErr_Clear()
    Clear the error indicator.  If the error indicator is not set, there is no
 …
 .. cfunction:: void PyErr_Fetch(PyObject **ptype, PyObject **pvalue, PyObject **ptraceback)
+.. c:function:: void PyErr_Fetch(PyObject **ptype, PyObject **pvalue, PyObject **ptraceback)
    Retrieve the error indicator into three variables whose addresses are passed.
 …
 .. cfunction:: void PyErr_Restore(PyObject *type, PyObject *value, PyObject *traceback)
+.. c:function:: void PyErr_Restore(PyObject *type, PyObject *value, PyObject *traceback)
    Set  the error indicator from the three objects.  If the error indicator is
 …
       This function is normally only used by code that needs to save and restore the
       error indicator temporarily; use :cfunc:`PyErr_Fetch` to save the current
+      error indicator temporarily; use :c:func:`PyErr_Fetch` to save the current
       exception state.
 .. cfunction:: void PyErr_SetString(PyObject *type, const char *message)
+.. c:function:: void PyErr_SetString(PyObject *type, const char *message)
    This is the most common way to set the error indicator.  The first argument
    specifies the exception type; it is normally one of the standard exceptions,
    e.g. :cdata:`PyExc_RuntimeError`.  You need not increment its reference count.
+   e.g. :c:data:`PyExc_RuntimeError`.  You need not increment its reference count.
    The second argument is an error message; it is converted to a string object.
 .. cfunction:: void PyErr_SetObject(PyObject *type, PyObject *value)
    This function is similar to :cfunc:`PyErr_SetString` but lets you specify an
+.. c:function:: void PyErr_SetObject(PyObject *type, PyObject *value)
+   This function is similar to :c:func:`PyErr_SetString` but lets you specify an
    arbitrary Python object for the "value" of the exception.
+.. cfunction:: PyObject* PyErr_Format(PyObject *exception, const char *format, ...)
+   This function sets the error indicator and returns *NULL*. *exception* should be
+   a Python exception (class, not an instance).  *format* should be a string,
+   containing format codes, similar to :cfunc:`printf`. The ``width.precision``
+   before a format code is parsed, but the width part is ignored.
+   .. % This should be exactly the same as the table in PyString_FromFormat.
+   .. % One should just refer to the other.
+   .. % The descriptions for %zd and %zu are wrong, but the truth is complicated
+   .. % because not all compilers support the %z width modifier -- we fake it
+   .. % when necessary via interpolating PY_FORMAT_SIZE_T.
+   .. % %u, %lu, %zu should have "new in Python 2.5" blurbs.
+   +-------------------+---------------+--------------------------------+
+   | Format Characters | Type          | Comment                        |
+   +===================+===============+================================+
+   | :attr:`%%`        | *n/a*         | The literal % character.       |
+   +-------------------+---------------+--------------------------------+
+   | :attr:`%c`        | int           | A single character,            |
+   |                   |               | represented as an C int.       |
+   +-------------------+---------------+--------------------------------+
+   | :attr:`%d`        | int           | Exactly equivalent to          |
+   |                   |               | ``printf("%d")``.              |
+   +-------------------+---------------+--------------------------------+
+   | :attr:`%u`        | unsigned int  | Exactly equivalent to          |
+   |                   |               | ``printf("%u")``.              |
+   +-------------------+---------------+--------------------------------+
+   | :attr:`%ld`       | long          | Exactly equivalent to          |
+   |                   |               | ``printf("%ld")``.             |
+   +-------------------+---------------+--------------------------------+
+   | :attr:`%lu`       | unsigned long | Exactly equivalent to          |
+   |                   |               | ``printf("%lu")``.             |
+   +-------------------+---------------+--------------------------------+
+   | :attr:`%zd`       | Py_ssize_t    | Exactly equivalent to          |
+   |                   |               | ``printf("%zd")``.             |
+   +-------------------+---------------+--------------------------------+
+   | :attr:`%zu`       | size_t        | Exactly equivalent to          |
+   |                   |               | ``printf("%zu")``.             |
+   +-------------------+---------------+--------------------------------+
+   | :attr:`%i`        | int           | Exactly equivalent to          |
+   |                   |               | ``printf("%i")``.              |
+   +-------------------+---------------+--------------------------------+
+   | :attr:`%x`        | int           | Exactly equivalent to          |
+   |                   |               | ``printf("%x")``.              |
+   +-------------------+---------------+--------------------------------+
+   | :attr:`%s`        | char\*        | A null-terminated C character  |
+   |                   |               | array.                         |
+   +-------------------+---------------+--------------------------------+
+   | :attr:`%p`        | void\*        | The hex representation of a C  |
+   |                   |               | pointer. Mostly equivalent to  |
+   |                   |               | ``printf("%p")`` except that   |
+   |                   |               | it is guaranteed to start with |
+   |                   |               | the literal ``0x`` regardless  |
+   |                   |               | of what the platform's         |
+   |                   |               | ``printf`` yields.             |
+   +-------------------+---------------+--------------------------------+
+   An unrecognized format character causes all the rest of the format string to be
+   copied as-is to the result string, and any extra arguments discarded.
+.. cfunction:: void PyErr_SetNone(PyObject *type)
+.. c:function:: PyObject* PyErr_Format(PyObject *exception, const char *format, ...)
+   This function sets the error indicator and returns *NULL*.  *exception*
+   should be a Python exception class.  The *format* and subsequent
+   parameters help format the error message; they have the same meaning and
+   values as in :c:func:`PyString_FromFormat`.
+.. c:function:: void PyErr_SetNone(PyObject *type)
    This is a shorthand for ``PyErr_SetObject(type, Py_None)``.
 .. cfunction:: int PyErr_BadArgument()
+.. c:function:: int PyErr_BadArgument()
    This is a shorthand for ``PyErr_SetString(PyExc_TypeError, message)``, where
 …
 .. cfunction:: PyObject* PyErr_NoMemory()
+.. c:function:: PyObject* PyErr_NoMemory()
    This is a shorthand for ``PyErr_SetNone(PyExc_MemoryError)``; it returns *NULL*
 …
 .. cfunction:: PyObject* PyErr_SetFromErrno(PyObject *type)
+.. c:function:: PyObject* PyErr_SetFromErrno(PyObject *type)
    .. index:: single: strerror()
    This is a convenience function to raise an exception when a C library function
    has returned an error and set the C variable :cdata:`errno`.  It constructs a
    tuple object whose first item is the integer :cdata:`errno` value and whose
    second item is the corresponding error message (gotten from :cfunc:`strerror`),
+   has returned an error and set the C variable :c:data:`errno`.  It constructs a
+   tuple object whose first item is the integer :c:data:`errno` value and whose
+   second item is the corresponding error message (gotten from :c:func:`strerror`),
    and then calls ``PyErr_SetObject(type, object)``.  On Unix, when the
    :cdata:`errno` value is :const:`EINTR`, indicating an interrupted system call,
    this calls :cfunc:`PyErr_CheckSignals`, and if that set the error indicator,
+   :c:data:`errno` value is :const:`EINTR`, indicating an interrupted system call,
+   this calls :c:func:`PyErr_CheckSignals`, and if that set the error indicator,
    leaves it set to that.  The function always returns *NULL*, so a wrapper
    function around a system call can write ``return PyErr_SetFromErrno(type);``
 …
+.. cfunction:: PyObject* PyErr_SetFromErrnoWithFilename(PyObject *type, const char *filename)
+   Similar to :cfunc:`PyErr_SetFromErrno`, with the additional behavior that if
+   *filename* is not *NULL*, it is passed to the constructor of *type* as a third
+   parameter.  In the case of exceptions such as :exc:`IOError` and :exc:`OSError`,
+   this is used to define the :attr:`filename` attribute of the exception instance.
+.. cfunction:: PyObject* PyErr_SetFromWindowsErr(int ierr)
+.. c:function:: PyObject* PyErr_SetFromErrnoWithFilenameObject(PyObject *type, PyObject *filenameObject)
+   Similar to :c:func:`PyErr_SetFromErrno`, with the additional behavior that if
+   *filenameObject* is not *NULL*, it is passed to the constructor of *type* as
+   a third parameter.  In the case of exceptions such as :exc:`IOError` and
+   :exc:`OSError`, this is used to define the :attr:`filename` attribute of the
+   exception instance.
+.. c:function:: PyObject* PyErr_SetFromErrnoWithFilename(PyObject *type, const char *filename)
+   Similar to :c:func:`PyErr_SetFromErrnoWithFilenameObject`, but the filename
+   is given as a C string.
+.. c:function:: PyObject* PyErr_SetFromWindowsErr(int ierr)
    This is a convenience function to raise :exc:`WindowsError`. If called with
    *ierr* of :cdata:`0`, the error code returned by a call to :cfunc:`GetLastError`
    is used instead.  It calls the Win32 function :cfunc:`FormatMessage` to retrieve
    the Windows description of error code given by *ierr* or :cfunc:`GetLastError`,
+   *ierr* of :c:data:`0`, the error code returned by a call to :c:func:`GetLastError`
+   is used instead.  It calls the Win32 function :c:func:`FormatMessage` to retrieve
+   the Windows description of error code given by *ierr* or :c:func:`GetLastError`,
    then it constructs a tuple object whose first item is the *ierr* value and whose
    second item is the corresponding error message (gotten from
    :cfunc:`FormatMessage`), and then calls ``PyErr_SetObject(PyExc_WindowsError,
+   :c:func:`FormatMessage`), and then calls ``PyErr_SetObject(PyExc_WindowsError,
    object)``. This function always returns *NULL*. Availability: Windows.
 .. cfunction:: PyObject* PyErr_SetExcFromWindowsErr(PyObject *type, int ierr)
    Similar to :cfunc:`PyErr_SetFromWindowsErr`, with an additional parameter
+.. c:function:: PyObject* PyErr_SetExcFromWindowsErr(PyObject *type, int ierr)
+   Similar to :c:func:`PyErr_SetFromWindowsErr`, with an additional parameter
    specifying the exception type to be raised. Availability: Windows.
 …
 .. cfunction:: PyObject* PyErr_SetFromWindowsErrWithFilename(int ierr, const char *filename)
    Similar to :cfunc:`PyErr_SetFromWindowsErr`, with the additional behavior that
    if *filename* is not *NULL*, it is passed to the constructor of
+.. c:function:: PyObject* PyErr_SetFromWindowsErrWithFilenameObject(int ierr, PyObject *filenameObject)
+   Similar to :c:func:`PyErr_SetFromWindowsErr`, with the additional behavior that
+   if *filenameObject* is not *NULL*, it is passed to the constructor of
    :exc:`WindowsError` as a third parameter. Availability: Windows.
+.. cfunction:: PyObject* PyErr_SetExcFromWindowsErrWithFilename(PyObject *type, int ierr, char *filename)
+   Similar to :cfunc:`PyErr_SetFromWindowsErrWithFilename`, with an additional
+.. c:function:: PyObject* PyErr_SetFromWindowsErrWithFilename(int ierr, const char *filename)
+   Similar to :c:func:`PyErr_SetFromWindowsErrWithFilenameObject`, but the
+   filename is given as a C string. Availability: Windows.
+.. c:function:: PyObject* PyErr_SetExcFromWindowsErrWithFilenameObject(PyObject *type, int ierr, PyObject *filename)
+   Similar to :c:func:`PyErr_SetFromWindowsErrWithFilenameObject`, with an
+   additional parameter specifying the exception type to be raised.
+   Availability: Windows.
+   .. versionadded:: 2.3
+.. c:function:: PyObject* PyErr_SetExcFromWindowsErrWithFilename(PyObject *type, int ierr, const char *filename)
+   Similar to :c:func:`PyErr_SetFromWindowsErrWithFilename`, with an additional
    parameter specifying the exception type to be raised. Availability: Windows.
 …
 .. cfunction:: void PyErr_BadInternalCall()
+.. c:function:: void PyErr_BadInternalCall()
    This is a shorthand for ``PyErr_SetString(PyExc_SystemError, message)``,
 …
 .. cfunction:: int PyErr_WarnEx(PyObject *category, char *message, int stacklevel)
+.. c:function:: int PyErr_WarnEx(PyObject *category, char *message, int stacklevel)
    Issue a warning message.  The *category* argument is a warning category (see
 …
    positive number giving a number of stack frames; the warning will be issued from
    the  currently executing line of code in that stack frame.  A *stacklevel* of 1
    is the function calling :cfunc:`PyErr_WarnEx`, 2 is  the function above that,
+   is the function calling :c:func:`PyErr_WarnEx`, 2 is  the function above that,
    and so forth.
 …
    actually printed, nor what the reason is for the exception; this is
    intentional.)  If an exception is raised, the caller should do its normal
    exception handling (for example, :cfunc:`Py_DECREF` owned references and return
+   exception handling (for example, :c:func:`Py_DECREF` owned references and return
    an error value).
    Warning categories must be subclasses of :cdata:`Warning`; the default warning
    category is :cdata:`RuntimeWarning`.  The standard Python warning categories are
+   Warning categories must be subclasses of :c:data:`Warning`; the default warning
+   category is :c:data:`RuntimeWarning`.  The standard Python warning categories are
    available as global variables whose names are ``PyExc_`` followed by the Python
    exception name. These have the type :ctype:`PyObject\*`; they are all class
    objects. Their names are :cdata:`PyExc_Warning`, :cdata:`PyExc_UserWarning`,
    :cdata:`PyExc_UnicodeWarning`, :cdata:`PyExc_DeprecationWarning`,
    :cdata:`PyExc_SyntaxWarning`, :cdata:`PyExc_RuntimeWarning`, and
    :cdata:`PyExc_FutureWarning`.  :cdata:`PyExc_Warning` is a subclass of
    :cdata:`PyExc_Exception`; the other warning categories are subclasses of
    :cdata:`PyExc_Warning`.
+   exception name. These have the type :c:type:`PyObject\*`; they are all class
+   objects. Their names are :c:data:`PyExc_Warning`, :c:data:`PyExc_UserWarning`,
+   :c:data:`PyExc_UnicodeWarning`, :c:data:`PyExc_DeprecationWarning`,
+   :c:data:`PyExc_SyntaxWarning`, :c:data:`PyExc_RuntimeWarning`, and
+   :c:data:`PyExc_FutureWarning`.  :c:data:`PyExc_Warning` is a subclass of
+   :c:data:`PyExc_Exception`; the other warning categories are subclasses of
+   :c:data:`PyExc_Warning`.
    For information about warning control, see the documentation for the
 …
 .. cfunction:: int PyErr_Warn(PyObject *category, char *message)
+.. c:function:: int PyErr_Warn(PyObject *category, char *message)
    Issue a warning message.  The *category* argument is a warning category (see
    below) or *NULL*; the *message* argument is a message string.  The warning will
    appear to be issued from the function calling :cfunc:`PyErr_Warn`, equivalent to
    calling :cfunc:`PyErr_WarnEx` with a *stacklevel* of 1.
    Deprecated; use :cfunc:`PyErr_WarnEx` instead.
 .. cfunction:: int PyErr_WarnExplicit(PyObject *category, const char *message, const char *filename, int lineno, const char *module, PyObject *registry)
+   appear to be issued from the function calling :c:func:`PyErr_Warn`, equivalent to
+   calling :c:func:`PyErr_WarnEx` with a *stacklevel* of 1.
+   Deprecated; use :c:func:`PyErr_WarnEx` instead.
+.. c:function:: int PyErr_WarnExplicit(PyObject *category, const char *message, const char *filename, int lineno, const char *module, PyObject *registry)
    Issue a warning message with explicit control over all warning attributes.  This
 …
 .. cfunction:: int PyErr_WarnPy3k(char *message, int stacklevel)
+.. c:function:: int PyErr_WarnPy3k(char *message, int stacklevel)
    Issue a :exc:`DeprecationWarning` with the given *message* and *stacklevel*
    if the :cdata:`Py_Py3kWarningFlag` flag is enabled.
+   if the :c:data:`Py_Py3kWarningFlag` flag is enabled.
    .. versionadded:: 2.6
 .. cfunction:: int PyErr_CheckSignals()
+.. c:function:: int PyErr_CheckSignals()
    .. index::
 …
 .. cfunction:: void PyErr_SetInterrupt()
+.. c:function:: void PyErr_SetInterrupt()
    .. index::
 …
    This function simulates the effect of a :const:`SIGINT` signal arriving --- the
    next time :cfunc:`PyErr_CheckSignals` is called,  :exc:`KeyboardInterrupt` will
+   next time :c:func:`PyErr_CheckSignals` is called,  :exc:`KeyboardInterrupt` will
    be raised.  It may be called without holding the interpreter lock.
 …
 .. cfunction:: int PySignal_SetWakeupFd(int fd)
+.. c:function:: int PySignal_SetWakeupFd(int fd)
    This utility function specifies a file descriptor to which a ``'\0'`` byte will
 …
    only be called from the main thread.
+.. cfunction:: PyObject* PyErr_NewException(char *name, PyObject *base, PyObject *dict)
+   This utility function creates and returns a new exception object. The *name*
+   .. versionadded:: 2.6
+.. c:function:: PyObject* PyErr_NewException(char *name, PyObject *base, PyObject *dict)
+   This utility function creates and returns a new exception class. The *name*
    argument must be the name of the new exception, a C string of the form
    ``module.class``.  The *base* and *dict* arguments are normally *NULL*.  This
    creates a class object derived from :exc:`Exception` (accessible in C as
    :cdata:`PyExc_Exception`).
+   ``module.classname``.  The *base* and *dict* arguments are normally *NULL*.
+   This creates a class object derived from :exc:`Exception` (accessible in C as
+   :c:data:`PyExc_Exception`).
    The :attr:`__module__` attribute of the new class is set to the first part (up
 …
+.. cfunction:: void PyErr_WriteUnraisable(PyObject *obj)
+.. c:function:: PyObject* PyErr_NewExceptionWithDoc(char *name, char *doc, PyObject *base, PyObject *dict)
+   Same as :c:func:`PyErr_NewException`, except that the new exception class can
+   easily be given a docstring: If *doc* is non-*NULL*, it will be used as the
+   docstring for the exception class.
+   .. versionadded:: 2.7
+.. c:function:: void PyErr_WriteUnraisable(PyObject *obj)
    This utility function prints a warning message to ``sys.stderr`` when an
 …
+.. _unicodeexceptions:
+Unicode Exception Objects
+=========================
+The following functions are used to create and modify Unicode exceptions from C.
+.. c:function:: PyObject* PyUnicodeDecodeError_Create(const char *encoding, const char *object, Py_ssize_t length, Py_ssize_t start, Py_ssize_t end, const char *reason)
+   Create a :class:`UnicodeDecodeError` object with the attributes *encoding*,
+   *object*, *length*, *start*, *end* and *reason*.
+.. c:function:: PyObject* PyUnicodeEncodeError_Create(const char *encoding, const Py_UNICODE *object, Py_ssize_t length, Py_ssize_t start, Py_ssize_t end, const char *reason)
+   Create a :class:`UnicodeEncodeError` object with the attributes *encoding*,
+   *object*, *length*, *start*, *end* and *reason*.
+.. c:function:: PyObject* PyUnicodeTranslateError_Create(const Py_UNICODE *object, Py_ssize_t length, Py_ssize_t start, Py_ssize_t end, const char *reason)
+   Create a :class:`UnicodeTranslateError` object with the attributes *object*,
+   *length*, *start*, *end* and *reason*.
+.. c:function:: PyObject* PyUnicodeDecodeError_GetEncoding(PyObject *exc)
+               PyObject* PyUnicodeEncodeError_GetEncoding(PyObject *exc)
+   Return the *encoding* attribute of the given exception object.
+.. c:function:: PyObject* PyUnicodeDecodeError_GetObject(PyObject *exc)
+               PyObject* PyUnicodeEncodeError_GetObject(PyObject *exc)
+               PyObject* PyUnicodeTranslateError_GetObject(PyObject *exc)
+   Return the *object* attribute of the given exception object.
+.. c:function:: int PyUnicodeDecodeError_GetStart(PyObject *exc, Py_ssize_t *start)
+               int PyUnicodeEncodeError_GetStart(PyObject *exc, Py_ssize_t *start)
+               int PyUnicodeTranslateError_GetStart(PyObject *exc, Py_ssize_t *start)
+   Get the *start* attribute of the given exception object and place it into
+   *\*start*.  *start* must not be *NULL*.  Return ``0`` on success, ``-1`` on
+   failure.
+.. c:function:: int PyUnicodeDecodeError_SetStart(PyObject *exc, Py_ssize_t start)
+               int PyUnicodeEncodeError_SetStart(PyObject *exc, Py_ssize_t start)
+               int PyUnicodeTranslateError_SetStart(PyObject *exc, Py_ssize_t start)
+   Set the *start* attribute of the given exception object to *start*.  Return
+   ``0`` on success, ``-1`` on failure.
+.. c:function:: int PyUnicodeDecodeError_GetEnd(PyObject *exc, Py_ssize_t *end)
+               int PyUnicodeEncodeError_GetEnd(PyObject *exc, Py_ssize_t *end)
+               int PyUnicodeTranslateError_GetEnd(PyObject *exc, Py_ssize_t *end)
+   Get the *end* attribute of the given exception object and place it into
+   *\*end*.  *end* must not be *NULL*.  Return ``0`` on success, ``-1`` on
+   failure.
+.. c:function:: int PyUnicodeDecodeError_SetEnd(PyObject *exc, Py_ssize_t end)
+               int PyUnicodeEncodeError_SetEnd(PyObject *exc, Py_ssize_t end)
+               int PyUnicodeTranslateError_SetEnd(PyObject *exc, Py_ssize_t end)
+   Set the *end* attribute of the given exception object to *end*.  Return ``0``
+   on success, ``-1`` on failure.
+.. c:function:: PyObject* PyUnicodeDecodeError_GetReason(PyObject *exc)
+               PyObject* PyUnicodeEncodeError_GetReason(PyObject *exc)
+               PyObject* PyUnicodeTranslateError_GetReason(PyObject *exc)
+   Return the *reason* attribute of the given exception object.
+.. c:function:: int PyUnicodeDecodeError_SetReason(PyObject *exc, const char *reason)
+               int PyUnicodeEncodeError_SetReason(PyObject *exc, const char *reason)
+               int PyUnicodeTranslateError_SetReason(PyObject *exc, const char *reason)
+   Set the *reason* attribute of the given exception object to *reason*.  Return
+   ``0`` on success, ``-1`` on failure.
+Recursion Control
+=================
+These two functions provide a way to perform safe recursive calls at the C
+level, both in the core and in extension modules.  They are needed if the
+recursive code does not necessarily invoke Python code (which tracks its
+recursion depth automatically).
+.. c:function:: int Py_EnterRecursiveCall(char *where)
+   Marks a point where a recursive C-level call is about to be performed.
+   If :const:`USE_STACKCHECK` is defined, this function checks if the OS
+   stack overflowed using :c:func:`PyOS_CheckStack`.  In this is the case, it
+   sets a :exc:`MemoryError` and returns a nonzero value.
+   The function then checks if the recursion limit is reached.  If this is the
+   case, a :exc:`RuntimeError` is set and a nonzero value is returned.
+   Otherwise, zero is returned.
+   *where* should be a string such as ``" in instance check"`` to be
+   concatenated to the :exc:`RuntimeError` message caused by the recursion depth
+   limit.
+.. c:function:: void Py_LeaveRecursiveCall()
+   Ends a :c:func:`Py_EnterRecursiveCall`.  Must be called once for each
+   *successful* invocation of :c:func:`Py_EnterRecursiveCall`.
 .. _standardexceptions:
 …
 All standard Python exceptions are available as global variables whose names are
 ``PyExc_`` followed by the Python exception name.  These have the type
 :ctype:`PyObject\*`; they are all class objects.  For completeness, here are all
+:c:type:`PyObject\*`; they are all class objects.  For completeness, here are all
 the variables:
 +------------------------------------+----------------------------+----------+
 | C Name                             | Python Name                | Notes    |
 +====================================+============================+==========+
 | :cdata:`PyExc_BaseException`       | :exc:`BaseException`       | (1), (4) |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_Exception`           | :exc:`Exception`           | \(1)     |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_StandardError`       | :exc:`StandardError`       | \(1)     |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_ArithmeticError`     | :exc:`ArithmeticError`     | \(1)     |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_LookupError`         | :exc:`LookupError`         | \(1)     |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_AssertionError`      | :exc:`AssertionError`      |          |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_AttributeError`      | :exc:`AttributeError`      |          |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_EOFError`            | :exc:`EOFError`            |          |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_EnvironmentError`    | :exc:`EnvironmentError`    | \(1)     |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_FloatingPointError`  | :exc:`FloatingPointError`  |          |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_IOError`             | :exc:`IOError`             |          |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_ImportError`         | :exc:`ImportError`         |          |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_IndexError`          | :exc:`IndexError`          |          |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_KeyError`            | :exc:`KeyError`            |          |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_KeyboardInterrupt`   | :exc:`KeyboardInterrupt`   |          |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_MemoryError`         | :exc:`MemoryError`         |          |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_NameError`           | :exc:`NameError`           |          |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_NotImplementedError` | :exc:`NotImplementedError` |          |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_OSError`             | :exc:`OSError`             |          |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_OverflowError`       | :exc:`OverflowError`       |          |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_ReferenceError`      | :exc:`ReferenceError`      | \(2)     |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_RuntimeError`        | :exc:`RuntimeError`        |          |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_SyntaxError`         | :exc:`SyntaxError`         |          |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_SystemError`         | :exc:`SystemError`         |          |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_SystemExit`          | :exc:`SystemExit`          |          |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_TypeError`           | :exc:`TypeError`           |          |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_ValueError`          | :exc:`ValueError`          |          |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_WindowsError`        | :exc:`WindowsError`        | \(3)     |
 +------------------------------------+----------------------------+----------+
 | :cdata:`PyExc_ZeroDivisionError`   | :exc:`ZeroDivisionError`   |          |
 +------------------------------------+----------------------------+----------+
++-------------------------------------+----------------------------+----------+
+| C Name                              | Python Name                | Notes    |
++=====================================+============================+==========+
+| :c:data:`PyExc_BaseException`       | :exc:`BaseException`       | (1), (4) |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_Exception`           | :exc:`Exception`           | \(1)     |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_StandardError`       | :exc:`StandardError`       | \(1)     |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_ArithmeticError`     | :exc:`ArithmeticError`     | \(1)     |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_LookupError`         | :exc:`LookupError`         | \(1)     |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_AssertionError`      | :exc:`AssertionError`      |          |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_AttributeError`      | :exc:`AttributeError`      |          |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_EOFError`            | :exc:`EOFError`            |          |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_EnvironmentError`    | :exc:`EnvironmentError`    | \(1)     |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_FloatingPointError`  | :exc:`FloatingPointError`  |          |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_IOError`             | :exc:`IOError`             |          |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_ImportError`         | :exc:`ImportError`         |          |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_IndexError`          | :exc:`IndexError`          |          |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_KeyError`            | :exc:`KeyError`            |          |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_KeyboardInterrupt`   | :exc:`KeyboardInterrupt`   |          |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_MemoryError`         | :exc:`MemoryError`         |          |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_NameError`           | :exc:`NameError`           |          |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_NotImplementedError` | :exc:`NotImplementedError` |          |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_OSError`             | :exc:`OSError`             |          |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_OverflowError`       | :exc:`OverflowError`       |          |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_ReferenceError`      | :exc:`ReferenceError`      | \(2)     |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_RuntimeError`        | :exc:`RuntimeError`        |          |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_SyntaxError`         | :exc:`SyntaxError`         |          |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_SystemError`         | :exc:`SystemError`         |          |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_SystemExit`          | :exc:`SystemExit`          |          |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_TypeError`           | :exc:`TypeError`           |          |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_ValueError`          | :exc:`ValueError`          |          |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_WindowsError`        | :exc:`WindowsError`        | \(3)     |
++-------------------------------------+----------------------------+----------+
+| :c:data:`PyExc_ZeroDivisionError`   | :exc:`ZeroDivisionError`   |          |
++-------------------------------------+----------------------------+----------+
 .. index::
 …
+Deprecation of String Exceptions
+================================
+.. index:: single: BaseException (built-in exception)
+All exceptions built into Python or provided in the standard library are derived
+from :exc:`BaseException`.
+String exceptions are still supported in the interpreter to allow existing code
+to run unmodified, but this will also change in a future release.
+String Exceptions
+=================
+.. versionchanged:: 2.6
+   All exceptions to be raised or caught must be derived from :exc:`BaseException`.
+   Trying to raise a string exception now raises :exc:`TypeError`.

python/vendor/current/Doc/c-api/file.rst

-              r2
+              r388
 .. index:: object: file
 Python's built-in file objects are implemented entirely on the :ctype:`FILE\*`
+Python's built-in file objects are implemented entirely on the :c:type:`FILE\*`
 support from the C standard library.  This is an implementation detail and may
 change in future releases of Python.
 .. ctype:: PyFileObject
+.. c:type:: PyFileObject
    This subtype of :ctype:`PyObject` represents a Python file object.
+   This subtype of :c:type:`PyObject` represents a Python file object.
 .. cvar:: PyTypeObject PyFile_Type
+.. c:var:: PyTypeObject PyFile_Type
    .. index:: single: FileType (in module types)
    This instance of :ctype:`PyTypeObject` represents the Python file type.  This is
+   This instance of :c:type:`PyTypeObject` represents the Python file type.  This is
    exposed to Python programs as ``file`` and ``types.FileType``.
 .. cfunction:: int PyFile_Check(PyObject *p)
+.. c:function:: int PyFile_Check(PyObject *p)
    Return true if its argument is a :ctype:`PyFileObject` or a subtype of
    :ctype:`PyFileObject`.
+   Return true if its argument is a :c:type:`PyFileObject` or a subtype of
+   :c:type:`PyFileObject`.
    .. versionchanged:: 2.2
 …
 .. cfunction:: int PyFile_CheckExact(PyObject *p)
+.. c:function:: int PyFile_CheckExact(PyObject *p)
    Return true if its argument is a :ctype:`PyFileObject`, but not a subtype of
    :ctype:`PyFileObject`.
+   Return true if its argument is a :c:type:`PyFileObject`, but not a subtype of
+   :c:type:`PyFileObject`.
    .. versionadded:: 2.2
 .. cfunction:: PyObject* PyFile_FromString(char *filename, char *mode)
+.. c:function:: PyObject* PyFile_FromString(char *filename, char *mode)
    .. index:: single: fopen()
 …
    On success, return a new file object that is opened on the file given by
    *filename*, with a file mode given by *mode*, where *mode* has the same
    semantics as the standard C routine :cfunc:`fopen`.  On failure, return *NULL*.
+   semantics as the standard C routine :c:func:`fopen`.  On failure, return *NULL*.
 .. cfunction:: PyObject* PyFile_FromFile(FILE *fp, char *name, char *mode, int (*close)(FILE*))
+.. c:function:: PyObject* PyFile_FromFile(FILE *fp, char *name, char *mode, int (*close)(FILE*))
    Create a new :ctype:`PyFileObject` from the already-open standard C file
+   Create a new :c:type:`PyFileObject` from the already-open standard C file
    pointer, *fp*.  The function *close* will be called when the file should be
+   closed.  Return *NULL* on failure.
+   closed.  Return *NULL* and close the file using *close* on failure.
+   *close* is optional and can be set to *NULL*.
 .. cfunction:: FILE* PyFile_AsFile(PyObject \*p)
+.. c:function:: FILE* PyFile_AsFile(PyObject \*p)
    Return the file object associated with *p* as a :ctype:`FILE\*`.
+   Return the file object associated with *p* as a :c:type:`FILE\*`.
    If the caller will ever use the returned :ctype:`FILE\*` object while
    the GIL is released it must also call the :cfunc:`PyFile_IncUseCount` and
    :cfunc:`PyFile_DecUseCount` functions described below as appropriate.
+   If the caller will ever use the returned :c:type:`FILE\*` object while
+   the :term:`GIL` is released it must also call the :c:func:`PyFile_IncUseCount` and
+   :c:func:`PyFile_DecUseCount` functions described below as appropriate.
 .. cfunction:: void PyFile_IncUseCount(PyFileObject \*p)
+.. c:function:: void PyFile_IncUseCount(PyFileObject \*p)
    Increments the PyFileObject's internal use count to indicate
    that the underlying :ctype:`FILE\*` is being used.
+   that the underlying :c:type:`FILE\*` is being used.
    This prevents Python from calling f_close() on it from another thread.
    Callers of this must call :cfunc:`PyFile_DecUseCount` when they are
    finished with the :ctype:`FILE\*`.  Otherwise the file object will
+   Callers of this must call :c:func:`PyFile_DecUseCount` when they are
+   finished with the :c:type:`FILE\*`.  Otherwise the file object will
    never be closed by Python.
    The GIL must be held while calling this function.
+   The :term:`GIL` must be held while calling this function.
+   The suggested use is to call this after :cfunc:`PyFile_AsFile` just before
+   you release the GIL.
+   The suggested use is to call this after :c:func:`PyFile_AsFile` and before
+   you release the GIL::
+      FILE *fp = PyFile_AsFile(p);
+      PyFile_IncUseCount(p);
+      /* ... */
+      Py_BEGIN_ALLOW_THREADS
+      do_something(fp);
+      Py_END_ALLOW_THREADS
+      /* ... */
+      PyFile_DecUseCount(p);
    .. versionadded:: 2.6
 .. cfunction:: void PyFile_DecUseCount(PyFileObject \*p)
+.. c:function:: void PyFile_DecUseCount(PyFileObject \*p)
    Decrements the PyFileObject's internal unlocked_count member to
    indicate that the caller is done with its own use of the :ctype:`FILE\*`.
    This may only be called to undo a prior call to :cfunc:`PyFile_IncUseCount`.
+   indicate that the caller is done with its own use of the :c:type:`FILE\*`.
+   This may only be called to undo a prior call to :c:func:`PyFile_IncUseCount`.
+   The GIL must be held while calling this function.
+   The :term:`GIL` must be held while calling this function (see the example
+   above).
    .. versionadded:: 2.6
 .. cfunction:: PyObject* PyFile_GetLine(PyObject *p, int n)
+.. c:function:: PyObject* PyFile_GetLine(PyObject *p, int n)
    .. index:: single: EOFError (built-in exception)
    Equivalent to ``p.readline([n])``, this function reads one line from the
+   object *p*.  *p* may be a file object or any object with a :meth:`readline`
+   object *p*.  *p* may be a file object or any object with a
+   :meth:`~io.IOBase.readline`
    method.  If *n* is ``0``, exactly one line is read, regardless of the length of
    the line.  If *n* is greater than ``0``, no more than *n* bytes will be read
 …
 .. cfunction:: PyObject* PyFile_Name(PyObject *p)
+.. c:function:: PyObject* PyFile_Name(PyObject *p)
    Return the name of the file specified by *p* as a string object.
 .. cfunction:: void PyFile_SetBufSize(PyFileObject *p, int n)
+.. c:function:: void PyFile_SetBufSize(PyFileObject *p, int n)
    .. index:: single: setvbuf()
    Available on systems with :cfunc:`setvbuf` only.  This should only be called
+   Available on systems with :c:func:`setvbuf` only.  This should only be called
    immediately after file object creation.
 .. cfunction:: int PyFile_SetEncoding(PyFileObject *p, const char *enc)
+.. c:function:: int PyFile_SetEncoding(PyFileObject *p, const char *enc)
    Set the file's encoding for Unicode output to *enc*. Return 1 on success and 0
 …
 .. cfunction:: int PyFile_SetEncodingAndErrors(PyFileObject *p, const char *enc, *errors)
+.. c:function:: int PyFile_SetEncodingAndErrors(PyFileObject *p, const char *enc, *errors)
    Set the file's encoding for Unicode output to *enc*, and its error
 …
 .. cfunction:: int PyFile_SoftSpace(PyObject *p, int newflag)
+.. c:function:: int PyFile_SoftSpace(PyObject *p, int newflag)
    .. index:: single: softspace (file attribute)
 …
 .. cfunction:: int PyFile_WriteObject(PyObject *obj, PyObject *p, int flags)
+.. c:function:: int PyFile_WriteObject(PyObject *obj, PyObject *p, int flags)
    .. index:: single: Py_PRINT_RAW
 …
 .. cfunction:: int PyFile_WriteString(const char *s, PyObject *p)
+.. c:function:: int PyFile_WriteString(const char *s, PyObject *p)
    Write string *s* to file object *p*.  Return ``0`` on success or ``-1`` on

python/vendor/current/Doc/c-api/float.rst

-              r2
+              r388
 .. ctype:: PyFloatObject
+.. c:type:: PyFloatObject
    This subtype of :ctype:`PyObject` represents a Python floating point object.
+   This subtype of :c:type:`PyObject` represents a Python floating point object.
 .. cvar:: PyTypeObject PyFloat_Type
+.. c:var:: PyTypeObject PyFloat_Type
    .. index:: single: FloatType (in modules types)
    This instance of :ctype:`PyTypeObject` represents the Python floating point
+   This instance of :c:type:`PyTypeObject` represents the Python floating point
    type.  This is the same object as ``float`` and ``types.FloatType``.
 .. cfunction:: int PyFloat_Check(PyObject *p)
+.. c:function:: int PyFloat_Check(PyObject *p)
    Return true if its argument is a :ctype:`PyFloatObject` or a subtype of
    :ctype:`PyFloatObject`.
+   Return true if its argument is a :c:type:`PyFloatObject` or a subtype of
+   :c:type:`PyFloatObject`.
    .. versionchanged:: 2.2
 …
 .. cfunction:: int PyFloat_CheckExact(PyObject *p)
+.. c:function:: int PyFloat_CheckExact(PyObject *p)
    Return true if its argument is a :ctype:`PyFloatObject`, but not a subtype of
    :ctype:`PyFloatObject`.
+   Return true if its argument is a :c:type:`PyFloatObject`, but not a subtype of
+   :c:type:`PyFloatObject`.
    .. versionadded:: 2.2
 .. cfunction:: PyObject* PyFloat_FromString(PyObject *str, char **pend)
+.. c:function:: PyObject* PyFloat_FromString(PyObject *str, char **pend)
    Create a :ctype:`PyFloatObject` object based on the string value in *str*, or
+   Create a :c:type:`PyFloatObject` object based on the string value in *str*, or
    *NULL* on failure.  The *pend* argument is ignored.  It remains only for
    backward compatibility.
 .. cfunction:: PyObject* PyFloat_FromDouble(double v)
+.. c:function:: PyObject* PyFloat_FromDouble(double v)
    Create a :ctype:`PyFloatObject` object from *v*, or *NULL* on failure.
+   Create a :c:type:`PyFloatObject` object from *v*, or *NULL* on failure.
 .. cfunction:: double PyFloat_AsDouble(PyObject *pyfloat)
+.. c:function:: double PyFloat_AsDouble(PyObject *pyfloat)
    Return a C :ctype:`double` representation of the contents of *pyfloat*.  If
+   Return a C :c:type:`double` representation of the contents of *pyfloat*.  If
    *pyfloat* is not a Python floating point object but has a :meth:`__float__`
    method, this method will first be called to convert *pyfloat* into a float.
+   This method returns ``-1.0`` upon failure, so one should call
+   :c:func:`PyErr_Occurred` to check for errors.
 .. cfunction:: double PyFloat_AS_DOUBLE(PyObject *pyfloat)
+.. c:function:: double PyFloat_AS_DOUBLE(PyObject *pyfloat)
    Return a C :ctype:`double` representation of the contents of *pyfloat*, but
+   Return a C :c:type:`double` representation of the contents of *pyfloat*, but
    without error checking.
 .. cfunction:: PyObject* PyFloat_GetInfo(void)
+.. c:function:: PyObject* PyFloat_GetInfo(void)
    Return a structseq instance which contains information about the
 …
 .. cfunction:: double PyFloat_GetMax()
+.. c:function:: double PyFloat_GetMax()
    Return the maximum representable finite float *DBL_MAX* as C :ctype:`double`.
+   Return the maximum representable finite float *DBL_MAX* as C :c:type:`double`.
    .. versionadded:: 2.6
 .. cfunction:: double PyFloat_GetMin()
+.. c:function:: double PyFloat_GetMin()
    Return the minimum normalized positive float *DBL_MIN* as C :ctype:`double`.
+   Return the minimum normalized positive float *DBL_MIN* as C :c:type:`double`.
    .. versionadded:: 2.6
 .. cfunction:: int PyFloat_ClearFreeList()
+.. c:function:: int PyFloat_ClearFreeList()
    Clear the float free list. Return the number of items that could not
 …
    .. versionadded:: 2.6
+.. c:function:: void PyFloat_AsString(char *buf, PyFloatObject *v)
+   Convert the argument *v* to a string, using the same rules as
+   :func:`str`. The length of *buf* should be at least 100.
+   This function is unsafe to call because it writes to a buffer whose
+   length it does not know.
+   .. deprecated:: 2.7
+      Use :func:`PyObject_Str` or :func:`PyOS_double_to_string` instead.
+.. c:function:: void PyFloat_AsReprString(char *buf, PyFloatObject *v)
+   Same as PyFloat_AsString, except uses the same rules as
+   :func:`repr`.  The length of *buf* should be at least 100.
+   This function is unsafe to call because it writes to a buffer whose
+   length it does not know.
+   .. deprecated:: 2.7
+      Use :func:`PyObject_Repr` or :func:`PyOS_double_to_string` instead.

python/vendor/current/Doc/c-api/function.rst

-              r2
+              r388
 .. ctype:: PyFunctionObject
+.. c:type:: PyFunctionObject
    The C structure used for functions.
 .. cvar:: PyTypeObject PyFunction_Type
+.. c:var:: PyTypeObject PyFunction_Type
    .. index:: single: MethodType (in module types)
    This is an instance of :ctype:`PyTypeObject` and represents the Python function
+   This is an instance of :c:type:`PyTypeObject` and represents the Python function
    type.  It is exposed to Python programmers as ``types.FunctionType``.
 .. cfunction:: int PyFunction_Check(PyObject *o)
+.. c:function:: int PyFunction_Check(PyObject *o)
    Return true if *o* is a function object (has type :cdata:`PyFunction_Type`).
+   Return true if *o* is a function object (has type :c:data:`PyFunction_Type`).
    The parameter must not be *NULL*.
 .. cfunction:: PyObject* PyFunction_New(PyObject *code, PyObject *globals)
+.. c:function:: PyObject* PyFunction_New(PyObject *code, PyObject *globals)
    Return a new function object associated with the code object *code*. *globals*
 …
 .. cfunction:: PyObject* PyFunction_GetCode(PyObject *op)
+.. c:function:: PyObject* PyFunction_GetCode(PyObject *op)
    Return the code object associated with the function object *op*.
 .. cfunction:: PyObject* PyFunction_GetGlobals(PyObject *op)
+.. c:function:: PyObject* PyFunction_GetGlobals(PyObject *op)
    Return the globals dictionary associated with the function object *op*.
 .. cfunction:: PyObject* PyFunction_GetModule(PyObject *op)
+.. c:function:: PyObject* PyFunction_GetModule(PyObject *op)
    Return the *__module__* attribute of the function object *op*. This is normally
 …
 .. cfunction:: PyObject* PyFunction_GetDefaults(PyObject *op)
+.. c:function:: PyObject* PyFunction_GetDefaults(PyObject *op)
    Return the argument default values of the function object *op*. This can be a
 …
 .. cfunction:: int PyFunction_SetDefaults(PyObject *op, PyObject *defaults)
+.. c:function:: int PyFunction_SetDefaults(PyObject *op, PyObject *defaults)
    Set the argument default values for the function object *op*. *defaults* must be
 …
 .. cfunction:: PyObject* PyFunction_GetClosure(PyObject *op)
+.. c:function:: PyObject* PyFunction_GetClosure(PyObject *op)
    Return the closure associated with the function object *op*. This can be *NULL*
 …
 .. cfunction:: int PyFunction_SetClosure(PyObject *op, PyObject *closure)
+.. c:function:: int PyFunction_SetClosure(PyObject *op, PyObject *closure)
    Set the closure associated with the function object *op*. *closure* must be

python/vendor/current/Doc/c-api/gcsupport.rst

-              r2
+              r388
 .. Cycle Collector (XXX not found: ../ext/example-cycle-support.html)".
 To create a container type, the :attr:`tp_flags` field of the type object must
+To create a container type, the :c:member:`~PyTypeObject.tp_flags` field of the type object must
 include the :const:`Py_TPFLAGS_HAVE_GC` and provide an implementation of the
 :attr:`tp_traverse` handler.  If instances of the type are mutable, a
 :attr:`tp_clear` implementation must also be provided.
+:c:member:`~PyTypeObject.tp_traverse` handler.  If instances of the type are mutable, a
+:c:member:`~PyTypeObject.tp_clear` implementation must also be provided.
 …
 Constructors for container types must conform to two rules:
 #. The memory for the object must be allocated using :cfunc:`PyObject_GC_New`
    or :cfunc:`PyObject_GC_VarNew`.
+#. The memory for the object must be allocated using :c:func:`PyObject_GC_New`
+   or :c:func:`PyObject_GC_NewVar`.
 #. Once all the fields which may contain references to other containers are
    initialized, it must call :cfunc:`PyObject_GC_Track`.
+   initialized, it must call :c:func:`PyObject_GC_Track`.
 .. cfunction:: TYPE* PyObject_GC_New(TYPE, PyTypeObject *type)
+.. c:function:: TYPE* PyObject_GC_New(TYPE, PyTypeObject *type)
    Analogous to :cfunc:`PyObject_New` but for container objects with the
+   Analogous to :c:func:`PyObject_New` but for container objects with the
    :const:`Py_TPFLAGS_HAVE_GC` flag set.
 .. cfunction:: TYPE* PyObject_GC_NewVar(TYPE, PyTypeObject *type, Py_ssize_t size)
+.. c:function:: TYPE* PyObject_GC_NewVar(TYPE, PyTypeObject *type, Py_ssize_t size)
    Analogous to :cfunc:`PyObject_NewVar` but for container objects with the
+   Analogous to :c:func:`PyObject_NewVar` but for container objects with the
    :const:`Py_TPFLAGS_HAVE_GC` flag set.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
+      This function used an :c:type:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: TYPE* PyObject_GC_Resize(TYPE, PyVarObject *op, Py_ssize_t newsize)
+.. c:function:: TYPE* PyObject_GC_Resize(TYPE, PyVarObject *op, Py_ssize_t newsize)
    Resize an object allocated by :cfunc:`PyObject_NewVar`.  Returns the
+   Resize an object allocated by :c:func:`PyObject_NewVar`.  Returns the
    resized object or *NULL* on failure.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *newsize*. This might
+      This function used an :c:type:`int` type for *newsize*. This might
       require changes in your code for properly supporting 64-bit systems.
 .. cfunction:: void PyObject_GC_Track(PyObject *op)
+.. c:function:: void PyObject_GC_Track(PyObject *op)
    Adds the object *op* to the set of container objects tracked by the
    collector.  The collector can run at unexpected times so objects must be
    valid while being tracked.  This should be called once all the fields
    followed by the :attr:`tp_traverse` handler become valid, usually near the
+   followed by the :c:member:`~PyTypeObject.tp_traverse` handler become valid, usually near the
    end of the constructor.
 .. cfunction:: void _PyObject_GC_TRACK(PyObject *op)
+.. c:function:: void _PyObject_GC_TRACK(PyObject *op)
    A macro version of :cfunc:`PyObject_GC_Track`.  It should not be used for
+   A macro version of :c:func:`PyObject_GC_Track`.  It should not be used for
    extension modules.
 …
 #. Before fields which refer to other containers are invalidated,
    :cfunc:`PyObject_GC_UnTrack` must be called.
+   :c:func:`PyObject_GC_UnTrack` must be called.
 #. The object's memory must be deallocated using :cfunc:`PyObject_GC_Del`.
+#. The object's memory must be deallocated using :c:func:`PyObject_GC_Del`.
 .. cfunction:: void PyObject_GC_Del(void *op)
+.. c:function:: void PyObject_GC_Del(void *op)
    Releases memory allocated to an object using :cfunc:`PyObject_GC_New` or
    :cfunc:`PyObject_GC_NewVar`.
+   Releases memory allocated to an object using :c:func:`PyObject_GC_New` or
+   :c:func:`PyObject_GC_NewVar`.
 .. cfunction:: void PyObject_GC_UnTrack(void *op)
+.. c:function:: void PyObject_GC_UnTrack(void *op)
    Remove the object *op* from the set of container objects tracked by the
    collector.  Note that :cfunc:`PyObject_GC_Track` can be called again on
+   collector.  Note that :c:func:`PyObject_GC_Track` can be called again on
    this object to add it back to the set of tracked objects.  The deallocator
    (:attr:`tp_dealloc` handler) should call this for the object before any of
    the fields used by the :attr:`tp_traverse` handler become invalid.
+   (:c:member:`~PyTypeObject.tp_dealloc` handler) should call this for the object before any of
+   the fields used by the :c:member:`~PyTypeObject.tp_traverse` handler become invalid.
 .. cfunction:: void _PyObject_GC_UNTRACK(PyObject *op)
+.. c:function:: void _PyObject_GC_UNTRACK(PyObject *op)
    A macro version of :cfunc:`PyObject_GC_UnTrack`.  It should not be used for
+   A macro version of :c:func:`PyObject_GC_UnTrack`.  It should not be used for
    extension modules.
 The :attr:`tp_traverse` handler accepts a function parameter of this type:
+The :c:member:`~PyTypeObject.tp_traverse` handler accepts a function parameter of this type:
 .. ctype:: int (*visitproc)(PyObject *object, void *arg)
+.. c:type:: int (*visitproc)(PyObject *object, void *arg)
    Type of the visitor function passed to the :attr:`tp_traverse` handler.
+   Type of the visitor function passed to the :c:member:`~PyTypeObject.tp_traverse` handler.
    The function should be called with an object to traverse as *object* and
    the third parameter to the :attr:`tp_traverse` handler as *arg*.  The
+   the third parameter to the :c:member:`~PyTypeObject.tp_traverse` handler as *arg*.  The
    Python core uses several visitor functions to implement cyclic garbage
    detection; it's not expected that users will need to write their own
    visitor functions.
 The :attr:`tp_traverse` handler must have the following type:
+The :c:member:`~PyTypeObject.tp_traverse` handler must have the following type:
 .. ctype:: int (*traverseproc)(PyObject *self, visitproc visit, void *arg)
+.. c:type:: int (*traverseproc)(PyObject *self, visitproc visit, void *arg)
    Traversal function for a container object.  Implementations must call the
 …
    returned immediately.
 To simplify writing :attr:`tp_traverse` handlers, a :cfunc:`Py_VISIT` macro is
 provided.  In order to use this macro, the :attr:`tp_traverse` implementation
+To simplify writing :c:member:`~PyTypeObject.tp_traverse` handlers, a :c:func:`Py_VISIT` macro is
+provided.  In order to use this macro, the :c:member:`~PyTypeObject.tp_traverse` implementation
 must name its arguments exactly *visit* and *arg*:
 .. cfunction:: void Py_VISIT(PyObject *o)
+.. c:function:: void Py_VISIT(PyObject *o)
    Call the *visit* callback, with arguments *o* and *arg*. If *visit* returns
    a non-zero value, then return it.  Using this macro, :attr:`tp_traverse`
+   a non-zero value, then return it.  Using this macro, :c:member:`~PyTypeObject.tp_traverse`
    handlers look like::
 …
    .. versionadded:: 2.4
 The :attr:`tp_clear` handler must be of the :ctype:`inquiry` type, or *NULL*
+The :c:member:`~PyTypeObject.tp_clear` handler must be of the :c:type:`inquiry` type, or *NULL*
 if the object is immutable.
 .. ctype:: int (*inquiry)(PyObject *self)
+.. c:type:: int (*inquiry)(PyObject *self)
    Drop references that may have created reference cycles.  Immutable objects
    do not have to define this method since they can never directly create
    reference cycles.  Note that the object must still be valid after calling
    this method (don't just call :cfunc:`Py_DECREF` on a reference).  The
+   this method (don't just call :c:func:`Py_DECREF` on a reference).  The
    collector will call this method if it detects that this object is involved
    in a reference cycle.

python/vendor/current/Doc/c-api/gen.rst

-              r2
+              r388
 Generator objects are what Python uses to implement generator iterators. They
 are normally created by iterating over a function that yields values, rather
 than explicitly calling :cfunc:`PyGen_New`.
+than explicitly calling :c:func:`PyGen_New`.
 .. ctype:: PyGenObject
+.. c:type:: PyGenObject
    The C structure used for generator objects.
 .. cvar:: PyTypeObject PyGen_Type
+.. c:var:: PyTypeObject PyGen_Type
    The type object corresponding to generator objects
 .. cfunction:: int PyGen_Check(ob)
+.. c:function:: int PyGen_Check(ob)
    Return true if *ob* is a generator object; *ob* must not be *NULL*.
 .. cfunction:: int PyGen_CheckExact(ob)
+.. c:function:: int PyGen_CheckExact(ob)
    Return true if *ob*'s type is *PyGen_Type* is a generator object; *ob* must not
 …
 .. cfunction:: PyObject* PyGen_New(PyFrameObject *frame)
+.. c:function:: PyObject* PyGen_New(PyFrameObject *frame)
    Create and return a new generator object based on the *frame* object. A

python/vendor/current/Doc/c-api/import.rst

-              r2
+              r388
 .. cfunction:: PyObject* PyImport_ImportModule(const char *name)
+.. c:function:: PyObject* PyImport_ImportModule(const char *name)
    .. index::
 …
       single: modules (in module sys)
    This is a simplified interface to :cfunc:`PyImport_ImportModuleEx` below,
+   This is a simplified interface to :c:func:`PyImport_ImportModuleEx` below,
    leaving the *globals* and *locals* arguments set to *NULL* and *level* set
    to 0.  When the *name*
 …
 .. cfunction:: PyObject* PyImport_ImportModuleNoBlock(const char *name)
    This version of :cfunc:`PyImport_ImportModule` does not block. It's intended
+.. c:function:: PyObject* PyImport_ImportModuleNoBlock(const char *name)
+   This version of :c:func:`PyImport_ImportModule` does not block. It's intended
    to be used in C functions that import other modules to execute a function.
    The import may block if another thread holds the import lock. The function
    :cfunc:`PyImport_ImportModuleNoBlock` never blocks. It first tries to fetch
    the module from sys.modules and falls back to :cfunc:`PyImport_ImportModule`
+   :c:func:`PyImport_ImportModuleNoBlock` never blocks. It first tries to fetch
+   the module from sys.modules and falls back to :c:func:`PyImport_ImportModule`
    unless the lock is held, in which case the function will raise an
    :exc:`ImportError`.
 …
 .. cfunction:: PyObject* PyImport_ImportModuleEx(char *name, PyObject *globals, PyObject *locals, PyObject *fromlist)
+.. c:function:: PyObject* PyImport_ImportModuleEx(char *name, PyObject *globals, PyObject *locals, PyObject *fromlist)
    .. index:: builtin: __import__
 …
    .. versionchanged:: 2.6
       The function is an alias for :cfunc:`PyImport_ImportModuleLevel` with
+      The function is an alias for :c:func:`PyImport_ImportModuleLevel` with
       -1 as level, meaning relative import.
 .. cfunction:: PyObject* PyImport_ImportModuleLevel(char *name, PyObject *globals, PyObject *locals, PyObject *fromlist, int level)
+.. c:function:: PyObject* PyImport_ImportModuleLevel(char *name, PyObject *globals, PyObject *locals, PyObject *fromlist, int level)
    Import a module.  This is best described by referring to the built-in Python
 …
 .. cfunction:: PyObject* PyImport_Import(PyObject *name)
+.. c:function:: PyObject* PyImport_Import(PyObject *name)
    .. index::
 …
 .. cfunction:: PyObject* PyImport_ReloadModule(PyObject *m)
+.. c:function:: PyObject* PyImport_ReloadModule(PyObject *m)
    .. index:: builtin: reload
 …
 .. cfunction:: PyObject* PyImport_AddModule(const char *name)
+.. c:function:: PyObject* PyImport_AddModule(const char *name)
    Return the module object corresponding to a module name.  The *name* argument
 …
       This function does not load or import the module; if the module wasn't already
       loaded, you will get an empty module object. Use :cfunc:`PyImport_ImportModule`
+      loaded, you will get an empty module object. Use :c:func:`PyImport_ImportModule`
       or one of its variants to import a module.  Package structures implied by a
       dotted name for *name* are not created if not already present.
 .. cfunction:: PyObject* PyImport_ExecCodeModule(char *name, PyObject *co)
+.. c:function:: PyObject* PyImport_ExecCodeModule(char *name, PyObject *co)
    .. index:: builtin: compile
 …
    module could still be created in error cases.  Starting with Python 2.4, *name*
    is removed from :attr:`sys.modules` in error cases, and even if *name* was already
    in :attr:`sys.modules` on entry to :cfunc:`PyImport_ExecCodeModule`.  Leaving
+   in :attr:`sys.modules` on entry to :c:func:`PyImport_ExecCodeModule`.  Leaving
    incompletely initialized modules in :attr:`sys.modules` is dangerous, as imports of
    such modules have no way to know that the module object is an unknown (and
    probably damaged with respect to the module author's intents) state.
+   The module's :attr:`__file__` attribute will be set to the code object's
+   :c:member:`co_filename`.
    This function will reload the module if it was already imported.  See
    :cfunc:`PyImport_ReloadModule` for the intended way to reload a module.
+   :c:func:`PyImport_ReloadModule` for the intended way to reload a module.
    If *name* points to a dotted name of the form ``package.module``, any package
 …
+.. cfunction:: long PyImport_GetMagicNumber()
+.. c:function:: PyObject* PyImport_ExecCodeModuleEx(char *name, PyObject *co, char *pathname)
+   Like :c:func:`PyImport_ExecCodeModule`, but the :attr:`__file__` attribute of
+   the module object is set to *pathname* if it is non-``NULL``.
+.. c:function:: long PyImport_GetMagicNumber()
    Return the magic number for Python bytecode files (a.k.a. :file:`.pyc` and
 …
 .. cfunction:: PyObject* PyImport_GetModuleDict()
+.. c:function:: PyObject* PyImport_GetModuleDict()
    Return the dictionary used for the module administration (a.k.a.
 …
 .. cfunction:: PyObject* PyImport_GetImporter(PyObject *path)
+.. c:function:: PyObject* PyImport_GetImporter(PyObject *path)
    Return an importer object for a :data:`sys.path`/:attr:`pkg.__path__` item
 …
 .. cfunction:: void _PyImport_Init()
+.. c:function:: void _PyImport_Init()
    Initialize the import mechanism.  For internal use only.
 .. cfunction:: void PyImport_Cleanup()
+.. c:function:: void PyImport_Cleanup()
    Empty the module table.  For internal use only.
 .. cfunction:: void _PyImport_Fini()
+.. c:function:: void _PyImport_Fini()
    Finalize the import mechanism.  For internal use only.
 .. cfunction:: PyObject* _PyImport_FindExtension(char *, char *)
+.. c:function:: PyObject* _PyImport_FindExtension(char *, char *)
    For internal use only.
 .. cfunction:: PyObject* _PyImport_FixupExtension(char *, char *)
+.. c:function:: PyObject* _PyImport_FixupExtension(char *, char *)
    For internal use only.
 .. cfunction:: int PyImport_ImportFrozenModule(char *name)
+.. c:function:: int PyImport_ImportFrozenModule(char *name)
    Load a frozen module named *name*.  Return ``1`` for success, ``0`` if the
    module is not found, and ``-1`` with an exception set if the initialization
    failed.  To access the imported module on a successful load, use
    :cfunc:`PyImport_ImportModule`.  (Note the misnomer --- this function would
+   :c:func:`PyImport_ImportModule`.  (Note the misnomer --- this function would
    reload the module if it was already imported.)
 .. ctype:: struct _frozen
+.. c:type:: struct _frozen
    .. index:: single: freeze utility
 …
 .. cvar:: struct _frozen* PyImport_FrozenModules
    This pointer is initialized to point to an array of :ctype:`struct _frozen`
+.. c:var:: struct _frozen* PyImport_FrozenModules
+   This pointer is initialized to point to an array of :c:type:`struct _frozen`
    records, terminated by one whose members are all *NULL* or zero.  When a frozen
    module is imported, it is searched in this table.  Third-party code could play
 …
 .. cfunction:: int PyImport_AppendInittab(char *name, void (*initfunc)(void))
+.. c:function:: int PyImport_AppendInittab(const char *name, void (*initfunc)(void))
    Add a single module to the existing table of built-in modules.  This is a
    convenience wrapper around :cfunc:`PyImport_ExtendInittab`, returning ``-1`` if
+   convenience wrapper around :c:func:`PyImport_ExtendInittab`, returning ``-1`` if
    the table could not be extended.  The new module can be imported by the name
    *name*, and uses the function *initfunc* as the initialization function called
    on the first attempted import.  This should be called before
    :cfunc:`Py_Initialize`.
 .. ctype:: struct _inittab
+   :c:func:`Py_Initialize`.
+.. c:type:: struct _inittab
    Structure describing a single entry in the list of built-in modules.  Each of
    these structures gives the name and initialization function for a module built
    into the interpreter.  Programs which embed Python may use an array of these
    structures in conjunction with :cfunc:`PyImport_ExtendInittab` to provide
+   structures in conjunction with :c:func:`PyImport_ExtendInittab` to provide
    additional built-in modules.  The structure is defined in
    :file:`Include/import.h` as::
 …
 .. cfunction:: int PyImport_ExtendInittab(struct _inittab *newtab)
+.. c:function:: int PyImport_ExtendInittab(struct _inittab *newtab)
    Add a collection of modules to the table of built-in modules.  The *newtab*
 …
    Returns ``0`` on success or ``-1`` if insufficient memory could be allocated to
    extend the internal table.  In the event of failure, no modules are added to the
    internal table.  This should be called before :cfunc:`Py_Initialize`.
+   internal table.  This should be called before :c:func:`Py_Initialize`.

python/vendor/current/Doc/c-api/index.rst

-              r2
+              r388
   Python/C API Reference Manual
 ##################################
-:Release: |version|
-:Date: |today|
 This manual documents the API used by C and C++ programmers who want to write

python/vendor/current/Doc/c-api/init.rst

-              r2
+              r388
+.. cfunction:: void Py_Initialize()
+Initializing and finalizing the interpreter
+===========================================
+.. c:function:: void Py_Initialize()
    .. index::
 …
       triple: module; search; path
       single: PySys_SetArgv()
+      single: PySys_SetArgvEx()
       single: Py_Finalize()
    Initialize the Python interpreter.  In an application embedding  Python, this
    should be called before using any other Python/C API functions; with the
    exception of :cfunc:`Py_SetProgramName`, :cfunc:`PyEval_InitThreads`,
    :cfunc:`PyEval_ReleaseLock`, and :cfunc:`PyEval_AcquireLock`. This initializes
+   exception of :c:func:`Py_SetProgramName`, :c:func:`Py_SetPythonHome`, :c:func:`PyEval_InitThreads`,
+   :c:func:`PyEval_ReleaseLock`, and :c:func:`PyEval_AcquireLock`. This initializes
    the table of loaded modules (``sys.modules``), and creates the fundamental
    modules :mod:`__builtin__`, :mod:`__main__` and :mod:`sys`.  It also initializes
    the module search path (``sys.path``). It does not set ``sys.argv``; use
    :cfunc:`PySys_SetArgv` for that.  This is a no-op when called for a second time
    (without calling :cfunc:`Py_Finalize` first).  There is no return value; it is a
+   :c:func:`PySys_SetArgvEx` for that.  This is a no-op when called for a second time
+   (without calling :c:func:`Py_Finalize` first).  There is no return value; it is a
    fatal error if the initialization fails.
 .. cfunction:: void Py_InitializeEx(int initsigs)
    This function works like :cfunc:`Py_Initialize` if *initsigs* is 1. If
+.. c:function:: void Py_InitializeEx(int initsigs)
+   This function works like :c:func:`Py_Initialize` if *initsigs* is 1. If
    *initsigs* is 0, it skips initialization registration of signal handlers, which
    might be useful when Python is embedded.
 …
 .. cfunction:: int Py_IsInitialized()
+.. c:function:: int Py_IsInitialized()
    Return true (nonzero) when the Python interpreter has been initialized, false
    (zero) if not.  After :cfunc:`Py_Finalize` is called, this returns false until
    :cfunc:`Py_Initialize` is called again.
 .. cfunction:: void Py_Finalize()
    Undo all initializations made by :cfunc:`Py_Initialize` and subsequent use of
+   (zero) if not.  After :c:func:`Py_Finalize` is called, this returns false until
+   :c:func:`Py_Initialize` is called again.
+.. c:function:: void Py_Finalize()
+   Undo all initializations made by :c:func:`Py_Initialize` and subsequent use of
    Python/C API functions, and destroy all sub-interpreters (see
    :cfunc:`Py_NewInterpreter` below) that were created and not yet destroyed since
    the last call to :cfunc:`Py_Initialize`.  Ideally, this frees all memory
+   :c:func:`Py_NewInterpreter` below) that were created and not yet destroyed since
+   the last call to :c:func:`Py_Initialize`.  Ideally, this frees all memory
    allocated by the Python interpreter.  This is a no-op when called for a second
    time (without calling :cfunc:`Py_Initialize` again first).  There is no return
+   time (without calling :c:func:`Py_Initialize` again first).  There is no return
    value; errors during finalization are ignored.
 …
    freed.  Some memory allocated by extension modules may not be freed.  Some
    extensions may not work properly if their initialization routine is called more
+   than once; this can happen if an application calls :cfunc:`Py_Initialize` and
+   :cfunc:`Py_Finalize` more than once.
+.. cfunction:: PyThreadState* Py_NewInterpreter()
+   than once; this can happen if an application calls :c:func:`Py_Initialize` and
+   :c:func:`Py_Finalize` more than once.
+Process-wide parameters
+=======================
+.. c:function:: void Py_SetProgramName(char *name)
    .. index::
+      module: __builtin__
+      single: Py_Initialize()
+      single: main()
+      single: Py_GetPath()
+   This function should be called before :c:func:`Py_Initialize` is called for
+   the first time, if it is called at all.  It tells the interpreter the value
+   of the ``argv[0]`` argument to the :c:func:`main` function of the program.
+   This is used by :c:func:`Py_GetPath` and some other functions below to find
+   the Python run-time libraries relative to the interpreter executable.  The
+   default value is ``'python'``.  The argument should point to a
+   zero-terminated character string in static storage whose contents will not
+   change for the duration of the program's execution.  No code in the Python
+   interpreter will change the contents of this storage.
+.. c:function:: char* Py_GetProgramName()
+   .. index:: single: Py_SetProgramName()
+   Return the program name set with :c:func:`Py_SetProgramName`, or the default.
+   The returned string points into static storage; the caller should not modify its
+   value.
+.. c:function:: char* Py_GetPrefix()
+   Return the *prefix* for installed platform-independent files. This is derived
+   through a number of complicated rules from the program name set with
+   :c:func:`Py_SetProgramName` and some environment variables; for example, if the
+   program name is ``'/usr/local/bin/python'``, the prefix is ``'/usr/local'``. The
+   returned string points into static storage; the caller should not modify its
+   value.  This corresponds to the :makevar:`prefix` variable in the top-level
+   :file:`Makefile` and the ``--prefix`` argument to the :program:`configure`
+   script at build time.  The value is available to Python code as ``sys.prefix``.
+   It is only useful on Unix.  See also the next function.
+.. c:function:: char* Py_GetExecPrefix()
+   Return the *exec-prefix* for installed platform-*dependent* files.  This is
+   derived through a number of complicated rules from the program name set with
+   :c:func:`Py_SetProgramName` and some environment variables; for example, if the
+   program name is ``'/usr/local/bin/python'``, the exec-prefix is
+   ``'/usr/local'``.  The returned string points into static storage; the caller
+   should not modify its value.  This corresponds to the :makevar:`exec_prefix`
+   variable in the top-level :file:`Makefile` and the ``--exec-prefix``
+   argument to the :program:`configure` script at build  time.  The value is
+   available to Python code as ``sys.exec_prefix``.  It is only useful on Unix.
+   Background: The exec-prefix differs from the prefix when platform dependent
+   files (such as executables and shared libraries) are installed in a different
+   directory tree.  In a typical installation, platform dependent files may be
+   installed in the :file:`/usr/local/plat` subtree while platform independent may
+   be installed in :file:`/usr/local`.
+   Generally speaking, a platform is a combination of hardware and software
+   families, e.g.  Sparc machines running the Solaris 2.x operating system are
+   considered the same platform, but Intel machines running Solaris 2.x are another
+   platform, and Intel machines running Linux are yet another platform.  Different
+   major revisions of the same operating system generally also form different
+   platforms.  Non-Unix operating systems are a different story; the installation
+   strategies on those systems are so different that the prefix and exec-prefix are
+   meaningless, and set to the empty string. Note that compiled Python bytecode
+   files are platform independent (but not independent from the Python version by
+   which they were compiled!).
+   System administrators will know how to configure the :program:`mount` or
+   :program:`automount` programs to share :file:`/usr/local` between platforms
+   while having :file:`/usr/local/plat` be a different filesystem for each
+   platform.
+.. c:function:: char* Py_GetProgramFullPath()
+   .. index::
+      single: Py_SetProgramName()
+      single: executable (in module sys)
+   Return the full program name of the Python executable; this is  computed as a
+   side-effect of deriving the default module search path  from the program name
+   (set by :c:func:`Py_SetProgramName` above). The returned string points into
+   static storage; the caller should not modify its value.  The value is available
+   to Python code as ``sys.executable``.
+.. c:function:: char* Py_GetPath()
+   .. index::
+      triple: module; search; path
+      single: path (in module sys)
+   Return the default module search path; this is computed from the program name
+   (set by :c:func:`Py_SetProgramName` above) and some environment variables.
+   The returned string consists of a series of directory names separated by a
+   platform dependent delimiter character.  The delimiter character is ``':'``
+   on Unix and Mac OS X, ``';'`` on Windows.  The returned string points into
+   static storage; the caller should not modify its value.  The list
+   :data:`sys.path` is initialized with this value on interpreter startup; it
+   can be (and usually is) modified later to change the search path for loading
+   modules.
+   .. XXX should give the exact rules
+.. c:function:: const char* Py_GetVersion()
+   Return the version of this Python interpreter.  This is a string that looks
+   something like ::
+      "1.5 (#67, Dec 31 1997, 22:34:28) [GCC 2.7.2.2]"
+   .. index:: single: version (in module sys)
+   The first word (up to the first space character) is the current Python version;
+   the first three characters are the major and minor version separated by a
+   period.  The returned string points into static storage; the caller should not
+   modify its value.  The value is available to Python code as ``sys.version``.
+.. c:function:: const char* Py_GetPlatform()
+   .. index:: single: platform (in module sys)
+   Return the platform identifier for the current platform.  On Unix, this is
+   formed from the "official" name of the operating system, converted to lower
+   case, followed by the major revision number; e.g., for Solaris 2.x, which is
+   also known as SunOS 5.x, the value is ``'sunos5'``.  On Mac OS X, it is
+   ``'darwin'``.  On Windows, it is ``'win'``.  The returned string points into
+   static storage; the caller should not modify its value.  The value is available
+   to Python code as ``sys.platform``.
+.. c:function:: const char* Py_GetCopyright()
+   Return the official copyright string for the current Python version, for example
+   ``'Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam'``
+   .. index:: single: copyright (in module sys)
+   The returned string points into static storage; the caller should not modify its
+   value.  The value is available to Python code as ``sys.copyright``.
+.. c:function:: const char* Py_GetCompiler()
+   Return an indication of the compiler used to build the current Python version,
+   in square brackets, for example::
+      "[GCC 2.7.2.2]"
+   .. index:: single: version (in module sys)
+   The returned string points into static storage; the caller should not modify its
+   value.  The value is available to Python code as part of the variable
+   ``sys.version``.
+.. c:function:: const char* Py_GetBuildInfo()
+   Return information about the sequence number and build date and time  of the
+   current Python interpreter instance, for example ::
+      "#67, Aug  1 1997, 22:34:28"
+   .. index:: single: version (in module sys)
+   The returned string points into static storage; the caller should not modify its
+   value.  The value is available to Python code as part of the variable
+   ``sys.version``.
+.. c:function:: void PySys_SetArgvEx(int argc, char **argv, int updatepath)
+   .. index::
+      single: main()
+      single: Py_FatalError()
+      single: argv (in module sys)
+   Set :data:`sys.argv` based on *argc* and *argv*.  These parameters are
+   similar to those passed to the program's :c:func:`main` function with the
+   difference that the first entry should refer to the script file to be
+   executed rather than the executable hosting the Python interpreter.  If there
+   isn't a script that will be run, the first entry in *argv* can be an empty
+   string.  If this function fails to initialize :data:`sys.argv`, a fatal
+   condition is signalled using :c:func:`Py_FatalError`.
+   If *updatepath* is zero, this is all the function does.  If *updatepath*
+   is non-zero, the function also modifies :data:`sys.path` according to the
+   following algorithm:
+   - If the name of an existing script is passed in ``argv[0]``, the absolute
+     path of the directory where the script is located is prepended to
+     :data:`sys.path`.
+   - Otherwise (that is, if *argc* is 0 or ``argv[0]`` doesn't point
+     to an existing file name), an empty string is prepended to
+     :data:`sys.path`, which is the same as prepending the current working
+     directory (``"."``).
+   .. note::
+      It is recommended that applications embedding the Python interpreter
+      for purposes other than executing a single script pass 0 as *updatepath*,
+      and update :data:`sys.path` themselves if desired.
+      See `CVE-2008-5983 <http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2008-5983>`_.
+      On versions before 2.6.6, you can achieve the same effect by manually
+      popping the first :data:`sys.path` element after having called
+      :c:func:`PySys_SetArgv`, for example using::
+         PyRun_SimpleString("import sys; sys.path.pop(0)\n");
+   .. versionadded:: 2.6.6
+   .. XXX impl. doesn't seem consistent in allowing 0/NULL for the params;
+      check w/ Guido.
+.. c:function:: void PySys_SetArgv(int argc, char **argv)
+   This function works like :c:func:`PySys_SetArgvEx` with *updatepath* set to 1.
+.. c:function:: void Py_SetPythonHome(char *home)
+   Set the default "home" directory, that is, the location of the standard
+   Python libraries.  See :envvar:`PYTHONHOME` for the meaning of the
+   argument string.
+   The argument should point to a zero-terminated character string in static
+   storage whose contents will not change for the duration of the program's
+   execution.  No code in the Python interpreter will change the contents of
+   this storage.
+.. c:function:: char* Py_GetPythonHome()
+   Return the default "home", that is, the value set by a previous call to
+   :c:func:`Py_SetPythonHome`, or the value of the :envvar:`PYTHONHOME`
+   environment variable if it is set.
+.. _threads:
+Thread State and the Global Interpreter Lock
+============================================
+.. index::
+   single: GIL
+   single: global interpreter lock
+   single: interpreter lock
+   single: lock, interpreter
+The Python interpreter is not fully thread-safe.  In order to support
+multi-threaded Python programs, there's a global lock, called the :term:`global
+interpreter lock` or :term:`GIL`, that must be held by the current thread before
+it can safely access Python objects. Without the lock, even the simplest
+operations could cause problems in a multi-threaded program: for example, when
+two threads simultaneously increment the reference count of the same object, the
+reference count could end up being incremented only once instead of twice.
+.. index:: single: setcheckinterval() (in module sys)
+Therefore, the rule exists that only the thread that has acquired the
+:term:`GIL` may operate on Python objects or call Python/C API functions.
+In order to emulate concurrency of execution, the interpreter regularly
+tries to switch threads (see :func:`sys.setcheckinterval`).  The lock is also
+released around potentially blocking I/O operations like reading or writing
+a file, so that other Python threads can run in the meantime.
+.. index::
+   single: PyThreadState
+   single: PyThreadState
+The Python interpreter keeps some thread-specific bookkeeping information
+inside a data structure called :c:type:`PyThreadState`.  There's also one
+global variable pointing to the current :c:type:`PyThreadState`: it can
+be retrieved using :c:func:`PyThreadState_Get`.
+Releasing the GIL from extension code
+-------------------------------------
+Most extension code manipulating the :term:`GIL` has the following simple
+structure::
+   Save the thread state in a local variable.
+   Release the global interpreter lock.
+   ... Do some blocking I/O operation ...
+   Reacquire the global interpreter lock.
+   Restore the thread state from the local variable.
+This is so common that a pair of macros exists to simplify it::
+   Py_BEGIN_ALLOW_THREADS
+   ... Do some blocking I/O operation ...
+   Py_END_ALLOW_THREADS
+.. index::
+   single: Py_BEGIN_ALLOW_THREADS
+   single: Py_END_ALLOW_THREADS
+The :c:macro:`Py_BEGIN_ALLOW_THREADS` macro opens a new block and declares a
+hidden local variable; the :c:macro:`Py_END_ALLOW_THREADS` macro closes the
+block.  These two macros are still available when Python is compiled without
+thread support (they simply have an empty expansion).
+When thread support is enabled, the block above expands to the following code::
+   PyThreadState *_save;
+   _save = PyEval_SaveThread();
+   ...Do some blocking I/O operation...
+   PyEval_RestoreThread(_save);
+.. index::
+   single: PyEval_RestoreThread()
+   single: PyEval_SaveThread()
+Here is how these functions work: the global interpreter lock is used to protect the pointer to the
+current thread state.  When releasing the lock and saving the thread state,
+the current thread state pointer must be retrieved before the lock is released
+(since another thread could immediately acquire the lock and store its own thread
+state in the global variable). Conversely, when acquiring the lock and restoring
+the thread state, the lock must be acquired before storing the thread state
+pointer.
+.. note::
+   Calling system I/O functions is the most common use case for releasing
+   the GIL, but it can also be useful before calling long-running computations
+   which don't need access to Python objects, such as compression or
+   cryptographic functions operating over memory buffers.  For example, the
+   standard :mod:`zlib` and :mod:`hashlib` modules release the GIL when
+   compressing or hashing data.
+.. _gilstate:
+Non-Python created threads
+--------------------------
+When threads are created using the dedicated Python APIs (such as the
+:mod:`threading` module), a thread state is automatically associated to them
+and the code showed above is therefore correct.  However, when threads are
+created from C (for example by a third-party library with its own thread
+management), they don't hold the GIL, nor is there a thread state structure
+for them.
+If you need to call Python code from these threads (often this will be part
+of a callback API provided by the aforementioned third-party library),
+you must first register these threads with the interpreter by
+creating a thread state data structure, then acquiring the GIL, and finally
+storing their thread state pointer, before you can start using the Python/C
+API.  When you are done, you should reset the thread state pointer, release
+the GIL, and finally free the thread state data structure.
+The :c:func:`PyGILState_Ensure` and :c:func:`PyGILState_Release` functions do
+all of the above automatically.  The typical idiom for calling into Python
+from a C thread is::
+   PyGILState_STATE gstate;
+   gstate = PyGILState_Ensure();
+   /* Perform Python actions here. */
+   result = CallSomeFunction();
+   /* evaluate result or handle exception */
+   /* Release the thread. No Python API allowed beyond this point. */
+   PyGILState_Release(gstate);
+Note that the :c:func:`PyGILState_\*` functions assume there is only one global
+interpreter (created automatically by :c:func:`Py_Initialize`).  Python
+supports the creation of additional interpreters (using
+:c:func:`Py_NewInterpreter`), but mixing multiple interpreters and the
+:c:func:`PyGILState_\*` API is unsupported.
+Another important thing to note about threads is their behaviour in the face
+of the C :c:func:`fork` call. On most systems with :c:func:`fork`, after a
+process forks only the thread that issued the fork will exist. That also
+means any locks held by other threads will never be released. Python solves
+this for :func:`os.fork` by acquiring the locks it uses internally before
+the fork, and releasing them afterwards. In addition, it resets any
+:ref:`lock-objects` in the child. When extending or embedding Python, there
+is no way to inform Python of additional (non-Python) locks that need to be
+acquired before or reset after a fork. OS facilities such as
+:c:func:`pthread_atfork` would need to be used to accomplish the same thing.
+Additionally, when extending or embedding Python, calling :c:func:`fork`
+directly rather than through :func:`os.fork` (and returning to or calling
+into Python) may result in a deadlock by one of Python's internal locks
+being held by a thread that is defunct after the fork.
+:c:func:`PyOS_AfterFork` tries to reset the necessary locks, but is not
+always able to.
+High-level API
+--------------
+These are the most commonly used types and functions when writing C extension
+code, or when embedding the Python interpreter:
+.. c:type:: PyInterpreterState
+   This data structure represents the state shared by a number of cooperating
+   threads.  Threads belonging to the same interpreter share their module
+   administration and a few other internal items. There are no public members in
+   this structure.
+   Threads belonging to different interpreters initially share nothing, except
+   process state like available memory, open file descriptors and such.  The global
+   interpreter lock is also shared by all threads, regardless of to which
+   interpreter they belong.
+.. c:type:: PyThreadState
+   This data structure represents the state of a single thread.  The only public
+   data member is :c:type:`PyInterpreterState \*`:attr:`interp`, which points to
+   this thread's interpreter state.
+.. c:function:: void PyEval_InitThreads()
+   .. index::
+      single: PyEval_ReleaseLock()
+      single: PyEval_ReleaseThread()
+      single: PyEval_SaveThread()
+      single: PyEval_RestoreThread()
+   Initialize and acquire the global interpreter lock.  It should be called in the
+   main thread before creating a second thread or engaging in any other thread
+   operations such as :c:func:`PyEval_ReleaseLock` or
+   ``PyEval_ReleaseThread(tstate)``. It is not needed before calling
+   :c:func:`PyEval_SaveThread` or :c:func:`PyEval_RestoreThread`.
+   .. index:: single: Py_Initialize()
+   This is a no-op when called for a second time.  It is safe to call this function
+   before calling :c:func:`Py_Initialize`.
+   .. index:: module: thread
+   .. note::
+      When only the main thread exists, no GIL operations are needed. This is a
+      common situation (most Python programs do not use threads), and the lock
+      operations slow the interpreter down a bit. Therefore, the lock is not
+      created initially.  This situation is equivalent to having acquired the lock:
+      when there is only a single thread, all object accesses are safe.  Therefore,
+      when this function initializes the global interpreter lock, it also acquires
+      it.  Before the Python :mod:`_thread` module creates a new thread, knowing
+      that either it has the lock or the lock hasn't been created yet, it calls
+      :c:func:`PyEval_InitThreads`.  When this call returns, it is guaranteed that
+      the lock has been created and that the calling thread has acquired it.
+      It is **not** safe to call this function when it is unknown which thread (if
+      any) currently has the global interpreter lock.
+      This function is not available when thread support is disabled at compile time.
+.. c:function:: int PyEval_ThreadsInitialized()
+   Returns a non-zero value if :c:func:`PyEval_InitThreads` has been called.  This
+   function can be called without holding the GIL, and therefore can be used to
+   avoid calls to the locking API when running single-threaded.  This function is
+   not available when thread support is disabled at compile time.
+   .. versionadded:: 2.4
+.. c:function:: PyThreadState* PyEval_SaveThread()
+   Release the global interpreter lock (if it has been created and thread
+   support is enabled) and reset the thread state to *NULL*, returning the
+   previous thread state (which is not *NULL*).  If the lock has been created,
+   the current thread must have acquired it.  (This function is available even
+   when thread support is disabled at compile time.)
+.. c:function:: void PyEval_RestoreThread(PyThreadState *tstate)
+   Acquire the global interpreter lock (if it has been created and thread
+   support is enabled) and set the thread state to *tstate*, which must not be
+   *NULL*.  If the lock has been created, the current thread must not have
+   acquired it, otherwise deadlock ensues.  (This function is available even
+   when thread support is disabled at compile time.)
+.. c:function:: PyThreadState* PyThreadState_Get()
+   Return the current thread state.  The global interpreter lock must be held.
+   When the current thread state is *NULL*, this issues a fatal error (so that
+   the caller needn't check for *NULL*).
+.. c:function:: PyThreadState* PyThreadState_Swap(PyThreadState *tstate)
+   Swap the current thread state with the thread state given by the argument
+   *tstate*, which may be *NULL*.  The global interpreter lock must be held
+   and is not released.
+.. c:function:: void PyEval_ReInitThreads()
+   This function is called from :c:func:`PyOS_AfterFork` to ensure that newly
+   created child processes don't hold locks referring to threads which
+   are not running in the child process.
+The following functions use thread-local storage, and are not compatible
+with sub-interpreters:
+.. c:function:: PyGILState_STATE PyGILState_Ensure()
+   Ensure that the current thread is ready to call the Python C API regardless
+   of the current state of Python, or of the global interpreter lock. This may
+   be called as many times as desired by a thread as long as each call is
+   matched with a call to :c:func:`PyGILState_Release`. In general, other
+   thread-related APIs may be used between :c:func:`PyGILState_Ensure` and
+   :c:func:`PyGILState_Release` calls as long as the thread state is restored to
+   its previous state before the Release().  For example, normal usage of the
+   :c:macro:`Py_BEGIN_ALLOW_THREADS` and :c:macro:`Py_END_ALLOW_THREADS` macros is
+   acceptable.
+   The return value is an opaque "handle" to the thread state when
+   :c:func:`PyGILState_Ensure` was called, and must be passed to
+   :c:func:`PyGILState_Release` to ensure Python is left in the same state. Even
+   though recursive calls are allowed, these handles *cannot* be shared - each
+   unique call to :c:func:`PyGILState_Ensure` must save the handle for its call
+   to :c:func:`PyGILState_Release`.
+   When the function returns, the current thread will hold the GIL and be able
+   to call arbitrary Python code.  Failure is a fatal error.
+   .. versionadded:: 2.3
+.. c:function:: void PyGILState_Release(PyGILState_STATE)
+   Release any resources previously acquired.  After this call, Python's state will
+   be the same as it was prior to the corresponding :c:func:`PyGILState_Ensure` call
+   (but generally this state will be unknown to the caller, hence the use of the
+   GILState API).
+   Every call to :c:func:`PyGILState_Ensure` must be matched by a call to
+   :c:func:`PyGILState_Release` on the same thread.
+   .. versionadded:: 2.3
+.. c:function:: PyThreadState PyGILState_GetThisThreadState()
+   Get the current thread state for this thread.  May return ``NULL`` if no
+   GILState API has been used on the current thread.  Note that the main thread
+   always has such a thread-state, even if no auto-thread-state call has been
+   made on the main thread.  This is mainly a helper/diagnostic function.
+   .. versionadded:: 2.3
+The following macros are normally used without a trailing semicolon; look for
+example usage in the Python source distribution.
+.. c:macro:: Py_BEGIN_ALLOW_THREADS
+   This macro expands to ``{ PyThreadState *_save; _save = PyEval_SaveThread();``.
+   Note that it contains an opening brace; it must be matched with a following
+   :c:macro:`Py_END_ALLOW_THREADS` macro.  See above for further discussion of this
+   macro.  It is a no-op when thread support is disabled at compile time.
+.. c:macro:: Py_END_ALLOW_THREADS
+   This macro expands to ``PyEval_RestoreThread(_save); }``. Note that it contains
+   a closing brace; it must be matched with an earlier
+   :c:macro:`Py_BEGIN_ALLOW_THREADS` macro.  See above for further discussion of
+   this macro.  It is a no-op when thread support is disabled at compile time.
+.. c:macro:: Py_BLOCK_THREADS
+   This macro expands to ``PyEval_RestoreThread(_save);``: it is equivalent to
+   :c:macro:`Py_END_ALLOW_THREADS` without the closing brace.  It is a no-op when
+   thread support is disabled at compile time.
+.. c:macro:: Py_UNBLOCK_THREADS
+   This macro expands to ``_save = PyEval_SaveThread();``: it is equivalent to
+   :c:macro:`Py_BEGIN_ALLOW_THREADS` without the opening brace and variable
+   declaration.  It is a no-op when thread support is disabled at compile time.
+Low-level API
+-------------
+All of the following functions are only available when thread support is enabled
+at compile time, and must be called only when the global interpreter lock has
+been created.
+.. c:function:: PyInterpreterState* PyInterpreterState_New()
+   Create a new interpreter state object.  The global interpreter lock need not
+   be held, but may be held if it is necessary to serialize calls to this
+   function.
+.. c:function:: void PyInterpreterState_Clear(PyInterpreterState *interp)
+   Reset all information in an interpreter state object.  The global interpreter
+   lock must be held.
+.. c:function:: void PyInterpreterState_Delete(PyInterpreterState *interp)
+   Destroy an interpreter state object.  The global interpreter lock need not be
+   held.  The interpreter state must have been reset with a previous call to
+   :c:func:`PyInterpreterState_Clear`.
+.. c:function:: PyThreadState* PyThreadState_New(PyInterpreterState *interp)
+   Create a new thread state object belonging to the given interpreter object.
+   The global interpreter lock need not be held, but may be held if it is
+   necessary to serialize calls to this function.
+.. c:function:: void PyThreadState_Clear(PyThreadState *tstate)
+   Reset all information in a thread state object.  The global interpreter lock
+   must be held.
+.. c:function:: void PyThreadState_Delete(PyThreadState *tstate)
+   Destroy a thread state object.  The global interpreter lock need not be held.
+   The thread state must have been reset with a previous call to
+   :c:func:`PyThreadState_Clear`.
+.. c:function:: PyObject* PyThreadState_GetDict()
+   Return a dictionary in which extensions can store thread-specific state
+   information.  Each extension should use a unique key to use to store state in
+   the dictionary.  It is okay to call this function when no current thread state
+   is available. If this function returns *NULL*, no exception has been raised and
+   the caller should assume no current thread state is available.
+   .. versionchanged:: 2.3
+      Previously this could only be called when a current thread is active, and *NULL*
+      meant that an exception was raised.
+.. c:function:: int PyThreadState_SetAsyncExc(long id, PyObject *exc)
+   Asynchronously raise an exception in a thread. The *id* argument is the thread
+   id of the target thread; *exc* is the exception object to be raised. This
+   function does not steal any references to *exc*. To prevent naive misuse, you
+   must write your own C extension to call this.  Must be called with the GIL held.
+   Returns the number of thread states modified; this is normally one, but will be
+   zero if the thread id isn't found.  If *exc* is :const:`NULL`, the pending
+   exception (if any) for the thread is cleared. This raises no exceptions.
+   .. versionadded:: 2.3
+.. c:function:: void PyEval_AcquireThread(PyThreadState *tstate)
+   Acquire the global interpreter lock and set the current thread state to
+   *tstate*, which should not be *NULL*.  The lock must have been created earlier.
+   If this thread already has the lock, deadlock ensues.
+   :c:func:`PyEval_RestoreThread` is a higher-level function which is always
+   available (even when thread support isn't enabled or when threads have
+   not been initialized).
+.. c:function:: void PyEval_ReleaseThread(PyThreadState *tstate)
+   Reset the current thread state to *NULL* and release the global interpreter
+   lock.  The lock must have been created earlier and must be held by the current
+   thread.  The *tstate* argument, which must not be *NULL*, is only used to check
+   that it represents the current thread state --- if it isn't, a fatal error is
+   reported.
+   :c:func:`PyEval_SaveThread` is a higher-level function which is always
+   available (even when thread support isn't enabled or when threads have
+   not been initialized).
+.. c:function:: void PyEval_AcquireLock()
+   Acquire the global interpreter lock.  The lock must have been created earlier.
+   If this thread already has the lock, a deadlock ensues.
+   .. warning::
+      This function does not change the current thread state.  Please use
+      :c:func:`PyEval_RestoreThread` or :c:func:`PyEval_AcquireThread`
+      instead.
+.. c:function:: void PyEval_ReleaseLock()
+   Release the global interpreter lock.  The lock must have been created earlier.
+   .. warning::
+      This function does not change the current thread state.  Please use
+      :c:func:`PyEval_SaveThread` or :c:func:`PyEval_ReleaseThread`
+      instead.
+Sub-interpreter support
+=======================
+While in most uses, you will only embed a single Python interpreter, there
+are cases where you need to create several independent interpreters in the
+same process and perhaps even in the same thread.  Sub-interpreters allow
+you to do that.  You can switch between sub-interpreters using the
+:c:func:`PyThreadState_Swap` function.  You can create and destroy them
+using the following functions:
+.. c:function:: PyThreadState* Py_NewInterpreter()
+   .. index::
+      module: builtins
       module: __main__
       module: sys
 …
    for the execution of Python code.  In particular, the new interpreter has
    separate, independent versions of all imported modules, including the
    fundamental modules :mod:`__builtin__`, :mod:`__main__` and :mod:`sys`.  The
+   fundamental modules :mod:`builtins`, :mod:`__main__` and :mod:`sys`.  The
    table of loaded modules (``sys.modules``) and the module search path
    (``sys.path``) are also separate.  The new environment has no ``sys.argv``
    variable.  It has new standard I/O stream file objects ``sys.stdin``,
    ``sys.stdout`` and ``sys.stderr`` (however these refer to the same underlying
    :ctype:`FILE` structures in the C library).
+   file descriptors).
    The return value points to the first thread state created in the new
 …
    not called.  Note that this is different from what happens when an extension is
    imported after the interpreter has been completely re-initialized by calling
    :cfunc:`Py_Finalize` and :cfunc:`Py_Initialize`; in that case, the extension's
+   :c:func:`Py_Finalize` and :c:func:`Py_Initialize`; in that case, the extension's
    ``initmodule`` function *is* called again.
    .. index:: single: close() (in module os)
+   **Bugs and caveats:** Because sub-interpreters (and the main interpreter) are
+   part of the same process, the insulation between them isn't perfect --- for
+   example, using low-level file operations like  :func:`os.close` they can
+   (accidentally or maliciously) affect each other's open files.  Because of the
+   way extensions are shared between (sub-)interpreters, some extensions may not
+   work properly; this is especially likely when the extension makes use of
+   (static) global variables, or when the extension manipulates its module's
+   dictionary after its initialization.  It is possible to insert objects created
+   in one sub-interpreter into a namespace of another sub-interpreter; this should
+   be done with great care to avoid sharing user-defined functions, methods,
+   instances or classes between sub-interpreters, since import operations executed
+   by such objects may affect the wrong (sub-)interpreter's dictionary of loaded
+   modules.  (XXX This is a hard-to-fix bug that will be addressed in a future
+   release.)
+   Also note that the use of this functionality is incompatible with extension
+   modules such as PyObjC and ctypes that use the :cfunc:`PyGILState_\*` APIs (and
+   this is inherent in the way the :cfunc:`PyGILState_\*` functions work).  Simple
+   things may work, but confusing behavior will always be near.
+.. cfunction:: void Py_EndInterpreter(PyThreadState *tstate)
+.. c:function:: void Py_EndInterpreter(PyThreadState *tstate)
    .. index:: single: Py_Finalize()
 …
    thread states associated with this interpreter are destroyed.  (The global
    interpreter lock must be held before calling this function and is still held
    when it returns.)  :cfunc:`Py_Finalize` will destroy all sub-interpreters that
+   when it returns.)  :c:func:`Py_Finalize` will destroy all sub-interpreters that
    haven't been explicitly destroyed at that point.
+.. cfunction:: void Py_SetProgramName(char *name)
+   .. index::
+      single: Py_Initialize()
+      single: main()
+      single: Py_GetPath()
+   This function should be called before :cfunc:`Py_Initialize` is called for
+   the first time, if it is called at all.  It tells the interpreter the value
+   of the ``argv[0]`` argument to the :cfunc:`main` function of the program.
+   This is used by :cfunc:`Py_GetPath` and some other functions below to find
+   the Python run-time libraries relative to the interpreter executable.  The
+   default value is ``'python'``.  The argument should point to a
+   zero-terminated character string in static storage whose contents will not
+   change for the duration of the program's execution.  No code in the Python
+   interpreter will change the contents of this storage.
+.. cfunction:: char* Py_GetProgramName()
+   .. index:: single: Py_SetProgramName()
+   Return the program name set with :cfunc:`Py_SetProgramName`, or the default.
+   The returned string points into static storage; the caller should not modify its
+   value.
+.. cfunction:: char* Py_GetPrefix()
+   Return the *prefix* for installed platform-independent files. This is derived
+   through a number of complicated rules from the program name set with
+   :cfunc:`Py_SetProgramName` and some environment variables; for example, if the
+   program name is ``'/usr/local/bin/python'``, the prefix is ``'/usr/local'``. The
+   returned string points into static storage; the caller should not modify its
+   value.  This corresponds to the :makevar:`prefix` variable in the top-level
+   :file:`Makefile` and the :option:`--prefix` argument to the :program:`configure`
+   script at build time.  The value is available to Python code as ``sys.prefix``.
+   It is only useful on Unix.  See also the next function.
+.. cfunction:: char* Py_GetExecPrefix()
+   Return the *exec-prefix* for installed platform-*dependent* files.  This is
+   derived through a number of complicated rules from the program name set with
+   :cfunc:`Py_SetProgramName` and some environment variables; for example, if the
+   program name is ``'/usr/local/bin/python'``, the exec-prefix is
+   ``'/usr/local'``.  The returned string points into static storage; the caller
+   should not modify its value.  This corresponds to the :makevar:`exec_prefix`
+   variable in the top-level :file:`Makefile` and the :option:`--exec-prefix`
+   argument to the :program:`configure` script at build  time.  The value is
+   available to Python code as ``sys.exec_prefix``.  It is only useful on Unix.
+   Background: The exec-prefix differs from the prefix when platform dependent
+   files (such as executables and shared libraries) are installed in a different
+   directory tree.  In a typical installation, platform dependent files may be
+   installed in the :file:`/usr/local/plat` subtree while platform independent may
+   be installed in :file:`/usr/local`.
+   Generally speaking, a platform is a combination of hardware and software
+   families, e.g.  Sparc machines running the Solaris 2.x operating system are
+   considered the same platform, but Intel machines running Solaris 2.x are another
+   platform, and Intel machines running Linux are yet another platform.  Different
+   major revisions of the same operating system generally also form different
+   platforms.  Non-Unix operating systems are a different story; the installation
+   strategies on those systems are so different that the prefix and exec-prefix are
+   meaningless, and set to the empty string. Note that compiled Python bytecode
+   files are platform independent (but not independent from the Python version by
+   which they were compiled!).
+   System administrators will know how to configure the :program:`mount` or
+   :program:`automount` programs to share :file:`/usr/local` between platforms
+   while having :file:`/usr/local/plat` be a different filesystem for each
+   platform.
+.. cfunction:: char* Py_GetProgramFullPath()
+   .. index::
+      single: Py_SetProgramName()
+      single: executable (in module sys)
+   Return the full program name of the Python executable; this is  computed as a
+   side-effect of deriving the default module search path  from the program name
+   (set by :cfunc:`Py_SetProgramName` above). The returned string points into
+   static storage; the caller should not modify its value.  The value is available
+   to Python code as ``sys.executable``.
+.. cfunction:: char* Py_GetPath()
+   .. index::
+      triple: module; search; path
+      single: path (in module sys)
+   Return the default module search path; this is computed from the  program name
+   (set by :cfunc:`Py_SetProgramName` above) and some environment variables.  The
+   returned string consists of a series of directory names separated by a platform
+   dependent delimiter character.  The delimiter character is ``':'`` on Unix and
+   Mac OS X, ``';'`` on Windows.  The returned string points into static storage;
+   the caller should not modify its value.  The value is available to Python code
+   as the list ``sys.path``, which may be modified to change the future search path
+   for loaded modules.
+   .. XXX should give the exact rules
+.. cfunction:: const char* Py_GetVersion()
+   Return the version of this Python interpreter.  This is a string that looks
+   something like ::
+      "1.5 (#67, Dec 31 1997, 22:34:28) [GCC 2.7.2.2]"
+   .. index:: single: version (in module sys)
+   The first word (up to the first space character) is the current Python version;
+   the first three characters are the major and minor version separated by a
+   period.  The returned string points into static storage; the caller should not
+   modify its value.  The value is available to Python code as ``sys.version``.
+.. cfunction:: const char* Py_GetBuildNumber()
+   Return a string representing the Subversion revision that this Python executable
+   was built from.  This number is a string because it may contain a trailing 'M'
+   if Python was built from a mixed revision source tree.
+   .. versionadded:: 2.5
+.. cfunction:: const char* Py_GetPlatform()
+   .. index:: single: platform (in module sys)
+   Return the platform identifier for the current platform.  On Unix, this is
+   formed from the "official" name of the operating system, converted to lower
+   case, followed by the major revision number; e.g., for Solaris 2.x, which is
+   also known as SunOS 5.x, the value is ``'sunos5'``.  On Mac OS X, it is
+   ``'darwin'``.  On Windows, it is ``'win'``.  The returned string points into
+   static storage; the caller should not modify its value.  The value is available
+   to Python code as ``sys.platform``.
+.. cfunction:: const char* Py_GetCopyright()
+   Return the official copyright string for the current Python version, for example
+   ``'Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam'``
+   .. index:: single: copyright (in module sys)
+   The returned string points into static storage; the caller should not modify its
+   value.  The value is available to Python code as ``sys.copyright``.
+.. cfunction:: const char* Py_GetCompiler()
+   Return an indication of the compiler used to build the current Python version,
+   in square brackets, for example::
+      "[GCC 2.7.2.2]"
+   .. index:: single: version (in module sys)
+   The returned string points into static storage; the caller should not modify its
+   value.  The value is available to Python code as part of the variable
+   ``sys.version``.
+.. cfunction:: const char* Py_GetBuildInfo()
+   Return information about the sequence number and build date and time  of the
+   current Python interpreter instance, for example ::
+      "#67, Aug  1 1997, 22:34:28"
+   .. index:: single: version (in module sys)
+   The returned string points into static storage; the caller should not modify its
+   value.  The value is available to Python code as part of the variable
+   ``sys.version``.
+.. cfunction:: void PySys_SetArgv(int argc, char **argv)
+   .. index::
+      single: main()
+      single: Py_FatalError()
+      single: argv (in module sys)
+   Set :data:`sys.argv` based on *argc* and *argv*.  These parameters are
+   similar to those passed to the program's :cfunc:`main` function with the
+   difference that the first entry should refer to the script file to be
+   executed rather than the executable hosting the Python interpreter.  If there
+   isn't a script that will be run, the first entry in *argv* can be an empty
+   string.  If this function fails to initialize :data:`sys.argv`, a fatal
+   condition is signalled using :cfunc:`Py_FatalError`.
+   This function also prepends the executed script's path to :data:`sys.path`.
+   If no script is executed (in the case of calling ``python -c`` or just the
+   interactive interpreter), the empty string is used instead.
+   .. XXX impl. doesn't seem consistent in allowing 0/NULL for the params;
+      check w/ Guido.
+.. cfunction:: void Py_SetPythonHome(char *home)
+   Set the default "home" directory, that is, the location of the standard
+   Python libraries.  The libraries are searched in
+   :file:`{home}/lib/python{version}` and :file:`{home}/lib/python{version}`.
+   The argument should point to a zero-terminated character string in static
+   storage whose contents will not change for the duration of the program's
+   execution.  No code in the Python interpreter will change the contents of
+   this storage.
+.. cfunction:: char* Py_GetPythonHome()
+   Return the default "home", that is, the value set by a previous call to
+   :cfunc:`Py_SetPythonHome`, or the value of the :envvar:`PYTHONHOME`
+   environment variable if it is set.
+.. _threads:
+Thread State and the Global Interpreter Lock
+============================================
+.. index::
+   single: global interpreter lock
+   single: interpreter lock
+   single: lock, interpreter
+The Python interpreter is not fully thread safe.  In order to support
+multi-threaded Python programs, there's a global lock, called the :dfn:`global
+interpreter lock` or :dfn:`GIL`, that must be held by the current thread before
+it can safely access Python objects. Without the lock, even the simplest
+operations could cause problems in a multi-threaded program: for example, when
+two threads simultaneously increment the reference count of the same object, the
+reference count could end up being incremented only once instead of twice.
+.. index:: single: setcheckinterval() (in module sys)
+Therefore, the rule exists that only the thread that has acquired the global
+interpreter lock may operate on Python objects or call Python/C API functions.
+In order to support multi-threaded Python programs, the interpreter regularly
+releases and reacquires the lock --- by default, every 100 bytecode instructions
+(this can be changed with  :func:`sys.setcheckinterval`).  The lock is also
+released and reacquired around potentially blocking I/O operations like reading
+or writing a file, so that other threads can run while the thread that requests
+the I/O is waiting for the I/O operation to complete.
+.. index::
+   single: PyThreadState
+   single: PyThreadState
+The Python interpreter needs to keep some bookkeeping information separate per
+thread --- for this it uses a data structure called :ctype:`PyThreadState`.
+There's one global variable, however: the pointer to the current
+:ctype:`PyThreadState` structure.  Before the addition of :dfn:`thread-local
+storage` (:dfn:`TLS`) the current thread state had to be manipulated
+explicitly.
+This is easy enough in most cases.  Most code manipulating the global
+interpreter lock has the following simple structure::
+   Save the thread state in a local variable.
+   Release the global interpreter lock.
+   ...Do some blocking I/O operation...
+   Reacquire the global interpreter lock.
+   Restore the thread state from the local variable.
+This is so common that a pair of macros exists to simplify it::
+   Py_BEGIN_ALLOW_THREADS
+   ...Do some blocking I/O operation...
+   Py_END_ALLOW_THREADS
+.. index::
+   single: Py_BEGIN_ALLOW_THREADS
+   single: Py_END_ALLOW_THREADS
+The :cmacro:`Py_BEGIN_ALLOW_THREADS` macro opens a new block and declares a
+hidden local variable; the :cmacro:`Py_END_ALLOW_THREADS` macro closes the
+block.  Another advantage of using these two macros is that when Python is
+compiled without thread support, they are defined empty, thus saving the thread
+state and GIL manipulations.
+When thread support is enabled, the block above expands to the following code::
+   PyThreadState *_save;
+   _save = PyEval_SaveThread();
+   ...Do some blocking I/O operation...
+   PyEval_RestoreThread(_save);
+Using even lower level primitives, we can get roughly the same effect as
+follows::
+   PyThreadState *_save;
+   _save = PyThreadState_Swap(NULL);
+   PyEval_ReleaseLock();
+   ...Do some blocking I/O operation...
+   PyEval_AcquireLock();
+   PyThreadState_Swap(_save);
+.. index::
+   single: PyEval_RestoreThread()
+   single: errno
+   single: PyEval_SaveThread()
+   single: PyEval_ReleaseLock()
+   single: PyEval_AcquireLock()
+There are some subtle differences; in particular, :cfunc:`PyEval_RestoreThread`
+saves and restores the value of the  global variable :cdata:`errno`, since the
+lock manipulation does not guarantee that :cdata:`errno` is left alone.  Also,
+when thread support is disabled, :cfunc:`PyEval_SaveThread` and
+:cfunc:`PyEval_RestoreThread` don't manipulate the GIL; in this case,
+:cfunc:`PyEval_ReleaseLock` and :cfunc:`PyEval_AcquireLock` are not available.
+This is done so that dynamically loaded extensions compiled with thread support
+enabled can be loaded by an interpreter that was compiled with disabled thread
+support.
+The global interpreter lock is used to protect the pointer to the current thread
+state.  When releasing the lock and saving the thread state, the current thread
+state pointer must be retrieved before the lock is released (since another
+thread could immediately acquire the lock and store its own thread state in the
+global variable). Conversely, when acquiring the lock and restoring the thread
+state, the lock must be acquired before storing the thread state pointer.
+It is important to note that when threads are created from C, they don't have
+the global interpreter lock, nor is there a thread state data structure for
+them.  Such threads must bootstrap themselves into existence, by first
+creating a thread state data structure, then acquiring the lock, and finally
+storing their thread state pointer, before they can start using the Python/C
+API.  When they are done, they should reset the thread state pointer, release
+the lock, and finally free their thread state data structure.
+Beginning with version 2.3, threads can now take advantage of the
+:cfunc:`PyGILState_\*` functions to do all of the above automatically.  The
+typical idiom for calling into Python from a C thread is now::
+   PyGILState_STATE gstate;
+   gstate = PyGILState_Ensure();
+   /* Perform Python actions here.  */
+   result = CallSomeFunction();
+   /* evaluate result */
+   /* Release the thread. No Python API allowed beyond this point. */
+   PyGILState_Release(gstate);
+Note that the :cfunc:`PyGILState_\*` functions assume there is only one global
+interpreter (created automatically by :cfunc:`Py_Initialize`).  Python still
+supports the creation of additional interpreters (using
+:cfunc:`Py_NewInterpreter`), but mixing multiple interpreters and the
+:cfunc:`PyGILState_\*` API is unsupported.
+Another important thing to note about threads is their behaviour in the face
+of the C :cfunc:`fork` call. On most systems with :cfunc:`fork`, after a
+process forks only the thread that issued the fork will exist. That also
+means any locks held by other threads will never be released. Python solves
+this for :func:`os.fork` by acquiring the locks it uses internally before
+the fork, and releasing them afterwards. In addition, it resets any
+:ref:`lock-objects` in the child. When extending or embedding Python, there
+is no way to inform Python of additional (non-Python) locks that need to be
+acquired before or reset after a fork. OS facilities such as
+:cfunc:`posix_atfork` would need to be used to accomplish the same thing.
+Additionally, when extending or embedding Python, calling :cfunc:`fork`
+directly rather than through :func:`os.fork` (and returning to or calling
+into Python) may result in a deadlock by one of Python's internal locks
+being held by a thread that is defunct after the fork.
+:cfunc:`PyOS_AfterFork` tries to reset the necessary locks, but is not
+always able to.
+.. ctype:: PyInterpreterState
+   This data structure represents the state shared by a number of cooperating
+   threads.  Threads belonging to the same interpreter share their module
+   administration and a few other internal items. There are no public members in
+   this structure.
+   Threads belonging to different interpreters initially share nothing, except
+   process state like available memory, open file descriptors and such.  The global
+   interpreter lock is also shared by all threads, regardless of to which
+   interpreter they belong.
+.. ctype:: PyThreadState
+   This data structure represents the state of a single thread.  The only public
+   data member is :ctype:`PyInterpreterState \*`:attr:`interp`, which points to
+   this thread's interpreter state.
+.. cfunction:: void PyEval_InitThreads()
+   .. index::
+      single: PyEval_ReleaseLock()
+      single: PyEval_ReleaseThread()
+      single: PyEval_SaveThread()
+      single: PyEval_RestoreThread()
+   Initialize and acquire the global interpreter lock.  It should be called in the
+   main thread before creating a second thread or engaging in any other thread
+   operations such as :cfunc:`PyEval_ReleaseLock` or
+   ``PyEval_ReleaseThread(tstate)``. It is not needed before calling
+   :cfunc:`PyEval_SaveThread` or :cfunc:`PyEval_RestoreThread`.
+   .. index:: single: Py_Initialize()
+   This is a no-op when called for a second time.  It is safe to call this function
+   before calling :cfunc:`Py_Initialize`.
+   .. index:: module: thread
+   When only the main thread exists, no GIL operations are needed. This is a
+   common situation (most Python programs do not use threads), and the lock
+   operations slow the interpreter down a bit. Therefore, the lock is not
+   created initially.  This situation is equivalent to having acquired the lock:
+   when there is only a single thread, all object accesses are safe.  Therefore,
+   when this function initializes the global interpreter lock, it also acquires
+   it.  Before the Python :mod:`thread` module creates a new thread, knowing
+   that either it has the lock or the lock hasn't been created yet, it calls
+   :cfunc:`PyEval_InitThreads`.  When this call returns, it is guaranteed that
+   the lock has been created and that the calling thread has acquired it.
+   It is **not** safe to call this function when it is unknown which thread (if
+   any) currently has the global interpreter lock.
+   This function is not available when thread support is disabled at compile time.
+.. cfunction:: int PyEval_ThreadsInitialized()
+   Returns a non-zero value if :cfunc:`PyEval_InitThreads` has been called.  This
+   function can be called without holding the GIL, and therefore can be used to
+   avoid calls to the locking API when running single-threaded.  This function is
+   not available when thread support is disabled at compile time.
+   .. versionadded:: 2.4
+.. cfunction:: void PyEval_AcquireLock()
+   Acquire the global interpreter lock.  The lock must have been created earlier.
+   If this thread already has the lock, a deadlock ensues.  This function is not
+   available when thread support is disabled at compile time.
+.. cfunction:: void PyEval_ReleaseLock()
+   Release the global interpreter lock.  The lock must have been created earlier.
+   This function is not available when thread support is disabled at compile time.
+.. cfunction:: void PyEval_AcquireThread(PyThreadState *tstate)
+   Acquire the global interpreter lock and set the current thread state to
+   *tstate*, which should not be *NULL*.  The lock must have been created earlier.
+   If this thread already has the lock, deadlock ensues.  This function is not
+   available when thread support is disabled at compile time.
+.. cfunction:: void PyEval_ReleaseThread(PyThreadState *tstate)
+   Reset the current thread state to *NULL* and release the global interpreter
+   lock.  The lock must have been created earlier and must be held by the current
+   thread.  The *tstate* argument, which must not be *NULL*, is only used to check
+   that it represents the current thread state --- if it isn't, a fatal error is
+   reported. This function is not available when thread support is disabled at
+   compile time.
+.. cfunction:: PyThreadState* PyEval_SaveThread()
+   Release the global interpreter lock (if it has been created and thread
+   support is enabled) and reset the thread state to *NULL*, returning the
+   previous thread state (which is not *NULL*).  If the lock has been created,
+   the current thread must have acquired it.  (This function is available even
+   when thread support is disabled at compile time.)
+.. cfunction:: void PyEval_RestoreThread(PyThreadState *tstate)
+   Acquire the global interpreter lock (if it has been created and thread
+   support is enabled) and set the thread state to *tstate*, which must not be
+   *NULL*.  If the lock has been created, the current thread must not have
+   acquired it, otherwise deadlock ensues.  (This function is available even
+   when thread support is disabled at compile time.)
+.. cfunction:: void PyEval_ReInitThreads()
+   This function is called from :cfunc:`PyOS_AfterFork` to ensure that newly
+   created child processes don't hold locks referring to threads which
+   are not running in the child process.
+The following macros are normally used without a trailing semicolon; look for
+example usage in the Python source distribution.
+.. cmacro:: Py_BEGIN_ALLOW_THREADS
+   This macro expands to ``{ PyThreadState *_save; _save = PyEval_SaveThread();``.
+   Note that it contains an opening brace; it must be matched with a following
+   :cmacro:`Py_END_ALLOW_THREADS` macro.  See above for further discussion of this
+   macro.  It is a no-op when thread support is disabled at compile time.
+.. cmacro:: Py_END_ALLOW_THREADS
+   This macro expands to ``PyEval_RestoreThread(_save); }``. Note that it contains
+   a closing brace; it must be matched with an earlier
+   :cmacro:`Py_BEGIN_ALLOW_THREADS` macro.  See above for further discussion of
+   this macro.  It is a no-op when thread support is disabled at compile time.
+.. cmacro:: Py_BLOCK_THREADS
+   This macro expands to ``PyEval_RestoreThread(_save);``: it is equivalent to
+   :cmacro:`Py_END_ALLOW_THREADS` without the closing brace.  It is a no-op when
+   thread support is disabled at compile time.
+.. cmacro:: Py_UNBLOCK_THREADS
+   This macro expands to ``_save = PyEval_SaveThread();``: it is equivalent to
+   :cmacro:`Py_BEGIN_ALLOW_THREADS` without the opening brace and variable
+   declaration.  It is a no-op when thread support is disabled at compile time.
+All of the following functions are only available when thread support is enabled
+at compile time, and must be called only when the global interpreter lock has
+been created.
+.. cfunction:: PyInterpreterState* PyInterpreterState_New()
+   Create a new interpreter state object.  The global interpreter lock need not
+   be held, but may be held if it is necessary to serialize calls to this
+   function.
+.. cfunction:: void PyInterpreterState_Clear(PyInterpreterState *interp)
+   Reset all information in an interpreter state object.  The global interpreter
+   lock must be held.
+.. cfunction:: void PyInterpreterState_Delete(PyInterpreterState *interp)
+   Destroy an interpreter state object.  The global interpreter lock need not be
+   held.  The interpreter state must have been reset with a previous call to
+   :cfunc:`PyInterpreterState_Clear`.
+.. cfunction:: PyThreadState* PyThreadState_New(PyInterpreterState *interp)
+   Create a new thread state object belonging to the given interpreter object.
+   The global interpreter lock need not be held, but may be held if it is
+   necessary to serialize calls to this function.
+.. cfunction:: void PyThreadState_Clear(PyThreadState *tstate)
+   Reset all information in a thread state object.  The global interpreter lock
+   must be held.
+.. cfunction:: void PyThreadState_Delete(PyThreadState *tstate)
+   Destroy a thread state object.  The global interpreter lock need not be held.
+   The thread state must have been reset with a previous call to
+   :cfunc:`PyThreadState_Clear`.
+.. cfunction:: PyThreadState* PyThreadState_Get()
+   Return the current thread state.  The global interpreter lock must be held.
+   When the current thread state is *NULL*, this issues a fatal error (so that
+   the caller needn't check for *NULL*).
+.. cfunction:: PyThreadState* PyThreadState_Swap(PyThreadState *tstate)
+   Swap the current thread state with the thread state given by the argument
+   *tstate*, which may be *NULL*.  The global interpreter lock must be held.
+.. cfunction:: PyObject* PyThreadState_GetDict()
+   Return a dictionary in which extensions can store thread-specific state
+   information.  Each extension should use a unique key to use to store state in
+   the dictionary.  It is okay to call this function when no current thread state
+   is available. If this function returns *NULL*, no exception has been raised and
+   the caller should assume no current thread state is available.
+   .. versionchanged:: 2.3
+      Previously this could only be called when a current thread is active, and *NULL*
+      meant that an exception was raised.
+.. cfunction:: int PyThreadState_SetAsyncExc(long id, PyObject *exc)
+   Asynchronously raise an exception in a thread. The *id* argument is the thread
+   id of the target thread; *exc* is the exception object to be raised. This
+   function does not steal any references to *exc*. To prevent naive misuse, you
+   must write your own C extension to call this.  Must be called with the GIL held.
+   Returns the number of thread states modified; this is normally one, but will be
+   zero if the thread id isn't found.  If *exc* is :const:`NULL`, the pending
+   exception (if any) for the thread is cleared. This raises no exceptions.
+   .. versionadded:: 2.3
+.. cfunction:: PyGILState_STATE PyGILState_Ensure()
+   Ensure that the current thread is ready to call the Python C API regardless
+   of the current state of Python, or of the global interpreter lock. This may
+   be called as many times as desired by a thread as long as each call is
+   matched with a call to :cfunc:`PyGILState_Release`. In general, other
+   thread-related APIs may be used between :cfunc:`PyGILState_Ensure` and
+   :cfunc:`PyGILState_Release` calls as long as the thread state is restored to
+   its previous state before the Release().  For example, normal usage of the
+   :cmacro:`Py_BEGIN_ALLOW_THREADS` and :cmacro:`Py_END_ALLOW_THREADS` macros is
+   acceptable.
+   The return value is an opaque "handle" to the thread state when
+   :cfunc:`PyGILState_Ensure` was called, and must be passed to
+   :cfunc:`PyGILState_Release` to ensure Python is left in the same state. Even
+   though recursive calls are allowed, these handles *cannot* be shared - each
+   unique call to :cfunc:`PyGILState_Ensure` must save the handle for its call
+   to :cfunc:`PyGILState_Release`.
+   When the function returns, the current thread will hold the GIL. Failure is a
+   fatal error.
+   .. versionadded:: 2.3
+.. cfunction:: void PyGILState_Release(PyGILState_STATE)
+   Release any resources previously acquired.  After this call, Python's state will
+   be the same as it was prior to the corresponding :cfunc:`PyGILState_Ensure` call
+   (but generally this state will be unknown to the caller, hence the use of the
+   GILState API.)
+   Every call to :cfunc:`PyGILState_Ensure` must be matched by a call to
+   :cfunc:`PyGILState_Release` on the same thread.
+   .. versionadded:: 2.3
+Bugs and caveats
+----------------
+Because sub-interpreters (and the main interpreter) are part of the same
+process, the insulation between them isn't perfect --- for example, using
+low-level file operations like  :func:`os.close` they can
+(accidentally or maliciously) affect each other's open files.  Because of the
+way extensions are shared between (sub-)interpreters, some extensions may not
+work properly; this is especially likely when the extension makes use of
+(static) global variables, or when the extension manipulates its module's
+dictionary after its initialization.  It is possible to insert objects created
+in one sub-interpreter into a namespace of another sub-interpreter; this should
+be done with great care to avoid sharing user-defined functions, methods,
+instances or classes between sub-interpreters, since import operations executed
+by such objects may affect the wrong (sub-)interpreter's dictionary of loaded
+modules.
+Also note that combining this functionality with :c:func:`PyGILState_\*` APIs
+is delicate, because these APIs assume a bijection between Python thread states
+and OS-level threads, an assumption broken by the presence of sub-interpreters.
+It is highly recommended that you don't switch sub-interpreters between a pair
+of matching :c:func:`PyGILState_Ensure` and :c:func:`PyGILState_Release` calls.
+Furthermore, extensions (such as :mod:`ctypes`) using these APIs to allow calling
+of Python code from non-Python created threads will probably be broken when using
+sub-interpreters.
+Asynchronous Notifications
+==========================
+A mechanism is provided to make asynchronous notifications to the main
+interpreter thread.  These notifications take the form of a function
+pointer and a void pointer argument.
+.. c:function:: int Py_AddPendingCall(int (*func)(void *), void *arg)
+   .. index:: single: Py_AddPendingCall()
+   Schedule a function to be called from the main interpreter thread.  On
+   success, 0 is returned and *func* is queued for being called in the
+   main thread.  On failure, -1 is returned without setting any exception.
+   When successfully queued, *func* will be *eventually* called from the
+   main interpreter thread with the argument *arg*.  It will be called
+   asynchronously with respect to normally running Python code, but with
+   both these conditions met:
+   * on a :term:`bytecode` boundary;
+   * with the main thread holding the :term:`global interpreter lock`
+     (*func* can therefore use the full C API).
+   *func* must return 0 on success, or -1 on failure with an exception
+   set.  *func* won't be interrupted to perform another asynchronous
+   notification recursively, but it can still be interrupted to switch
+   threads if the global interpreter lock is released.
+   This function doesn't need a current thread state to run, and it doesn't
+   need the global interpreter lock.
+   .. warning::
+      This is a low-level function, only useful for very special cases.
+      There is no guarantee that *func* will be called as quick as
+      possible.  If the main thread is busy executing a system call,
+      *func* won't be called before the system call returns.  This
+      function is generally **not** suitable for calling Python code from
+      arbitrary C threads.  Instead, use the :ref:`PyGILState API<gilstate>`.
+   .. versionadded:: 2.7
 …
 .. ctype:: int (*Py_tracefunc)(PyObject *obj, PyFrameObject *frame, int what, PyObject *arg)
    The type of the trace function registered using :cfunc:`PyEval_SetProfile` and
    :cfunc:`PyEval_SetTrace`. The first parameter is the object passed to the
+.. c:type:: int (*Py_tracefunc)(PyObject *obj, PyFrameObject *frame, int what, PyObject *arg)
+   The type of the trace function registered using :c:func:`PyEval_SetProfile` and
+   :c:func:`PyEval_SetTrace`. The first parameter is the object passed to the
    registration function as *obj*, *frame* is the frame object to which the event
    pertains, *what* is one of the constants :const:`PyTrace_CALL`,
 …
    | :const:`PyTrace_LINE`        | Always *NULL*.                       |
    +------------------------------+--------------------------------------+
+   | :const:`PyTrace_RETURN`      | Value being returned to the caller.  |
+   | :const:`PyTrace_RETURN`      | Value being returned to the caller,  |
+   |                              | or *NULL* if caused by an exception. |
    +------------------------------+--------------------------------------+
    | :const:`PyTrace_C_CALL`      | Name of function being called.       |
+   | :const:`PyTrace_C_CALL`      | Function object being called.        |
    +------------------------------+--------------------------------------+
    | :const:`PyTrace_C_EXCEPTION` | Always *NULL*.                       |
+   | :const:`PyTrace_C_EXCEPTION` | Function object being called.        |
    +------------------------------+--------------------------------------+
    | :const:`PyTrace_C_RETURN`    | Always *NULL*.                       |
+   | :const:`PyTrace_C_RETURN`    | Function object being called.        |
    +------------------------------+--------------------------------------+
 .. cvar:: int PyTrace_CALL
    The value of the *what* parameter to a :ctype:`Py_tracefunc` function when a new
+.. c:var:: int PyTrace_CALL
+   The value of the *what* parameter to a :c:type:`Py_tracefunc` function when a new
    call to a function or method is being reported, or a new entry into a generator.
    Note that the creation of the iterator for a generator function is not reported
 …
 .. cvar:: int PyTrace_EXCEPTION
    The value of the *what* parameter to a :ctype:`Py_tracefunc` function when an
+.. c:var:: int PyTrace_EXCEPTION
+   The value of the *what* parameter to a :c:type:`Py_tracefunc` function when an
    exception has been raised.  The callback function is called with this value for
    *what* when after any bytecode is processed after which the exception becomes
 …
 .. cvar:: int PyTrace_LINE
+.. c:var:: int PyTrace_LINE
    The value passed as the *what* parameter to a trace function (but not a
 …
 .. cvar:: int PyTrace_RETURN
    The value for the *what* parameter to :ctype:`Py_tracefunc` functions when a
+.. c:var:: int PyTrace_RETURN
+   The value for the *what* parameter to :c:type:`Py_tracefunc` functions when a
    call is returning without propagating an exception.
 .. cvar:: int PyTrace_C_CALL
    The value for the *what* parameter to :ctype:`Py_tracefunc` functions when a C
+.. c:var:: int PyTrace_C_CALL
+   The value for the *what* parameter to :c:type:`Py_tracefunc` functions when a C
    function is about to be called.
 .. cvar:: int PyTrace_C_EXCEPTION
    The value for the *what* parameter to :ctype:`Py_tracefunc` functions when a C
    function has thrown an exception.
 .. cvar:: int PyTrace_C_RETURN
    The value for the *what* parameter to :ctype:`Py_tracefunc` functions when a C
+.. c:var:: int PyTrace_C_EXCEPTION
+   The value for the *what* parameter to :c:type:`Py_tracefunc` functions when a C
+   function has raised an exception.
+.. c:var:: int PyTrace_C_RETURN
+   The value for the *what* parameter to :c:type:`Py_tracefunc` functions when a C
    function has returned.
 .. cfunction:: void PyEval_SetProfile(Py_tracefunc func, PyObject *obj)
+.. c:function:: void PyEval_SetProfile(Py_tracefunc func, PyObject *obj)
    Set the profiler function to *func*.  The *obj* parameter is passed to the
 …
 .. cfunction:: void PyEval_SetTrace(Py_tracefunc func, PyObject *obj)
+.. c:function:: void PyEval_SetTrace(Py_tracefunc func, PyObject *obj)
    Set the tracing function to *func*.  This is similar to
    :cfunc:`PyEval_SetProfile`, except the tracing function does receive line-number
+   :c:func:`PyEval_SetProfile`, except the tracing function does receive line-number
    events.
 .. cfunction:: PyObject* PyEval_GetCallStats(PyObject *self)
+.. c:function:: PyObject* PyEval_GetCallStats(PyObject *self)
    Return a tuple of function call counts.  There are constants defined for the
 …
 .. cfunction:: PyInterpreterState* PyInterpreterState_Head()
+.. c:function:: PyInterpreterState* PyInterpreterState_Head()
    Return the interpreter state object at the head of the list of all such objects.
 …
 .. cfunction:: PyInterpreterState* PyInterpreterState_Next(PyInterpreterState *interp)
+.. c:function:: PyInterpreterState* PyInterpreterState_Next(PyInterpreterState *interp)
    Return the next interpreter state object after *interp* from the list of all
 …
 .. cfunction:: PyThreadState * PyInterpreterState_ThreadHead(PyInterpreterState *interp)
    Return the a pointer to the first :ctype:`PyThreadState` object in the list of
+.. c:function:: PyThreadState * PyInterpreterState_ThreadHead(PyInterpreterState *interp)
+   Return the a pointer to the first :c:type:`PyThreadState` object in the list of
    threads associated with the interpreter *interp*.
 …
 .. cfunction:: PyThreadState* PyThreadState_Next(PyThreadState *tstate)
+.. c:function:: PyThreadState* PyThreadState_Next(PyThreadState *tstate)
    Return the next thread state object after *tstate* from the list of all such
    objects belonging to the same :ctype:`PyInterpreterState` object.
+   objects belonging to the same :c:type:`PyInterpreterState` object.
    .. versionadded:: 2.2

python/vendor/current/Doc/c-api/int.rst

-              r2
+              r388
 .. ctype:: PyIntObject
+.. c:type:: PyIntObject
    This subtype of :ctype:`PyObject` represents a Python integer object.
+   This subtype of :c:type:`PyObject` represents a Python integer object.
 .. cvar:: PyTypeObject PyInt_Type
+.. c:var:: PyTypeObject PyInt_Type
    .. index:: single: IntType (in modules types)
    This instance of :ctype:`PyTypeObject` represents the Python plain integer type.
+   This instance of :c:type:`PyTypeObject` represents the Python plain integer type.
    This is the same object as ``int`` and ``types.IntType``.
 .. cfunction:: int PyInt_Check(PyObject *o)
+.. c:function:: int PyInt_Check(PyObject *o)
    Return true if *o* is of type :cdata:`PyInt_Type` or a subtype of
    :cdata:`PyInt_Type`.
+   Return true if *o* is of type :c:data:`PyInt_Type` or a subtype of
+   :c:data:`PyInt_Type`.
    .. versionchanged:: 2.2
 …
 .. cfunction:: int PyInt_CheckExact(PyObject *o)
+.. c:function:: int PyInt_CheckExact(PyObject *o)
    Return true if *o* is of type :cdata:`PyInt_Type`, but not a subtype of
    :cdata:`PyInt_Type`.
+   Return true if *o* is of type :c:data:`PyInt_Type`, but not a subtype of
+   :c:data:`PyInt_Type`.
    .. versionadded:: 2.2
 .. cfunction:: PyObject* PyInt_FromString(char *str, char **pend, int base)
+.. c:function:: PyObject* PyInt_FromString(char *str, char **pend, int base)
    Return a new :ctype:`PyIntObject` or :ctype:`PyLongObject` based on the string
+   Return a new :c:type:`PyIntObject` or :c:type:`PyLongObject` based on the string
    value in *str*, which is interpreted according to the radix in *base*.  If
    *pend* is non-*NULL*, ``*pend`` will point to the first character in *str* which
 …
    must be between ``2`` and ``36``, inclusive.  Leading spaces are ignored.  If
    there are no digits, :exc:`ValueError` will be raised.  If the string represents
    a number too large to be contained within the machine's :ctype:`long int` type
    and overflow warnings are being suppressed, a :ctype:`PyLongObject` will be
+   a number too large to be contained within the machine's :c:type:`long int` type
+   and overflow warnings are being suppressed, a :c:type:`PyLongObject` will be
    returned.  If overflow warnings are not being suppressed, *NULL* will be
    returned in this case.
 .. cfunction:: PyObject* PyInt_FromLong(long ival)
+.. c:function:: PyObject* PyInt_FromLong(long ival)
    Create a new integer object with a value of *ival*.
 …
 .. cfunction:: PyObject* PyInt_FromSsize_t(Py_ssize_t ival)
+.. c:function:: PyObject* PyInt_FromSsize_t(Py_ssize_t ival)
    Create a new integer object with a value of *ival*. If the value is larger
 …
 .. cfunction:: PyObject* PyInt_FromSize_t(size_t ival)
+.. c:function:: PyObject* PyInt_FromSize_t(size_t ival)
    Create a new integer object with a value of *ival*. If the value exceeds
 …
 .. cfunction:: long PyInt_AsLong(PyObject *io)
+.. c:function:: long PyInt_AsLong(PyObject *io)
    Will first attempt to cast the object to a :ctype:`PyIntObject`, if it is not
+   Will first attempt to cast the object to a :c:type:`PyIntObject`, if it is not
    already one, and then return its value. If there is an error, ``-1`` is
    returned, and the caller should check ``PyErr_Occurred()`` to find out whether
 …
 .. cfunction:: long PyInt_AS_LONG(PyObject *io)
+.. c:function:: long PyInt_AS_LONG(PyObject *io)
    Return the value of the object *io*.  No error checking is performed.
 .. cfunction:: unsigned long PyInt_AsUnsignedLongMask(PyObject *io)
+.. c:function:: unsigned long PyInt_AsUnsignedLongMask(PyObject *io)
    Will first attempt to cast the object to a :ctype:`PyIntObject` or
    :ctype:`PyLongObject`, if it is not already one, and then return its value as
+   Will first attempt to cast the object to a :c:type:`PyIntObject` or
+   :c:type:`PyLongObject`, if it is not already one, and then return its value as
    unsigned long.  This function does not check for overflow.
 …
 .. cfunction:: unsigned PY_LONG_LONG PyInt_AsUnsignedLongLongMask(PyObject *io)
+.. c:function:: unsigned PY_LONG_LONG PyInt_AsUnsignedLongLongMask(PyObject *io)
    Will first attempt to cast the object to a :ctype:`PyIntObject` or
    :ctype:`PyLongObject`, if it is not already one, and then return its value as
+   Will first attempt to cast the object to a :c:type:`PyIntObject` or
+   :c:type:`PyLongObject`, if it is not already one, and then return its value as
    unsigned long long, without checking for overflow.
 …
 .. cfunction:: Py_ssize_t PyInt_AsSsize_t(PyObject *io)
+.. c:function:: Py_ssize_t PyInt_AsSsize_t(PyObject *io)
    Will first attempt to cast the object to a :ctype:`PyIntObject` or
    :ctype:`PyLongObject`, if it is not already one, and then return its value as
    :ctype:`Py_ssize_t`.
+   Will first attempt to cast the object to a :c:type:`PyIntObject` or
+   :c:type:`PyLongObject`, if it is not already one, and then return its value as
+   :c:type:`Py_ssize_t`.
    .. versionadded:: 2.5
 .. cfunction:: long PyInt_GetMax()
+.. c:function:: long PyInt_GetMax()
    .. index:: single: LONG_MAX
 …
 .. cfunction:: int PyInt_ClearFreeList()
+.. c:function:: int PyInt_ClearFreeList()
    Clear the integer free list. Return the number of items that could not

python/vendor/current/Doc/c-api/intro.rst

-              r2
+              r388
 This implies inclusion of the following standard headers: ``<stdio.h>``,
 ``<string.h>``, ``<errno.h>``, ``<limits.h>``, and ``<stdlib.h>`` (if
 available).
+``<string.h>``, ``<errno.h>``, ``<limits.h>``, ``<assert.h>`` and ``<stdlib.h>``
+(if available).
 .. note::
 …
 Most Python/C API functions have one or more arguments as well as a return value
 of type :ctype:`PyObject\*`.  This type is a pointer to an opaque data type
+of type :c:type:`PyObject\*`.  This type is a pointer to an opaque data type
 representing an arbitrary Python object.  Since all Python object types are
 treated the same way by the Python language in most situations (e.g.,
 …
 should be represented by a single C type.  Almost all Python objects live on the
 heap: you never declare an automatic or static variable of type
 :ctype:`PyObject`, only pointer variables of type :ctype:`PyObject\*` can  be
+:c:type:`PyObject`, only pointer variables of type :c:type:`PyObject\*` can  be
 declared.  The sole exception are the type objects; since these must never be
 deallocated, they are typically static :ctype:`PyTypeObject` objects.
+deallocated, they are typically static :c:type:`PyTypeObject` objects.
 All Python objects (even Python integers) have a :dfn:`type` and a
 …
 Reference counts are always manipulated explicitly.  The normal way is  to use
 the macro :cfunc:`Py_INCREF` to increment an object's reference count by one,
 and :cfunc:`Py_DECREF` to decrement it by   one.  The :cfunc:`Py_DECREF` macro
+the macro :c:func:`Py_INCREF` to increment an object's reference count by one,
+and :c:func:`Py_DECREF` to decrement it by   one.  The :c:func:`Py_DECREF` macro
 is considerably more complex than the incref one, since it must check whether
 the reference count becomes zero and then cause the object's deallocator to be
 …
 and possible deallocating it. The real danger is that innocent-looking
 operations may invoke arbitrary Python code which could do this; there is a code
 path which allows control to flow back to the user from a :cfunc:`Py_DECREF`, so
+path which allows control to flow back to the user from a :c:func:`Py_DECREF`, so
 almost any operation is potentially dangerous.
 …
 begins with ``PyObject_``, ``PyNumber_``, ``PySequence_`` or ``PyMapping_``).
 These operations always increment the reference count of the object they return.
 This leaves the caller with the responsibility to call :cfunc:`Py_DECREF` when
+This leaves the caller with the responsibility to call :c:func:`Py_DECREF` when
 they are done with the result; this soon becomes second nature.
 …
 reference is no longer needed.  Ownership can also be transferred, meaning that
 the code that receives ownership of the reference then becomes responsible for
 eventually decref'ing it by calling :cfunc:`Py_DECREF` or :cfunc:`Py_XDECREF`
+eventually decref'ing it by calling :c:func:`Py_DECREF` or :c:func:`Py_XDECREF`
 when it's no longer needed---or passing on this responsibility (usually to its
 caller). When a function passes ownership of a reference on to its caller, the
 …
 Few functions steal references; the two notable exceptions are
 :cfunc:`PyList_SetItem` and :cfunc:`PyTuple_SetItem`, which  steal a reference
+:c:func:`PyList_SetItem` and :c:func:`PyTuple_SetItem`, which  steal a reference
 to the item (but not to the tuple or list into which the item is put!).  These
 functions were designed to steal a reference because of a common idiom for
 …
    PyTuple_SetItem(t, 2, PyString_FromString("three"));
 Here, :cfunc:`PyInt_FromLong` returns a new reference which is immediately
 stolen by :cfunc:`PyTuple_SetItem`.  When you want to keep using an object
 although the reference to it will be stolen, use :cfunc:`Py_INCREF` to grab
+Here, :c:func:`PyInt_FromLong` returns a new reference which is immediately
+stolen by :c:func:`PyTuple_SetItem`.  When you want to keep using an object
+although the reference to it will be stolen, use :c:func:`Py_INCREF` to grab
 another reference before calling the reference-stealing function.
 Incidentally, :cfunc:`PyTuple_SetItem` is the *only* way to set tuple items;
 :cfunc:`PySequence_SetItem` and :cfunc:`PyObject_SetItem` refuse to do this
+Incidentally, :c:func:`PyTuple_SetItem` is the *only* way to set tuple items;
+:c:func:`PySequence_SetItem` and :c:func:`PyObject_SetItem` refuse to do this
 since tuples are an immutable data type.  You should only use
 :cfunc:`PyTuple_SetItem` for tuples that you are creating yourself.
 Equivalent code for populating a list can be written using :cfunc:`PyList_New`
 and :cfunc:`PyList_SetItem`.
+:c:func:`PyTuple_SetItem` for tuples that you are creating yourself.
+Equivalent code for populating a list can be written using :c:func:`PyList_New`
+and :c:func:`PyList_SetItem`.
 However, in practice, you will rarely use these ways of creating and populating
 a tuple or list.  There's a generic function, :cfunc:`Py_BuildValue`, that can
+a tuple or list.  There's a generic function, :c:func:`Py_BuildValue`, that can
 create most common objects from C values, directed by a :dfn:`format string`.
 For example, the above two blocks of code could be replaced by the following
 …
    list = Py_BuildValue("[iis]", 1, 2, "three");
 It is much more common to use :cfunc:`PyObject_SetItem` and friends with items
+It is much more common to use :c:func:`PyObject_SetItem` and friends with items
 whose references you are only borrowing, like arguments that were passed in to
 the function you are writing.  In that case, their behaviour regarding reference
 …
            if (!index)
                return -1;
+           if (PyObject_SetItem(target, index, item) < 0)
+           if (PyObject_SetItem(target, index, item) < 0) {
+               Py_DECREF(index);
                return -1;
+       }
            Py_DECREF(index);
+       }
 …
 returned object is created  on the fly, and the reference you get is the only
 reference to the  object.  Therefore, the generic functions that return object
 references, like :cfunc:`PyObject_GetItem` and  :cfunc:`PySequence_GetItem`,
+references, like :c:func:`PyObject_GetItem` and  :c:func:`PySequence_GetItem`,
 always return a new reference (the caller becomes the owner of the reference).
 …
 function depends on which function you call only --- *the plumage* (the type of
 the object passed as an argument to the function) *doesn't enter into it!*
 Thus, if you  extract an item from a list using :cfunc:`PyList_GetItem`, you
+Thus, if you  extract an item from a list using :c:func:`PyList_GetItem`, you
 don't own the reference --- but if you obtain the same item from the same list
 using :cfunc:`PySequence_GetItem` (which happens to take exactly the same
+using :c:func:`PySequence_GetItem` (which happens to take exactly the same
 arguments), you do own a reference to the returned object.
 …
 Here is an example of how you could write a function that computes the sum of
 the items in a list of integers; once using  :cfunc:`PyList_GetItem`, and once
 using :cfunc:`PySequence_GetItem`. ::
+the items in a list of integers; once using  :c:func:`PyList_GetItem`, and once
+using :c:func:`PySequence_GetItem`. ::
    long
 …
 There are few other data types that play a significant role in  the Python/C
 API; most are simple C types such as :ctype:`int`,  :ctype:`long`,
 :ctype:`double` and :ctype:`char\*`.  A few structure types  are used to
+API; most are simple C types such as :c:type:`int`,  :c:type:`long`,
+:c:type:`double` and :c:type:`char\*`.  A few structure types  are used to
 describe static tables used to list the functions exported  by a module or the
 data attributes of a new object type, and another is used to describe the value
 …
 .. index:: single: PyErr_Occurred()
+For C programmers, however, error checking always has to be explicit.   All
+functions in the Python/C API can raise exceptions, unless an  explicit claim is
+made otherwise in a function's documentation.  In  general, when a function
+encounters an error, it sets an exception,  discards any object references that
+it owns, and returns an  error indicator --- usually *NULL* or ``-1``.  A few
+functions  return a Boolean true/false result, with false indicating an error.
+Very few functions return no explicit error indicator or have an  ambiguous
+return value, and require explicit testing for errors with
+:cfunc:`PyErr_Occurred`.
+For C programmers, however, error checking always has to be explicit.  All
+functions in the Python/C API can raise exceptions, unless an explicit claim is
+made otherwise in a function's documentation.  In general, when a function
+encounters an error, it sets an exception, discards any object references that
+it owns, and returns an error indicator.  If not documented otherwise, this
+indicator is either *NULL* or ``-1``, depending on the function's return type.
+A few functions return a Boolean true/false result, with false indicating an
+error.  Very few functions return no explicit error indicator or have an
+ambiguous return value, and require explicit testing for errors with
+:c:func:`PyErr_Occurred`.  These exceptions are always explicitly documented.
 .. index::
 …
 using global storage in an unthreaded application).  A  thread can be in one of
 two states: an exception has occurred, or not. The function
 :cfunc:`PyErr_Occurred` can be used to check for this: it returns a borrowed
+:c:func:`PyErr_Occurred` can be used to check for this: it returns a borrowed
 reference to the exception type object when an exception has occurred, and
 *NULL* otherwise.  There are a number of functions to set the exception state:
 :cfunc:`PyErr_SetString` is the most common (though not the most general)
 function to set the exception state, and :cfunc:`PyErr_Clear` clears the
+:c:func:`PyErr_SetString` is the most common (though not the most general)
+function to set the exception state, and :c:func:`PyErr_Clear` clears the
 exception state.
 …
 A simple example of detecting exceptions and passing them on is shown in the
 :cfunc:`sum_sequence` example above.  It so happens that that example doesn't
+:c:func:`sum_sequence` example above.  It so happens that this example doesn't
 need to clean up any owned references when it detects an error.  The following
 example function shows some error cleanup.  First, to remind you why you like
 …
 This example represents an endorsed use of the ``goto`` statement  in C!
 It illustrates the use of :cfunc:`PyErr_ExceptionMatches` and
 :cfunc:`PyErr_Clear` to handle specific exceptions, and the use of
 :cfunc:`Py_XDECREF` to dispose of owned references that may be *NULL* (note the
 ``'X'`` in the name; :cfunc:`Py_DECREF` would crash when confronted with a
+It illustrates the use of :c:func:`PyErr_ExceptionMatches` and
+:c:func:`PyErr_Clear` to handle specific exceptions, and the use of
+:c:func:`Py_XDECREF` to dispose of owned references that may be *NULL* (note the
+``'X'`` in the name; :c:func:`Py_DECREF` would crash when confronted with a
 *NULL* reference).  It is important that the variables used to hold owned
 references are initialized to *NULL* for this to work; likewise, the proposed
 …
    single: path (in module sys)
 The basic initialization function is :cfunc:`Py_Initialize`. This initializes
+The basic initialization function is :c:func:`Py_Initialize`. This initializes
 the table of loaded modules, and creates the fundamental modules
 :mod:`__builtin__`, :mod:`__main__`, :mod:`sys`, and :mod:`exceptions`.  It also
 initializes the module search path (``sys.path``).
 .. index:: single: PySys_SetArgv()
 :cfunc:`Py_Initialize` does not set the "script argument list"  (``sys.argv``).
 If this variable is needed by Python code that  will be executed later, it must
 be set explicitly with a call to  ``PySys_SetArgv(argc, argv)`` subsequent to
 the call to :cfunc:`Py_Initialize`.
+.. index:: single: PySys_SetArgvEx()
+:c:func:`Py_Initialize` does not set the "script argument list"  (``sys.argv``).
+If this variable is needed by Python code that will be executed later, it must
+be set explicitly with a call to  ``PySys_SetArgvEx(argc, argv, updatepath)``
+after the call to :c:func:`Py_Initialize`.
 On most systems (in particular, on Unix and Windows, although the details are
 slightly different), :cfunc:`Py_Initialize` calculates the module search path
+slightly different), :c:func:`Py_Initialize` calculates the module search path
 based upon its best guess for the location of the standard Python interpreter
 executable, assuming that the Python library is found in a fixed location
 …
 The embedding application can steer the search by calling
 ``Py_SetProgramName(file)`` *before* calling  :cfunc:`Py_Initialize`.  Note that
+``Py_SetProgramName(file)`` *before* calling  :c:func:`Py_Initialize`.  Note that
 :envvar:`PYTHONHOME` still overrides this and :envvar:`PYTHONPATH` is still
 inserted in front of the standard path.  An application that requires total
 control has to provide its own implementation of :cfunc:`Py_GetPath`,
 :cfunc:`Py_GetPrefix`, :cfunc:`Py_GetExecPrefix`, and
 :cfunc:`Py_GetProgramFullPath` (all defined in :file:`Modules/getpath.c`).
+control has to provide its own implementation of :c:func:`Py_GetPath`,
+:c:func:`Py_GetPrefix`, :c:func:`Py_GetExecPrefix`, and
+:c:func:`Py_GetProgramFullPath` (all defined in :file:`Modules/getpath.c`).
 .. index:: single: Py_IsInitialized()
 …
 Sometimes, it is desirable to "uninitialize" Python.  For instance,  the
 application may want to start over (make another call to
 :cfunc:`Py_Initialize`) or the application is simply done with its  use of
+:c:func:`Py_Initialize`) or the application is simply done with its  use of
 Python and wants to free memory allocated by Python.  This can be accomplished
 by calling :cfunc:`Py_Finalize`.  The function :cfunc:`Py_IsInitialized` returns
+by calling :c:func:`Py_Finalize`.  The function :c:func:`Py_IsInitialized` returns
 true if Python is currently in the initialized state.  More information about
 these functions is given in a later chapter. Notice that :cfunc:`Py_Finalize`
+these functions is given in a later chapter. Notice that :c:func:`Py_Finalize`
 does *not* free all memory allocated by the Python interpreter, e.g. memory
 allocated by extension modules currently cannot be released.
 …
 frequently-used builds will be described in the remainder of this section.
 Compiling the interpreter with the :cmacro:`Py_DEBUG` macro defined produces
 what is generally meant by "a debug build" of Python. :cmacro:`Py_DEBUG` is
 enabled in the Unix build by adding :option:`--with-pydebug` to the
 :file:`configure` command.  It is also implied by the presence of the
 not-Python-specific :cmacro:`_DEBUG` macro.  When :cmacro:`Py_DEBUG` is enabled
+Compiling the interpreter with the :c:macro:`Py_DEBUG` macro defined produces
+what is generally meant by "a debug build" of Python. :c:macro:`Py_DEBUG` is
+enabled in the Unix build by adding ``--with-pydebug`` to the
+:file:`./configure` command.  It is also implied by the presence of the
+not-Python-specific :c:macro:`_DEBUG` macro.  When :c:macro:`Py_DEBUG` is enabled
 in the Unix build, compiler optimization is disabled.
 …
 There may be additional checks not mentioned here.
 Defining :cmacro:`Py_TRACE_REFS` enables reference tracing.  When defined, a
+Defining :c:macro:`Py_TRACE_REFS` enables reference tracing.  When defined, a
 circular doubly linked list of active objects is maintained by adding two extra
 fields to every :ctype:`PyObject`.  Total allocations are tracked as well.  Upon
+fields to every :c:type:`PyObject`.  Total allocations are tracked as well.  Upon
 exit, all existing references are printed.  (In interactive mode this happens
 after every statement run by the interpreter.)  Implied by :cmacro:`Py_DEBUG`.
+after every statement run by the interpreter.)  Implied by :c:macro:`Py_DEBUG`.
 Please refer to :file:`Misc/SpecialBuilds.txt` in the Python source distribution

python/vendor/current/Doc/c-api/iter.rst

-              r2
+              r388
 .. versionadded:: 2.2
 There are only a couple of functions specifically for working with iterators.
+There are two functions specifically for working with iterators.
 .. cfunction:: int PyIter_Check(PyObject *o)
+.. c:function:: int PyIter_Check(PyObject *o)
    Return true if the object *o* supports the iterator protocol.
 .. cfunction:: PyObject* PyIter_Next(PyObject *o)
+.. c:function:: PyObject* PyIter_Next(PyObject *o)
+   Return the next value from the iteration *o*.  If the object is an iterator,
+   this retrieves the next value from the iteration, and returns *NULL* with no
+   exception set if there are no remaining items.  If the object is not an
+   iterator, :exc:`TypeError` is raised, or if there is an error in retrieving the
+   item, returns *NULL* and passes along the exception.
+   Return the next value from the iteration *o*.  The object must be an iterator
+   (it is up to the caller to check this).  If there are no remaining values,
+   returns *NULL* with no exception set.  If an error occurs while retrieving
+   the item, returns *NULL* and passes along the exception.
 To write a loop which iterates over an iterator, the C code should look

python/vendor/current/Doc/c-api/iterator.rst

-              r2
+              r388
 .. cvar:: PyTypeObject PySeqIter_Type
+.. c:var:: PyTypeObject PySeqIter_Type
    Type object for iterator objects returned by :cfunc:`PySeqIter_New` and the
+   Type object for iterator objects returned by :c:func:`PySeqIter_New` and the
    one-argument form of the :func:`iter` built-in function for built-in sequence
    types.
 …
 .. cfunction:: int PySeqIter_Check(op)
+.. c:function:: int PySeqIter_Check(op)
    Return true if the type of *op* is :cdata:`PySeqIter_Type`.
+   Return true if the type of *op* is :c:data:`PySeqIter_Type`.
    .. versionadded:: 2.2
 .. cfunction:: PyObject* PySeqIter_New(PyObject *seq)
+.. c:function:: PyObject* PySeqIter_New(PyObject *seq)
    Return an iterator that works with a general sequence object, *seq*.  The
 …
 .. cvar:: PyTypeObject PyCallIter_Type
+.. c:var:: PyTypeObject PyCallIter_Type
    Type object for iterator objects returned by :cfunc:`PyCallIter_New` and the
+   Type object for iterator objects returned by :c:func:`PyCallIter_New` and the
    two-argument form of the :func:`iter` built-in function.
 …
 .. cfunction:: int PyCallIter_Check(op)
+.. c:function:: int PyCallIter_Check(op)
    Return true if the type of *op* is :cdata:`PyCallIter_Type`.
+   Return true if the type of *op* is :c:data:`PyCallIter_Type`.
    .. versionadded:: 2.2
 .. cfunction:: PyObject* PyCallIter_New(PyObject *callable, PyObject *sentinel)
+.. c:function:: PyObject* PyCallIter_New(PyObject *callable, PyObject *sentinel)
    Return a new iterator.  The first parameter, *callable*, can be any Python

python/vendor/current/Doc/c-api/list.rst

-              r2
+              r388
 .. ctype:: PyListObject
+.. c:type:: PyListObject
    This subtype of :ctype:`PyObject` represents a Python list object.
+   This subtype of :c:type:`PyObject` represents a Python list object.
 .. cvar:: PyTypeObject PyList_Type
+.. c:var:: PyTypeObject PyList_Type
+   .. index:: single: ListType (in module types)
+   This instance of :ctype:`PyTypeObject` represents the Python list type.
+   This is the same object as ``list`` and ``types.ListType`` in the Python
+   layer.
+   This instance of :c:type:`PyTypeObject` represents the Python list type.  This
+   is the same object as ``list`` in the Python layer.
 .. cfunction:: int PyList_Check(PyObject *p)
+.. c:function:: int PyList_Check(PyObject *p)
    Return true if *p* is a list object or an instance of a subtype of the list
 …
 .. cfunction:: int PyList_CheckExact(PyObject *p)
+.. c:function:: int PyList_CheckExact(PyObject *p)
    Return true if *p* is a list object, but not an instance of a subtype of
 …
 .. cfunction:: PyObject* PyList_New(Py_ssize_t len)
+.. c:function:: PyObject* PyList_New(Py_ssize_t len)
    Return a new list of length *len* on success, or *NULL* on failure.
 …
    .. note::
       If *length* is greater than zero, the returned list object's items are
+      If *len* is greater than zero, the returned list object's items are
       set to ``NULL``.  Thus you cannot use abstract API functions such as
       :cfunc:`PySequence_SetItem`  or expose the object to Python code before
       setting all items to a real object with :cfunc:`PyList_SetItem`.
+      :c:func:`PySequence_SetItem`  or expose the object to Python code before
+      setting all items to a real object with :c:func:`PyList_SetItem`.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` for *size*. This might require
+      This function used an :c:type:`int` for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: Py_ssize_t PyList_Size(PyObject *list)
+.. c:function:: Py_ssize_t PyList_Size(PyObject *list)
    .. index:: builtin: len
 …
    .. versionchanged:: 2.5
       This function returned an :ctype:`int`. This might require changes in
+      This function returned an :c:type:`int`. This might require changes in
       your code for properly supporting 64-bit systems.
 .. cfunction:: Py_ssize_t PyList_GET_SIZE(PyObject *list)
+.. c:function:: Py_ssize_t PyList_GET_SIZE(PyObject *list)
    Macro form of :cfunc:`PyList_Size` without error checking.
+   Macro form of :c:func:`PyList_Size` without error checking.
    .. versionchanged:: 2.5
       This macro returned an :ctype:`int`. This might require changes in your
+      This macro returned an :c:type:`int`. This might require changes in your
       code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyList_GetItem(PyObject *list, Py_ssize_t index)
+.. c:function:: PyObject* PyList_GetItem(PyObject *list, Py_ssize_t index)
    Return the object at position *pos* in the list pointed to by *p*.  The
+   Return the object at position *index* in the list pointed to by *list*.  The
    position must be positive, indexing from the end of the list is not
    supported.  If *pos* is out of bounds, return *NULL* and set an
+   supported.  If *index* is out of bounds, return *NULL* and set an
    :exc:`IndexError` exception.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` for *index*. This might require
+      This function used an :c:type:`int` for *index*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyList_GET_ITEM(PyObject *list, Py_ssize_t i)
+.. c:function:: PyObject* PyList_GET_ITEM(PyObject *list, Py_ssize_t i)
    Macro form of :cfunc:`PyList_GetItem` without error checking.
+   Macro form of :c:func:`PyList_GetItem` without error checking.
    .. versionchanged:: 2.5
       This macro used an :ctype:`int` for *i*. This might require changes in
+      This macro used an :c:type:`int` for *i*. This might require changes in
       your code for properly supporting 64-bit systems.
 .. cfunction:: int PyList_SetItem(PyObject *list, Py_ssize_t index, PyObject *item)
+.. c:function:: int PyList_SetItem(PyObject *list, Py_ssize_t index, PyObject *item)
    Set the item at index *index* in list to *item*.  Return ``0`` on success
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` for *index*. This might require
+      This function used an :c:type:`int` for *index*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: void PyList_SET_ITEM(PyObject *list, Py_ssize_t i, PyObject *o)
+.. c:function:: void PyList_SET_ITEM(PyObject *list, Py_ssize_t i, PyObject *o)
    Macro form of :cfunc:`PyList_SetItem` without error checking. This is
+   Macro form of :c:func:`PyList_SetItem` without error checking. This is
    normally only used to fill in new lists where there is no previous content.
 …
       This macro "steals" a reference to *item*, and, unlike
       :cfunc:`PyList_SetItem`, does *not* discard a reference to any item that
+      :c:func:`PyList_SetItem`, does *not* discard a reference to any item that
       it being replaced; any reference in *list* at position *i* will be
       leaked.
    .. versionchanged:: 2.5
       This macro used an :ctype:`int` for *i*. This might require
+      This macro used an :c:type:`int` for *i*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: int PyList_Insert(PyObject *list, Py_ssize_t index, PyObject *item)
+.. c:function:: int PyList_Insert(PyObject *list, Py_ssize_t index, PyObject *item)
    Insert the item *item* into list *list* in front of index *index*.  Return
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` for *index*. This might require
+      This function used an :c:type:`int` for *index*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: int PyList_Append(PyObject *list, PyObject *item)
+.. c:function:: int PyList_Append(PyObject *list, PyObject *item)
    Append the object *item* at the end of list *list*. Return ``0`` if
 …
 .. cfunction:: PyObject* PyList_GetSlice(PyObject *list, Py_ssize_t low, Py_ssize_t high)
+.. c:function:: PyObject* PyList_GetSlice(PyObject *list, Py_ssize_t low, Py_ssize_t high)
    Return a list of the objects in *list* containing the objects *between* *low*
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` for *low* and *high*. This might
+      This function used an :c:type:`int` for *low* and *high*. This might
       require changes in your code for properly supporting 64-bit systems.
 .. cfunction:: int PyList_SetSlice(PyObject *list, Py_ssize_t low, Py_ssize_t high, PyObject *itemlist)
+.. c:function:: int PyList_SetSlice(PyObject *list, Py_ssize_t low, Py_ssize_t high, PyObject *itemlist)
    Set the slice of *list* between *low* and *high* to the contents of
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` for *low* and *high*. This might
+      This function used an :c:type:`int` for *low* and *high*. This might
       require changes in your code for properly supporting 64-bit systems.
 .. cfunction:: int PyList_Sort(PyObject *list)
+.. c:function:: int PyList_Sort(PyObject *list)
    Sort the items of *list* in place.  Return ``0`` on success, ``-1`` on
 …
 .. cfunction:: int PyList_Reverse(PyObject *list)
+.. c:function:: int PyList_Reverse(PyObject *list)
    Reverse the items of *list* in place.  Return ``0`` on success, ``-1`` on
 …
 .. cfunction:: PyObject* PyList_AsTuple(PyObject *list)
+.. c:function:: PyObject* PyList_AsTuple(PyObject *list)
    .. index:: builtin: tuple

python/vendor/current/Doc/c-api/long.rst

-              r2
+              r388
 .. ctype:: PyLongObject
    This subtype of :ctype:`PyObject` represents a Python long integer object.
 .. cvar:: PyTypeObject PyLong_Type
+.. c:type:: PyLongObject
+   This subtype of :c:type:`PyObject` represents a Python long integer object.
+.. c:var:: PyTypeObject PyLong_Type
    .. index:: single: LongType (in modules types)
    This instance of :ctype:`PyTypeObject` represents the Python long integer type.
+   This instance of :c:type:`PyTypeObject` represents the Python long integer type.
    This is the same object as ``long`` and ``types.LongType``.
 .. cfunction:: int PyLong_Check(PyObject *p)
    Return true if its argument is a :ctype:`PyLongObject` or a subtype of
    :ctype:`PyLongObject`.
+.. c:function:: int PyLong_Check(PyObject *p)
+   Return true if its argument is a :c:type:`PyLongObject` or a subtype of
+   :c:type:`PyLongObject`.
    .. versionchanged:: 2.2
 …
 .. cfunction:: int PyLong_CheckExact(PyObject *p)
    Return true if its argument is a :ctype:`PyLongObject`, but not a subtype of
    :ctype:`PyLongObject`.
+.. c:function:: int PyLong_CheckExact(PyObject *p)
+   Return true if its argument is a :c:type:`PyLongObject`, but not a subtype of
+   :c:type:`PyLongObject`.
    .. versionadded:: 2.2
 .. cfunction:: PyObject* PyLong_FromLong(long v)
    Return a new :ctype:`PyLongObject` object from *v*, or *NULL* on failure.
 .. cfunction:: PyObject* PyLong_FromUnsignedLong(unsigned long v)
    Return a new :ctype:`PyLongObject` object from a C :ctype:`unsigned long`, or
    *NULL* on failure.
 .. cfunction:: PyObject* PyLong_FromSsize_t(Py_ssize_t v)
    Return a new :ctype:`PyLongObject` object from a C :ctype:`Py_ssize_t`, or
    *NULL* on failure.
    .. versionadded:: 2.6
 .. cfunction:: PyObject* PyLong_FromSize_t(size_t v)
    Return a new :ctype:`PyLongObject` object from a C :ctype:`size_t`, or
    *NULL* on failure.
    .. versionadded:: 2.6
 .. cfunction:: PyObject* PyLong_FromLongLong(PY_LONG_LONG v)
    Return a new :ctype:`PyLongObject` object from a C :ctype:`long long`, or *NULL*
+.. c:function:: PyObject* PyLong_FromLong(long v)
+   Return a new :c:type:`PyLongObject` object from *v*, or *NULL* on failure.
+.. c:function:: PyObject* PyLong_FromUnsignedLong(unsigned long v)
+   Return a new :c:type:`PyLongObject` object from a C :c:type:`unsigned long`, or
+   *NULL* on failure.
+.. c:function:: PyObject* PyLong_FromSsize_t(Py_ssize_t v)
+   Return a new :c:type:`PyLongObject` object from a C :c:type:`Py_ssize_t`, or
+   *NULL* on failure.
+   .. versionadded:: 2.6
+.. c:function:: PyObject* PyLong_FromSize_t(size_t v)
+   Return a new :c:type:`PyLongObject` object from a C :c:type:`size_t`, or
+   *NULL* on failure.
+   .. versionadded:: 2.6
+.. c:function:: PyObject* PyLong_FromSsize_t(Py_ssize_t v)
+   Return a new :c:type:`PyLongObject` object with a value of *v*, or *NULL*
    on failure.
+.. cfunction:: PyObject* PyLong_FromUnsignedLongLong(unsigned PY_LONG_LONG v)
+   Return a new :ctype:`PyLongObject` object from a C :ctype:`unsigned long long`,
+   .. versionadded:: 2.6
+.. c:function:: PyObject* PyLong_FromSize_t(size_t v)
+   Return a new :c:type:`PyLongObject` object with a value of *v*, or *NULL*
+   on failure.
+   .. versionadded:: 2.6
+.. c:function:: PyObject* PyLong_FromLongLong(PY_LONG_LONG v)
+   Return a new :c:type:`PyLongObject` object from a C :c:type:`long long`, or *NULL*
+   on failure.
+.. c:function:: PyObject* PyLong_FromUnsignedLongLong(unsigned PY_LONG_LONG v)
+   Return a new :c:type:`PyLongObject` object from a C :c:type:`unsigned long long`,
    or *NULL* on failure.
 .. cfunction:: PyObject* PyLong_FromDouble(double v)
    Return a new :ctype:`PyLongObject` object from the integer part of *v*, or
    *NULL* on failure.
 .. cfunction:: PyObject* PyLong_FromString(char *str, char **pend, int base)
    Return a new :ctype:`PyLongObject` based on the string value in *str*, which is
+.. c:function:: PyObject* PyLong_FromDouble(double v)
+   Return a new :c:type:`PyLongObject` object from the integer part of *v*, or
+   *NULL* on failure.
+.. c:function:: PyObject* PyLong_FromString(char *str, char **pend, int base)
+   Return a new :c:type:`PyLongObject` based on the string value in *str*, which is
    interpreted according to the radix in *base*.  If *pend* is non-*NULL*,
    ``*pend`` will point to the first character in *str* which follows the
+   *\*pend* will point to the first character in *str* which follows the
    representation of the number.  If *base* is ``0``, the radix will be determined
    based on the leading characters of *str*: if *str* starts with ``'0x'`` or
 …
 .. cfunction:: PyObject* PyLong_FromUnicode(Py_UNICODE *u, Py_ssize_t length, int base)
+.. c:function:: PyObject* PyLong_FromUnicode(Py_UNICODE *u, Py_ssize_t length, int base)
    Convert a sequence of Unicode digits to a Python long integer value.  The first
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` for *length*. This might require
+      This function used an :c:type:`int` for *length*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyLong_FromVoidPtr(void *p)
+.. c:function:: PyObject* PyLong_FromVoidPtr(void *p)
    Create a Python integer or long integer from the pointer *p*. The pointer value
    can be retrieved from the resulting value using :cfunc:`PyLong_AsVoidPtr`.
+   can be retrieved from the resulting value using :c:func:`PyLong_AsVoidPtr`.
    .. versionadded:: 1.5.2
 …
 .. cfunction:: long PyLong_AsLong(PyObject *pylong)
+.. c:function:: long PyLong_AsLong(PyObject *pylong)
    .. index::
 …
       single: OverflowError (built-in exception)
    Return a C :ctype:`long` representation of the contents of *pylong*.  If
+   Return a C :c:type:`long` representation of the contents of *pylong*.  If
    *pylong* is greater than :const:`LONG_MAX`, an :exc:`OverflowError` is raised
    and ``-1`` will be returned.
+.. cfunction:: Py_ssize_t PyLong_AsSsize_t(PyObject *pylong)
+.. c:function:: long PyLong_AsLongAndOverflow(PyObject *pylong, int *overflow)
+   Return a C :c:type:`long` representation of the contents of
+   *pylong*.  If *pylong* is greater than :const:`LONG_MAX` or less
+   than :const:`LONG_MIN`, set *\*overflow* to ``1`` or ``-1``,
+   respectively, and return ``-1``; otherwise, set *\*overflow* to
+   ``0``.  If any other exception occurs (for example a TypeError or
+   MemoryError), then ``-1`` will be returned and *\*overflow* will
+   be ``0``.
+   .. versionadded:: 2.7
+.. c:function:: PY_LONG_LONG PyLong_AsLongLongAndOverflow(PyObject *pylong, int *overflow)
+   Return a C :c:type:`long long` representation of the contents of
+   *pylong*.  If *pylong* is greater than :const:`PY_LLONG_MAX` or less
+   than :const:`PY_LLONG_MIN`, set *\*overflow* to ``1`` or ``-1``,
+   respectively, and return ``-1``; otherwise, set *\*overflow* to
+   ``0``.  If any other exception occurs (for example a TypeError or
+   MemoryError), then ``-1`` will be returned and *\*overflow* will
+   be ``0``.
+   .. versionadded:: 2.7
+.. c:function:: Py_ssize_t PyLong_AsSsize_t(PyObject *pylong)
    .. index::
 …
       single: OverflowError (built-in exception)
    Return a C :ctype:`Py_ssize_t` representation of the contents of *pylong*.  If
+   Return a C :c:type:`Py_ssize_t` representation of the contents of *pylong*.  If
    *pylong* is greater than :const:`PY_SSIZE_T_MAX`, an :exc:`OverflowError` is raised
    and ``-1`` will be returned.
 …
 .. cfunction:: unsigned long PyLong_AsUnsignedLong(PyObject *pylong)
+.. c:function:: unsigned long PyLong_AsUnsignedLong(PyObject *pylong)
    .. index::
 …
       single: OverflowError (built-in exception)
    Return a C :ctype:`unsigned long` representation of the contents of *pylong*.
+   Return a C :c:type:`unsigned long` representation of the contents of *pylong*.
    If *pylong* is greater than :const:`ULONG_MAX`, an :exc:`OverflowError` is
    raised.
+.. cfunction:: PY_LONG_LONG PyLong_AsLongLong(PyObject *pylong)
+   Return a C :ctype:`long long` from a Python long integer.  If *pylong* cannot be
+   represented as a :ctype:`long long`, an :exc:`OverflowError` will be raised.
+.. c:function:: Py_ssize_t PyLong_AsSsize_t(PyObject *pylong)
+   .. index::
+      single: PY_SSIZE_T_MAX
+   Return a :c:type:`Py_ssize_t` representation of the contents of *pylong*.  If
+   *pylong* is greater than :const:`PY_SSIZE_T_MAX`, an :exc:`OverflowError` is
+   raised.
+   .. versionadded:: 2.6
+.. c:function:: PY_LONG_LONG PyLong_AsLongLong(PyObject *pylong)
+   .. index::
+      single: OverflowError (built-in exception)
+   Return a C :c:type:`long long` from a Python long integer.  If
+   *pylong* cannot be represented as a :c:type:`long long`, an
+   :exc:`OverflowError` is raised and ``-1`` is returned.
    .. versionadded:: 2.2
+.. cfunction:: unsigned PY_LONG_LONG PyLong_AsUnsignedLongLong(PyObject *pylong)
+   Return a C :ctype:`unsigned long long` from a Python long integer. If *pylong*
+   cannot be represented as an :ctype:`unsigned long long`, an :exc:`OverflowError`
+   will be raised if the value is positive, or a :exc:`TypeError` will be raised if
+   the value is negative.
+.. c:function:: unsigned PY_LONG_LONG PyLong_AsUnsignedLongLong(PyObject *pylong)
+   .. index::
+      single: OverflowError (built-in exception)
+   Return a C :c:type:`unsigned long long` from a Python long integer. If
+   *pylong* cannot be represented as an :c:type:`unsigned long long`, an
+   :exc:`OverflowError` is raised and ``(unsigned long long)-1`` is
+   returned.
    .. versionadded:: 2.2
+.. cfunction:: unsigned long PyLong_AsUnsignedLongMask(PyObject *io)
+   Return a C :ctype:`unsigned long` from a Python long integer, without checking
+   .. versionchanged:: 2.7
+      A negative *pylong* now raises :exc:`OverflowError`, not
+      :exc:`TypeError`.
+.. c:function:: unsigned long PyLong_AsUnsignedLongMask(PyObject *io)
+   Return a C :c:type:`unsigned long` from a Python long integer, without checking
    for overflow.
 …
 .. cfunction:: unsigned PY_LONG_LONG PyLong_AsUnsignedLongLongMask(PyObject *io)
    Return a C :ctype:`unsigned long long` from a Python long integer, without
+.. c:function:: unsigned PY_LONG_LONG PyLong_AsUnsignedLongLongMask(PyObject *io)
+   Return a C :c:type:`unsigned long long` from a Python long integer, without
    checking for overflow.
 …
 .. cfunction:: double PyLong_AsDouble(PyObject *pylong)
    Return a C :ctype:`double` representation of the contents of *pylong*.  If
    *pylong* cannot be approximately represented as a :ctype:`double`, an
+.. c:function:: double PyLong_AsDouble(PyObject *pylong)
+   Return a C :c:type:`double` representation of the contents of *pylong*.  If
+   *pylong* cannot be approximately represented as a :c:type:`double`, an
    :exc:`OverflowError` exception is raised and ``-1.0`` will be returned.
 .. cfunction:: void* PyLong_AsVoidPtr(PyObject *pylong)
    Convert a Python integer or long integer *pylong* to a C :ctype:`void` pointer.
+.. c:function:: void* PyLong_AsVoidPtr(PyObject *pylong)
+   Convert a Python integer or long integer *pylong* to a C :c:type:`void` pointer.
    If *pylong* cannot be converted, an :exc:`OverflowError` will be raised.  This
    is only assured to produce a usable :ctype:`void` pointer for values created
    with :cfunc:`PyLong_FromVoidPtr`.
+   is only assured to produce a usable :c:type:`void` pointer for values created
+   with :c:func:`PyLong_FromVoidPtr`.
    .. versionadded:: 1.5.2

python/vendor/current/Doc/c-api/mapping.rst

-              r2
+              r388
 .. cfunction:: int PyMapping_Check(PyObject *o)
+.. c:function:: int PyMapping_Check(PyObject *o)
    Return ``1`` if the object provides mapping protocol, and ``0`` otherwise.  This
 …
 .. cfunction:: Py_ssize_t PyMapping_Size(PyObject *o)
+.. c:function:: Py_ssize_t PyMapping_Size(PyObject *o)
                Py_ssize_t PyMapping_Length(PyObject *o)
 …
    .. versionchanged:: 2.5
       These functions returned an :ctype:`int` type. This might require
+      These functions returned an :c:type:`int` type. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: int PyMapping_DelItemString(PyObject *o, char *key)
+.. c:function:: int PyMapping_DelItemString(PyObject *o, char *key)
    Remove the mapping for object *key* from the object *o*. Return ``-1`` on
 …
 .. cfunction:: int PyMapping_DelItem(PyObject *o, PyObject *key)
+.. c:function:: int PyMapping_DelItem(PyObject *o, PyObject *key)
    Remove the mapping for object *key* from the object *o*. Return ``-1`` on
 …
 .. cfunction:: int PyMapping_HasKeyString(PyObject *o, char *key)
+.. c:function:: int PyMapping_HasKeyString(PyObject *o, char *key)
    On success, return ``1`` if the mapping object has the key *key* and ``0``
 …
 .. cfunction:: int PyMapping_HasKey(PyObject *o, PyObject *key)
+.. c:function:: int PyMapping_HasKey(PyObject *o, PyObject *key)
    Return ``1`` if the mapping object has the key *key* and ``0`` otherwise.
 …
 .. cfunction:: PyObject* PyMapping_Keys(PyObject *o)
+.. c:function:: PyObject* PyMapping_Keys(PyObject *o)
    On success, return a list of the keys in object *o*.  On failure, return *NULL*.
 …
 .. cfunction:: PyObject* PyMapping_Values(PyObject *o)
+.. c:function:: PyObject* PyMapping_Values(PyObject *o)
    On success, return a list of the values in object *o*.  On failure, return
 …
 .. cfunction:: PyObject* PyMapping_Items(PyObject *o)
+.. c:function:: PyObject* PyMapping_Items(PyObject *o)
    On success, return a list of the items in object *o*, where each item is a tuple
 …
 .. cfunction:: PyObject* PyMapping_GetItemString(PyObject *o, char *key)
+.. c:function:: PyObject* PyMapping_GetItemString(PyObject *o, char *key)
    Return element of *o* corresponding to the object *key* or *NULL* on failure.
 …
 .. cfunction:: int PyMapping_SetItemString(PyObject *o, char *key, PyObject *v)
+.. c:function:: int PyMapping_SetItemString(PyObject *o, char *key, PyObject *v)
    Map the object *key* to the value *v* in object *o*. Returns ``-1`` on failure.

python/vendor/current/Doc/c-api/marshal.rst

-              r2
+              r388
 .. cfunction:: void PyMarshal_WriteLongToFile(long value, FILE *file, int version)
+.. c:function:: void PyMarshal_WriteLongToFile(long value, FILE *file, int version)
    Marshal a :ctype:`long` integer, *value*, to *file*.  This will only write
+   Marshal a :c:type:`long` integer, *value*, to *file*.  This will only write
    the least-significant 32 bits of *value*; regardless of the size of the
    native :ctype:`long` type.
+   native :c:type:`long` type.
    .. versionchanged:: 2.4
 …
 .. cfunction:: void PyMarshal_WriteObjectToFile(PyObject *value, FILE *file, int version)
+.. c:function:: void PyMarshal_WriteObjectToFile(PyObject *value, FILE *file, int version)
    Marshal a Python object, *value*, to *file*.
 …
 .. cfunction:: PyObject* PyMarshal_WriteObjectToString(PyObject *value, int version)
+.. c:function:: PyObject* PyMarshal_WriteObjectToString(PyObject *value, int version)
    Return a string object containing the marshalled representation of *value*.
 …
 .. cfunction:: long PyMarshal_ReadLongFromFile(FILE *file)
+.. c:function:: long PyMarshal_ReadLongFromFile(FILE *file)
    Return a C :ctype:`long` from the data stream in a :ctype:`FILE\*` opened
+   Return a C :c:type:`long` from the data stream in a :c:type:`FILE\*` opened
    for reading.  Only a 32-bit value can be read in using this function,
    regardless of the native size of :ctype:`long`.
+   regardless of the native size of :c:type:`long`.
 .. cfunction:: int PyMarshal_ReadShortFromFile(FILE *file)
+.. c:function:: int PyMarshal_ReadShortFromFile(FILE *file)
    Return a C :ctype:`short` from the data stream in a :ctype:`FILE\*` opened
+   Return a C :c:type:`short` from the data stream in a :c:type:`FILE\*` opened
    for reading.  Only a 16-bit value can be read in using this function,
    regardless of the native size of :ctype:`short`.
+   regardless of the native size of :c:type:`short`.
 .. cfunction:: PyObject* PyMarshal_ReadObjectFromFile(FILE *file)
+.. c:function:: PyObject* PyMarshal_ReadObjectFromFile(FILE *file)
    Return a Python object from the data stream in a :ctype:`FILE\*` opened for
+   Return a Python object from the data stream in a :c:type:`FILE\*` opened for
    reading.  On error, sets the appropriate exception (:exc:`EOFError` or
    :exc:`TypeError`) and returns *NULL*.
 .. cfunction:: PyObject* PyMarshal_ReadLastObjectFromFile(FILE *file)
+.. c:function:: PyObject* PyMarshal_ReadLastObjectFromFile(FILE *file)
    Return a Python object from the data stream in a :ctype:`FILE\*` opened for
    reading.  Unlike :cfunc:`PyMarshal_ReadObjectFromFile`, this function
+   Return a Python object from the data stream in a :c:type:`FILE\*` opened for
+   reading.  Unlike :c:func:`PyMarshal_ReadObjectFromFile`, this function
    assumes that no further objects will be read from the file, allowing it to
    aggressively load file data into memory so that the de-serialization can
 …
 .. cfunction:: PyObject* PyMarshal_ReadObjectFromString(char *string, Py_ssize_t len)
+.. c:function:: PyObject* PyMarshal_ReadObjectFromString(char *string, Py_ssize_t len)
    Return a Python object from the data stream in a character buffer
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *len*. This might require
+      This function used an :c:type:`int` type for *len*. This might require
       changes in your code for properly supporting 64-bit systems.

python/vendor/current/Doc/c-api/memory.rst

-              r2
+              r388
 To avoid memory corruption, extension writers should never try to operate on
 Python objects with the functions exported by the C library: :cfunc:`malloc`,
 :cfunc:`calloc`, :cfunc:`realloc` and :cfunc:`free`.  This will result in  mixed
+Python objects with the functions exported by the C library: :c:func:`malloc`,
+:c:func:`calloc`, :c:func:`realloc` and :c:func:`free`.  This will result in  mixed
 calls between the C allocator and the Python memory manager with fatal
 consequences, because they implement different algorithms and operate on
 …
 .. cfunction:: void* PyMem_Malloc(size_t n)
    Allocates *n* bytes and returns a pointer of type :ctype:`void\*` to the
+.. c:function:: void* PyMem_Malloc(size_t n)
+   Allocates *n* bytes and returns a pointer of type :c:type:`void\*` to the
    allocated memory, or *NULL* if the request fails. Requesting zero bytes returns
    a distinct non-*NULL* pointer if possible, as if :cfunc:`PyMem_Malloc(1)` had
+   a distinct non-*NULL* pointer if possible, as if ``PyMem_Malloc(1)`` had
    been called instead. The memory will not have been initialized in any way.
 .. cfunction:: void* PyMem_Realloc(void *p, size_t n)
+.. c:function:: void* PyMem_Realloc(void *p, size_t n)
    Resizes the memory block pointed to by *p* to *n* bytes. The contents will be
    unchanged to the minimum of the old and the new sizes. If *p* is *NULL*, the
    call is equivalent to :cfunc:`PyMem_Malloc(n)`; else if *n* is equal to zero,
+   call is equivalent to ``PyMem_Malloc(n)``; else if *n* is equal to zero,
    the memory block is resized but is not freed, and the returned pointer is
    non-*NULL*.  Unless *p* is *NULL*, it must have been returned by a previous call
    to :cfunc:`PyMem_Malloc` or :cfunc:`PyMem_Realloc`. If the request fails,
    :cfunc:`PyMem_Realloc` returns *NULL* and *p* remains a valid pointer to the
+   to :c:func:`PyMem_Malloc` or :c:func:`PyMem_Realloc`. If the request fails,
+   :c:func:`PyMem_Realloc` returns *NULL* and *p* remains a valid pointer to the
    previous memory area.
 .. cfunction:: void PyMem_Free(void *p)
+.. c:function:: void PyMem_Free(void *p)
    Frees the memory block pointed to by *p*, which must have been returned by a
    previous call to :cfunc:`PyMem_Malloc` or :cfunc:`PyMem_Realloc`.  Otherwise, or
    if :cfunc:`PyMem_Free(p)` has been called before, undefined behavior occurs. If
+   previous call to :c:func:`PyMem_Malloc` or :c:func:`PyMem_Realloc`.  Otherwise, or
+   if ``PyMem_Free(p)`` has been called before, undefined behavior occurs. If
    *p* is *NULL*, no operation is performed.
 …
 .. cfunction:: TYPE* PyMem_New(TYPE, size_t n)
    Same as :cfunc:`PyMem_Malloc`, but allocates ``(n * sizeof(TYPE))`` bytes of
    memory.  Returns a pointer cast to :ctype:`TYPE\*`.  The memory will not have
+.. c:function:: TYPE* PyMem_New(TYPE, size_t n)
+   Same as :c:func:`PyMem_Malloc`, but allocates ``(n * sizeof(TYPE))`` bytes of
+   memory.  Returns a pointer cast to :c:type:`TYPE\*`.  The memory will not have
    been initialized in any way.
 .. cfunction:: TYPE* PyMem_Resize(void *p, TYPE, size_t n)
    Same as :cfunc:`PyMem_Realloc`, but the memory block is resized to ``(n *
    sizeof(TYPE))`` bytes.  Returns a pointer cast to :ctype:`TYPE\*`. On return,
+.. c:function:: TYPE* PyMem_Resize(void *p, TYPE, size_t n)
+   Same as :c:func:`PyMem_Realloc`, but the memory block is resized to ``(n *
+   sizeof(TYPE))`` bytes.  Returns a pointer cast to :c:type:`TYPE\*`. On return,
    *p* will be a pointer to the new memory area, or *NULL* in the event of
    failure.  This is a C preprocessor macro; p is always reassigned.  Save
 …
 .. cfunction:: void PyMem_Del(void *p)
    Same as :cfunc:`PyMem_Free`.
+.. c:function:: void PyMem_Del(void *p)
+   Same as :c:func:`PyMem_Free`.
 In addition, the following macro sets are provided for calling the Python memory
 …
 versions and is therefore deprecated in extension modules.
 :cfunc:`PyMem_MALLOC`, :cfunc:`PyMem_REALLOC`, :cfunc:`PyMem_FREE`.
 :cfunc:`PyMem_NEW`, :cfunc:`PyMem_RESIZE`, :cfunc:`PyMem_DEL`.
+:c:func:`PyMem_MALLOC`, :c:func:`PyMem_REALLOC`, :c:func:`PyMem_FREE`.
+:c:func:`PyMem_NEW`, :c:func:`PyMem_RESIZE`, :c:func:`PyMem_DEL`.
 …
 In addition to the functions aimed at handling raw memory blocks from the Python
 heap, objects in Python are allocated and released with :cfunc:`PyObject_New`,
 :cfunc:`PyObject_NewVar` and :cfunc:`PyObject_Del`.
+heap, objects in Python are allocated and released with :c:func:`PyObject_New`,
+:c:func:`PyObject_NewVar` and :c:func:`PyObject_Del`.
 These will be explained in the next chapter on defining and implementing new

python/vendor/current/Doc/c-api/method.rst

-              r2
+              r388
 .. cvar:: PyTypeObject PyMethod_Type
+.. c:var:: PyTypeObject PyMethod_Type
    .. index:: single: MethodType (in module types)
    This instance of :ctype:`PyTypeObject` represents the Python method type.  This
+   This instance of :c:type:`PyTypeObject` represents the Python method type.  This
    is exposed to Python programs as ``types.MethodType``.
 .. cfunction:: int PyMethod_Check(PyObject *o)
+.. c:function:: int PyMethod_Check(PyObject *o)
    Return true if *o* is a method object (has type :cdata:`PyMethod_Type`).  The
+   Return true if *o* is a method object (has type :c:data:`PyMethod_Type`).  The
    parameter must not be *NULL*.
 .. cfunction:: PyObject* PyMethod_New(PyObject *func, PyObject *self, PyObject *class)
+.. c:function:: PyObject* PyMethod_New(PyObject *func, PyObject *self, PyObject *class)
    Return a new method object, with *func* being any callable object; this is the
 …
 .. cfunction:: PyObject* PyMethod_Class(PyObject *meth)
+.. c:function:: PyObject* PyMethod_Class(PyObject *meth)
    Return the class object from which the method *meth* was created; if this was
 …
 .. cfunction:: PyObject* PyMethod_GET_CLASS(PyObject *meth)
+.. c:function:: PyObject* PyMethod_GET_CLASS(PyObject *meth)
    Macro version of :cfunc:`PyMethod_Class` which avoids error checking.
+   Macro version of :c:func:`PyMethod_Class` which avoids error checking.
 .. cfunction:: PyObject* PyMethod_Function(PyObject *meth)
+.. c:function:: PyObject* PyMethod_Function(PyObject *meth)
    Return the function object associated with the method *meth*.
 .. cfunction:: PyObject* PyMethod_GET_FUNCTION(PyObject *meth)
+.. c:function:: PyObject* PyMethod_GET_FUNCTION(PyObject *meth)
    Macro version of :cfunc:`PyMethod_Function` which avoids error checking.
+   Macro version of :c:func:`PyMethod_Function` which avoids error checking.
 .. cfunction:: PyObject* PyMethod_Self(PyObject *meth)
+.. c:function:: PyObject* PyMethod_Self(PyObject *meth)
    Return the instance associated with the method *meth* if it is bound, otherwise
 …
 .. cfunction:: PyObject* PyMethod_GET_SELF(PyObject *meth)
+.. c:function:: PyObject* PyMethod_GET_SELF(PyObject *meth)
    Macro version of :cfunc:`PyMethod_Self` which avoids error checking.
+   Macro version of :c:func:`PyMethod_Self` which avoids error checking.
 .. cfunction:: int PyMethod_ClearFreeList()
+.. c:function:: int PyMethod_ClearFreeList()
    Clear the free list. Return the total number of freed items.

python/vendor/current/Doc/c-api/module.rst

-              r2
+              r388
 .. cvar:: PyTypeObject PyModule_Type
+.. c:var:: PyTypeObject PyModule_Type
    .. index:: single: ModuleType (in module types)
    This instance of :ctype:`PyTypeObject` represents the Python module type.  This
+   This instance of :c:type:`PyTypeObject` represents the Python module type.  This
    is exposed to Python programs as ``types.ModuleType``.
 .. cfunction:: int PyModule_Check(PyObject *p)
+.. c:function:: int PyModule_Check(PyObject *p)
    Return true if *p* is a module object, or a subtype of a module object.
 …
 .. cfunction:: int PyModule_CheckExact(PyObject *p)
+.. c:function:: int PyModule_CheckExact(PyObject *p)
    Return true if *p* is a module object, but not a subtype of
    :cdata:`PyModule_Type`.
+   :c:data:`PyModule_Type`.
    .. versionadded:: 2.2
 .. cfunction:: PyObject* PyModule_New(const char *name)
+.. c:function:: PyObject* PyModule_New(const char *name)
    .. index::
 …
 .. cfunction:: PyObject* PyModule_GetDict(PyObject *module)
+.. c:function:: PyObject* PyModule_GetDict(PyObject *module)
    .. index:: single: __dict__ (module attribute)
 …
    is the same as the :attr:`__dict__` attribute of the module object.  This
    function never fails.  It is recommended extensions use other
    :cfunc:`PyModule_\*` and :cfunc:`PyObject_\*` functions rather than directly
+   :c:func:`PyModule_\*` and :c:func:`PyObject_\*` functions rather than directly
    manipulate a module's :attr:`__dict__`.
 .. cfunction:: char* PyModule_GetName(PyObject *module)
+.. c:function:: char* PyModule_GetName(PyObject *module)
    .. index::
 …
 .. cfunction:: char* PyModule_GetFilename(PyObject *module)
+.. c:function:: char* PyModule_GetFilename(PyObject *module)
    .. index::
 …
 .. cfunction:: int PyModule_AddObject(PyObject *module, const char *name, PyObject *value)
+.. c:function:: int PyModule_AddObject(PyObject *module, const char *name, PyObject *value)
    Add an object to *module* as *name*.  This is a convenience function which can
 …
 .. cfunction:: int PyModule_AddIntConstant(PyObject *module, const char *name, long value)
+.. c:function:: int PyModule_AddIntConstant(PyObject *module, const char *name, long value)
    Add an integer constant to *module* as *name*.  This convenience function can be
 …
 .. cfunction:: int PyModule_AddStringConstant(PyObject *module, const char *name, const char *value)
+.. c:function:: int PyModule_AddStringConstant(PyObject *module, const char *name, const char *value)
    Add a string constant to *module* as *name*.  This convenience function can be
 …
    .. versionadded:: 2.0
 .. cfunction:: int PyModule_AddIntMacro(PyObject *module, macro)
+.. c:function:: int PyModule_AddIntMacro(PyObject *module, macro)
    Add an int constant to *module*. The name and the value are taken from
    *macro*. For example ``PyModule_AddConstant(module, AF_INET)`` adds the int
+   *macro*. For example ``PyModule_AddIntMacro(module, AF_INET)`` adds the int
    constant *AF_INET* with the value of *AF_INET* to *module*.
    Return ``-1`` on error, ``0`` on success.
 …
    .. versionadded:: 2.6
 .. cfunction:: int PyModule_AddStringMacro(PyObject *module, macro)
+.. c:function:: int PyModule_AddStringMacro(PyObject *module, macro)
    Add a string constant to *module*.

python/vendor/current/Doc/c-api/none.rst

-              r2
+              r388
 .. index:: object: None
 Note that the :ctype:`PyTypeObject` for ``None`` is not directly exposed in the
+Note that the :c:type:`PyTypeObject` for ``None`` is not directly exposed in the
 Python/C API.  Since ``None`` is a singleton, testing for object identity (using
 ``==`` in C) is sufficient. There is no :cfunc:`PyNone_Check` function for the
+``==`` in C) is sufficient. There is no :c:func:`PyNone_Check` function for the
 same reason.
 .. cvar:: PyObject* Py_None
+.. c:var:: PyObject* Py_None
    The Python ``None`` object, denoting lack of value.  This object has no methods.
 …
 .. cmacro:: Py_RETURN_NONE
+.. c:macro:: Py_RETURN_NONE
    Properly handle returning :cdata:`Py_None` from within a C function.
+   Properly handle returning :c:data:`Py_None` from within a C function.
    .. versionadded:: 2.4

python/vendor/current/Doc/c-api/number.rst

-              r2
+              r388
 .. cfunction:: int PyNumber_Check(PyObject *o)
+.. c:function:: int PyNumber_Check(PyObject *o)
    Returns ``1`` if the object *o* provides numeric protocols, and false otherwise.
 …
 .. cfunction:: PyObject* PyNumber_Add(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_Add(PyObject *o1, PyObject *o2)
    Returns the result of adding *o1* and *o2*, or *NULL* on failure.  This is the
 …
 .. cfunction:: PyObject* PyNumber_Subtract(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_Subtract(PyObject *o1, PyObject *o2)
    Returns the result of subtracting *o2* from *o1*, or *NULL* on failure.  This is
 …
 .. cfunction:: PyObject* PyNumber_Multiply(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_Multiply(PyObject *o1, PyObject *o2)
    Returns the result of multiplying *o1* and *o2*, or *NULL* on failure.  This is
 …
 .. cfunction:: PyObject* PyNumber_Divide(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_Divide(PyObject *o1, PyObject *o2)
    Returns the result of dividing *o1* by *o2*, or *NULL* on failure.  This is the
 …
 .. cfunction:: PyObject* PyNumber_FloorDivide(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_FloorDivide(PyObject *o1, PyObject *o2)
    Return the floor of *o1* divided by *o2*, or *NULL* on failure.  This is
 …
 .. cfunction:: PyObject* PyNumber_TrueDivide(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_TrueDivide(PyObject *o1, PyObject *o2)
    Return a reasonable approximation for the mathematical value of *o1* divided by
 …
 .. cfunction:: PyObject* PyNumber_Remainder(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_Remainder(PyObject *o1, PyObject *o2)
    Returns the remainder of dividing *o1* by *o2*, or *NULL* on failure.  This is
 …
 .. cfunction:: PyObject* PyNumber_Divmod(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_Divmod(PyObject *o1, PyObject *o2)
    .. index:: builtin: divmod
 …
 .. cfunction:: PyObject* PyNumber_Power(PyObject *o1, PyObject *o2, PyObject *o3)
+.. c:function:: PyObject* PyNumber_Power(PyObject *o1, PyObject *o2, PyObject *o3)
    .. index:: builtin: pow
 …
    See the built-in function :func:`pow`. Returns *NULL* on failure.  This is the
    equivalent of the Python expression ``pow(o1, o2, o3)``, where *o3* is optional.
    If *o3* is to be ignored, pass :cdata:`Py_None` in its place (passing *NULL* for
+   If *o3* is to be ignored, pass :c:data:`Py_None` in its place (passing *NULL* for
    *o3* would cause an illegal memory access).
 .. cfunction:: PyObject* PyNumber_Negative(PyObject *o)
+.. c:function:: PyObject* PyNumber_Negative(PyObject *o)
    Returns the negation of *o* on success, or *NULL* on failure. This is the
 …
 .. cfunction:: PyObject* PyNumber_Positive(PyObject *o)
+.. c:function:: PyObject* PyNumber_Positive(PyObject *o)
    Returns *o* on success, or *NULL* on failure.  This is the equivalent of the
 …
 .. cfunction:: PyObject* PyNumber_Absolute(PyObject *o)
+.. c:function:: PyObject* PyNumber_Absolute(PyObject *o)
    .. index:: builtin: abs
 …
 .. cfunction:: PyObject* PyNumber_Invert(PyObject *o)
+.. c:function:: PyObject* PyNumber_Invert(PyObject *o)
    Returns the bitwise negation of *o* on success, or *NULL* on failure.  This is
 …
 .. cfunction:: PyObject* PyNumber_Lshift(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_Lshift(PyObject *o1, PyObject *o2)
    Returns the result of left shifting *o1* by *o2* on success, or *NULL* on
 …
 .. cfunction:: PyObject* PyNumber_Rshift(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_Rshift(PyObject *o1, PyObject *o2)
    Returns the result of right shifting *o1* by *o2* on success, or *NULL* on
 …
 .. cfunction:: PyObject* PyNumber_And(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_And(PyObject *o1, PyObject *o2)
    Returns the "bitwise and" of *o1* and *o2* on success and *NULL* on failure.
 …
 .. cfunction:: PyObject* PyNumber_Xor(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_Xor(PyObject *o1, PyObject *o2)
    Returns the "bitwise exclusive or" of *o1* by *o2* on success, or *NULL* on
 …
 .. cfunction:: PyObject* PyNumber_Or(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_Or(PyObject *o1, PyObject *o2)
    Returns the "bitwise or" of *o1* and *o2* on success, or *NULL* on failure.
 …
 .. cfunction:: PyObject* PyNumber_InPlaceAdd(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_InPlaceAdd(PyObject *o1, PyObject *o2)
    Returns the result of adding *o1* and *o2*, or *NULL* on failure.  The operation
 …
 .. cfunction:: PyObject* PyNumber_InPlaceSubtract(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_InPlaceSubtract(PyObject *o1, PyObject *o2)
    Returns the result of subtracting *o2* from *o1*, or *NULL* on failure.  The
 …
 .. cfunction:: PyObject* PyNumber_InPlaceMultiply(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_InPlaceMultiply(PyObject *o1, PyObject *o2)
    Returns the result of multiplying *o1* and *o2*, or *NULL* on failure.  The
 …
 .. cfunction:: PyObject* PyNumber_InPlaceDivide(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_InPlaceDivide(PyObject *o1, PyObject *o2)
    Returns the result of dividing *o1* by *o2*, or *NULL* on failure.  The
 …
 .. cfunction:: PyObject* PyNumber_InPlaceFloorDivide(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_InPlaceFloorDivide(PyObject *o1, PyObject *o2)
    Returns the mathematical floor of dividing *o1* by *o2*, or *NULL* on failure.
 …
 .. cfunction:: PyObject* PyNumber_InPlaceTrueDivide(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_InPlaceTrueDivide(PyObject *o1, PyObject *o2)
    Return a reasonable approximation for the mathematical value of *o1* divided by
 …
 .. cfunction:: PyObject* PyNumber_InPlaceRemainder(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_InPlaceRemainder(PyObject *o1, PyObject *o2)
    Returns the remainder of dividing *o1* by *o2*, or *NULL* on failure.  The
 …
 .. cfunction:: PyObject* PyNumber_InPlacePower(PyObject *o1, PyObject *o2, PyObject *o3)
+.. c:function:: PyObject* PyNumber_InPlacePower(PyObject *o1, PyObject *o2, PyObject *o3)
    .. index:: builtin: pow
 …
    See the built-in function :func:`pow`. Returns *NULL* on failure.  The operation
    is done *in-place* when *o1* supports it.  This is the equivalent of the Python
    statement ``o1 **= o2`` when o3 is :cdata:`Py_None`, or an in-place variant of
    ``pow(o1, o2, o3)`` otherwise. If *o3* is to be ignored, pass :cdata:`Py_None`
+   statement ``o1 **= o2`` when o3 is :c:data:`Py_None`, or an in-place variant of
+   ``pow(o1, o2, o3)`` otherwise. If *o3* is to be ignored, pass :c:data:`Py_None`
    in its place (passing *NULL* for *o3* would cause an illegal memory access).
 .. cfunction:: PyObject* PyNumber_InPlaceLshift(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_InPlaceLshift(PyObject *o1, PyObject *o2)
    Returns the result of left shifting *o1* by *o2* on success, or *NULL* on
 …
 .. cfunction:: PyObject* PyNumber_InPlaceRshift(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_InPlaceRshift(PyObject *o1, PyObject *o2)
    Returns the result of right shifting *o1* by *o2* on success, or *NULL* on
 …
 .. cfunction:: PyObject* PyNumber_InPlaceAnd(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_InPlaceAnd(PyObject *o1, PyObject *o2)
    Returns the "bitwise and" of *o1* and *o2* on success and *NULL* on failure. The
 …
 .. cfunction:: PyObject* PyNumber_InPlaceXor(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_InPlaceXor(PyObject *o1, PyObject *o2)
    Returns the "bitwise exclusive or" of *o1* by *o2* on success, or *NULL* on
 …
 .. cfunction:: PyObject* PyNumber_InPlaceOr(PyObject *o1, PyObject *o2)
+.. c:function:: PyObject* PyNumber_InPlaceOr(PyObject *o1, PyObject *o2)
    Returns the "bitwise or" of *o1* and *o2* on success, or *NULL* on failure.  The
 …
 .. cfunction:: int PyNumber_Coerce(PyObject **p1, PyObject **p2)
+.. c:function:: int PyNumber_Coerce(PyObject **p1, PyObject **p2)
    .. index:: builtin: coerce
    This function takes the addresses of two variables of type :ctype:`PyObject\*`.
+   This function takes the addresses of two variables of type :c:type:`PyObject\*`.
    If the objects pointed to by ``*p1`` and ``*p2`` have the same type, increment
    their reference count and return ``0`` (success). If the objects can be
 …
 .. cfunction:: int PyNumber_CoerceEx(PyObject **p1, PyObject **p2)
    This function is similar to :cfunc:`PyNumber_Coerce`, except that it returns
+.. c:function:: int PyNumber_CoerceEx(PyObject **p1, PyObject **p2)
+   This function is similar to :c:func:`PyNumber_Coerce`, except that it returns
    ``1`` when the conversion is not possible and when no error is raised.
    Reference counts are still not increased in this case.
 .. cfunction:: PyObject* PyNumber_Int(PyObject *o)
+.. c:function:: PyObject* PyNumber_Int(PyObject *o)
    .. index:: builtin: int
 …
 .. cfunction:: PyObject* PyNumber_Long(PyObject *o)
+.. c:function:: PyObject* PyNumber_Long(PyObject *o)
    .. index:: builtin: long
 …
 .. cfunction:: PyObject* PyNumber_Float(PyObject *o)
+.. c:function:: PyObject* PyNumber_Float(PyObject *o)
    .. index:: builtin: float
 …
 .. cfunction:: PyObject* PyNumber_Index(PyObject *o)
+.. c:function:: PyObject* PyNumber_Index(PyObject *o)
    Returns the *o* converted to a Python int or long on success or *NULL* with a
 …
 .. cfunction:: PyObject* PyNumber_ToBase(PyObject *n, int base)
+.. c:function:: PyObject* PyNumber_ToBase(PyObject *n, int base)
    Returns the integer *n* converted to *base* as a string with a base
 …
    *base* is not 2, 8, 10, or 16, the format is ``'x#num'`` where x is the
    base. If *n* is not an int object, it is converted with
    :cfunc:`PyNumber_Index` first.
+   :c:func:`PyNumber_Index` first.
    .. versionadded:: 2.6
 .. cfunction:: Py_ssize_t PyNumber_AsSsize_t(PyObject *o, PyObject *exc)
+.. c:function:: Py_ssize_t PyNumber_AsSsize_t(PyObject *o, PyObject *exc)
    Returns *o* converted to a Py_ssize_t value if *o* can be interpreted as an
 …
 .. cfunction:: int PyIndex_Check(PyObject *o)
+.. c:function:: int PyIndex_Check(PyObject *o)
    Returns True if *o* is an index integer (has the nb_index slot of  the

python/vendor/current/Doc/c-api/objbuffer.rst

-              r2
+              r388
 .. _abstract-buffer:
 Old Buffer Protocol
 ===================
 This section describes the legacy buffer protocol, which has been introduced
 in Python 1.6. It is still supported but deprecated in the Python 2.x series.
 Python 3.0 introduces a new buffer protocol which fixes weaknesses and
+Python 3 introduces a new buffer protocol which fixes weaknesses and
 shortcomings of the protocol, and has been backported to Python 2.6.  See
 :ref:`bufferobjects` for more information.
 .. cfunction:: int PyObject_AsCharBuffer(PyObject *obj, const char **buffer, Py_ssize_t *buffer_len)
+.. c:function:: int PyObject_AsCharBuffer(PyObject *obj, const char **buffer, Py_ssize_t *buffer_len)
    Returns a pointer to a read-only memory location usable as character-based
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int *` type for *buffer_len*. This might
+      This function used an :c:type:`int *` type for *buffer_len*. This might
       require changes in your code for properly supporting 64-bit systems.
 .. cfunction:: int PyObject_AsReadBuffer(PyObject *obj, const void **buffer, Py_ssize_t *buffer_len)
+.. c:function:: int PyObject_AsReadBuffer(PyObject *obj, const void **buffer, Py_ssize_t *buffer_len)
    Returns a pointer to a read-only memory location containing arbitrary data.
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int *` type for *buffer_len*. This might
+      This function used an :c:type:`int *` type for *buffer_len*. This might
       require changes in your code for properly supporting 64-bit systems.
 .. cfunction:: int PyObject_CheckReadBuffer(PyObject *o)
+.. c:function:: int PyObject_CheckReadBuffer(PyObject *o)
    Returns ``1`` if *o* supports the single-segment readable buffer interface.
 …
 .. cfunction:: int PyObject_AsWriteBuffer(PyObject *obj, void **buffer, Py_ssize_t *buffer_len)
+.. c:function:: int PyObject_AsWriteBuffer(PyObject *obj, void **buffer, Py_ssize_t *buffer_len)
    Returns a pointer to a writeable memory location.  The *obj* argument must
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int *` type for *buffer_len*. This might
+      This function used an :c:type:`int *` type for *buffer_len*. This might
       require changes in your code for properly supporting 64-bit systems.

python/vendor/current/Doc/c-api/object.rst

-              r2
+              r388
 .. cfunction:: int PyObject_Print(PyObject *o, FILE *fp, int flags)
+.. c:function:: int PyObject_Print(PyObject *o, FILE *fp, int flags)
    Print an object *o*, on file *fp*.  Returns ``-1`` on error.  The flags argument
 …
 .. cfunction:: int PyObject_HasAttr(PyObject *o, PyObject *attr_name)
+.. c:function:: int PyObject_HasAttr(PyObject *o, PyObject *attr_name)
    Returns ``1`` if *o* has the attribute *attr_name*, and ``0`` otherwise.  This
 …
 .. cfunction:: int PyObject_HasAttrString(PyObject *o, const char *attr_name)
+.. c:function:: int PyObject_HasAttrString(PyObject *o, const char *attr_name)
    Returns ``1`` if *o* has the attribute *attr_name*, and ``0`` otherwise.  This
 …
 .. cfunction:: PyObject* PyObject_GetAttr(PyObject *o, PyObject *attr_name)
+.. c:function:: PyObject* PyObject_GetAttr(PyObject *o, PyObject *attr_name)
    Retrieve an attribute named *attr_name* from object *o*. Returns the attribute
 …
 .. cfunction:: PyObject* PyObject_GetAttrString(PyObject *o, const char *attr_name)
+.. c:function:: PyObject* PyObject_GetAttrString(PyObject *o, const char *attr_name)
    Retrieve an attribute named *attr_name* from object *o*. Returns the attribute
 …
 .. cfunction:: PyObject* PyObject_GenericGetAttr(PyObject *o, PyObject *name)
+.. c:function:: PyObject* PyObject_GenericGetAttr(PyObject *o, PyObject *name)
    Generic attribute getter function that is meant to be put into a type
    object's ``tp_getattro`` slot.  It looks for a descriptor in the dictionary
    of classes in the object's MRO as well as an attribute in the object's
    :attr:`__dict__` (if present).  As outlined in :ref:`descriptors`, data
    descriptors take preference over instance attributes, while non-data
+   :attr:`~object.__dict__` (if present).  As outlined in :ref:`descriptors`,
+   data descriptors take preference over instance attributes, while non-data
    descriptors don't.  Otherwise, an :exc:`AttributeError` is raised.
 .. cfunction:: int PyObject_SetAttr(PyObject *o, PyObject *attr_name, PyObject *v)
+.. c:function:: int PyObject_SetAttr(PyObject *o, PyObject *attr_name, PyObject *v)
    Set the value of the attribute named *attr_name*, for object *o*, to the value
 …
 .. cfunction:: int PyObject_SetAttrString(PyObject *o, const char *attr_name, PyObject *v)
+.. c:function:: int PyObject_SetAttrString(PyObject *o, const char *attr_name, PyObject *v)
    Set the value of the attribute named *attr_name*, for object *o*, to the value
 …
 .. cfunction:: int PyObject_GenericSetAttr(PyObject *o, PyObject *name, PyObject *value)
+.. c:function:: int PyObject_GenericSetAttr(PyObject *o, PyObject *name, PyObject *value)
    Generic attribute setter function that is meant to be put into a type
 …
    dictionary of classes in the object's MRO, and if found it takes preference
    over setting the attribute in the instance dictionary. Otherwise, the
    attribute is set in the object's :attr:`__dict__` (if present).  Otherwise,
    an :exc:`AttributeError` is raised and ``-1`` is returned.
 .. cfunction:: int PyObject_DelAttr(PyObject *o, PyObject *attr_name)
+   attribute is set in the object's :attr:`~object.__dict__` (if present).
+   Otherwise, an :exc:`AttributeError` is raised and ``-1`` is returned.
+.. c:function:: int PyObject_DelAttr(PyObject *o, PyObject *attr_name)
    Delete attribute named *attr_name*, for object *o*. Returns ``-1`` on failure.
 …
 .. cfunction:: int PyObject_DelAttrString(PyObject *o, const char *attr_name)
+.. c:function:: int PyObject_DelAttrString(PyObject *o, const char *attr_name)
    Delete attribute named *attr_name*, for object *o*. Returns ``-1`` on failure.
 …
 .. cfunction:: PyObject* PyObject_RichCompare(PyObject *o1, PyObject *o2, int opid)
+.. c:function:: PyObject* PyObject_RichCompare(PyObject *o1, PyObject *o2, int opid)
    Compare the values of *o1* and *o2* using the operation specified by *opid*,
 …
 .. cfunction:: int PyObject_RichCompareBool(PyObject *o1, PyObject *o2, int opid)
+.. c:function:: int PyObject_RichCompareBool(PyObject *o1, PyObject *o2, int opid)
    Compare the values of *o1* and *o2* using the operation specified by *opid*,
 …
    *opid*.
+.. cfunction:: int PyObject_Cmp(PyObject *o1, PyObject *o2, int *result)
+.. note::
+   If *o1* and *o2* are the same object, :c:func:`PyObject_RichCompareBool`
+   will always return ``1`` for :const:`Py_EQ` and ``0`` for :const:`Py_NE`.
+.. c:function:: int PyObject_Cmp(PyObject *o1, PyObject *o2, int *result)
    .. index:: builtin: cmp
 …
 .. cfunction:: int PyObject_Compare(PyObject *o1, PyObject *o2)
+.. c:function:: int PyObject_Compare(PyObject *o1, PyObject *o2)
    .. index:: builtin: cmp
 …
    exists, otherwise with a routine provided by *o2*.  Returns the result of the
    comparison on success.  On error, the value returned is undefined; use
    :cfunc:`PyErr_Occurred` to detect an error.  This is equivalent to the Python
+   :c:func:`PyErr_Occurred` to detect an error.  This is equivalent to the Python
    expression ``cmp(o1, o2)``.
 .. cfunction:: PyObject* PyObject_Repr(PyObject *o)
+.. c:function:: PyObject* PyObject_Repr(PyObject *o)
    .. index:: builtin: repr
 …
 .. cfunction:: PyObject* PyObject_Str(PyObject *o)
+.. c:function:: PyObject* PyObject_Str(PyObject *o)
    .. index:: builtin: str
 …
 .. cfunction:: PyObject* PyObject_Bytes(PyObject *o)
+.. c:function:: PyObject* PyObject_Bytes(PyObject *o)
    .. index:: builtin: bytes
    Compute a bytes representation of object *o*.  In 2.x, this is just a alias
    for :cfunc:`PyObject_Str`.
 .. cfunction:: PyObject* PyObject_Unicode(PyObject *o)
+   for :c:func:`PyObject_Str`.
+.. c:function:: PyObject* PyObject_Unicode(PyObject *o)
    .. index:: builtin: unicode
 …
 .. cfunction:: int PyObject_IsInstance(PyObject *inst, PyObject *cls)
+.. c:function:: int PyObject_IsInstance(PyObject *inst, PyObject *cls)
    Returns ``1`` if *inst* is an instance of the class *cls* or a subclass of
    *cls*, or ``0`` if not.  On error, returns ``-1`` and sets an exception.  If
    *cls* is a type object rather than a class object, :cfunc:`PyObject_IsInstance`
+   *cls* is a type object rather than a class object, :c:func:`PyObject_IsInstance`
    returns ``1`` if *inst* is of type *cls*.  If *cls* is a tuple, the check will
    be done against every entry in *cls*. The result will be ``1`` when at least one
    of the checks returns ``1``, otherwise it will be ``0``. If *inst* is not a
    class instance and *cls* is neither a type object, nor a class object, nor a
    tuple, *inst* must have a :attr:`__class__` attribute --- the class relationship
    of the value of that attribute with *cls* will be used to determine the result
    of this function.
+   tuple, *inst* must have a :attr:`~instance.__class__` attribute --- the
+   class relationship of the value of that attribute with *cls* will be used
+   to determine the result of this function.
    .. versionadded:: 2.1
 …
 either is not a class object, a more general mechanism is used to determine the
 class relationship of the two objects.  When testing if *B* is a subclass of
 *A*, if *A* is *B*, :cfunc:`PyObject_IsSubclass` returns true.  If *A* and *B*
 are different objects, *B*'s :attr:`__bases__` attribute is searched in a
+depth-first fashion for *A* --- the presence of the :attr:`__bases__` attribute
 is considered sufficient for this determination.
 .. cfunction:: int PyObject_IsSubclass(PyObject *derived, PyObject *cls)
+*A*, if *A* is *B*, :c:func:`PyObject_IsSubclass` returns true.  If *A* and *B*
+are different objects, *B*'s :attr:`~class.__bases__` attribute is searched in
+a depth-first fashion for *A* --- the presence of the :attr:`~class.__bases__`
+attribute is considered sufficient for this determination.
+.. c:function:: int PyObject_IsSubclass(PyObject *derived, PyObject *cls)
    Returns ``1`` if the class *derived* is identical to or derived from the class
 …
 .. cfunction:: int PyCallable_Check(PyObject *o)
+.. c:function:: int PyCallable_Check(PyObject *o)
    Determine if the object *o* is callable.  Return ``1`` if the object is callable
 …
 .. cfunction:: PyObject* PyObject_Call(PyObject *callable_object, PyObject *args, PyObject *kw)
+.. c:function:: PyObject* PyObject_Call(PyObject *callable_object, PyObject *args, PyObject *kw)
    .. index:: builtin: apply
 …
 .. cfunction:: PyObject* PyObject_CallObject(PyObject *callable_object, PyObject *args)
+.. c:function:: PyObject* PyObject_CallObject(PyObject *callable_object, PyObject *args)
    .. index:: builtin: apply
 …
 .. cfunction:: PyObject* PyObject_CallFunction(PyObject *callable, char *format, ...)
+.. c:function:: PyObject* PyObject_CallFunction(PyObject *callable, char *format, ...)
    .. index:: builtin: apply
    Call a callable Python object *callable*, with a variable number of C arguments.
    The C arguments are described using a :cfunc:`Py_BuildValue` style format
+   The C arguments are described using a :c:func:`Py_BuildValue` style format
    string.  The format may be *NULL*, indicating that no arguments are provided.
    Returns the result of the call on success, or *NULL* on failure.  This is the
    equivalent of the Python expression ``apply(callable, args)`` or
    ``callable(*args)``. Note that if you only pass :ctype:`PyObject \*` args,
    :cfunc:`PyObject_CallFunctionObjArgs` is a faster alternative.
 .. cfunction:: PyObject* PyObject_CallMethod(PyObject *o, char *method, char *format, ...)
+   ``callable(*args)``. Note that if you only pass :c:type:`PyObject \*` args,
+   :c:func:`PyObject_CallFunctionObjArgs` is a faster alternative.
+.. c:function:: PyObject* PyObject_CallMethod(PyObject *o, char *method, char *format, ...)
    Call the method named *method* of object *o* with a variable number of C
    arguments.  The C arguments are described by a :cfunc:`Py_BuildValue` format
+   arguments.  The C arguments are described by a :c:func:`Py_BuildValue` format
    string that should  produce a tuple.  The format may be *NULL*, indicating that
    no arguments are provided. Returns the result of the call on success, or *NULL*
    on failure.  This is the equivalent of the Python expression ``o.method(args)``.
    Note that if you only pass :ctype:`PyObject \*` args,
    :cfunc:`PyObject_CallMethodObjArgs` is a faster alternative.
 .. cfunction:: PyObject* PyObject_CallFunctionObjArgs(PyObject *callable, ..., NULL)
+   Note that if you only pass :c:type:`PyObject \*` args,
+   :c:func:`PyObject_CallMethodObjArgs` is a faster alternative.
+.. c:function:: PyObject* PyObject_CallFunctionObjArgs(PyObject *callable, ..., NULL)
    Call a callable Python object *callable*, with a variable number of
    :ctype:`PyObject\*` arguments.  The arguments are provided as a variable number
+   :c:type:`PyObject\*` arguments.  The arguments are provided as a variable number
    of parameters followed by *NULL*. Returns the result of the call on success, or
    *NULL* on failure.
 …
 .. cfunction:: PyObject* PyObject_CallMethodObjArgs(PyObject *o, PyObject *name, ..., NULL)
+.. c:function:: PyObject* PyObject_CallMethodObjArgs(PyObject *o, PyObject *name, ..., NULL)
    Calls a method of the object *o*, where the name of the method is given as a
    Python string object in *name*.  It is called with a variable number of
    :ctype:`PyObject\*` arguments.  The arguments are provided as a variable number
+   :c:type:`PyObject\*` arguments.  The arguments are provided as a variable number
    of parameters followed by *NULL*. Returns the result of the call on success, or
    *NULL* on failure.
 …
 .. cfunction:: long PyObject_Hash(PyObject *o)
+.. c:function:: long PyObject_Hash(PyObject *o)
    .. index:: builtin: hash
 …
 .. cfunction:: long PyObject_HashNotImplemented(PyObject *o)
+.. c:function:: long PyObject_HashNotImplemented(PyObject *o)
    Set a :exc:`TypeError` indicating that ``type(o)`` is not hashable and return ``-1``.
 …
 .. cfunction:: int PyObject_IsTrue(PyObject *o)
+.. c:function:: int PyObject_IsTrue(PyObject *o)
    Returns ``1`` if the object *o* is considered to be true, and ``0`` otherwise.
 …
 .. cfunction:: int PyObject_Not(PyObject *o)
+.. c:function:: int PyObject_Not(PyObject *o)
    Returns ``0`` if the object *o* is considered to be true, and ``1`` otherwise.
 …
 .. cfunction:: PyObject* PyObject_Type(PyObject *o)
+.. c:function:: PyObject* PyObject_Type(PyObject *o)
    .. index:: builtin: type
 …
    reference count of the return value. There's really no reason to use this
    function instead of the common expression ``o->ob_type``, which returns a
    pointer of type :ctype:`PyTypeObject\*`, except when the incremented reference
+   pointer of type :c:type:`PyTypeObject\*`, except when the incremented reference
    count is needed.
 .. cfunction:: int PyObject_TypeCheck(PyObject *o, PyTypeObject *type)
+.. c:function:: int PyObject_TypeCheck(PyObject *o, PyTypeObject *type)
    Return true if the object *o* is of type *type* or a subtype of *type*.  Both
 …
 .. cfunction:: Py_ssize_t PyObject_Length(PyObject *o)
+.. c:function:: Py_ssize_t PyObject_Length(PyObject *o)
                Py_ssize_t PyObject_Size(PyObject *o)
 …
    .. versionchanged:: 2.5
       These functions returned an :ctype:`int` type. This might require
+      These functions returned an :c:type:`int` type. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyObject_GetItem(PyObject *o, PyObject *key)
+.. c:function:: PyObject* PyObject_GetItem(PyObject *o, PyObject *key)
    Return element of *o* corresponding to the object *key* or *NULL* on failure.
 …
 .. cfunction:: int PyObject_SetItem(PyObject *o, PyObject *key, PyObject *v)
+.. c:function:: int PyObject_SetItem(PyObject *o, PyObject *key, PyObject *v)
    Map the object *key* to the value *v*.  Returns ``-1`` on failure.  This is the
 …
 .. cfunction:: int PyObject_DelItem(PyObject *o, PyObject *key)
+.. c:function:: int PyObject_DelItem(PyObject *o, PyObject *key)
    Delete the mapping for *key* from *o*.  Returns ``-1`` on failure. This is the
 …
 .. cfunction:: int PyObject_AsFileDescriptor(PyObject *o)
+.. c:function:: int PyObject_AsFileDescriptor(PyObject *o)
    Derives a file descriptor from a Python object.  If the object is an integer or
 …
 .. cfunction:: PyObject* PyObject_Dir(PyObject *o)
+.. c:function:: PyObject* PyObject_Dir(PyObject *o)
    This is equivalent to the Python expression ``dir(o)``, returning a (possibly
 …
    was an error.  If the argument is *NULL*, this is like the Python ``dir()``,
    returning the names of the current locals; in this case, if no execution frame
    is active then *NULL* is returned but :cfunc:`PyErr_Occurred` will return false.
 .. cfunction:: PyObject* PyObject_GetIter(PyObject *o)
+   is active then *NULL* is returned but :c:func:`PyErr_Occurred` will return false.
+.. c:function:: PyObject* PyObject_GetIter(PyObject *o)
    This is equivalent to the Python expression ``iter(o)``. It returns a new

python/vendor/current/Doc/c-api/refcounting.rst

-              r2
+              r388
 .. cfunction:: void Py_INCREF(PyObject *o)
+.. c:function:: void Py_INCREF(PyObject *o)
    Increment the reference count for object *o*.  The object must not be *NULL*; if
    you aren't sure that it isn't *NULL*, use :cfunc:`Py_XINCREF`.
+   you aren't sure that it isn't *NULL*, use :c:func:`Py_XINCREF`.
 .. cfunction:: void Py_XINCREF(PyObject *o)
+.. c:function:: void Py_XINCREF(PyObject *o)
    Increment the reference count for object *o*.  The object may be *NULL*, in
 …
 .. cfunction:: void Py_DECREF(PyObject *o)
+.. c:function:: void Py_DECREF(PyObject *o)
    Decrement the reference count for object *o*.  The object must not be *NULL*; if
    you aren't sure that it isn't *NULL*, use :cfunc:`Py_XDECREF`.  If the reference
+   you aren't sure that it isn't *NULL*, use :c:func:`Py_XDECREF`.  If the reference
    count reaches zero, the object's type's deallocation function (which must not be
    *NULL*) is invoked.
 …
       exceptions in such code are not propagated, the executed code has free access to
       all Python global variables.  This means that any object that is reachable from
       a global variable should be in a consistent state before :cfunc:`Py_DECREF` is
+      a global variable should be in a consistent state before :c:func:`Py_DECREF` is
       invoked.  For example, code to delete an object from a list should copy a
       reference to the deleted object in a temporary variable, update the list data
       structure, and then call :cfunc:`Py_DECREF` for the temporary variable.
+      structure, and then call :c:func:`Py_DECREF` for the temporary variable.
 .. cfunction:: void Py_XDECREF(PyObject *o)
+.. c:function:: void Py_XDECREF(PyObject *o)
    Decrement the reference count for object *o*.  The object may be *NULL*, in
    which case the macro has no effect; otherwise the effect is the same as for
    :cfunc:`Py_DECREF`, and the same warning applies.
+   :c:func:`Py_DECREF`, and the same warning applies.
 .. cfunction:: void Py_CLEAR(PyObject *o)
+.. c:function:: void Py_CLEAR(PyObject *o)
    Decrement the reference count for object *o*.  The object may be *NULL*, in
    which case the macro has no effect; otherwise the effect is the same as for
    :cfunc:`Py_DECREF`, except that the argument is also set to *NULL*.  The warning
    for :cfunc:`Py_DECREF` does not apply with respect to the object passed because
+   :c:func:`Py_DECREF`, except that the argument is also set to *NULL*.  The warning
+   for :c:func:`Py_DECREF` does not apply with respect to the object passed because
    the macro carefully uses a temporary variable and sets the argument to *NULL*
    before decrementing its reference count.
 …
 The following functions are for runtime dynamic embedding of Python:
 ``Py_IncRef(PyObject *o)``, ``Py_DecRef(PyObject *o)``. They are
 simply exported function versions of :cfunc:`Py_XINCREF` and
 :cfunc:`Py_XDECREF`, respectively.
+simply exported function versions of :c:func:`Py_XINCREF` and
+:c:func:`Py_XDECREF`, respectively.
 The following functions or macros are only for use within the interpreter core:
 :cfunc:`_Py_Dealloc`, :cfunc:`_Py_ForgetReference`, :cfunc:`_Py_NewReference`,
 as well as the global variable :cdata:`_Py_RefTotal`.
+:c:func:`_Py_Dealloc`, :c:func:`_Py_ForgetReference`, :c:func:`_Py_NewReference`,
+as well as the global variable :c:data:`_Py_RefTotal`.

python/vendor/current/Doc/c-api/reflection.rst

-              r2
+              r388
 ==========
 .. cfunction:: PyObject* PyEval_GetBuiltins()
+.. c:function:: PyObject* PyEval_GetBuiltins()
    Return a dictionary of the builtins in the current execution frame,
 …
 .. cfunction:: PyObject* PyEval_GetLocals()
+.. c:function:: PyObject* PyEval_GetLocals()
    Return a dictionary of the local variables in the current execution frame,
 …
 .. cfunction:: PyObject* PyEval_GetGlobals()
+.. c:function:: PyObject* PyEval_GetGlobals()
    Return a dictionary of the global variables in the current execution frame,
 …
 .. cfunction:: PyFrameObject* PyEval_GetFrame()
+.. c:function:: PyFrameObject* PyEval_GetFrame()
    Return the current thread state's frame, which is *NULL* if no frame is
 …
+.. cfunction:: int PyEval_GetRestricted()
+.. c:function:: int PyFrame_GetLineNumber(PyFrameObject *frame)
+   Return the line number that *frame* is currently executing.
+.. c:function:: int PyEval_GetRestricted()
    If there is a current frame and it is executing in restricted mode, return true,
 …
 .. cfunction:: const char* PyEval_GetFuncName(PyObject *func)
+.. c:function:: const char* PyEval_GetFuncName(PyObject *func)
    Return the name of *func* if it is a function, class or instance object, else the
 …
 .. cfunction:: const char* PyEval_GetFuncDesc(PyObject *func)
+.. c:function:: const char* PyEval_GetFuncDesc(PyObject *func)
    Return a description string, depending on the type of *func*.
    Return values include "()" for functions and methods, " constructor",
    " instance", and " object".  Concatenated with the result of
    :cfunc:`PyEval_GetFuncName`, the result will be a description of
+   :c:func:`PyEval_GetFuncName`, the result will be a description of
    *func*.

python/vendor/current/Doc/c-api/sequence.rst

-              r2
+              r388
 .. cfunction:: int PySequence_Check(PyObject *o)
+.. c:function:: int PySequence_Check(PyObject *o)
    Return ``1`` if the object provides sequence protocol, and ``0`` otherwise.
 …
 .. cfunction:: Py_ssize_t PySequence_Size(PyObject *o)
+.. c:function:: Py_ssize_t PySequence_Size(PyObject *o)
                Py_ssize_t PySequence_Length(PyObject *o)
 …
    .. versionchanged:: 2.5
       These functions returned an :ctype:`int` type. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PySequence_Concat(PyObject *o1, PyObject *o2)
+      These functions returned an :c:type:`int` type. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PySequence_Concat(PyObject *o1, PyObject *o2)
    Return the concatenation of *o1* and *o2* on success, and *NULL* on failure.
 …
 .. cfunction:: PyObject* PySequence_Repeat(PyObject *o, Py_ssize_t count)
+.. c:function:: PyObject* PySequence_Repeat(PyObject *o, Py_ssize_t count)
    Return the result of repeating sequence object *o* *count* times, or *NULL* on
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *count*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PySequence_InPlaceConcat(PyObject *o1, PyObject *o2)
+      This function used an :c:type:`int` type for *count*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PySequence_InPlaceConcat(PyObject *o1, PyObject *o2)
    Return the concatenation of *o1* and *o2* on success, and *NULL* on failure.
 …
 .. cfunction:: PyObject* PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count)
+.. c:function:: PyObject* PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count)
    Return the result of repeating sequence object *o* *count* times, or *NULL* on
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *count*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PySequence_GetItem(PyObject *o, Py_ssize_t i)
+      This function used an :c:type:`int` type for *count*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PySequence_GetItem(PyObject *o, Py_ssize_t i)
    Return the *i*\ th element of *o*, or *NULL* on failure. This is the equivalent of
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *i*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PySequence_GetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2)
+      This function used an :c:type:`int` type for *i*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PySequence_GetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2)
    Return the slice of sequence object *o* between *i1* and *i2*, or *NULL* on
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *i1* and *i2*. This might
+      This function used an :c:type:`int` type for *i1* and *i2*. This might
       require changes in your code for properly supporting 64-bit systems.
 .. cfunction:: int PySequence_SetItem(PyObject *o, Py_ssize_t i, PyObject *v)
+.. c:function:: int PySequence_SetItem(PyObject *o, Py_ssize_t i, PyObject *v)
    Assign object *v* to the *i*\ th element of *o*.  Returns ``-1`` on failure.  This
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *i*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: int PySequence_DelItem(PyObject *o, Py_ssize_t i)
+      This function used an :c:type:`int` type for *i*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: int PySequence_DelItem(PyObject *o, Py_ssize_t i)
    Delete the *i*\ th element of object *o*.  Returns ``-1`` on failure.  This is the
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *i*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: int PySequence_SetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2, PyObject *v)
+      This function used an :c:type:`int` type for *i*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: int PySequence_SetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2, PyObject *v)
    Assign the sequence object *v* to the slice in sequence object *o* from *i1* to
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *i1* and *i2*. This might
+      This function used an :c:type:`int` type for *i1* and *i2*. This might
       require changes in your code for properly supporting 64-bit systems.
 .. cfunction:: int PySequence_DelSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2)
+.. c:function:: int PySequence_DelSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2)
    Delete the slice in sequence object *o* from *i1* to *i2*.  Returns ``-1`` on
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *i1* and *i2*. This might
+      This function used an :c:type:`int` type for *i1* and *i2*. This might
       require changes in your code for properly supporting 64-bit systems.
 .. cfunction:: Py_ssize_t PySequence_Count(PyObject *o, PyObject *value)
+.. c:function:: Py_ssize_t PySequence_Count(PyObject *o, PyObject *value)
    Return the number of occurrences of *value* in *o*, that is, return the number
 …
    .. versionchanged:: 2.5
       This function returned an :ctype:`int` type. This might require changes
+      This function returned an :c:type:`int` type. This might require changes
       in your code for properly supporting 64-bit systems.
 .. cfunction:: int PySequence_Contains(PyObject *o, PyObject *value)
+.. c:function:: int PySequence_Contains(PyObject *o, PyObject *value)
    Determine if *o* contains *value*.  If an item in *o* is equal to *value*,
 …
 .. cfunction:: Py_ssize_t PySequence_Index(PyObject *o, PyObject *value)
+.. c:function:: Py_ssize_t PySequence_Index(PyObject *o, PyObject *value)
    Return the first index *i* for which ``o[i] == value``.  On error, return
 …
    .. versionchanged:: 2.5
       This function returned an :ctype:`int` type. This might require changes
+      This function returned an :c:type:`int` type. This might require changes
       in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PySequence_List(PyObject *o)
+.. c:function:: PyObject* PySequence_List(PyObject *o)
    Return a list object with the same contents as the arbitrary sequence *o*.  The
 …
 .. cfunction:: PyObject* PySequence_Tuple(PyObject *o)
+.. c:function:: PyObject* PySequence_Tuple(PyObject *o)
    .. index:: builtin: tuple
 …
 .. cfunction:: PyObject* PySequence_Fast(PyObject *o, const char *m)
+.. c:function:: PyObject* PySequence_Fast(PyObject *o, const char *m)
    Returns the sequence *o* as a tuple, unless it is already a tuple or list, in
    which case *o* is returned.  Use :cfunc:`PySequence_Fast_GET_ITEM` to access the
+   which case *o* is returned.  Use :c:func:`PySequence_Fast_GET_ITEM` to access the
    members of the result.  Returns *NULL* on failure.  If the object is not a
    sequence, raises :exc:`TypeError` with *m* as the message text.
 .. cfunction:: PyObject* PySequence_Fast_GET_ITEM(PyObject *o, Py_ssize_t i)
+.. c:function:: PyObject* PySequence_Fast_GET_ITEM(PyObject *o, Py_ssize_t i)
    Return the *i*\ th element of *o*, assuming that *o* was returned by
    :cfunc:`PySequence_Fast`, *o* is not *NULL*, and that *i* is within bounds.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *i*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject** PySequence_Fast_ITEMS(PyObject *o)
+   :c:func:`PySequence_Fast`, *o* is not *NULL*, and that *i* is within bounds.
+   .. versionchanged:: 2.5
+      This function used an :c:type:`int` type for *i*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject** PySequence_Fast_ITEMS(PyObject *o)
    Return the underlying array of PyObject pointers.  Assumes that *o* was returned
    by :cfunc:`PySequence_Fast` and *o* is not *NULL*.
+   by :c:func:`PySequence_Fast` and *o* is not *NULL*.
    Note, if a list gets resized, the reallocation may relocate the items array.
 …
 .. cfunction:: PyObject* PySequence_ITEM(PyObject *o, Py_ssize_t i)
+.. c:function:: PyObject* PySequence_ITEM(PyObject *o, Py_ssize_t i)
    Return the *i*\ th element of *o* or *NULL* on failure. Macro form of
    :cfunc:`PySequence_GetItem` but without checking that
    :cfunc:`PySequence_Check(o)` is true and without adjustment for negative
+   :c:func:`PySequence_GetItem` but without checking that
+   :c:func:`PySequence_Check` on *o* is true and without adjustment for negative
    indices.
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *i*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: Py_ssize_t PySequence_Fast_GET_SIZE(PyObject *o)
+      This function used an :c:type:`int` type for *i*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: Py_ssize_t PySequence_Fast_GET_SIZE(PyObject *o)
    Returns the length of *o*, assuming that *o* was returned by
    :cfunc:`PySequence_Fast` and that *o* is not *NULL*.  The size can also be
    gotten by calling :cfunc:`PySequence_Size` on *o*, but
    :cfunc:`PySequence_Fast_GET_SIZE` is faster because it can assume *o* is a list
+   :c:func:`PySequence_Fast` and that *o* is not *NULL*.  The size can also be
+   gotten by calling :c:func:`PySequence_Size` on *o*, but
+   :c:func:`PySequence_Fast_GET_SIZE` is faster because it can assume *o* is a list
    or tuple.

python/vendor/current/Doc/c-api/set.rst

-              r2
+              r388
 This section details the public API for :class:`set` and :class:`frozenset`
 objects.  Any functionality not listed below is best accessed using the either
 the abstract object protocol (including :cfunc:`PyObject_CallMethod`,
 :cfunc:`PyObject_RichCompareBool`, :cfunc:`PyObject_Hash`,
 :cfunc:`PyObject_Repr`, :cfunc:`PyObject_IsTrue`, :cfunc:`PyObject_Print`, and
 :cfunc:`PyObject_GetIter`) or the abstract number protocol (including
 :cfunc:`PyNumber_And`, :cfunc:`PyNumber_Subtract`, :cfunc:`PyNumber_Or`,
 :cfunc:`PyNumber_Xor`, :cfunc:`PyNumber_InPlaceAnd`,
 :cfunc:`PyNumber_InPlaceSubtract`, :cfunc:`PyNumber_InPlaceOr`, and
 :cfunc:`PyNumber_InPlaceXor`).
+the abstract object protocol (including :c:func:`PyObject_CallMethod`,
+:c:func:`PyObject_RichCompareBool`, :c:func:`PyObject_Hash`,
+:c:func:`PyObject_Repr`, :c:func:`PyObject_IsTrue`, :c:func:`PyObject_Print`, and
+:c:func:`PyObject_GetIter`) or the abstract number protocol (including
+:c:func:`PyNumber_And`, :c:func:`PyNumber_Subtract`, :c:func:`PyNumber_Or`,
+:c:func:`PyNumber_Xor`, :c:func:`PyNumber_InPlaceAnd`,
+:c:func:`PyNumber_InPlaceSubtract`, :c:func:`PyNumber_InPlaceOr`, and
+:c:func:`PyNumber_InPlaceXor`).
 .. ctype:: PySetObject
+.. c:type:: PySetObject
    This subtype of :ctype:`PyObject` is used to hold the internal data for both
    :class:`set` and :class:`frozenset` objects.  It is like a :ctype:`PyDictObject`
+   This subtype of :c:type:`PyObject` is used to hold the internal data for both
+   :class:`set` and :class:`frozenset` objects.  It is like a :c:type:`PyDictObject`
    in that it is a fixed size for small sets (much like tuple storage) and will
    point to a separate, variable sized block of memory for medium and large sized
 …
 .. cvar:: PyTypeObject PySet_Type
+.. c:var:: PyTypeObject PySet_Type
    This is an instance of :ctype:`PyTypeObject` representing the Python
+   This is an instance of :c:type:`PyTypeObject` representing the Python
    :class:`set` type.
 .. cvar:: PyTypeObject PyFrozenSet_Type
+.. c:var:: PyTypeObject PyFrozenSet_Type
    This is an instance of :ctype:`PyTypeObject` representing the Python
+   This is an instance of :c:type:`PyTypeObject` representing the Python
    :class:`frozenset` type.
 …
 .. cfunction:: int PySet_Check(PyObject *p)
+.. c:function:: int PySet_Check(PyObject *p)
    Return true if *p* is a :class:`set` object or an instance of a subtype.
 …
    .. versionadded:: 2.6
 .. cfunction:: int PyFrozenSet_Check(PyObject *p)
+.. c:function:: int PyFrozenSet_Check(PyObject *p)
    Return true if *p* is a :class:`frozenset` object or an instance of a
 …
    .. versionadded:: 2.6
 .. cfunction:: int PyAnySet_Check(PyObject *p)
+.. c:function:: int PyAnySet_Check(PyObject *p)
    Return true if *p* is a :class:`set` object, a :class:`frozenset` object, or an
 …
 .. cfunction:: int PyAnySet_CheckExact(PyObject *p)
+.. c:function:: int PyAnySet_CheckExact(PyObject *p)
    Return true if *p* is a :class:`set` object or a :class:`frozenset` object but
 …
 .. cfunction:: int PyFrozenSet_CheckExact(PyObject *p)
+.. c:function:: int PyFrozenSet_CheckExact(PyObject *p)
    Return true if *p* is a :class:`frozenset` object but not an instance of a
 …
 .. cfunction:: PyObject* PySet_New(PyObject *iterable)
+.. c:function:: PyObject* PySet_New(PyObject *iterable)
    Return a new :class:`set` containing objects returned by the *iterable*.  The
 …
 .. cfunction:: PyObject* PyFrozenSet_New(PyObject *iterable)
+.. c:function:: PyObject* PyFrozenSet_New(PyObject *iterable)
    Return a new :class:`frozenset` containing objects returned by the *iterable*.
 …
 .. cfunction:: Py_ssize_t PySet_Size(PyObject *anyset)
+.. c:function:: Py_ssize_t PySet_Size(PyObject *anyset)
    .. index:: builtin: len
 …
    .. versionchanged:: 2.5
       This function returned an :ctype:`int`. This might require changes in
+      This function returned an :c:type:`int`. This might require changes in
       your code for properly supporting 64-bit systems.
 .. cfunction:: Py_ssize_t PySet_GET_SIZE(PyObject *anyset)
+.. c:function:: Py_ssize_t PySet_GET_SIZE(PyObject *anyset)
    Macro form of :cfunc:`PySet_Size` without error checking.
+   Macro form of :c:func:`PySet_Size` without error checking.
 .. cfunction:: int PySet_Contains(PyObject *anyset, PyObject *key)
+.. c:function:: int PySet_Contains(PyObject *anyset, PyObject *key)
    Return 1 if found, 0 if not found, and -1 if an error is encountered.  Unlike
 …
 .. cfunction:: int PySet_Add(PyObject *set, PyObject *key)
+.. c:function:: int PySet_Add(PyObject *set, PyObject *key)
    Add *key* to a :class:`set` instance.  Does not apply to :class:`frozenset`
 …
    .. versionchanged:: 2.6
       Now works with instances of :class:`frozenset` or its subtypes.
       Like :cfunc:`PyTuple_SetItem` in that it can be used to fill-in the
+      Like :c:func:`PyTuple_SetItem` in that it can be used to fill-in the
       values of brand new frozensets before they are exposed to other code.
 …
 .. cfunction:: int PySet_Discard(PyObject *set, PyObject *key)
+.. c:function:: int PySet_Discard(PyObject *set, PyObject *key)
    Return 1 if found and removed, 0 if not found (no action taken), and -1 if an
    error is encountered.  Does not raise :exc:`KeyError` for missing keys.  Raise a
    :exc:`TypeError` if the *key* is unhashable.  Unlike the Python :meth:`discard`
+   :exc:`TypeError` if the *key* is unhashable.  Unlike the Python :meth:`~set.discard`
    method, this function does not automatically convert unhashable sets into
    temporary frozensets. Raise :exc:`PyExc_SystemError` if *set* is an not an
 …
 .. cfunction:: PyObject* PySet_Pop(PyObject *set)
+.. c:function:: PyObject* PySet_Pop(PyObject *set)
    Return a new reference to an arbitrary object in the *set*, and removes the
 …
 .. cfunction:: int PySet_Clear(PyObject *set)
+.. c:function:: int PySet_Clear(PyObject *set)
    Empty an existing set of all elements.

python/vendor/current/Doc/c-api/slice.rst

-              r2
+              r388
 .. cvar:: PyTypeObject PySlice_Type
+.. c:var:: PyTypeObject PySlice_Type
    .. index:: single: SliceType (in module types)
 …
 .. cfunction:: int PySlice_Check(PyObject *ob)
+.. c:function:: int PySlice_Check(PyObject *ob)
    Return true if *ob* is a slice object; *ob* must not be *NULL*.
 .. cfunction:: PyObject* PySlice_New(PyObject *start, PyObject *stop, PyObject *step)
+.. c:function:: PyObject* PySlice_New(PyObject *start, PyObject *stop, PyObject *step)
    Return a new slice object with the given values.  The *start*, *stop*, and
 …
 .. cfunction:: int PySlice_GetIndices(PySliceObject *slice, Py_ssize_t length, Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step)
+.. c:function:: int PySlice_GetIndices(PySliceObject *slice, Py_ssize_t length, Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step)
    Retrieve the start, stop and step indices from the slice object *slice*,
 …
    You probably do not want to use this function.  If you want to use slice
    objects in versions of Python prior to 2.3, you would probably do well to
    incorporate the source of :cfunc:`PySlice_GetIndicesEx`, suitably renamed,
+   incorporate the source of :c:func:`PySlice_GetIndicesEx`, suitably renamed,
    in the source of your extension.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *length* and an
       :ctype:`int *` type for *start*, *stop*, and *step*. This might require
+      This function used an :c:type:`int` type for *length* and an
+      :c:type:`int *` type for *start*, *stop*, and *step*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: int PySlice_GetIndicesEx(PySliceObject *slice, Py_ssize_t length, Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step, Py_ssize_t *slicelength)
+.. c:function:: int PySlice_GetIndicesEx(PySliceObject *slice, Py_ssize_t length, Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step, Py_ssize_t *slicelength)
    Usable replacement for :cfunc:`PySlice_GetIndices`.  Retrieve the start,
+   Usable replacement for :c:func:`PySlice_GetIndices`.  Retrieve the start,
    stop, and step indices from the slice object *slice* assuming a sequence of
    length *length*, and store the length of the slice in *slicelength*.  Out
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *length* and an
       :ctype:`int *` type for *start*, *stop*, *step*, and *slicelength*. This
+      This function used an :c:type:`int` type for *length* and an
+      :c:type:`int *` type for *start*, *stop*, *step*, and *slicelength*. This
       might require changes in your code for properly supporting 64-bit
       systems.

python/vendor/current/Doc/c-api/string.rst

-              r2
+              r388
 .. ctype:: PyStringObject
    This subtype of :ctype:`PyObject` represents a Python string object.
 .. cvar:: PyTypeObject PyString_Type
+.. c:type:: PyStringObject
+   This subtype of :c:type:`PyObject` represents a Python string object.
+.. c:var:: PyTypeObject PyString_Type
    .. index:: single: StringType (in module types)
    This instance of :ctype:`PyTypeObject` represents the Python string type; it is
+   This instance of :c:type:`PyTypeObject` represents the Python string type; it is
    the same object as ``str`` and ``types.StringType`` in the Python layer. .
 .. cfunction:: int PyString_Check(PyObject *o)
+.. c:function:: int PyString_Check(PyObject *o)
    Return true if the object *o* is a string object or an instance of a subtype of
 …
 .. cfunction:: int PyString_CheckExact(PyObject *o)
+.. c:function:: int PyString_CheckExact(PyObject *o)
    Return true if the object *o* is a string object, but not an instance of a
 …
 .. cfunction:: PyObject* PyString_FromString(const char *v)
+.. c:function:: PyObject* PyString_FromString(const char *v)
    Return a new string object with a copy of the string *v* as value on success,
 …
 .. cfunction:: PyObject* PyString_FromStringAndSize(const char *v, Py_ssize_t len)
+.. c:function:: PyObject* PyString_FromStringAndSize(const char *v, Py_ssize_t len)
    Return a new string object with a copy of the string *v* as value and length
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *len*. This might require
+      This function used an :c:type:`int` type for *len*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyString_FromFormat(const char *format, ...)
    Take a C :cfunc:`printf`\ -style *format* string and a variable number of
+.. c:function:: PyObject* PyString_FromFormat(const char *format, ...)
+   Take a C :c:func:`printf`\ -style *format* string and a variable number of
    arguments, calculate the size of the resulting Python string and return a string
    with the values formatted into it.  The variable arguments must be C types and
 …
    .. % because not all compilers support the %z width modifier -- we fake it
    .. % when necessary via interpolating PY_FORMAT_SIZE_T.
+   .. % Similar comments apply to the %ll width modifier and
+   .. % PY_FORMAT_LONG_LONG.
    .. % %u, %lu, %zu should have "new in Python 2.5" blurbs.
 …
    | :attr:`%lu`       | unsigned long | Exactly equivalent to          |
    |                   |               | ``printf("%lu")``.             |
+   +-------------------+---------------+--------------------------------+
+   | :attr:`%lld`      | long long     | Exactly equivalent to          |
+   |                   |               | ``printf("%lld")``.            |
+   +-------------------+---------------+--------------------------------+
+   | :attr:`%llu`      | unsigned      | Exactly equivalent to          |
+   |                   | long long     | ``printf("%llu")``.            |
    +-------------------+---------------+--------------------------------+
    | :attr:`%zd`       | Py_ssize_t    | Exactly equivalent to          |
 …
    copied as-is to the result string, and any extra arguments discarded.
+.. cfunction:: PyObject* PyString_FromFormatV(const char *format, va_list vargs)
+   Identical to :cfunc:`PyString_FromFormat` except that it takes exactly two
+   .. note::
+      The `"%lld"` and `"%llu"` format specifiers are only available
+      when :const:`HAVE_LONG_LONG` is defined.
+   .. versionchanged:: 2.7
+      Support for `"%lld"` and `"%llu"` added.
+.. c:function:: PyObject* PyString_FromFormatV(const char *format, va_list vargs)
+   Identical to :c:func:`PyString_FromFormat` except that it takes exactly two
    arguments.
 .. cfunction:: Py_ssize_t PyString_Size(PyObject *string)
+.. c:function:: Py_ssize_t PyString_Size(PyObject *string)
    Return the length of the string in string object *string*.
    .. versionchanged:: 2.5
       This function returned an :ctype:`int` type. This might require changes
+      This function returned an :c:type:`int` type. This might require changes
       in your code for properly supporting 64-bit systems.
 .. cfunction:: Py_ssize_t PyString_GET_SIZE(PyObject *string)
    Macro form of :cfunc:`PyString_Size` but without error checking.
    .. versionchanged:: 2.5
       This macro returned an :ctype:`int` type. This might require changes in
+.. c:function:: Py_ssize_t PyString_GET_SIZE(PyObject *string)
+   Macro form of :c:func:`PyString_Size` but without error checking.
+   .. versionchanged:: 2.5
+      This macro returned an :c:type:`int` type. This might require changes in
       your code for properly supporting 64-bit systems.
 .. cfunction:: char* PyString_AsString(PyObject *string)
+.. c:function:: char* PyString_AsString(PyObject *string)
    Return a NUL-terminated representation of the contents of *string*.  The pointer
 …
    *string* is a Unicode object, this function computes the default encoding of
    *string* and operates on that.  If *string* is not a string object at all,
    :cfunc:`PyString_AsString` returns *NULL* and raises :exc:`TypeError`.
 .. cfunction:: char* PyString_AS_STRING(PyObject *string)
    Macro form of :cfunc:`PyString_AsString` but without error checking.  Only
+   :c:func:`PyString_AsString` returns *NULL* and raises :exc:`TypeError`.
+.. c:function:: char* PyString_AS_STRING(PyObject *string)
+   Macro form of :c:func:`PyString_AsString` but without error checking.  Only
    string objects are supported; no Unicode objects should be passed.
 .. cfunction:: int PyString_AsStringAndSize(PyObject *obj, char **buffer, Py_ssize_t *length)
+.. c:function:: int PyString_AsStringAndSize(PyObject *obj, char **buffer, Py_ssize_t *length)
    Return a NUL-terminated representation of the contents of the object *obj*
 …
    *string* is a Unicode object, this function computes the default encoding of
    *string* and operates on that.  If *string* is not a string object at all,
    :cfunc:`PyString_AsStringAndSize` returns ``-1`` and raises :exc:`TypeError`.
    .. versionchanged:: 2.5
       This function used an :ctype:`int *` type for *length*. This might
+   :c:func:`PyString_AsStringAndSize` returns ``-1`` and raises :exc:`TypeError`.
+   .. versionchanged:: 2.5
+      This function used an :c:type:`int *` type for *length*. This might
       require changes in your code for properly supporting 64-bit systems.
 .. cfunction:: void PyString_Concat(PyObject **string, PyObject *newpart)
+.. c:function:: void PyString_Concat(PyObject **string, PyObject *newpart)
    Create a new string object in *\*string* containing the contents of *newpart*
 …
 .. cfunction:: void PyString_ConcatAndDel(PyObject **string, PyObject *newpart)
+.. c:function:: void PyString_ConcatAndDel(PyObject **string, PyObject *newpart)
    Create a new string object in *\*string* containing the contents of *newpart*
 …
 .. cfunction:: int _PyString_Resize(PyObject **string, Py_ssize_t newsize)
+.. c:function:: int _PyString_Resize(PyObject **string, Py_ssize_t newsize)
    A way to resize a string object even though it is "immutable". Only use this to
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *newsize*. This might
+      This function used an :c:type:`int` type for *newsize*. This might
       require changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyString_Format(PyObject *format, PyObject *args)
+.. c:function:: PyObject* PyString_Format(PyObject *format, PyObject *args)
    Return a new string object from *format* and *args*. Analogous to ``format %
    args``.  The *args* argument must be a tuple.
 .. cfunction:: void PyString_InternInPlace(PyObject **string)
+   args``.  The *args* argument must be a tuple or dict.
+.. c:function:: void PyString_InternInPlace(PyObject **string)
    Intern the argument *\*string* in place.  The argument must be the address of a
 …
 .. cfunction:: PyObject* PyString_InternFromString(const char *v)
    A combination of :cfunc:`PyString_FromString` and
    :cfunc:`PyString_InternInPlace`, returning either a new string object that has
+.. c:function:: PyObject* PyString_InternFromString(const char *v)
+   A combination of :c:func:`PyString_FromString` and
+   :c:func:`PyString_InternInPlace`, returning either a new string object that has
    been interned, or a new ("owned") reference to an earlier interned string object
    with the same value.
 …
 .. cfunction:: PyObject* PyString_Decode(const char *s, Py_ssize_t size, const char *encoding, const char *errors)
+.. c:function:: PyObject* PyString_Decode(const char *s, Py_ssize_t size, const char *encoding, const char *errors)
    Create an object by decoding *size* bytes of the encoded buffer *s* using the
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
+      This function used an :c:type:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyString_AsDecodedObject(PyObject *str, const char *encoding, const char *errors)
+.. c:function:: PyObject* PyString_AsDecodedObject(PyObject *str, const char *encoding, const char *errors)
    Decode a string object by passing it to the codec registered for *encoding* and
 …
 .. cfunction:: PyObject* PyString_Encode(const char *s, Py_ssize_t size, const char *encoding, const char *errors)
    Encode the :ctype:`char` buffer of the given size by passing it to the codec
+.. c:function:: PyObject* PyString_Encode(const char *s, Py_ssize_t size, const char *encoding, const char *errors)
+   Encode the :c:type:`char` buffer of the given size by passing it to the codec
    registered for *encoding* and return a Python object. *encoding* and *errors*
    have the same meaning as the parameters of the same name in the string
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
+      This function used an :c:type:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyString_AsEncodedObject(PyObject *str, const char *encoding, const char *errors)
+.. c:function:: PyObject* PyString_AsEncodedObject(PyObject *str, const char *encoding, const char *errors)
    Encode a string object using the codec registered for *encoding* and return the

python/vendor/current/Doc/c-api/structures.rst

-              r2
+              r388
 All Python objects ultimately share a small number of fields at the beginning
 of the object's representation in memory.  These are represented by the
 :ctype:`PyObject` and :ctype:`PyVarObject` types, which are defined, in turn,
+:c:type:`PyObject` and :c:type:`PyVarObject` types, which are defined, in turn,
 by the expansions of some macros also used, whether directly or indirectly, in
 the definition of all other Python objects.
 .. ctype:: PyObject
+.. c:type:: PyObject
    All object types are extensions of this type.  This is a type which
 …
 .. ctype:: PyVarObject
    This is an extension of :ctype:`PyObject` that adds the :attr:`ob_size`
+.. c:type:: PyVarObject
+   This is an extension of :c:type:`PyObject` that adds the :attr:`ob_size`
    field.  This is only used for objects that have some notion of *length*.
    This type does not often appear in the Python/C API.  It corresponds to the
    fields defined by the expansion of the ``PyObject_VAR_HEAD`` macro.
 These macros are used in the definition of :ctype:`PyObject` and
 :ctype:`PyVarObject`:
 .. cmacro:: PyObject_HEAD
+These macros are used in the definition of :c:type:`PyObject` and
+:c:type:`PyVarObject`:
+.. c:macro:: PyObject_HEAD
    This is a macro which expands to the declarations of the fields of the
    :ctype:`PyObject` type; it is used when declaring new types which represent
+   :c:type:`PyObject` type; it is used when declaring new types which represent
    objects without a varying length.  The specific fields it expands to depend
    on the definition of :cmacro:`Py_TRACE_REFS`.  By default, that macro is
    not defined, and :cmacro:`PyObject_HEAD` expands to::
+   on the definition of :c:macro:`Py_TRACE_REFS`.  By default, that macro is
+   not defined, and :c:macro:`PyObject_HEAD` expands to::
       Py_ssize_t ob_refcnt;
       PyTypeObject *ob_type;
    When :cmacro:`Py_TRACE_REFS` is defined, it expands to::
+   When :c:macro:`Py_TRACE_REFS` is defined, it expands to::
       PyObject *_ob_next, *_ob_prev;
 …
 .. cmacro:: PyObject_VAR_HEAD
+.. c:macro:: PyObject_VAR_HEAD
    This is a macro which expands to the declarations of the fields of the
    :ctype:`PyVarObject` type; it is used when declaring new types which
+   :c:type:`PyVarObject` type; it is used when declaring new types which
    represent objects with a length that varies from instance to instance.
    This macro always expands to::
 …
       Py_ssize_t ob_size;
    Note that :cmacro:`PyObject_HEAD` is part of the expansion, and that its own
    expansion varies depending on the definition of :cmacro:`Py_TRACE_REFS`.
 .. cmacro:: PyObject_HEAD_INIT(type)
+   Note that :c:macro:`PyObject_HEAD` is part of the expansion, and that its own
+   expansion varies depending on the definition of :c:macro:`Py_TRACE_REFS`.
+.. c:macro:: PyObject_HEAD_INIT(type)
    This is a macro which expands to initialization values for a new
    :ctype:`PyObject` type.  This macro expands to::
+   :c:type:`PyObject` type.  This macro expands to::
       _PyObject_EXTRA_INIT
 …
 .. cmacro:: PyVarObject_HEAD_INIT(type, size)
+.. c:macro:: PyVarObject_HEAD_INIT(type, size)
    This is a macro which expands to initialization values for a new
    :ctype:`PyVarObject` type, including the :attr:`ob_size` field.
+   :c:type:`PyVarObject` type, including the :attr:`ob_size` field.
    This macro expands to::
 …
 .. ctype:: PyCFunction
+.. c:type:: PyCFunction
    Type of the functions used to implement most Python callables in C.
    Functions of this type take two :ctype:`PyObject\*` parameters and return
+   Functions of this type take two :c:type:`PyObject\*` parameters and return
    one such value.  If the return value is *NULL*, an exception shall have
    been set.  If not *NULL*, the return value is interpreted as the return
 …
 .. ctype:: PyMethodDef
+.. c:type:: PyMethodDef
    Structure used to describe a method of an extension type.  This structure has
 …
 The :attr:`ml_meth` is a C function pointer.  The functions may be of different
 types, but they always return :ctype:`PyObject\*`.  If the function is not of
 the :ctype:`PyCFunction`, the compiler will require a cast in the method table.
 Even though :ctype:`PyCFunction` defines the first parameter as
 :ctype:`PyObject\*`, it is common that the method implementation uses a the
+types, but they always return :c:type:`PyObject\*`.  If the function is not of
+the :c:type:`PyCFunction`, the compiler will require a cast in the method table.
+Even though :c:type:`PyCFunction` defines the first parameter as
+:c:type:`PyObject\*`, it is common that the method implementation uses a the
 specific C type of the *self* object.
 …
    This is the typical calling convention, where the methods have the type
+   :ctype:`PyCFunction`. The function expects two :ctype:`PyObject\*` values.
+   The first one is the *self* object for methods; for module functions, it
+   has the value given to :cfunc:`Py_InitModule4` (or *NULL* if
+   :cfunc:`Py_InitModule` was used).  The second parameter (often called
+   *args*) is a tuple object representing all arguments. This parameter is
+   typically processed using :cfunc:`PyArg_ParseTuple` or
+   :cfunc:`PyArg_UnpackTuple`.
+   :c:type:`PyCFunction`. The function expects two :c:type:`PyObject\*` values.
+   The first one is the *self* object for methods; for module functions, it is
+   the module object.  The second parameter (often called *args*) is a tuple
+   object representing all arguments.  This parameter is typically processed
+   using :c:func:`PyArg_ParseTuple` or :c:func:`PyArg_UnpackTuple`.
 .. data:: METH_KEYWORDS
    Methods with these flags must be of type :ctype:`PyCFunctionWithKeywords`.
+   Methods with these flags must be of type :c:type:`PyCFunctionWithKeywords`.
    The function expects three parameters: *self*, *args*, and a dictionary of
    all the keyword arguments.  The flag is typically combined with
    :const:`METH_VARARGS`, and the parameters are typically processed using
    :cfunc:`PyArg_ParseTupleAndKeywords`.
+   :c:func:`PyArg_ParseTupleAndKeywords`.
 …
    Methods without parameters don't need to check whether arguments are given if
    they are listed with the :const:`METH_NOARGS` flag.  They need to be of type
    :ctype:`PyCFunction`.  When used with object methods, the first parameter is
    typically named ``self`` and will hold a reference to the object instance.
    In all cases the second parameter will be *NULL*.
+   :c:type:`PyCFunction`.  The first parameter is typically named ``self`` and
+   will hold a reference to the module or object instance.  In all cases the
+   second parameter will be *NULL*.
 …
    Methods with a single object argument can be listed with the :const:`METH_O`
    flag, instead of invoking :cfunc:`PyArg_ParseTuple` with a ``"O"`` argument.
    They have the type :ctype:`PyCFunction`, with the *self* parameter, and a
    :ctype:`PyObject\*` parameter representing the single argument.
+   flag, instead of invoking :c:func:`PyArg_ParseTuple` with a ``"O"`` argument.
+   They have the type :c:type:`PyCFunction`, with the *self* parameter, and a
+   :c:type:`PyObject\*` parameter representing the single argument.
 …
    This calling convention is deprecated.  The method must be of type
    :ctype:`PyCFunction`.  The second argument is *NULL* if no arguments are
+   :c:type:`PyCFunction`.  The second argument is *NULL* if no arguments are
    given, a single object if exactly one argument is given, and a tuple of
    objects if more than one argument is given.  There is no way for a function
 …
 .. ctype:: PyMemberDef
+.. c:type:: PyMemberDef
    Structure which describes an attribute of a type which corresponds to a C
 …
    =============== ==================
    :cmacro:`T_OBJECT` and :cmacro:`T_OBJECT_EX` differ in that
    :cmacro:`T_OBJECT` returns ``None`` if the member is *NULL* and
    :cmacro:`T_OBJECT_EX` raises an :exc:`AttributeError`.  Try to use
    :cmacro:`T_OBJECT_EX` over :cmacro:`T_OBJECT` because :cmacro:`T_OBJECT_EX`
+   :c:macro:`T_OBJECT` and :c:macro:`T_OBJECT_EX` differ in that
+   :c:macro:`T_OBJECT` returns ``None`` if the member is *NULL* and
+   :c:macro:`T_OBJECT_EX` raises an :exc:`AttributeError`.  Try to use
+   :c:macro:`T_OBJECT_EX` over :c:macro:`T_OBJECT` because :c:macro:`T_OBJECT_EX`
    handles use of the :keyword:`del` statement on that attribute more correctly
    than :cmacro:`T_OBJECT`.
    :attr:`flags` can be 0 for write and read access or :cmacro:`READONLY` for
    read-only access.  Using :cmacro:`T_STRING` for :attr:`type` implies
    :cmacro:`READONLY`.  Only :cmacro:`T_OBJECT` and :cmacro:`T_OBJECT_EX`
+   than :c:macro:`T_OBJECT`.
+   :attr:`flags` can be 0 for write and read access or :c:macro:`READONLY` for
+   read-only access.  Using :c:macro:`T_STRING` for :attr:`type` implies
+   :c:macro:`READONLY`.  Only :c:macro:`T_OBJECT` and :c:macro:`T_OBJECT_EX`
    members can be deleted.  (They are set to *NULL*).
 .. cfunction:: PyObject* Py_FindMethod(PyMethodDef table[], PyObject *ob, char *name)
+.. c:function:: PyObject* Py_FindMethod(PyMethodDef table[], PyObject *ob, char *name)
    Return a bound method object for an extension type implemented in C.  This
    can be useful in the implementation of a :attr:`tp_getattro` or
    :attr:`tp_getattr` handler that does not use the
    :cfunc:`PyObject_GenericGetAttr` function.
+   can be useful in the implementation of a :c:member:`~PyTypeObject.tp_getattro` or
+   :c:member:`~PyTypeObject.tp_getattr` handler that does not use the
+   :c:func:`PyObject_GenericGetAttr` function.

python/vendor/current/Doc/c-api/sys.rst

-              r2
+              r388
 .. cfunction:: int Py_FdIsInteractive(FILE *fp, const char *filename)
+.. c:function:: int Py_FdIsInteractive(FILE *fp, const char *filename)
    Return true (nonzero) if the standard I/O file *fp* with name *filename* is
    deemed interactive.  This is the case for files for which ``isatty(fileno(fp))``
    is true.  If the global flag :cdata:`Py_InteractiveFlag` is true, this function
+   is true.  If the global flag :c:data:`Py_InteractiveFlag` is true, this function
    also returns true if the *filename* pointer is *NULL* or if the name is equal to
    one of the strings ``'<stdin>'`` or ``'???'``.
+.. cfunction:: long PyOS_GetLastModificationTime(char *filename)
+   Return the time of last modification of the file *filename*. The result is
+   encoded in the same way as the timestamp returned by the standard C library
+   function :cfunc:`time`.
+.. cfunction:: void PyOS_AfterFork()
+.. c:function:: void PyOS_AfterFork()
    Function to update some internal state after a process fork; this should be
 …
 .. cfunction:: int PyOS_CheckStack()
+.. c:function:: int PyOS_CheckStack()
    Return true when the interpreter runs out of stack space.  This is a reliable
 …
 .. cfunction:: PyOS_sighandler_t PyOS_getsig(int i)
+.. c:function:: PyOS_sighandler_t PyOS_getsig(int i)
    Return the current signal handler for signal *i*.  This is a thin wrapper around
    either :cfunc:`sigaction` or :cfunc:`signal`.  Do not call those functions
    directly! :ctype:`PyOS_sighandler_t` is a typedef alias for :ctype:`void
+   either :c:func:`sigaction` or :c:func:`signal`.  Do not call those functions
+   directly! :c:type:`PyOS_sighandler_t` is a typedef alias for :c:type:`void
    (\*)(int)`.
 .. cfunction:: PyOS_sighandler_t PyOS_setsig(int i, PyOS_sighandler_t h)
+.. c:function:: PyOS_sighandler_t PyOS_setsig(int i, PyOS_sighandler_t h)
    Set the signal handler for signal *i* to be *h*; return the old signal handler.
    This is a thin wrapper around either :cfunc:`sigaction` or :cfunc:`signal`.  Do
    not call those functions directly!  :ctype:`PyOS_sighandler_t` is a typedef
    alias for :ctype:`void (\*)(int)`.
+   This is a thin wrapper around either :c:func:`sigaction` or :c:func:`signal`.  Do
+   not call those functions directly!  :c:type:`PyOS_sighandler_t` is a typedef
+   alias for :c:type:`void (\*)(int)`.
 .. _systemfunctions:
 …
 :mod:`sys` module's dict, which is contained in the internal thread state structure.
 .. cfunction:: PyObject *PySys_GetObject(char *name)
+.. c:function:: PyObject *PySys_GetObject(char *name)
    Return the object *name* from the :mod:`sys` module or *NULL* if it does
    not exist, without setting an exception.
 .. cfunction:: FILE *PySys_GetFile(char *name, FILE *def)
+.. c:function:: FILE *PySys_GetFile(char *name, FILE *def)
    Return the :ctype:`FILE*` associated with the object *name* in the
+   Return the :c:type:`FILE*` associated with the object *name* in the
    :mod:`sys` module, or *def* if *name* is not in the module or is not associated
    with a :ctype:`FILE*`.
+   with a :c:type:`FILE*`.
 .. cfunction:: int PySys_SetObject(char *name, PyObject *v)
+.. c:function:: int PySys_SetObject(char *name, PyObject *v)
    Set *name* in the :mod:`sys` module to *v* unless *v* is *NULL*, in which
 …
    on error.
 .. cfunction:: void PySys_ResetWarnOptions()
+.. c:function:: void PySys_ResetWarnOptions()
    Reset :data:`sys.warnoptions` to an empty list.
 .. cfunction:: void PySys_AddWarnOption(char *s)
+.. c:function:: void PySys_AddWarnOption(char *s)
    Append *s* to :data:`sys.warnoptions`.
 .. cfunction:: void PySys_SetPath(char *path)
+.. c:function:: void PySys_SetPath(char *path)
    Set :data:`sys.path` to a list object of paths found in *path* which should
 …
    (``:`` on Unix, ``;`` on Windows).
 .. cfunction:: void PySys_WriteStdout(const char *format, ...)
+.. c:function:: void PySys_WriteStdout(const char *format, ...)
    Write the output string described by *format* to :data:`sys.stdout`.  No
 …
    is written to the real (C level) *stdout*.
 .. cfunction:: void PySys_WriteStderr(const char *format, ...)
+.. c:function:: void PySys_WriteStderr(const char *format, ...)
    As above, but write to :data:`sys.stderr` or *stderr* instead.
 …
 .. cfunction:: void Py_FatalError(const char *message)
+.. c:function:: void Py_FatalError(const char *message)
    .. index:: single: abort()
 …
    make it dangerous to continue using the Python interpreter; e.g., when the
    object administration appears to be corrupted.  On Unix, the standard C library
    function :cfunc:`abort` is called which will attempt to produce a :file:`core`
+   function :c:func:`abort` is called which will attempt to produce a :file:`core`
    file.
 .. cfunction:: void Py_Exit(int status)
+.. c:function:: void Py_Exit(int status)
    .. index::
 …
       single: exit()
    Exit the current process.  This calls :cfunc:`Py_Finalize` and then calls the
+   Exit the current process.  This calls :c:func:`Py_Finalize` and then calls the
    standard C library function ``exit(status)``.
 .. cfunction:: int Py_AtExit(void (*func) ())
+.. c:function:: int Py_AtExit(void (*func) ())
    .. index::
 …
       single: cleanup functions
    Register a cleanup function to be called by :cfunc:`Py_Finalize`.  The cleanup
+   Register a cleanup function to be called by :c:func:`Py_Finalize`.  The cleanup
    function will be called with no arguments and should return no value.  At most
 cleanup functions can be registered.  When the registration is successful,
    :cfunc:`Py_AtExit` returns ``0``; on failure, it returns ``-1``.  The cleanup
+   :c:func:`Py_AtExit` returns ``0``; on failure, it returns ``-1``.  The cleanup
    function registered last is called first. Each cleanup function will be called
    at most once.  Since Python's internal finalization will have completed before

python/vendor/current/Doc/c-api/tuple.rst

-              r2
+              r388
 .. ctype:: PyTupleObject
+.. c:type:: PyTupleObject
    This subtype of :ctype:`PyObject` represents a Python tuple object.
+   This subtype of :c:type:`PyObject` represents a Python tuple object.
 .. cvar:: PyTypeObject PyTuple_Type
+.. c:var:: PyTypeObject PyTuple_Type
    .. index:: single: TupleType (in module types)
    This instance of :ctype:`PyTypeObject` represents the Python tuple type; it is
+   This instance of :c:type:`PyTypeObject` represents the Python tuple type; it is
    the same object as ``tuple`` and ``types.TupleType`` in the Python layer..
 .. cfunction:: int PyTuple_Check(PyObject *p)
+.. c:function:: int PyTuple_Check(PyObject *p)
    Return true if *p* is a tuple object or an instance of a subtype of the tuple
 …
 .. cfunction:: int PyTuple_CheckExact(PyObject *p)
+.. c:function:: int PyTuple_CheckExact(PyObject *p)
    Return true if *p* is a tuple object, but not an instance of a subtype of the
 …
 .. cfunction:: PyObject* PyTuple_New(Py_ssize_t len)
+.. c:function:: PyObject* PyTuple_New(Py_ssize_t len)
    Return a new tuple object of size *len*, or *NULL* on failure.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *len*. This might require
+      This function used an :c:type:`int` type for *len*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyTuple_Pack(Py_ssize_t n, ...)
+.. c:function:: PyObject* PyTuple_Pack(Py_ssize_t n, ...)
    Return a new tuple object of size *n*, or *NULL* on failure. The tuple values
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *n*. This might require
+      This function used an :c:type:`int` type for *n*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: Py_ssize_t PyTuple_Size(PyObject *p)
+.. c:function:: Py_ssize_t PyTuple_Size(PyObject *p)
    Take a pointer to a tuple object, and return the size of that tuple.
    .. versionchanged:: 2.5
       This function returned an :ctype:`int` type. This might require changes
+      This function returned an :c:type:`int` type. This might require changes
       in your code for properly supporting 64-bit systems.
 .. cfunction:: Py_ssize_t PyTuple_GET_SIZE(PyObject *p)
+.. c:function:: Py_ssize_t PyTuple_GET_SIZE(PyObject *p)
    Return the size of the tuple *p*, which must be non-*NULL* and point to a tuple;
 …
    .. versionchanged:: 2.5
       This function returned an :ctype:`int` type. This might require changes
+      This function returned an :c:type:`int` type. This might require changes
       in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyTuple_GetItem(PyObject *p, Py_ssize_t pos)
+.. c:function:: PyObject* PyTuple_GetItem(PyObject *p, Py_ssize_t pos)
    Return the object at position *pos* in the tuple pointed to by *p*.  If *pos* is
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *pos*. This might require
+      This function used an :c:type:`int` type for *pos*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyTuple_GET_ITEM(PyObject *p, Py_ssize_t pos)
+.. c:function:: PyObject* PyTuple_GET_ITEM(PyObject *p, Py_ssize_t pos)
    Like :cfunc:`PyTuple_GetItem`, but does no checking of its arguments.
+   Like :c:func:`PyTuple_GetItem`, but does no checking of its arguments.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *pos*. This might require
+      This function used an :c:type:`int` type for *pos*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyTuple_GetSlice(PyObject *p, Py_ssize_t low, Py_ssize_t high)
+.. c:function:: PyObject* PyTuple_GetSlice(PyObject *p, Py_ssize_t low, Py_ssize_t high)
    Take a slice of the tuple pointed to by *p* from *low* to *high* and return it
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *low* and *high*. This might
+      This function used an :c:type:`int` type for *low* and *high*. This might
       require changes in your code for properly supporting 64-bit systems.
 .. cfunction:: int PyTuple_SetItem(PyObject *p, Py_ssize_t pos, PyObject *o)
+.. c:function:: int PyTuple_SetItem(PyObject *p, Py_ssize_t pos, PyObject *o)
    Insert a reference to object *o* at position *pos* of the tuple pointed to by
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *pos*. This might require
+      This function used an :c:type:`int` type for *pos*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: void PyTuple_SET_ITEM(PyObject *p, Py_ssize_t pos, PyObject *o)
+.. c:function:: void PyTuple_SET_ITEM(PyObject *p, Py_ssize_t pos, PyObject *o)
    Like :cfunc:`PyTuple_SetItem`, but does no error checking, and should *only* be
+   Like :c:func:`PyTuple_SetItem`, but does no error checking, and should *only* be
    used to fill in brand new tuples.
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *pos*. This might require
+      This function used an :c:type:`int` type for *pos*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: int _PyTuple_Resize(PyObject **p, Py_ssize_t newsize)
+.. c:function:: int _PyTuple_Resize(PyObject **p, Py_ssize_t newsize)
    Can be used to resize a tuple.  *newsize* will be the new length of the tuple.
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *newsize*. This might
+      This function used an :c:type:`int` type for *newsize*. This might
       require changes in your code for properly supporting 64-bit systems.
 .. cfunction:: int PyTuple_ClearFreeList()
+.. c:function:: int PyTuple_ClearFreeList()
    Clear the free list. Return the total number of freed items.

python/vendor/current/Doc/c-api/type.rst

-              r2
+              r388
 .. ctype:: PyTypeObject
+.. c:type:: PyTypeObject
    The C structure of the objects used to describe built-in types.
 .. cvar:: PyObject* PyType_Type
+.. c:var:: PyObject* PyType_Type
    .. index:: single: TypeType (in module types)
 …
 .. cfunction:: int PyType_Check(PyObject *o)
+.. c:function:: int PyType_Check(PyObject *o)
    Return true if the object *o* is a type object, including instances of types
 …
 .. cfunction:: int PyType_CheckExact(PyObject *o)
+.. c:function:: int PyType_CheckExact(PyObject *o)
    Return true if the object *o* is a type object, but not a subtype of the
 …
 .. cfunction:: unsigned int PyType_ClearCache()
+.. c:function:: unsigned int PyType_ClearCache()
    Clear the internal lookup cache. Return the current version tag.
 …
 .. cfunction:: void PyType_Modified(PyTypeObject *type)
+.. c:function:: void PyType_Modified(PyTypeObject *type)
    Invalidate the internal lookup cache for the type and all of its
 …
 .. cfunction:: int PyType_HasFeature(PyObject *o, int feature)
+.. c:function:: int PyType_HasFeature(PyObject *o, int feature)
    Return true if the type object *o* sets the feature *feature*.  Type features
 …
 .. cfunction:: int PyType_IS_GC(PyObject *o)
+.. c:function:: int PyType_IS_GC(PyObject *o)
    Return true if the type object includes support for the cycle detector; this
 …
 .. cfunction:: int PyType_IsSubtype(PyTypeObject *a, PyTypeObject *b)
+.. c:function:: int PyType_IsSubtype(PyTypeObject *a, PyTypeObject *b)
    Return true if *a* is a subtype of *b*.
 …
 .. cfunction:: PyObject* PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems)
+.. c:function:: PyObject* PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems)
    .. versionadded:: 2.2
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *nitems*. This might require
+      This function used an :c:type:`int` type for *nitems*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyType_GenericNew(PyTypeObject *type, PyObject *args, PyObject *kwds)
+.. c:function:: PyObject* PyType_GenericNew(PyTypeObject *type, PyObject *args, PyObject *kwds)
    .. versionadded:: 2.2
 .. cfunction:: int PyType_Ready(PyTypeObject *type)
+.. c:function:: int PyType_Ready(PyTypeObject *type)
    Finalize a type object.  This should be called on all type objects to finish

python/vendor/current/Doc/c-api/typeobj.rst

-              r2
+              r388
 Perhaps one of the most important structures of the Python object system is the
 structure that defines a new type: the :ctype:`PyTypeObject` structure.  Type
 objects can be handled using any of the :cfunc:`PyObject_\*` or
 :cfunc:`PyType_\*` functions, but do not offer much that's interesting to most
+structure that defines a new type: the :c:type:`PyTypeObject` structure.  Type
+objects can be handled using any of the :c:func:`PyObject_\*` or
+:c:func:`PyType_\*` functions, but do not offer much that's interesting to most
 Python applications. These objects are fundamental to how objects behave, so
 they are very important to the interpreter itself and to any extension module
 …
 cmpfunc, reprfunc, hashfunc
 The structure definition for :ctype:`PyTypeObject` can be found in
+The structure definition for :c:type:`PyTypeObject` can be found in
 :file:`Include/object.h`.  For convenience of reference, this repeats the
 definition found there:
 …
 The type object structure extends the :ctype:`PyVarObject` structure. The
+The type object structure extends the :c:type:`PyVarObject` structure. The
 :attr:`ob_size` field is used for dynamic types (created by  :func:`type_new`,
 usually called from a class statement). Note that :cdata:`PyType_Type` (the
 metatype) initializes :attr:`tp_itemsize`, which means that its instances (i.e.
+usually called from a class statement). Note that :c:data:`PyType_Type` (the
+metatype) initializes :c:member:`~PyTypeObject.tp_itemsize`, which means that its instances (i.e.
 type objects) *must* have the :attr:`ob_size` field.
 .. cmember:: PyObject* PyObject._ob_next
+.. c:member:: PyObject* PyObject._ob_next
              PyObject* PyObject._ob_prev
 …
 .. cmember:: Py_ssize_t PyObject.ob_refcnt
+.. c:member:: Py_ssize_t PyObject.ob_refcnt
    This is the type object's reference count, initialized to ``1`` by the
 …
    .. versionchanged:: 2.5
       This field used to be an :ctype:`int` type. This might require changes
+      This field used to be an :c:type:`int` type. This might require changes
       in your code for properly supporting 64-bit systems.
 .. cmember:: PyTypeObject* PyObject.ob_type
+.. c:member:: PyTypeObject* PyObject.ob_type
    This is the type's type, in other words its metatype.  It is initialized by the
 …
    This should be done before any instances of the type are created.
    :cfunc:`PyType_Ready` checks if :attr:`ob_type` is *NULL*, and if so,
+   :c:func:`PyType_Ready` checks if :attr:`ob_type` is *NULL*, and if so,
    initializes it: in Python 2.2, it is set to ``&PyType_Type``; in Python 2.2.1
    and later it is initialized to the :attr:`ob_type` field of the base class.
    :cfunc:`PyType_Ready` will not change this field if it is non-zero.
+   :c:func:`PyType_Ready` will not change this field if it is non-zero.
    In Python 2.2, this field is not inherited by subtypes.  In 2.2.1, and in 2.3
 …
 .. cmember:: Py_ssize_t PyVarObject.ob_size
+.. c:member:: Py_ssize_t PyVarObject.ob_size
    For statically allocated type objects, this should be initialized to zero.  For
 …
 .. cmember:: char* PyTypeObject.tp_name
+.. c:member:: char* PyTypeObject.tp_name
    Pointer to a NUL-terminated string containing the name of the type. For types
 …
    full package name is part of the full module name.  For example, a type named
    :class:`T` defined in module :mod:`M` in subpackage :mod:`Q` in package :mod:`P`
    should have the :attr:`tp_name` initializer ``"P.Q.M.T"``.
+   should have the :c:member:`~PyTypeObject.tp_name` initializer ``"P.Q.M.T"``.
    For dynamically allocated type objects, this should just be the type name, and
 …
    :attr:`__name__` attribute.
    If no dot is present, the entire :attr:`tp_name` field is made accessible as the
+   If no dot is present, the entire :c:member:`~PyTypeObject.tp_name` field is made accessible as the
    :attr:`__name__` attribute, and the :attr:`__module__` attribute is undefined
    (unless explicitly set in the dictionary, as explained above).  This means your
 …
 .. cmember:: Py_ssize_t PyTypeObject.tp_basicsize
+.. c:member:: Py_ssize_t PyTypeObject.tp_basicsize
              Py_ssize_t PyTypeObject.tp_itemsize
 …
    There are two kinds of types: types with fixed-length instances have a zero
    :attr:`tp_itemsize` field, types with variable-length instances have a non-zero
    :attr:`tp_itemsize` field.  For a type with fixed-length instances, all
    instances have the same size, given in :attr:`tp_basicsize`.
+   :c:member:`~PyTypeObject.tp_itemsize` field, types with variable-length instances have a non-zero
+   :c:member:`~PyTypeObject.tp_itemsize` field.  For a type with fixed-length instances, all
+   instances have the same size, given in :c:member:`~PyTypeObject.tp_basicsize`.
    For a type with variable-length instances, the instances must have an
    :attr:`ob_size` field, and the instance size is :attr:`tp_basicsize` plus N
    times :attr:`tp_itemsize`, where N is the "length" of the object.  The value of
+   :attr:`ob_size` field, and the instance size is :c:member:`~PyTypeObject.tp_basicsize` plus N
+   times :c:member:`~PyTypeObject.tp_itemsize`, where N is the "length" of the object.  The value of
    N is typically stored in the instance's :attr:`ob_size` field.  There are
    exceptions:  for example, long ints use a negative :attr:`ob_size` to indicate a
 …
    The basic size includes the fields in the instance declared by the macro
    :cmacro:`PyObject_HEAD` or :cmacro:`PyObject_VAR_HEAD` (whichever is used to
+   :c:macro:`PyObject_HEAD` or :c:macro:`PyObject_VAR_HEAD` (whichever is used to
    declare the instance struct) and this in turn includes the :attr:`_ob_prev` and
    :attr:`_ob_next` fields if they are present.  This means that the only correct
    way to get an initializer for the :attr:`tp_basicsize` is to use the
+   way to get an initializer for the :c:member:`~PyTypeObject.tp_basicsize` is to use the
    ``sizeof`` operator on the struct used to declare the instance layout.
    The basic size does not include the GC header size (this is new in Python 2.2;
    in 2.1 and 2.0, the GC header size was included in :attr:`tp_basicsize`).
+   in 2.1 and 2.0, the GC header size was included in :c:member:`~PyTypeObject.tp_basicsize`).
    These fields are inherited separately by subtypes.  If the base type has a
    non-zero :attr:`tp_itemsize`, it is generally not safe to set
    :attr:`tp_itemsize` to a different non-zero value in a subtype (though this
+   non-zero :c:member:`~PyTypeObject.tp_itemsize`, it is generally not safe to set
+   :c:member:`~PyTypeObject.tp_itemsize` to a different non-zero value in a subtype (though this
    depends on the implementation of the base type).
    A note about alignment: if the variable items require a particular alignment,
    this should be taken care of by the value of :attr:`tp_basicsize`.  Example:
    suppose a type implements an array of ``double``. :attr:`tp_itemsize` is
+   this should be taken care of by the value of :c:member:`~PyTypeObject.tp_basicsize`.  Example:
+   suppose a type implements an array of ``double``. :c:member:`~PyTypeObject.tp_itemsize` is
    ``sizeof(double)``. It is the programmer's responsibility that
    :attr:`tp_basicsize` is a multiple of ``sizeof(double)`` (assuming this is the
+   :c:member:`~PyTypeObject.tp_basicsize` is a multiple of ``sizeof(double)`` (assuming this is the
    alignment requirement for ``double``).
 .. cmember:: destructor PyTypeObject.tp_dealloc
+.. c:member:: destructor PyTypeObject.tp_dealloc
    A pointer to the instance destructor function.  This function must be defined
 …
    the case for the singletons ``None`` and ``Ellipsis``).
    The destructor function is called by the :cfunc:`Py_DECREF` and
    :cfunc:`Py_XDECREF` macros when the new reference count is zero.  At this point,
+   The destructor function is called by the :c:func:`Py_DECREF` and
+   :c:func:`Py_XDECREF` macros when the new reference count is zero.  At this point,
    the instance is still in existence, but there are no references to it.  The
    destructor function should free all references which the instance owns, free all
    memory buffers owned by the instance (using the freeing function corresponding
    to the allocation function used to allocate the buffer), and finally (as its
    last action) call the type's :attr:`tp_free` function.  If the type is not
+   last action) call the type's :c:member:`~PyTypeObject.tp_free` function.  If the type is not
    subtypable (doesn't have the :const:`Py_TPFLAGS_BASETYPE` flag bit set), it is
    permissible to call the object deallocator directly instead of via
    :attr:`tp_free`.  The object deallocator should be the one used to allocate the
    instance; this is normally :cfunc:`PyObject_Del` if the instance was allocated
    using :cfunc:`PyObject_New` or :cfunc:`PyObject_VarNew`, or
    :cfunc:`PyObject_GC_Del` if the instance was allocated using
    :cfunc:`PyObject_GC_New` or :cfunc:`PyObject_GC_VarNew`.
+   :c:member:`~PyTypeObject.tp_free`.  The object deallocator should be the one used to allocate the
+   instance; this is normally :c:func:`PyObject_Del` if the instance was allocated
+   using :c:func:`PyObject_New` or :c:func:`PyObject_VarNew`, or
+   :c:func:`PyObject_GC_Del` if the instance was allocated using
+   :c:func:`PyObject_GC_New` or :c:func:`PyObject_GC_NewVar`.
    This field is inherited by subtypes.
 .. cmember:: printfunc PyTypeObject.tp_print
+.. c:member:: printfunc PyTypeObject.tp_print
    An optional pointer to the instance print function.
    The print function is only called when the instance is printed to a *real* file;
    when it is printed to a pseudo-file (like a :class:`StringIO` instance), the
    instance's :attr:`tp_repr` or :attr:`tp_str` function is called to convert it to
    a string.  These are also called when the type's :attr:`tp_print` field is
    *NULL*.  A type should never implement :attr:`tp_print` in a way that produces
    different output than :attr:`tp_repr` or :attr:`tp_str` would.
    The print function is called with the same signature as :cfunc:`PyObject_Print`:
+   when it is printed to a pseudo-file (like a :class:`~StringIO.StringIO` instance), the
+   instance's :c:member:`~PyTypeObject.tp_repr` or :c:member:`~PyTypeObject.tp_str` function is called to convert it to
+   a string.  These are also called when the type's :c:member:`~PyTypeObject.tp_print` field is
+   *NULL*.  A type should never implement :c:member:`~PyTypeObject.tp_print` in a way that produces
+   different output than :c:member:`~PyTypeObject.tp_repr` or :c:member:`~PyTypeObject.tp_str` would.
+   The print function is called with the same signature as :c:func:`PyObject_Print`:
    ``int tp_print(PyObject *self, FILE *file, int flags)``.  The *self* argument is
    the instance to be printed.  The *file* argument is the stdio file to which it
    is to be printed.  The *flags* argument is composed of flag bits. The only flag
    bit currently defined is :const:`Py_PRINT_RAW`. When the :const:`Py_PRINT_RAW`
    flag bit is set, the instance should be printed the same way as :attr:`tp_str`
+   flag bit is set, the instance should be printed the same way as :c:member:`~PyTypeObject.tp_str`
    would format it; when the :const:`Py_PRINT_RAW` flag bit is clear, the instance
    should be printed the same was as :attr:`tp_repr` would format it. It should
+   should be printed the same was as :c:member:`~PyTypeObject.tp_repr` would format it. It should
    return ``-1`` and set an exception condition when an error occurred during the
    comparison.
    It is possible that the :attr:`tp_print` field will be deprecated. In any case,
    it is recommended not to define :attr:`tp_print`, but instead to rely on
    :attr:`tp_repr` and :attr:`tp_str` for printing.
+   It is possible that the :c:member:`~PyTypeObject.tp_print` field will be deprecated. In any case,
+   it is recommended not to define :c:member:`~PyTypeObject.tp_print`, but instead to rely on
+   :c:member:`~PyTypeObject.tp_repr` and :c:member:`~PyTypeObject.tp_str` for printing.
    This field is inherited by subtypes.
 .. cmember:: getattrfunc PyTypeObject.tp_getattr
+.. c:member:: getattrfunc PyTypeObject.tp_getattr
    An optional pointer to the get-attribute-string function.
    This field is deprecated.  When it is defined, it should point to a function
    that acts the same as the :attr:`tp_getattro` function, but taking a C string
+   that acts the same as the :c:member:`~PyTypeObject.tp_getattro` function, but taking a C string
    instead of a Python string object to give the attribute name.  The signature is
    the same as for :cfunc:`PyObject_GetAttrString`.
    This field is inherited by subtypes together with :attr:`tp_getattro`: a subtype
    inherits both :attr:`tp_getattr` and :attr:`tp_getattro` from its base type when
    the subtype's :attr:`tp_getattr` and :attr:`tp_getattro` are both *NULL*.
 .. cmember:: setattrfunc PyTypeObject.tp_setattr
+   the same as for :c:func:`PyObject_GetAttrString`.
+   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_getattro`: a subtype
+   inherits both :c:member:`~PyTypeObject.tp_getattr` and :c:member:`~PyTypeObject.tp_getattro` from its base type when
+   the subtype's :c:member:`~PyTypeObject.tp_getattr` and :c:member:`~PyTypeObject.tp_getattro` are both *NULL*.
+.. c:member:: setattrfunc PyTypeObject.tp_setattr
    An optional pointer to the set-attribute-string function.
    This field is deprecated.  When it is defined, it should point to a function
    that acts the same as the :attr:`tp_setattro` function, but taking a C string
+   that acts the same as the :c:member:`~PyTypeObject.tp_setattro` function, but taking a C string
    instead of a Python string object to give the attribute name.  The signature is
    the same as for :cfunc:`PyObject_SetAttrString`.
    This field is inherited by subtypes together with :attr:`tp_setattro`: a subtype
    inherits both :attr:`tp_setattr` and :attr:`tp_setattro` from its base type when
    the subtype's :attr:`tp_setattr` and :attr:`tp_setattro` are both *NULL*.
 .. cmember:: cmpfunc PyTypeObject.tp_compare
+   the same as for :c:func:`PyObject_SetAttrString`.
+   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_setattro`: a subtype
+   inherits both :c:member:`~PyTypeObject.tp_setattr` and :c:member:`~PyTypeObject.tp_setattro` from its base type when
+   the subtype's :c:member:`~PyTypeObject.tp_setattr` and :c:member:`~PyTypeObject.tp_setattro` are both *NULL*.
+.. c:member:: cmpfunc PyTypeObject.tp_compare
    An optional pointer to the three-way comparison function.
    The signature is the same as for :cfunc:`PyObject_Compare`. The function should
+   The signature is the same as for :c:func:`PyObject_Compare`. The function should
    return ``1`` if *self* greater than *other*, ``0`` if *self* is equal to
    *other*, and ``-1`` if *self* less than *other*.  It should return ``-1`` and
    set an exception condition when an error occurred during the comparison.
    This field is inherited by subtypes together with :attr:`tp_richcompare` and
    :attr:`tp_hash`: a subtypes inherits all three of :attr:`tp_compare`,
    :attr:`tp_richcompare`, and :attr:`tp_hash` when the subtype's
    :attr:`tp_compare`, :attr:`tp_richcompare`, and :attr:`tp_hash` are all *NULL*.
 .. cmember:: reprfunc PyTypeObject.tp_repr
+   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_richcompare` and
+   :c:member:`~PyTypeObject.tp_hash`: a subtypes inherits all three of :c:member:`~PyTypeObject.tp_compare`,
+   :c:member:`~PyTypeObject.tp_richcompare`, and :c:member:`~PyTypeObject.tp_hash` when the subtype's
+   :c:member:`~PyTypeObject.tp_compare`, :c:member:`~PyTypeObject.tp_richcompare`, and :c:member:`~PyTypeObject.tp_hash` are all *NULL*.
+.. c:member:: reprfunc PyTypeObject.tp_repr
    .. index:: builtin: repr
 …
    :func:`repr`.
    The signature is the same as for :cfunc:`PyObject_Repr`; it must return a string
+   The signature is the same as for :c:func:`PyObject_Repr`; it must return a string
    or a Unicode object.  Ideally, this function should return a string that, when
    passed to :func:`eval`, given a suitable environment, returns an object with the
 …
    This field is inherited by subtypes.
 .. cmember:: PyNumberMethods* tp_as_number
+.. c:member:: PyNumberMethods* tp_as_number
    Pointer to an additional structure that contains fields relevant only to
 …
    :ref:`number-structs`.
    The :attr:`tp_as_number` field is not inherited, but the contained fields are
+   The :c:member:`~PyTypeObject.tp_as_number` field is not inherited, but the contained fields are
    inherited individually.
 .. cmember:: PySequenceMethods* tp_as_sequence
+.. c:member:: PySequenceMethods* tp_as_sequence
    Pointer to an additional structure that contains fields relevant only to
 …
    in :ref:`sequence-structs`.
    The :attr:`tp_as_sequence` field is not inherited, but the contained fields
+   The :c:member:`~PyTypeObject.tp_as_sequence` field is not inherited, but the contained fields
    are inherited individually.
 .. cmember:: PyMappingMethods* tp_as_mapping
+.. c:member:: PyMappingMethods* tp_as_mapping
    Pointer to an additional structure that contains fields relevant only to
 …
    :ref:`mapping-structs`.
    The :attr:`tp_as_mapping` field is not inherited, but the contained fields
+   The :c:member:`~PyTypeObject.tp_as_mapping` field is not inherited, but the contained fields
    are inherited individually.
 .. cmember:: hashfunc PyTypeObject.tp_hash
+.. c:member:: hashfunc PyTypeObject.tp_hash
    .. index:: builtin: hash
 …
    :func:`hash`.
    The signature is the same as for :cfunc:`PyObject_Hash`; it must return a C
+   The signature is the same as for :c:func:`PyObject_Hash`; it must return a C
    long.  The value ``-1`` should not be returned as a normal return value; when an
    error occurs during the computation of the hash value, the function should set
    an exception and return ``-1``.
    This field can be set explicitly to :cfunc:`PyObject_HashNotImplemented` to
+   This field can be set explicitly to :c:func:`PyObject_HashNotImplemented` to
    block inheritance of the hash method from a parent type. This is interpreted
    as the equivalent of ``__hash__ = None`` at the Python level, causing
 …
    that the converse is also true - setting ``__hash__ = None`` on a class at
    the Python level will result in the ``tp_hash`` slot being set to
    :cfunc:`PyObject_HashNotImplemented`.
    When this field is not set, two possibilities exist: if the :attr:`tp_compare`
    and :attr:`tp_richcompare` fields are both *NULL*, a default hash value based on
+   :c:func:`PyObject_HashNotImplemented`.
+   When this field is not set, two possibilities exist: if the :c:member:`~PyTypeObject.tp_compare`
+   and :c:member:`~PyTypeObject.tp_richcompare` fields are both *NULL*, a default hash value based on
    the object's address is returned; otherwise, a :exc:`TypeError` is raised.
    This field is inherited by subtypes together with :attr:`tp_richcompare` and
    :attr:`tp_compare`: a subtypes inherits all three of :attr:`tp_compare`,
    :attr:`tp_richcompare`, and :attr:`tp_hash`, when the subtype's
    :attr:`tp_compare`, :attr:`tp_richcompare` and :attr:`tp_hash` are all *NULL*.
 .. cmember:: ternaryfunc PyTypeObject.tp_call
+   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_richcompare` and
+   :c:member:`~PyTypeObject.tp_compare`: a subtypes inherits all three of :c:member:`~PyTypeObject.tp_compare`,
+   :c:member:`~PyTypeObject.tp_richcompare`, and :c:member:`~PyTypeObject.tp_hash`, when the subtype's
+   :c:member:`~PyTypeObject.tp_compare`, :c:member:`~PyTypeObject.tp_richcompare` and :c:member:`~PyTypeObject.tp_hash` are all *NULL*.
+.. c:member:: ternaryfunc PyTypeObject.tp_call
    An optional pointer to a function that implements calling the object.  This
    should be *NULL* if the object is not callable.  The signature is the same as
    for :cfunc:`PyObject_Call`.
+   for :c:func:`PyObject_Call`.
    This field is inherited by subtypes.
 .. cmember:: reprfunc PyTypeObject.tp_str
+.. c:member:: reprfunc PyTypeObject.tp_str
    An optional pointer to a function that implements the built-in operation
    :func:`str`.  (Note that :class:`str` is a type now, and :func:`str` calls the
    constructor for that type.  This constructor calls :cfunc:`PyObject_Str` to do
    the actual work, and :cfunc:`PyObject_Str` will call this handler.)
    The signature is the same as for :cfunc:`PyObject_Str`; it must return a string
+   constructor for that type.  This constructor calls :c:func:`PyObject_Str` to do
+   the actual work, and :c:func:`PyObject_Str` will call this handler.)
+   The signature is the same as for :c:func:`PyObject_Str`; it must return a string
    or a Unicode object.  This function should return a "friendly" string
    representation of the object, as this is the representation that will be used by
    the print statement.
    When this field is not set, :cfunc:`PyObject_Repr` is called to return a string
+   When this field is not set, :c:func:`PyObject_Repr` is called to return a string
    representation.
 …
 .. cmember:: getattrofunc PyTypeObject.tp_getattro
+.. c:member:: getattrofunc PyTypeObject.tp_getattro
    An optional pointer to the get-attribute function.
    The signature is the same as for :cfunc:`PyObject_GetAttr`.  It is usually
    convenient to set this field to :cfunc:`PyObject_GenericGetAttr`, which
+   The signature is the same as for :c:func:`PyObject_GetAttr`.  It is usually
+   convenient to set this field to :c:func:`PyObject_GenericGetAttr`, which
    implements the normal way of looking for object attributes.
    This field is inherited by subtypes together with :attr:`tp_getattr`: a subtype
    inherits both :attr:`tp_getattr` and :attr:`tp_getattro` from its base type when
    the subtype's :attr:`tp_getattr` and :attr:`tp_getattro` are both *NULL*.
 .. cmember:: setattrofunc PyTypeObject.tp_setattro
+   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_getattr`: a subtype
+   inherits both :c:member:`~PyTypeObject.tp_getattr` and :c:member:`~PyTypeObject.tp_getattro` from its base type when
+   the subtype's :c:member:`~PyTypeObject.tp_getattr` and :c:member:`~PyTypeObject.tp_getattro` are both *NULL*.
+.. c:member:: setattrofunc PyTypeObject.tp_setattro
    An optional pointer to the set-attribute function.
    The signature is the same as for :cfunc:`PyObject_SetAttr`.  It is usually
    convenient to set this field to :cfunc:`PyObject_GenericSetAttr`, which
+   The signature is the same as for :c:func:`PyObject_SetAttr`.  It is usually
+   convenient to set this field to :c:func:`PyObject_GenericSetAttr`, which
    implements the normal way of setting object attributes.
    This field is inherited by subtypes together with :attr:`tp_setattr`: a subtype
    inherits both :attr:`tp_setattr` and :attr:`tp_setattro` from its base type when
    the subtype's :attr:`tp_setattr` and :attr:`tp_setattro` are both *NULL*.
 .. cmember:: PyBufferProcs* PyTypeObject.tp_as_buffer
+   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_setattr`: a subtype
+   inherits both :c:member:`~PyTypeObject.tp_setattr` and :c:member:`~PyTypeObject.tp_setattro` from its base type when
+   the subtype's :c:member:`~PyTypeObject.tp_setattr` and :c:member:`~PyTypeObject.tp_setattro` are both *NULL*.
+.. c:member:: PyBufferProcs* PyTypeObject.tp_as_buffer
    Pointer to an additional structure that contains fields relevant only to objects
 …
    :ref:`buffer-structs`.
    The :attr:`tp_as_buffer` field is not inherited, but the contained fields are
+   The :c:member:`~PyTypeObject.tp_as_buffer` field is not inherited, but the contained fields are
    inherited individually.
 .. cmember:: long PyTypeObject.tp_flags
+.. c:member:: long PyTypeObject.tp_flags
    This field is a bit mask of various flags.  Some flags indicate variant
    semantics for certain situations; others are used to indicate that certain
    fields in the type object (or in the extension structures referenced via
    :attr:`tp_as_number`, :attr:`tp_as_sequence`, :attr:`tp_as_mapping`, and
    :attr:`tp_as_buffer`) that were historically not always present are valid; if
+   :c:member:`~PyTypeObject.tp_as_number`, :c:member:`~PyTypeObject.tp_as_sequence`, :c:member:`~PyTypeObject.tp_as_mapping`, and
+   :c:member:`~PyTypeObject.tp_as_buffer`) that were historically not always present are valid; if
    such a flag bit is clear, the type fields it guards must not be accessed and
    must be considered to have a zero or *NULL* value instead.
 …
    the flag bit is copied into the subtype together with a pointer to the extension
    structure.  The :const:`Py_TPFLAGS_HAVE_GC` flag bit is inherited together with
    the :attr:`tp_traverse` and :attr:`tp_clear` fields, i.e. if the
+   the :c:member:`~PyTypeObject.tp_traverse` and :c:member:`~PyTypeObject.tp_clear` fields, i.e. if the
    :const:`Py_TPFLAGS_HAVE_GC` flag bit is clear in the subtype and the
    :attr:`tp_traverse` and :attr:`tp_clear` fields in the subtype exist (as
+   :c:member:`~PyTypeObject.tp_traverse` and :c:member:`~PyTypeObject.tp_clear` fields in the subtype exist (as
    indicated by the :const:`Py_TPFLAGS_HAVE_RICHCOMPARE` flag bit) and have *NULL*
    values.
    The following bit masks are currently defined; these can be ORed together using
    the ``|`` operator to form the value of the :attr:`tp_flags` field.  The macro
    :cfunc:`PyType_HasFeature` takes a type and a flags value, *tp* and *f*, and
+   the ``|`` operator to form the value of the :c:member:`~PyTypeObject.tp_flags` field.  The macro
+   :c:func:`PyType_HasFeature` takes a type and a flags value, *tp* and *f*, and
    checks whether ``tp->tp_flags & f`` is non-zero.
 …
    .. data:: Py_TPFLAGS_HAVE_GETCHARBUFFER
       If this bit is set, the :ctype:`PyBufferProcs` struct referenced by
       :attr:`tp_as_buffer` has the :attr:`bf_getcharbuffer` field.
+      If this bit is set, the :c:type:`PyBufferProcs` struct referenced by
+      :c:member:`~PyTypeObject.tp_as_buffer` has the :attr:`bf_getcharbuffer` field.
    .. data:: Py_TPFLAGS_HAVE_SEQUENCE_IN
       If this bit is set, the :ctype:`PySequenceMethods` struct referenced by
       :attr:`tp_as_sequence` has the :attr:`sq_contains` field.
+      If this bit is set, the :c:type:`PySequenceMethods` struct referenced by
+      :c:member:`~PyTypeObject.tp_as_sequence` has the :attr:`sq_contains` field.
 …
    .. data:: Py_TPFLAGS_HAVE_INPLACEOPS
       If this bit is set, the :ctype:`PySequenceMethods` struct referenced by
       :attr:`tp_as_sequence` and the :ctype:`PyNumberMethods` structure referenced by
       :attr:`tp_as_number` contain the fields for in-place operators. In particular,
       this means that the :ctype:`PyNumberMethods` structure has the fields
+      If this bit is set, the :c:type:`PySequenceMethods` struct referenced by
+      :c:member:`~PyTypeObject.tp_as_sequence` and the :c:type:`PyNumberMethods` structure referenced by
+      :c:member:`~PyTypeObject.tp_as_number` contain the fields for in-place operators. In particular,
+      this means that the :c:type:`PyNumberMethods` structure has the fields
       :attr:`nb_inplace_add`, :attr:`nb_inplace_subtract`,
       :attr:`nb_inplace_multiply`, :attr:`nb_inplace_divide`,
 …
       :attr:`nb_inplace_lshift`, :attr:`nb_inplace_rshift`, :attr:`nb_inplace_and`,
       :attr:`nb_inplace_xor`, and :attr:`nb_inplace_or`; and the
       :ctype:`PySequenceMethods` struct has the fields :attr:`sq_inplace_concat` and
+      :c:type:`PySequenceMethods` struct has the fields :attr:`sq_inplace_concat` and
       :attr:`sq_inplace_repeat`.
 …
       If this bit is set, the binary and ternary operations in the
       :ctype:`PyNumberMethods` structure referenced by :attr:`tp_as_number` accept
+      :c:type:`PyNumberMethods` structure referenced by :c:member:`~PyTypeObject.tp_as_number` accept
       arguments of arbitrary object types, and do their own type conversions if
       needed.  If this bit is clear, those operations require that all arguments have
 …
    .. data:: Py_TPFLAGS_HAVE_RICHCOMPARE
       If this bit is set, the type object has the :attr:`tp_richcompare` field, as
       well as the :attr:`tp_traverse` and the :attr:`tp_clear` fields.
+      If this bit is set, the type object has the :c:member:`~PyTypeObject.tp_richcompare` field, as
+      well as the :c:member:`~PyTypeObject.tp_traverse` and the :c:member:`~PyTypeObject.tp_clear` fields.
    .. data:: Py_TPFLAGS_HAVE_WEAKREFS
       If this bit is set, the :attr:`tp_weaklistoffset` field is defined.  Instances
       of a type are weakly referenceable if the type's :attr:`tp_weaklistoffset` field
+      If this bit is set, the :c:member:`~PyTypeObject.tp_weaklistoffset` field is defined.  Instances
+      of a type are weakly referenceable if the type's :c:member:`~PyTypeObject.tp_weaklistoffset` field
       has a value greater than zero.
 …
    .. data:: Py_TPFLAGS_HAVE_ITER
       If this bit is set, the type object has the :attr:`tp_iter` and
       :attr:`tp_iternext` fields.
+      If this bit is set, the type object has the :c:member:`~PyTypeObject.tp_iter` and
+      :c:member:`~PyTypeObject.tp_iternext` fields.
 …
       If this bit is set, the type object has several new fields defined starting in
       Python 2.2: :attr:`tp_methods`, :attr:`tp_members`, :attr:`tp_getset`,
       :attr:`tp_base`, :attr:`tp_dict`, :attr:`tp_descr_get`, :attr:`tp_descr_set`,
       :attr:`tp_dictoffset`, :attr:`tp_init`, :attr:`tp_alloc`, :attr:`tp_new`,
       :attr:`tp_free`, :attr:`tp_is_gc`, :attr:`tp_bases`, :attr:`tp_mro`,
       :attr:`tp_cache`, :attr:`tp_subclasses`, and :attr:`tp_weaklist`.
+      Python 2.2: :c:member:`~PyTypeObject.tp_methods`, :c:member:`~PyTypeObject.tp_members`, :c:member:`~PyTypeObject.tp_getset`,
+      :c:member:`~PyTypeObject.tp_base`, :c:member:`~PyTypeObject.tp_dict`, :c:member:`~PyTypeObject.tp_descr_get`, :c:member:`~PyTypeObject.tp_descr_set`,
+      :c:member:`~PyTypeObject.tp_dictoffset`, :c:member:`~PyTypeObject.tp_init`, :c:member:`~PyTypeObject.tp_alloc`, :c:member:`~PyTypeObject.tp_new`,
+      :c:member:`~PyTypeObject.tp_free`, :c:member:`~PyTypeObject.tp_is_gc`, :c:member:`~PyTypeObject.tp_bases`, :c:member:`~PyTypeObject.tp_mro`,
+      :c:member:`~PyTypeObject.tp_cache`, :c:member:`~PyTypeObject.tp_subclasses`, and :c:member:`~PyTypeObject.tp_weaklist`.
 …
       This bit is set when the type object has been fully initialized by
       :cfunc:`PyType_Ready`.
+      :c:func:`PyType_Ready`.
    .. data:: Py_TPFLAGS_READYING
       This bit is set while :cfunc:`PyType_Ready` is in the process of initializing
+      This bit is set while :c:func:`PyType_Ready` is in the process of initializing
       the type object.
 …
       This bit is set when the object supports garbage collection.  If this bit
       is set, instances must be created using :cfunc:`PyObject_GC_New` and
       destroyed using :cfunc:`PyObject_GC_Del`.  More information in section
+      is set, instances must be created using :c:func:`PyObject_GC_New` and
+      destroyed using :c:func:`PyObject_GC_Del`.  More information in section
       :ref:`supporting-cycle-detection`.  This bit also implies that the
       GC-related fields :attr:`tp_traverse` and :attr:`tp_clear` are present in
+      GC-related fields :c:member:`~PyTypeObject.tp_traverse` and :c:member:`~PyTypeObject.tp_clear` are present in
       the type object; but those fields also exist when
       :const:`Py_TPFLAGS_HAVE_GC` is clear but
 …
 .. cmember:: char* PyTypeObject.tp_doc
+.. c:member:: char* PyTypeObject.tp_doc
    An optional pointer to a NUL-terminated C string giving the docstring for this
 …
 .. cmember:: traverseproc PyTypeObject.tp_traverse
+.. c:member:: traverseproc PyTypeObject.tp_traverse
    An optional pointer to a traversal function for the garbage collector.  This is
 …
    :ref:`supporting-cycle-detection`.
    The :attr:`tp_traverse` pointer is used by the garbage collector to detect
    reference cycles. A typical implementation of a :attr:`tp_traverse` function
    simply calls :cfunc:`Py_VISIT` on each of the instance's members that are Python
    objects.  For example, this is function :cfunc:`local_traverse` from the
+   The :c:member:`~PyTypeObject.tp_traverse` pointer is used by the garbage collector to detect
+   reference cycles. A typical implementation of a :c:member:`~PyTypeObject.tp_traverse` function
+   simply calls :c:func:`Py_VISIT` on each of the instance's members that are Python
+   objects.  For example, this is function :c:func:`local_traverse` from the
    :mod:`thread` extension module::
 …
+      }
    Note that :cfunc:`Py_VISIT` is called only on those members that can participate
+   Note that :c:func:`Py_VISIT` is called only on those members that can participate
    in reference cycles.  Although there is also a ``self->key`` member, it can only
    be *NULL* or a Python string and therefore cannot be part of a reference cycle.
 …
    On the other hand, even if you know a member can never be part of a cycle, as a
    debugging aid you may want to visit it anyway just so the :mod:`gc` module's
    :func:`get_referents` function will include it.
    Note that :cfunc:`Py_VISIT` requires the *visit* and *arg* parameters to
    :cfunc:`local_traverse` to have these specific names; don't name them just
+   :func:`~gc.get_referents` function will include it.
+   Note that :c:func:`Py_VISIT` requires the *visit* and *arg* parameters to
+   :c:func:`local_traverse` to have these specific names; don't name them just
    anything.
    This field is inherited by subtypes together with :attr:`tp_clear` and the
    :const:`Py_TPFLAGS_HAVE_GC` flag bit: the flag bit, :attr:`tp_traverse`, and
    :attr:`tp_clear` are all inherited from the base type if they are all zero in
+   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_clear` and the
+   :const:`Py_TPFLAGS_HAVE_GC` flag bit: the flag bit, :c:member:`~PyTypeObject.tp_traverse`, and
+   :c:member:`~PyTypeObject.tp_clear` are all inherited from the base type if they are all zero in
    the subtype *and* the subtype has the :const:`Py_TPFLAGS_HAVE_RICHCOMPARE` flag
    bit set.
 .. cmember:: inquiry PyTypeObject.tp_clear
+.. c:member:: inquiry PyTypeObject.tp_clear
    An optional pointer to a clear function for the garbage collector. This is only
    used if the :const:`Py_TPFLAGS_HAVE_GC` flag bit is set.
    The :attr:`tp_clear` member function is used to break reference cycles in cyclic
    garbage detected by the garbage collector.  Taken together, all :attr:`tp_clear`
+   The :c:member:`~PyTypeObject.tp_clear` member function is used to break reference cycles in cyclic
+   garbage detected by the garbage collector.  Taken together, all :c:member:`~PyTypeObject.tp_clear`
    functions in the system must combine to break all reference cycles.  This is
    subtle, and if in any doubt supply a :attr:`tp_clear` function.  For example,
    the tuple type does not implement a :attr:`tp_clear` function, because it's
+   subtle, and if in any doubt supply a :c:member:`~PyTypeObject.tp_clear` function.  For example,
+   the tuple type does not implement a :c:member:`~PyTypeObject.tp_clear` function, because it's
    possible to prove that no reference cycle can be composed entirely of tuples.
    Therefore the :attr:`tp_clear` functions of other types must be sufficient to
+   Therefore the :c:member:`~PyTypeObject.tp_clear` functions of other types must be sufficient to
    break any cycle containing a tuple.  This isn't immediately obvious, and there's
    rarely a good reason to avoid implementing :attr:`tp_clear`.
    Implementations of :attr:`tp_clear` should drop the instance's references to
+   rarely a good reason to avoid implementing :c:member:`~PyTypeObject.tp_clear`.
+   Implementations of :c:member:`~PyTypeObject.tp_clear` should drop the instance's references to
    those of its members that may be Python objects, and set its pointers to those
    members to *NULL*, as in the following example::
 …
+      }
    The :cfunc:`Py_CLEAR` macro should be used, because clearing references is
+   The :c:func:`Py_CLEAR` macro should be used, because clearing references is
    delicate:  the reference to the contained object must not be decremented until
    after the pointer to the contained object is set to *NULL*.  This is because
 …
    it's important that the pointer to the contained object be *NULL* at that time,
    so that *self* knows the contained object can no longer be used.  The
    :cfunc:`Py_CLEAR` macro performs the operations in a safe order.
    Because the goal of :attr:`tp_clear` functions is to break reference cycles,
+   :c:func:`Py_CLEAR` macro performs the operations in a safe order.
+   Because the goal of :c:member:`~PyTypeObject.tp_clear` functions is to break reference cycles,
    it's not necessary to clear contained objects like Python strings or Python
    integers, which can't participate in reference cycles. On the other hand, it may
    be convenient to clear all contained Python objects, and write the type's
    :attr:`tp_dealloc` function to invoke :attr:`tp_clear`.
+   :c:member:`~PyTypeObject.tp_dealloc` function to invoke :c:member:`~PyTypeObject.tp_clear`.
    More information about Python's garbage collection scheme can be found in
    section :ref:`supporting-cycle-detection`.
    This field is inherited by subtypes together with :attr:`tp_traverse` and the
    :const:`Py_TPFLAGS_HAVE_GC` flag bit: the flag bit, :attr:`tp_traverse`, and
    :attr:`tp_clear` are all inherited from the base type if they are all zero in
+   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_traverse` and the
+   :const:`Py_TPFLAGS_HAVE_GC` flag bit: the flag bit, :c:member:`~PyTypeObject.tp_traverse`, and
+   :c:member:`~PyTypeObject.tp_clear` are all inherited from the base type if they are all zero in
    the subtype *and* the subtype has the :const:`Py_TPFLAGS_HAVE_RICHCOMPARE` flag
    bit set.
 .. cmember:: richcmpfunc PyTypeObject.tp_richcompare
+.. c:member:: richcmpfunc PyTypeObject.tp_richcompare
    An optional pointer to the rich comparison function, whose signature is
 …
       friends), directly raise :exc:`TypeError` in the rich comparison function.
    This field is inherited by subtypes together with :attr:`tp_compare` and
    :attr:`tp_hash`: a subtype inherits all three of :attr:`tp_compare`,
    :attr:`tp_richcompare`, and :attr:`tp_hash`, when the subtype's
    :attr:`tp_compare`, :attr:`tp_richcompare`, and :attr:`tp_hash` are all *NULL*.
+   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_compare` and
+   :c:member:`~PyTypeObject.tp_hash`: a subtype inherits all three of :c:member:`~PyTypeObject.tp_compare`,
+   :c:member:`~PyTypeObject.tp_richcompare`, and :c:member:`~PyTypeObject.tp_hash`, when the subtype's
+   :c:member:`~PyTypeObject.tp_compare`, :c:member:`~PyTypeObject.tp_richcompare`, and :c:member:`~PyTypeObject.tp_hash` are all *NULL*.
    The following constants are defined to be used as the third argument for
    :attr:`tp_richcompare` and for :cfunc:`PyObject_RichCompare`:
+   :c:member:`~PyTypeObject.tp_richcompare` and for :c:func:`PyObject_RichCompare`:
    +----------------+------------+
 …
 set.
 .. cmember:: long PyTypeObject.tp_weaklistoffset
+.. c:member:: long PyTypeObject.tp_weaklistoffset
    If the instances of this type are weakly referenceable, this field is greater
    than zero and contains the offset in the instance structure of the weak
    reference list head (ignoring the GC header, if present); this offset is used by
    :cfunc:`PyObject_ClearWeakRefs` and the :cfunc:`PyWeakref_\*` functions.  The
    instance structure needs to include a field of type :ctype:`PyObject\*` which is
+   :c:func:`PyObject_ClearWeakRefs` and the :c:func:`PyWeakref_\*` functions.  The
+   instance structure needs to include a field of type :c:type:`PyObject\*` which is
    initialized to *NULL*.
    Do not confuse this field with :attr:`tp_weaklist`; that is the list head for
+   Do not confuse this field with :c:member:`~PyTypeObject.tp_weaklist`; that is the list head for
    weak references to the type object itself.
 …
    may override this offset; this means that the subtype uses a different weak
    reference list head than the base type.  Since the list head is always found via
    :attr:`tp_weaklistoffset`, this should not be a problem.
    When a type defined by a class statement has no :attr:`__slots__` declaration,
+   :c:member:`~PyTypeObject.tp_weaklistoffset`, this should not be a problem.
+   When a type defined by a class statement has no :attr:`~object.__slots__` declaration,
    and none of its base types are weakly referenceable, the type is made weakly
    referenceable by adding a weak reference list head slot to the instance layout
    and setting the :attr:`tp_weaklistoffset` of that slot's offset.
+   and setting the :c:member:`~PyTypeObject.tp_weaklistoffset` of that slot's offset.
    When a type's :attr:`__slots__` declaration contains a slot named
    :attr:`__weakref__`, that slot becomes the weak reference list head for
    instances of the type, and the slot's offset is stored in the type's
    :attr:`tp_weaklistoffset`.
+   :c:member:`~PyTypeObject.tp_weaklistoffset`.
    When a type's :attr:`__slots__` declaration does not contain a slot named
    :attr:`__weakref__`, the type inherits its :attr:`tp_weaklistoffset` from its
+   :attr:`__weakref__`, the type inherits its :c:member:`~PyTypeObject.tp_weaklistoffset` from its
    base type.
 …
 .. cmember:: getiterfunc PyTypeObject.tp_iter
+.. c:member:: getiterfunc PyTypeObject.tp_iter
    An optional pointer to a function that returns an iterator for the object.  Its
 …
    have this function, even if they don't define an :meth:`__iter__` method).
    This function has the same signature as :cfunc:`PyObject_GetIter`.
+   This function has the same signature as :c:func:`PyObject_GetIter`.
    This field is inherited by subtypes.
 .. cmember:: iternextfunc PyTypeObject.tp_iternext
+.. c:member:: iternextfunc PyTypeObject.tp_iternext
    An optional pointer to a function that returns the next item in an iterator.
 …
    they don't define a :meth:`next` method).
    Iterator types should also define the :attr:`tp_iter` function, and that
+   Iterator types should also define the :c:member:`~PyTypeObject.tp_iter` function, and that
    function should return the iterator instance itself (not a new iterator
    instance).
    This function has the same signature as :cfunc:`PyIter_Next`.
+   This function has the same signature as :c:func:`PyIter_Next`.
    This field is inherited by subtypes.
 The next fields, up to and including :attr:`tp_weaklist`, only exist if the
+The next fields, up to and including :c:member:`~PyTypeObject.tp_weaklist`, only exist if the
 :const:`Py_TPFLAGS_HAVE_CLASS` flag bit is set.
 .. cmember:: struct PyMethodDef* PyTypeObject.tp_methods
    An optional pointer to a static *NULL*-terminated array of :ctype:`PyMethodDef`
+.. c:member:: struct PyMethodDef* PyTypeObject.tp_methods
+   An optional pointer to a static *NULL*-terminated array of :c:type:`PyMethodDef`
    structures, declaring regular methods of this type.
    For each entry in the array, an entry is added to the type's dictionary (see
    :attr:`tp_dict` below) containing a method descriptor.
+   :c:member:`~PyTypeObject.tp_dict` below) containing a method descriptor.
    This field is not inherited by subtypes (methods are inherited through a
 …
 .. cmember:: struct PyMemberDef* PyTypeObject.tp_members
    An optional pointer to a static *NULL*-terminated array of :ctype:`PyMemberDef`
+.. c:member:: struct PyMemberDef* PyTypeObject.tp_members
+   An optional pointer to a static *NULL*-terminated array of :c:type:`PyMemberDef`
    structures, declaring regular data members (fields or slots) of instances of
    this type.
    For each entry in the array, an entry is added to the type's dictionary (see
    :attr:`tp_dict` below) containing a member descriptor.
+   :c:member:`~PyTypeObject.tp_dict` below) containing a member descriptor.
    This field is not inherited by subtypes (members are inherited through a
 …
 .. cmember:: struct PyGetSetDef* PyTypeObject.tp_getset
    An optional pointer to a static *NULL*-terminated array of :ctype:`PyGetSetDef`
+.. c:member:: struct PyGetSetDef* PyTypeObject.tp_getset
+   An optional pointer to a static *NULL*-terminated array of :c:type:`PyGetSetDef`
    structures, declaring computed attributes of instances of this type.
    For each entry in the array, an entry is added to the type's dictionary (see
    :attr:`tp_dict` below) containing a getset descriptor.
+   :c:member:`~PyTypeObject.tp_dict` below) containing a getset descriptor.
    This field is not inherited by subtypes (computed attributes are inherited
    through a different mechanism).
+   Docs for PyGetSetDef (XXX belong elsewhere)::
+   .. XXX belongs elsewhere
+   Docs for PyGetSetDef::
       typedef PyObject *(*getter)(PyObject *, void *);
 …
 .. cmember:: PyTypeObject* PyTypeObject.tp_base
+.. c:member:: PyTypeObject* PyTypeObject.tp_base
    An optional pointer to a base type from which type properties are inherited.  At
 …
 .. cmember:: PyObject* PyTypeObject.tp_dict
    The type's dictionary is stored here by :cfunc:`PyType_Ready`.
+.. c:member:: PyObject* PyTypeObject.tp_dict
+   The type's dictionary is stored here by :c:func:`PyType_Ready`.
    This field should normally be initialized to *NULL* before PyType_Ready is
    called; it may also be initialized to a dictionary containing initial attributes
    for the type.  Once :cfunc:`PyType_Ready` has initialized the type, extra
+   for the type.  Once :c:func:`PyType_Ready` has initialized the type, extra
    attributes for the type may be added to this dictionary only if they don't
    correspond to overloaded operations (like :meth:`__add__`).
 …
 .. cmember:: descrgetfunc PyTypeObject.tp_descr_get
+.. c:member:: descrgetfunc PyTypeObject.tp_descr_get
    An optional pointer to a "descriptor get" function.
 …
       PyObject * tp_descr_get(PyObject *self, PyObject *obj, PyObject *type);
    XXX explain.
+   .. XXX explain.
    This field is inherited by subtypes.
 .. cmember:: descrsetfunc PyTypeObject.tp_descr_set
+.. c:member:: descrsetfunc PyTypeObject.tp_descr_set
    An optional pointer to a "descriptor set" function.
 …
    This field is inherited by subtypes.
    XXX explain.
 .. cmember:: long PyTypeObject.tp_dictoffset
+   .. XXX explain.
+.. c:member:: long PyTypeObject.tp_dictoffset
    If the instances of this type have a dictionary containing instance variables,
    this field is non-zero and contains the offset in the instances of the type of
    the instance variable dictionary; this offset is used by
    :cfunc:`PyObject_GenericGetAttr`.
    Do not confuse this field with :attr:`tp_dict`; that is the dictionary for
+   :c:func:`PyObject_GenericGetAttr`.
+   Do not confuse this field with :c:member:`~PyTypeObject.tp_dict`; that is the dictionary for
    attributes of the type object itself.
 …
    structure contains a variable-length part.  This is used for example to add an
    instance variable dictionary to subtypes of :class:`str` or :class:`tuple`. Note
    that the :attr:`tp_basicsize` field should account for the dictionary added to
+   that the :c:member:`~PyTypeObject.tp_basicsize` field should account for the dictionary added to
    the end in that case, even though the dictionary is not included in the basic
    object layout.  On a system with a pointer size of 4 bytes,
    :attr:`tp_dictoffset` should be set to ``-4`` to indicate that the dictionary is
+   :c:member:`~PyTypeObject.tp_dictoffset` should be set to ``-4`` to indicate that the dictionary is
    at the very end of the structure.
    The real dictionary offset in an instance can be computed from a negative
    :attr:`tp_dictoffset` as follows::
+   :c:member:`~PyTypeObject.tp_dictoffset` as follows::
       dictoffset = tp_basicsize + abs(ob_size)*tp_itemsize + tp_dictoffset
 …
           round up to sizeof(void*)
    where :attr:`tp_basicsize`, :attr:`tp_itemsize` and :attr:`tp_dictoffset` are
+   where :c:member:`~PyTypeObject.tp_basicsize`, :c:member:`~PyTypeObject.tp_itemsize` and :c:member:`~PyTypeObject.tp_dictoffset` are
    taken from the type object, and :attr:`ob_size` is taken from the instance.  The
    absolute value is taken because long ints use the sign of :attr:`ob_size` to
    store the sign of the number.  (There's never a need to do this calculation
    yourself; it is done for you by :cfunc:`_PyObject_GetDictPtr`.)
+   yourself; it is done for you by :c:func:`_PyObject_GetDictPtr`.)
    This field is inherited by subtypes, but see the rules listed below. A subtype
    may override this offset; this means that the subtype instances store the
    dictionary at a difference offset than the base type.  Since the dictionary is
    always found via :attr:`tp_dictoffset`, this should not be a problem.
    When a type defined by a class statement has no :attr:`__slots__` declaration,
+   always found via :c:member:`~PyTypeObject.tp_dictoffset`, this should not be a problem.
+   When a type defined by a class statement has no :attr:`~object.__slots__` declaration,
    and none of its base types has an instance variable dictionary, a dictionary
    slot is added to the instance layout and the :attr:`tp_dictoffset` is set to
+   slot is added to the instance layout and the :c:member:`~PyTypeObject.tp_dictoffset` is set to
    that slot's offset.
    When a type defined by a class statement has a :attr:`__slots__` declaration,
    the type inherits its :attr:`tp_dictoffset` from its base type.
    (Adding a slot named :attr:`__dict__` to the :attr:`__slots__` declaration does
+   the type inherits its :c:member:`~PyTypeObject.tp_dictoffset` from its base type.
+   (Adding a slot named :attr:`~object.__dict__` to the :attr:`__slots__` declaration does
    not have the expected effect, it just causes confusion.  Maybe this should be
    added as a feature just like :attr:`__weakref__` though.)
 .. cmember:: initproc PyTypeObject.tp_init
+.. c:member:: initproc PyTypeObject.tp_init
    An optional pointer to an instance initialization function.
 …
    :meth:`__init__`.
    The :attr:`tp_init` function, if not *NULL*, is called when an instance is
    created normally by calling its type, after the type's :attr:`tp_new` function
    has returned an instance of the type.  If the :attr:`tp_new` function returns an
+   The :c:member:`~PyTypeObject.tp_init` function, if not *NULL*, is called when an instance is
+   created normally by calling its type, after the type's :c:member:`~PyTypeObject.tp_new` function
+   has returned an instance of the type.  If the :c:member:`~PyTypeObject.tp_new` function returns an
    instance of some other type that is not a subtype of the original type, no
    :attr:`tp_init` function is called; if :attr:`tp_new` returns an instance of a
    subtype of the original type, the subtype's :attr:`tp_init` is called.  (VERSION
+   :c:member:`~PyTypeObject.tp_init` function is called; if :c:member:`~PyTypeObject.tp_new` returns an instance of a
+   subtype of the original type, the subtype's :c:member:`~PyTypeObject.tp_init` is called.  (VERSION
    NOTE: described here is what is implemented in Python 2.2.1 and later.  In
    Python 2.2, the :attr:`tp_init` of the type of the object returned by
    :attr:`tp_new` was always called, if not *NULL*.)
+   Python 2.2, the :c:member:`~PyTypeObject.tp_init` of the type of the object returned by
+   :c:member:`~PyTypeObject.tp_new` was always called, if not *NULL*.)
    This field is inherited by subtypes.
 .. cmember:: allocfunc PyTypeObject.tp_alloc
+.. c:member:: allocfunc PyTypeObject.tp_alloc
    An optional pointer to an instance allocation function.
 …
    length for the instance, suitably aligned, and initialized to zeros, but with
    :attr:`ob_refcnt` set to ``1`` and :attr:`ob_type` set to the type argument.  If
    the type's :attr:`tp_itemsize` is non-zero, the object's :attr:`ob_size` field
+   the type's :c:member:`~PyTypeObject.tp_itemsize` is non-zero, the object's :attr:`ob_size` field
    should be initialized to *nitems* and the length of the allocated memory block
    should be ``tp_basicsize + nitems*tp_itemsize``, rounded up to a multiple of
    ``sizeof(void*)``; otherwise, *nitems* is not used and the length of the block
    should be :attr:`tp_basicsize`.
+   should be :c:member:`~PyTypeObject.tp_basicsize`.
    Do not use this function to do any other instance initialization, not even to
    allocate additional memory; that should be done by :attr:`tp_new`.
+   allocate additional memory; that should be done by :c:member:`~PyTypeObject.tp_new`.
    This field is inherited by static subtypes, but not by dynamic subtypes
    (subtypes created by a class statement); in the latter, this field is always set
    to :cfunc:`PyType_GenericAlloc`, to force a standard heap allocation strategy.
+   to :c:func:`PyType_GenericAlloc`, to force a standard heap allocation strategy.
    That is also the recommended value for statically defined types.
 .. cmember:: newfunc PyTypeObject.tp_new
+.. c:member:: newfunc PyTypeObject.tp_new
    An optional pointer to an instance creation function.
 …
    The subtype argument is the type of the object being created; the *args* and
    *kwds* arguments represent positional and keyword arguments of the call to the
    type.  Note that subtype doesn't have to equal the type whose :attr:`tp_new`
+   type.  Note that subtype doesn't have to equal the type whose :c:member:`~PyTypeObject.tp_new`
    function is called; it may be a subtype of that type (but not an unrelated
    type).
    The :attr:`tp_new` function should call ``subtype->tp_alloc(subtype, nitems)``
+   The :c:member:`~PyTypeObject.tp_new` function should call ``subtype->tp_alloc(subtype, nitems)``
    to allocate space for the object, and then do only as much further
    initialization as is absolutely necessary.  Initialization that can safely be
    ignored or repeated should be placed in the :attr:`tp_init` handler.  A good
+   ignored or repeated should be placed in the :c:member:`~PyTypeObject.tp_init` handler.  A good
    rule of thumb is that for immutable types, all initialization should take place
    in :attr:`tp_new`, while for mutable types, most initialization should be
    deferred to :attr:`tp_init`.
+   in :c:member:`~PyTypeObject.tp_new`, while for mutable types, most initialization should be
+   deferred to :c:member:`~PyTypeObject.tp_init`.
    This field is inherited by subtypes, except it is not inherited by static types
    whose :attr:`tp_base` is *NULL* or ``&PyBaseObject_Type``.  The latter exception
+   whose :c:member:`~PyTypeObject.tp_base` is *NULL* or ``&PyBaseObject_Type``.  The latter exception
    is a precaution so that old extension types don't become callable simply by
    being linked with Python 2.2.
 .. cmember:: destructor PyTypeObject.tp_free
+.. c:member:: destructor PyTypeObject.tp_free
    An optional pointer to an instance deallocation function.
    The signature of this function has changed slightly: in Python 2.2 and 2.2.1,
    its signature is :ctype:`destructor`::
+   its signature is :c:type:`destructor`::
       void tp_free(PyObject *)
    In Python 2.3 and beyond, its signature is :ctype:`freefunc`::
+   In Python 2.3 and beyond, its signature is :c:type:`freefunc`::
       void tp_free(void *)
 …
    This field is inherited by static subtypes, but not by dynamic subtypes
    (subtypes created by a class statement); in the latter, this field is set to a
    deallocator suitable to match :cfunc:`PyType_GenericAlloc` and the value of the
+   deallocator suitable to match :c:func:`PyType_GenericAlloc` and the value of the
    :const:`Py_TPFLAGS_HAVE_GC` flag bit.
 .. cmember:: inquiry PyTypeObject.tp_is_gc
+.. c:member:: inquiry PyTypeObject.tp_is_gc
    An optional pointer to a function called by the garbage collector.
 …
    The garbage collector needs to know whether a particular object is collectible
    or not.  Normally, it is sufficient to look at the object's type's
    :attr:`tp_flags` field, and check the :const:`Py_TPFLAGS_HAVE_GC` flag bit.  But
+   :c:member:`~PyTypeObject.tp_flags` field, and check the :const:`Py_TPFLAGS_HAVE_GC` flag bit.  But
    some types have a mixture of statically and dynamically allocated instances, and
    the statically allocated instances are not collectible.  Such types should
 …
    (The only example of this are types themselves.  The metatype,
    :cdata:`PyType_Type`, defines this function to distinguish between statically
+   :c:data:`PyType_Type`, defines this function to distinguish between statically
    and dynamically allocated types.)
 …
 .. cmember:: PyObject* PyTypeObject.tp_bases
+.. c:member:: PyObject* PyTypeObject.tp_bases
    Tuple of base types.
 …
 .. cmember:: PyObject* PyTypeObject.tp_mro
+.. c:member:: PyObject* PyTypeObject.tp_mro
    Tuple containing the expanded set of base types, starting with the type itself
    and ending with :class:`object`, in Method Resolution Order.
    This field is not inherited; it is calculated fresh by :cfunc:`PyType_Ready`.
 .. cmember:: PyObject* PyTypeObject.tp_cache
+   This field is not inherited; it is calculated fresh by :c:func:`PyType_Ready`.
+.. c:member:: PyObject* PyTypeObject.tp_cache
    Unused.  Not inherited.  Internal use only.
 .. cmember:: PyObject* PyTypeObject.tp_subclasses
+.. c:member:: PyObject* PyTypeObject.tp_subclasses
    List of weak references to subclasses.  Not inherited.  Internal use only.
 .. cmember:: PyObject* PyTypeObject.tp_weaklist
+.. c:member:: PyObject* PyTypeObject.tp_weaklist
    Weak reference list head, for weak references to this type object.  Not
 …
 .. cmember:: Py_ssize_t PyTypeObject.tp_allocs
+.. c:member:: Py_ssize_t PyTypeObject.tp_allocs
    Number of allocations.
 .. cmember:: Py_ssize_t PyTypeObject.tp_frees
+.. c:member:: Py_ssize_t PyTypeObject.tp_frees
    Number of frees.
 .. cmember:: Py_ssize_t PyTypeObject.tp_maxalloc
+.. c:member:: Py_ssize_t PyTypeObject.tp_maxalloc
    Maximum simultaneously allocated objects.
 .. cmember:: PyTypeObject* PyTypeObject.tp_next
    Pointer to the next type object with a non-zero :attr:`tp_allocs` field.
+.. c:member:: PyTypeObject* PyTypeObject.tp_next
+   Pointer to the next type object with a non-zero :c:member:`~PyTypeObject.tp_allocs` field.
 Also, note that, in a garbage collected Python, tp_dealloc may be called from
 …
 .. ctype:: PyNumberMethods
+.. c:type:: PyNumberMethods
    This structure holds pointers to the functions which an object uses to
 …
   arguments:
   .. cmember:: coercion PyNumberMethods.nb_coerce
      This function is used by :cfunc:`PyNumber_CoerceEx` and has the same
+  .. c:member:: coercion PyNumberMethods.nb_coerce
+     This function is used by :c:func:`PyNumber_CoerceEx` and has the same
      signature.  The first argument is always a pointer to an object of the
      defined type.  If the conversion to a common "larger" type is possible, the
 …
   functions must check the type of all their operands, and implement the
   necessary conversions (at least one of the operands is an instance of the
   defined type).  This is the recommended way; with Python 3.0 coercion will
+  defined type).  This is the recommended way; with Python 3 coercion will
   disappear completely.
 …
 .. ctype:: PyMappingMethods
+.. c:type:: PyMappingMethods
    This structure holds pointers to the functions which an object uses to
    implement the mapping protocol.  It has three members:
 .. cmember:: lenfunc PyMappingMethods.mp_length
    This function is used by :cfunc:`PyMapping_Length` and
    :cfunc:`PyObject_Size`, and has the same signature.  This slot may be set to
+.. c:member:: lenfunc PyMappingMethods.mp_length
+   This function is used by :c:func:`PyMapping_Length` and
+   :c:func:`PyObject_Size`, and has the same signature.  This slot may be set to
    *NULL* if the object has no defined length.
 .. cmember:: binaryfunc PyMappingMethods.mp_subscript
    This function is used by :cfunc:`PyObject_GetItem` and has the same
    signature.  This slot must be filled for the :cfunc:`PyMapping_Check`
+.. c:member:: binaryfunc PyMappingMethods.mp_subscript
+   This function is used by :c:func:`PyObject_GetItem` and has the same
+   signature.  This slot must be filled for the :c:func:`PyMapping_Check`
    function to return ``1``, it can be *NULL* otherwise.
 .. cmember:: objobjargproc PyMappingMethods.mp_ass_subscript
    This function is used by :cfunc:`PyObject_SetItem` and has the same
+.. c:member:: objobjargproc PyMappingMethods.mp_ass_subscript
+   This function is used by :c:func:`PyObject_SetItem` and has the same
    signature.  If this slot is *NULL*, the object does not support item
    assignment.
 …
 .. ctype:: PySequenceMethods
+.. c:type:: PySequenceMethods
    This structure holds pointers to the functions which an object uses to
    implement the sequence protocol.
 .. cmember:: lenfunc PySequenceMethods.sq_length
    This function is used by :cfunc:`PySequence_Size` and :cfunc:`PyObject_Size`,
+.. c:member:: lenfunc PySequenceMethods.sq_length
+   This function is used by :c:func:`PySequence_Size` and :c:func:`PyObject_Size`,
    and has the same signature.
 .. cmember:: binaryfunc PySequenceMethods.sq_concat
    This function is used by :cfunc:`PySequence_Concat` and has the same
+.. c:member:: binaryfunc PySequenceMethods.sq_concat
+   This function is used by :c:func:`PySequence_Concat` and has the same
    signature.  It is also used by the ``+`` operator, after trying the numeric
    addition via the :attr:`tp_as_number.nb_add` slot.
 .. cmember:: ssizeargfunc PySequenceMethods.sq_repeat
    This function is used by :cfunc:`PySequence_Repeat` and has the same
+   addition via the :c:member:`~PyTypeObject.tp_as_number.nb_add` slot.
+.. c:member:: ssizeargfunc PySequenceMethods.sq_repeat
+   This function is used by :c:func:`PySequence_Repeat` and has the same
    signature.  It is also used by the ``*`` operator, after trying numeric
    multiplication via the :attr:`tp_as_number.nb_mul` slot.
 .. cmember:: ssizeargfunc PySequenceMethods.sq_item
    This function is used by :cfunc:`PySequence_GetItem` and has the same
    signature.  This slot must be filled for the :cfunc:`PySequence_Check`
+   multiplication via the :c:member:`~PyTypeObject.tp_as_number.nb_mul` slot.
+.. c:member:: ssizeargfunc PySequenceMethods.sq_item
+   This function is used by :c:func:`PySequence_GetItem` and has the same
+   signature.  This slot must be filled for the :c:func:`PySequence_Check`
    function to return ``1``, it can be *NULL* otherwise.
 …
    the index is passed as is to the function.
 .. cmember:: ssizeobjargproc PySequenceMethods.sq_ass_item
    This function is used by :cfunc:`PySequence_SetItem` and has the same
+.. c:member:: ssizeobjargproc PySequenceMethods.sq_ass_item
+   This function is used by :c:func:`PySequence_SetItem` and has the same
    signature.  This slot may be left to *NULL* if the object does not support
    item assignment.
 .. cmember:: objobjproc PySequenceMethods.sq_contains
    This function may be used by :cfunc:`PySequence_Contains` and has the same
+.. c:member:: objobjproc PySequenceMethods.sq_contains
+   This function may be used by :c:func:`PySequence_Contains` and has the same
    signature.  This slot may be left to *NULL*, in this case
    :cfunc:`PySequence_Contains` simply traverses the sequence until it finds a
+   :c:func:`PySequence_Contains` simply traverses the sequence until it finds a
    match.
 .. cmember:: binaryfunc PySequenceMethods.sq_inplace_concat
    This function is used by :cfunc:`PySequence_InPlaceConcat` and has the same
+.. c:member:: binaryfunc PySequenceMethods.sq_inplace_concat
+   This function is used by :c:func:`PySequence_InPlaceConcat` and has the same
    signature.  It should modify its first operand, and return it.
 .. cmember:: ssizeargfunc PySequenceMethods.sq_inplace_repeat
    This function is used by :cfunc:`PySequence_InPlaceRepeat` and has the same
+.. c:member:: ssizeargfunc PySequenceMethods.sq_inplace_repeat
+   This function is used by :c:func:`PySequence_InPlaceRepeat` and has the same
    signature.  It should modify its first operand, and return it.
 …
 to be non-contiguous in memory.
 If an object does not export the buffer interface, then its :attr:`tp_as_buffer`
 member in the :ctype:`PyTypeObject` structure should be *NULL*.  Otherwise, the
 :attr:`tp_as_buffer` will point to a :ctype:`PyBufferProcs` structure.
+If an object does not export the buffer interface, then its :c:member:`~PyTypeObject.tp_as_buffer`
+member in the :c:type:`PyTypeObject` structure should be *NULL*.  Otherwise, the
+:c:member:`~PyTypeObject.tp_as_buffer` will point to a :c:type:`PyBufferProcs` structure.
 .. note::
    It is very important that your :ctype:`PyTypeObject` structure uses
    :const:`Py_TPFLAGS_DEFAULT` for the value of the :attr:`tp_flags` member rather
    than ``0``.  This tells the Python runtime that your :ctype:`PyBufferProcs`
+   It is very important that your :c:type:`PyTypeObject` structure uses
+   :const:`Py_TPFLAGS_DEFAULT` for the value of the :c:member:`~PyTypeObject.tp_flags` member rather
+   than ``0``.  This tells the Python runtime that your :c:type:`PyBufferProcs`
    structure contains the :attr:`bf_getcharbuffer` slot. Older versions of Python
    did not have this member, so a new Python interpreter using an old extension
 …
 .. ctype:: PyBufferProcs
+.. c:type:: PyBufferProcs
    Structure used to hold the function pointers which define an implementation of
    the buffer protocol.
    The first slot is :attr:`bf_getreadbuffer`, of type :ctype:`getreadbufferproc`.
+   The first slot is :attr:`bf_getreadbuffer`, of type :c:type:`getreadbufferproc`.
    If this slot is *NULL*, then the object does not support reading from the
    internal data.  This is non-sensical, so implementors should fill this in, but
 …
    The next slot is :attr:`bf_getwritebuffer` having type
    :ctype:`getwritebufferproc`.  This slot may be *NULL* if the object does not
+   :c:type:`getwritebufferproc`.  This slot may be *NULL* if the object does not
    allow writing into its returned buffers.
    The third slot is :attr:`bf_getsegcount`, with type :ctype:`getsegcountproc`.
+   The third slot is :attr:`bf_getsegcount`, with type :c:type:`getsegcountproc`.
    This slot must not be *NULL* and is used to inform the caller how many segments
    the object contains.  Simple objects such as :ctype:`PyString_Type` and
    :ctype:`PyBuffer_Type` objects contain a single segment.
+   the object contains.  Simple objects such as :c:type:`PyString_Type` and
+   :c:type:`PyBuffer_Type` objects contain a single segment.
    .. index:: single: PyType_HasFeature()
    The last slot is :attr:`bf_getcharbuffer`, of type :ctype:`getcharbufferproc`.
+   The last slot is :attr:`bf_getcharbuffer`, of type :c:type:`getcharbufferproc`.
    This slot will only be present if the :const:`Py_TPFLAGS_HAVE_GETCHARBUFFER`
    flag is present in the :attr:`tp_flags` field of the object's
    :ctype:`PyTypeObject`. Before using this slot, the caller should test whether it
    is present by using the :cfunc:`PyType_HasFeature` function.  If the flag is
+   flag is present in the :c:member:`~PyTypeObject.tp_flags` field of the object's
+   :c:type:`PyTypeObject`. Before using this slot, the caller should test whether it
+   is present by using the :c:func:`PyType_HasFeature` function.  If the flag is
    present, :attr:`bf_getcharbuffer` may be *NULL*, indicating that the object's
    contents cannot be used as *8-bit characters*. The slot function may also raise
 …
 .. ctype:: Py_ssize_t (*readbufferproc) (PyObject *self, Py_ssize_t segment, void **ptrptr)
+.. c:type:: Py_ssize_t (*readbufferproc) (PyObject *self, Py_ssize_t segment, void **ptrptr)
    Return a pointer to a readable segment of the buffer in ``*ptrptr``.  This
 …
 .. ctype:: Py_ssize_t (*writebufferproc) (PyObject *self, Py_ssize_t segment, void **ptrptr)
+.. c:type:: Py_ssize_t (*writebufferproc) (PyObject *self, Py_ssize_t segment, void **ptrptr)
    Return a pointer to a writable memory buffer in ``*ptrptr``, and the length of
 …
 .. ctype:: Py_ssize_t (*segcountproc) (PyObject *self, Py_ssize_t *lenp)
+.. c:type:: Py_ssize_t (*segcountproc) (PyObject *self, Py_ssize_t *lenp)
    Return the number of memory segments which comprise the buffer.  If *lenp* is
 …
 .. ctype:: Py_ssize_t (*charbufferproc) (PyObject *self, Py_ssize_t segment, const char **ptrptr)
+.. c:type:: Py_ssize_t (*charbufferproc) (PyObject *self, Py_ssize_t segment, const char **ptrptr)
    Return the size of the segment *segment* that *ptrptr*  is set to.  ``*ptrptr``

python/vendor/current/Doc/c-api/unicode.rst

-              r2
+              r388
+Unicode Type
+""""""""""""
 These are the basic Unicode object types used for the Unicode implementation in
 Python:
+.. % --- Unicode Type -------------------------------------------------------
+.. ctype:: Py_UNICODE
+.. c:type:: Py_UNICODE
    This type represents the storage type which is used by Python internally as
    basis for holding Unicode ordinals.  Python's default builds use a 16-bit type
    for :ctype:`Py_UNICODE` and store Unicode values internally as UCS2. It is also
+   for :c:type:`Py_UNICODE` and store Unicode values internally as UCS2. It is also
    possible to build a UCS4 version of Python (most recent Linux distributions come
    with UCS4 builds of Python). These builds then use a 32-bit type for
    :ctype:`Py_UNICODE` and store Unicode data internally as UCS4. On platforms
    where :ctype:`wchar_t` is available and compatible with the chosen Python
    Unicode build variant, :ctype:`Py_UNICODE` is a typedef alias for
    :ctype:`wchar_t` to enhance native platform compatibility. On all other
    platforms, :ctype:`Py_UNICODE` is a typedef alias for either :ctype:`unsigned
    short` (UCS2) or :ctype:`unsigned long` (UCS4).
+   :c:type:`Py_UNICODE` and store Unicode data internally as UCS4. On platforms
+   where :c:type:`wchar_t` is available and compatible with the chosen Python
+   Unicode build variant, :c:type:`Py_UNICODE` is a typedef alias for
+   :c:type:`wchar_t` to enhance native platform compatibility. On all other
+   platforms, :c:type:`Py_UNICODE` is a typedef alias for either :c:type:`unsigned
+   short` (UCS2) or :c:type:`unsigned long` (UCS4).
 Note that UCS2 and UCS4 Python builds are not binary compatible. Please keep
 …
 .. ctype:: PyUnicodeObject
    This subtype of :ctype:`PyObject` represents a Python Unicode object.
 .. cvar:: PyTypeObject PyUnicode_Type
    This instance of :ctype:`PyTypeObject` represents the Python Unicode type.  It
+.. c:type:: PyUnicodeObject
+   This subtype of :c:type:`PyObject` represents a Python Unicode object.
+.. c:var:: PyTypeObject PyUnicode_Type
+   This instance of :c:type:`PyTypeObject` represents the Python Unicode type.  It
    is exposed to Python code as ``unicode`` and ``types.UnicodeType``.
 …
 .. cfunction:: int PyUnicode_Check(PyObject *o)
+.. c:function:: int PyUnicode_Check(PyObject *o)
    Return true if the object *o* is a Unicode object or an instance of a Unicode
 …
 .. cfunction:: int PyUnicode_CheckExact(PyObject *o)
+.. c:function:: int PyUnicode_CheckExact(PyObject *o)
    Return true if the object *o* is a Unicode object, but not an instance of a
 …
 .. cfunction:: Py_ssize_t PyUnicode_GET_SIZE(PyObject *o)
    Return the size of the object.  *o* has to be a :ctype:`PyUnicodeObject` (not
+.. c:function:: Py_ssize_t PyUnicode_GET_SIZE(PyObject *o)
+   Return the size of the object.  *o* has to be a :c:type:`PyUnicodeObject` (not
    checked).
    .. versionchanged:: 2.5
       This function returned an :ctype:`int` type. This might require changes
+      This function returned an :c:type:`int` type. This might require changes
       in your code for properly supporting 64-bit systems.
 .. cfunction:: Py_ssize_t PyUnicode_GET_DATA_SIZE(PyObject *o)
+.. c:function:: Py_ssize_t PyUnicode_GET_DATA_SIZE(PyObject *o)
    Return the size of the object's internal buffer in bytes.  *o* has to be a
    :ctype:`PyUnicodeObject` (not checked).
    .. versionchanged:: 2.5
       This function returned an :ctype:`int` type. This might require changes
+   :c:type:`PyUnicodeObject` (not checked).
+   .. versionchanged:: 2.5
+      This function returned an :c:type:`int` type. This might require changes
       in your code for properly supporting 64-bit systems.
 .. cfunction:: Py_UNICODE* PyUnicode_AS_UNICODE(PyObject *o)
    Return a pointer to the internal :ctype:`Py_UNICODE` buffer of the object.  *o*
    has to be a :ctype:`PyUnicodeObject` (not checked).
 .. cfunction:: const char* PyUnicode_AS_DATA(PyObject *o)
+.. c:function:: Py_UNICODE* PyUnicode_AS_UNICODE(PyObject *o)
+   Return a pointer to the internal :c:type:`Py_UNICODE` buffer of the object.  *o*
+   has to be a :c:type:`PyUnicodeObject` (not checked).
+.. c:function:: const char* PyUnicode_AS_DATA(PyObject *o)
    Return a pointer to the internal buffer of the object. *o* has to be a
    :ctype:`PyUnicodeObject` (not checked).
 .. cfunction:: int PyUnicode_ClearFreeList()
+   :c:type:`PyUnicodeObject` (not checked).
+.. c:function:: int PyUnicode_ClearFreeList()
    Clear the free list. Return the total number of freed items.
 …
    .. versionadded:: 2.6
+Unicode Character Properties
+""""""""""""""""""""""""""""
 Unicode provides many different character properties. The most often needed ones
 …
 the Python configuration.
+.. % --- Unicode character properties ---------------------------------------
+.. cfunction:: int Py_UNICODE_ISSPACE(Py_UNICODE ch)
+.. c:function:: int Py_UNICODE_ISSPACE(Py_UNICODE ch)
    Return 1 or 0 depending on whether *ch* is a whitespace character.
 .. cfunction:: int Py_UNICODE_ISLOWER(Py_UNICODE ch)
+.. c:function:: int Py_UNICODE_ISLOWER(Py_UNICODE ch)
    Return 1 or 0 depending on whether *ch* is a lowercase character.
 .. cfunction:: int Py_UNICODE_ISUPPER(Py_UNICODE ch)
+.. c:function:: int Py_UNICODE_ISUPPER(Py_UNICODE ch)
    Return 1 or 0 depending on whether *ch* is an uppercase character.
 .. cfunction:: int Py_UNICODE_ISTITLE(Py_UNICODE ch)
+.. c:function:: int Py_UNICODE_ISTITLE(Py_UNICODE ch)
    Return 1 or 0 depending on whether *ch* is a titlecase character.
 .. cfunction:: int Py_UNICODE_ISLINEBREAK(Py_UNICODE ch)
+.. c:function:: int Py_UNICODE_ISLINEBREAK(Py_UNICODE ch)
    Return 1 or 0 depending on whether *ch* is a linebreak character.
 .. cfunction:: int Py_UNICODE_ISDECIMAL(Py_UNICODE ch)
+.. c:function:: int Py_UNICODE_ISDECIMAL(Py_UNICODE ch)
    Return 1 or 0 depending on whether *ch* is a decimal character.
 .. cfunction:: int Py_UNICODE_ISDIGIT(Py_UNICODE ch)
+.. c:function:: int Py_UNICODE_ISDIGIT(Py_UNICODE ch)
    Return 1 or 0 depending on whether *ch* is a digit character.
 .. cfunction:: int Py_UNICODE_ISNUMERIC(Py_UNICODE ch)
+.. c:function:: int Py_UNICODE_ISNUMERIC(Py_UNICODE ch)
    Return 1 or 0 depending on whether *ch* is a numeric character.
 .. cfunction:: int Py_UNICODE_ISALPHA(Py_UNICODE ch)
+.. c:function:: int Py_UNICODE_ISALPHA(Py_UNICODE ch)
    Return 1 or 0 depending on whether *ch* is an alphabetic character.
 .. cfunction:: int Py_UNICODE_ISALNUM(Py_UNICODE ch)
+.. c:function:: int Py_UNICODE_ISALNUM(Py_UNICODE ch)
    Return 1 or 0 depending on whether *ch* is an alphanumeric character.
 …
 .. cfunction:: Py_UNICODE Py_UNICODE_TOLOWER(Py_UNICODE ch)
+.. c:function:: Py_UNICODE Py_UNICODE_TOLOWER(Py_UNICODE ch)
    Return the character *ch* converted to lower case.
 .. cfunction:: Py_UNICODE Py_UNICODE_TOUPPER(Py_UNICODE ch)
+.. c:function:: Py_UNICODE Py_UNICODE_TOUPPER(Py_UNICODE ch)
    Return the character *ch* converted to upper case.
 .. cfunction:: Py_UNICODE Py_UNICODE_TOTITLE(Py_UNICODE ch)
+.. c:function:: Py_UNICODE Py_UNICODE_TOTITLE(Py_UNICODE ch)
    Return the character *ch* converted to title case.
 .. cfunction:: int Py_UNICODE_TODECIMAL(Py_UNICODE ch)
+.. c:function:: int Py_UNICODE_TODECIMAL(Py_UNICODE ch)
    Return the character *ch* converted to a decimal positive integer.  Return
 …
 .. cfunction:: int Py_UNICODE_TODIGIT(Py_UNICODE ch)
+.. c:function:: int Py_UNICODE_TODIGIT(Py_UNICODE ch)
    Return the character *ch* converted to a single digit integer. Return ``-1`` if
 …
 .. cfunction:: double Py_UNICODE_TONUMERIC(Py_UNICODE ch)
+.. c:function:: double Py_UNICODE_TONUMERIC(Py_UNICODE ch)
    Return the character *ch* converted to a double. Return ``-1.0`` if this is not
    possible.  This macro does not raise exceptions.
+Plain Py_UNICODE
+""""""""""""""""
 To create Unicode objects and access their basic sequence properties, use these
 APIs:
+.. % --- Plain Py_UNICODE ---------------------------------------------------
+.. cfunction:: PyObject* PyUnicode_FromUnicode(const Py_UNICODE *u, Py_ssize_t size)
+   Create a Unicode Object from the Py_UNICODE buffer *u* of the given size. *u*
+.. c:function:: PyObject* PyUnicode_FromUnicode(const Py_UNICODE *u, Py_ssize_t size)
+   Create a Unicode object from the Py_UNICODE buffer *u* of the given size. *u*
    may be *NULL* which causes the contents to be undefined. It is the user's
    responsibility to fill in the needed data.  The buffer is copied into the new
 …
    .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. cfunction:: Py_UNICODE* PyUnicode_AsUnicode(PyObject *unicode)
+   Return a read-only pointer to the Unicode object's internal :ctype:`Py_UNICODE`
+   buffer, *NULL* if *unicode* is not a Unicode object.
+.. cfunction:: Py_ssize_t PyUnicode_GetSize(PyObject *unicode)
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PyUnicode_FromStringAndSize(const char *u, Py_ssize_t size)
+   Create a Unicode object from the char buffer *u*.  The bytes will be interpreted
+   as being UTF-8 encoded.  *u* may also be *NULL* which
+   causes the contents to be undefined. It is the user's responsibility to fill in
+   the needed data.  The buffer is copied into the new object. If the buffer is not
+   *NULL*, the return value might be a shared object. Therefore, modification of
+   the resulting Unicode object is only allowed when *u* is *NULL*.
+   .. versionadded:: 2.6
+.. c:function:: PyObject *PyUnicode_FromString(const char *u)
+   Create a Unicode object from an UTF-8 encoded null-terminated char buffer
+   *u*.
+   .. versionadded:: 2.6
+.. c:function:: PyObject* PyUnicode_FromFormat(const char *format, ...)
+   Take a C :c:func:`printf`\ -style *format* string and a variable number of
+   arguments, calculate the size of the resulting Python unicode string and return
+   a string with the values formatted into it.  The variable arguments must be C
+   types and must correspond exactly to the format characters in the *format*
+   string.  The following format characters are allowed:
+   .. % The descriptions for %zd and %zu are wrong, but the truth is complicated
+   .. % because not all compilers support the %z width modifier -- we fake it
+   .. % when necessary via interpolating PY_FORMAT_SIZE_T.
+   .. tabularcolumns:: |l|l|L|
+   +-------------------+---------------------+--------------------------------+
+   | Format Characters | Type                | Comment                        |
+   +===================+=====================+================================+
+   | :attr:`%%`        | *n/a*               | The literal % character.       |
+   +-------------------+---------------------+--------------------------------+
+   | :attr:`%c`        | int                 | A single character,            |
+   |                   |                     | represented as an C int.       |
+   +-------------------+---------------------+--------------------------------+
+   | :attr:`%d`        | int                 | Exactly equivalent to          |
+   |                   |                     | ``printf("%d")``.              |
+   +-------------------+---------------------+--------------------------------+
+   | :attr:`%u`        | unsigned int        | Exactly equivalent to          |
+   |                   |                     | ``printf("%u")``.              |
+   +-------------------+---------------------+--------------------------------+
+   | :attr:`%ld`       | long                | Exactly equivalent to          |
+   |                   |                     | ``printf("%ld")``.             |
+   +-------------------+---------------------+--------------------------------+
+   | :attr:`%lu`       | unsigned long       | Exactly equivalent to          |
+   |                   |                     | ``printf("%lu")``.             |
+   +-------------------+---------------------+--------------------------------+
+   | :attr:`%zd`       | Py_ssize_t          | Exactly equivalent to          |
+   |                   |                     | ``printf("%zd")``.             |
+   +-------------------+---------------------+--------------------------------+
+   | :attr:`%zu`       | size_t              | Exactly equivalent to          |
+   |                   |                     | ``printf("%zu")``.             |
+   +-------------------+---------------------+--------------------------------+
+   | :attr:`%i`        | int                 | Exactly equivalent to          |
+   |                   |                     | ``printf("%i")``.              |
+   +-------------------+---------------------+--------------------------------+
+   | :attr:`%x`        | int                 | Exactly equivalent to          |
+   |                   |                     | ``printf("%x")``.              |
+   +-------------------+---------------------+--------------------------------+
+   | :attr:`%s`        | char\*              | A null-terminated C character  |
+   |                   |                     | array.                         |
+   +-------------------+---------------------+--------------------------------+
+   | :attr:`%p`        | void\*              | The hex representation of a C  |
+   |                   |                     | pointer. Mostly equivalent to  |
+   |                   |                     | ``printf("%p")`` except that   |
+   |                   |                     | it is guaranteed to start with |
+   |                   |                     | the literal ``0x`` regardless  |
+   |                   |                     | of what the platform's         |
+   |                   |                     | ``printf`` yields.             |
+   +-------------------+---------------------+--------------------------------+
+   | :attr:`%U`        | PyObject\*          | A unicode object.              |
+   +-------------------+---------------------+--------------------------------+
+   | :attr:`%V`        | PyObject\*, char \* | A unicode object (which may be |
+   |                   |                     | *NULL*) and a null-terminated  |
+   |                   |                     | C character array as a second  |
+   |                   |                     | parameter (which will be used, |
+   |                   |                     | if the first parameter is      |
+   |                   |                     | *NULL*).                       |
+   +-------------------+---------------------+--------------------------------+
+   | :attr:`%S`        | PyObject\*          | The result of calling          |
+   |                   |                     | :func:`PyObject_Unicode`.      |
+   +-------------------+---------------------+--------------------------------+
+   | :attr:`%R`        | PyObject\*          | The result of calling          |
+   |                   |                     | :func:`PyObject_Repr`.         |
+   +-------------------+---------------------+--------------------------------+
+   An unrecognized format character causes all the rest of the format string to be
+   copied as-is to the result string, and any extra arguments discarded.
+   .. versionadded:: 2.6
+.. c:function:: PyObject* PyUnicode_FromFormatV(const char *format, va_list vargs)
+   Identical to :func:`PyUnicode_FromFormat` except that it takes exactly two
+   arguments.
+   .. versionadded:: 2.6
+.. c:function:: Py_UNICODE* PyUnicode_AsUnicode(PyObject *unicode)
+   Return a read-only pointer to the Unicode object's internal
+   :c:type:`Py_UNICODE` buffer, *NULL* if *unicode* is not a Unicode object.
+   Note that the resulting :c:type:`Py_UNICODE*` string may contain embedded
+   null characters, which would cause the string to be truncated when used in
+   most C functions.
+.. c:function:: Py_ssize_t PyUnicode_GetSize(PyObject *unicode)
    Return the length of the Unicode object.
    .. versionchanged:: 2.5
       This function returned an :ctype:`int` type. This might require changes
+      This function returned an :c:type:`int` type. This might require changes
       in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_FromEncodedObject(PyObject *obj, const char *encoding, const char *errors)
+.. c:function:: PyObject* PyUnicode_FromEncodedObject(PyObject *obj, const char *encoding, const char *errors)
    Coerce an encoded object *obj* to an Unicode object and return a reference with
 …
 .. cfunction:: PyObject* PyUnicode_FromObject(PyObject *obj)
+.. c:function:: PyObject* PyUnicode_FromObject(PyObject *obj)
    Shortcut for ``PyUnicode_FromEncodedObject(obj, NULL, "strict")`` which is used
    throughout the interpreter whenever coercion to Unicode is needed.
 If the platform supports :ctype:`wchar_t` and provides a header file wchar.h,
+If the platform supports :c:type:`wchar_t` and provides a header file wchar.h,
 Python can interface directly to this type using the following functions.
+Support is optimized if Python's own :ctype:`Py_UNICODE` type is identical to
+the system's :ctype:`wchar_t`.
+.. % --- wchar_t support for platforms which support it ---------------------
+.. cfunction:: PyObject* PyUnicode_FromWideChar(const wchar_t *w, Py_ssize_t size)
+   Create a Unicode object from the :ctype:`wchar_t` buffer *w* of the given size.
+Support is optimized if Python's own :c:type:`Py_UNICODE` type is identical to
+the system's :c:type:`wchar_t`.
+wchar_t Support
+"""""""""""""""
+:c:type:`wchar_t` support for platforms which support it:
+.. c:function:: PyObject* PyUnicode_FromWideChar(const wchar_t *w, Py_ssize_t size)
+   Create a Unicode object from the :c:type:`wchar_t` buffer *w* of the given *size*.
    Return *NULL* on failure.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: Py_ssize_t PyUnicode_AsWideChar(PyUnicodeObject *unicode, wchar_t *w, Py_ssize_t size)
    Copy the Unicode object contents into the :ctype:`wchar_t` buffer *w*.  At most
    *size* :ctype:`wchar_t` characters are copied (excluding a possibly trailing
 -termination character).  Return the number of :ctype:`wchar_t` characters
    copied or -1 in case of an error.  Note that the resulting :ctype:`wchar_t`
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: Py_ssize_t PyUnicode_AsWideChar(PyUnicodeObject *unicode, wchar_t *w, Py_ssize_t size)
+   Copy the Unicode object contents into the :c:type:`wchar_t` buffer *w*.  At most
+   *size* :c:type:`wchar_t` characters are copied (excluding a possibly trailing
+-termination character).  Return the number of :c:type:`wchar_t` characters
+   copied or -1 in case of an error.  Note that the resulting :c:type:`wchar_t`
    string may or may not be 0-terminated.  It is the responsibility of the caller
+   to make sure that the :ctype:`wchar_t` string is 0-terminated in case this is
+   required by the application.
+   .. versionchanged:: 2.5
+      This function returned an :ctype:`int` type and used an :ctype:`int`
+   to make sure that the :c:type:`wchar_t` string is 0-terminated in case this is
+   required by the application. Also, note that the :c:type:`wchar_t*` string
+   might contain null characters, which would cause the string to be truncated
+   when used with most C functions.
+   .. versionchanged:: 2.5
+      This function returned an :c:type:`int` type and used an :c:type:`int`
       type for *size*. This might require changes in your code for properly
       supporting 64-bit systems.
 …
 these codecs are directly usable via the following functions.
 Many of the following APIs take two arguments encoding and errors. These
 parameters encoding and errors have the same semantics as the ones of the
 built-in :func:`unicode` Unicode object constructor.
+Many of the following APIs take two arguments encoding and errors, and they
+have the same semantics as the ones of the built-in :func:`unicode` Unicode
+object constructor.
 Setting encoding to *NULL* causes the default encoding to be used which is
 ASCII.  The file system calls should use :cdata:`Py_FileSystemDefaultEncoding`
 as the encoding for file names. This variable should be treated as read-only: On
+ASCII.  The file system calls should use :c:data:`Py_FileSystemDefaultEncoding`
+as the encoding for file names. This variable should be treated as read-only: on
 some systems, it will be a pointer to a static string, on others, it will change
 at run-time (such as when the application invokes setlocale).
 …
 generic ones are documented for simplicity.
+Generic Codecs
+""""""""""""""
 These are the generic codec APIs:
+.. % --- Generic Codecs -----------------------------------------------------
+.. cfunction:: PyObject* PyUnicode_Decode(const char *s, Py_ssize_t size, const char *encoding, const char *errors)
+.. c:function:: PyObject* PyUnicode_Decode(const char *s, Py_ssize_t size, const char *encoding, const char *errors)
    Create a Unicode object by decoding *size* bytes of the encoded string *s*.
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_Encode(const Py_UNICODE *s, Py_ssize_t size, const char *encoding, const char *errors)
    Encode the :ctype:`Py_UNICODE` buffer of the given size and return a Python
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PyUnicode_Encode(const Py_UNICODE *s, Py_ssize_t size, const char *encoding, const char *errors)
+   Encode the :c:type:`Py_UNICODE` buffer *s* of the given *size* and return a Python
    string object.  *encoding* and *errors* have the same meaning as the parameters
    of the same name in the Unicode :meth:`encode` method.  The codec to be used is
    looked up using the Python codec registry.  Return *NULL* if an exception was
    raised by the codec.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_AsEncodedString(PyObject *unicode, const char *encoding, const char *errors)
+   of the same name in the Unicode :meth:`~unicode.encode` method.  The codec
+   to be used is looked up using the Python codec registry.  Return *NULL* if
+   an exception was raised by the codec.
+   .. versionchanged:: 2.5
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PyUnicode_AsEncodedString(PyObject *unicode, const char *encoding, const char *errors)
    Encode a Unicode object and return the result as Python string object.
 …
    codec.
+UTF-8 Codecs
+""""""""""""
 These are the UTF-8 codec APIs:
+.. % --- UTF-8 Codecs -------------------------------------------------------
+.. cfunction:: PyObject* PyUnicode_DecodeUTF8(const char *s, Py_ssize_t size, const char *errors)
+.. c:function:: PyObject* PyUnicode_DecodeUTF8(const char *s, Py_ssize_t size, const char *errors)
    Create a Unicode object by decoding *size* bytes of the UTF-8 encoded string
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_DecodeUTF8Stateful(const char *s, Py_ssize_t size, const char *errors, Py_ssize_t *consumed)
    If *consumed* is *NULL*, behave like :cfunc:`PyUnicode_DecodeUTF8`. If
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PyUnicode_DecodeUTF8Stateful(const char *s, Py_ssize_t size, const char *errors, Py_ssize_t *consumed)
+   If *consumed* is *NULL*, behave like :c:func:`PyUnicode_DecodeUTF8`. If
    *consumed* is not *NULL*, trailing incomplete UTF-8 byte sequences will not be
    treated as an error. Those bytes will not be decoded and the number of bytes
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_EncodeUTF8(const Py_UNICODE *s, Py_ssize_t size, const char *errors)
    Encode the :ctype:`Py_UNICODE` buffer of the given size using UTF-8 and return a
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PyUnicode_EncodeUTF8(const Py_UNICODE *s, Py_ssize_t size, const char *errors)
+   Encode the :c:type:`Py_UNICODE` buffer *s* of the given *size* using UTF-8 and return a
    Python string object.  Return *NULL* if an exception was raised by the codec.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_AsUTF8String(PyObject *unicode)
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PyUnicode_AsUTF8String(PyObject *unicode)
    Encode a Unicode object using UTF-8 and return the result as Python string
 …
    by the codec.
+UTF-32 Codecs
+"""""""""""""
 These are the UTF-32 codec APIs:
+.. % --- UTF-32 Codecs ------------------------------------------------------ */
+.. cfunction:: PyObject* PyUnicode_DecodeUTF32(const char *s, Py_ssize_t size, const char *errors, int *byteorder)
+   Decode *length* bytes from a UTF-32 encoded buffer string and return the
+.. c:function:: PyObject* PyUnicode_DecodeUTF32(const char *s, Py_ssize_t size, const char *errors, int *byteorder)
+   Decode *size* bytes from a UTF-32 encoded buffer string and return the
    corresponding Unicode object.  *errors* (if non-*NULL*) defines the error
    handling. It defaults to "strict".
 …
 .. cfunction:: PyObject* PyUnicode_DecodeUTF32Stateful(const char *s, Py_ssize_t size, const char *errors, int *byteorder, Py_ssize_t *consumed)
    If *consumed* is *NULL*, behave like :cfunc:`PyUnicode_DecodeUTF32`. If
    *consumed* is not *NULL*, :cfunc:`PyUnicode_DecodeUTF32Stateful` will not treat
+.. c:function:: PyObject* PyUnicode_DecodeUTF32Stateful(const char *s, Py_ssize_t size, const char *errors, int *byteorder, Py_ssize_t *consumed)
+   If *consumed* is *NULL*, behave like :c:func:`PyUnicode_DecodeUTF32`. If
+   *consumed* is not *NULL*, :c:func:`PyUnicode_DecodeUTF32Stateful` will not treat
    trailing incomplete UTF-32 byte sequences (such as a number of bytes not divisible
    by four) as an error. Those bytes will not be decoded and the number of bytes
 …
 .. cfunction:: PyObject* PyUnicode_EncodeUTF32(const Py_UNICODE *s, Py_ssize_t size, const char *errors, int byteorder)
+.. c:function:: PyObject* PyUnicode_EncodeUTF32(const Py_UNICODE *s, Py_ssize_t size, const char *errors, int byteorder)
    Return a Python bytes object holding the UTF-32 encoded value of the Unicode
 …
 .. cfunction:: PyObject* PyUnicode_AsUTF32String(PyObject *unicode)
+.. c:function:: PyObject* PyUnicode_AsUTF32String(PyObject *unicode)
    Return a Python string using the UTF-32 encoding in native byte order. The
 …
+UTF-16 Codecs
+"""""""""""""
 These are the UTF-16 codec APIs:
+.. % --- UTF-16 Codecs ------------------------------------------------------ */
+.. cfunction:: PyObject* PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors, int *byteorder)
+   Decode *length* bytes from a UTF-16 encoded buffer string and return the
+.. c:function:: PyObject* PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors, int *byteorder)
+   Decode *size* bytes from a UTF-16 encoded buffer string and return the
    corresponding Unicode object.  *errors* (if non-*NULL*) defines the error
    handling. It defaults to "strict".
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_DecodeUTF16Stateful(const char *s, Py_ssize_t size, const char *errors, int *byteorder, Py_ssize_t *consumed)
    If *consumed* is *NULL*, behave like :cfunc:`PyUnicode_DecodeUTF16`. If
    *consumed* is not *NULL*, :cfunc:`PyUnicode_DecodeUTF16Stateful` will not treat
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PyUnicode_DecodeUTF16Stateful(const char *s, Py_ssize_t size, const char *errors, int *byteorder, Py_ssize_t *consumed)
+   If *consumed* is *NULL*, behave like :c:func:`PyUnicode_DecodeUTF16`. If
+   *consumed* is not *NULL*, :c:func:`PyUnicode_DecodeUTF16Stateful` will not treat
    trailing incomplete UTF-16 byte sequences (such as an odd number of bytes or a
    split surrogate pair) as an error. Those bytes will not be decoded and the
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size* and an :ctype:`int *`
+      This function used an :c:type:`int` type for *size* and an :c:type:`int *`
       type for *consumed*. This might require changes in your code for
       properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_EncodeUTF16(const Py_UNICODE *s, Py_ssize_t size, const char *errors, int byteorder)
+.. c:function:: PyObject* PyUnicode_EncodeUTF16(const Py_UNICODE *s, Py_ssize_t size, const char *errors, int byteorder)
    Return a Python string object holding the UTF-16 encoded value of the Unicode
 …
    mark (U+FEFF). In the other two modes, no BOM mark is prepended.
    If *Py_UNICODE_WIDE* is defined, a single :ctype:`Py_UNICODE` value may get
    represented as a surrogate pair. If it is not defined, each :ctype:`Py_UNICODE`
+   If *Py_UNICODE_WIDE* is defined, a single :c:type:`Py_UNICODE` value may get
+   represented as a surrogate pair. If it is not defined, each :c:type:`Py_UNICODE`
    values is interpreted as an UCS-2 character.
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_AsUTF16String(PyObject *unicode)
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PyUnicode_AsUTF16String(PyObject *unicode)
    Return a Python string using the UTF-16 encoding in native byte order. The
 …
    *NULL* if an exception was raised by the codec.
+UTF-7 Codecs
+""""""""""""
+These are the UTF-7 codec APIs:
+.. c:function:: PyObject* PyUnicode_DecodeUTF7(const char *s, Py_ssize_t size, const char *errors)
+   Create a Unicode object by decoding *size* bytes of the UTF-7 encoded string
+   *s*.  Return *NULL* if an exception was raised by the codec.
+.. c:function:: PyObject* PyUnicode_DecodeUTF7Stateful(const char *s, Py_ssize_t size, const char *errors, Py_ssize_t *consumed)
+   If *consumed* is *NULL*, behave like :c:func:`PyUnicode_DecodeUTF7`.  If
+   *consumed* is not *NULL*, trailing incomplete UTF-7 base-64 sections will not
+   be treated as an error.  Those bytes will not be decoded and the number of
+   bytes that have been decoded will be stored in *consumed*.
+.. c:function:: PyObject* PyUnicode_EncodeUTF7(const Py_UNICODE *s, Py_ssize_t size, int base64SetO, int base64WhiteSpace, const char *errors)
+   Encode the :c:type:`Py_UNICODE` buffer of the given size using UTF-7 and
+   return a Python bytes object.  Return *NULL* if an exception was raised by
+   the codec.
+   If *base64SetO* is nonzero, "Set O" (punctuation that has no otherwise
+   special meaning) will be encoded in base-64.  If *base64WhiteSpace* is
+   nonzero, whitespace will be encoded in base-64.  Both are set to zero for the
+   Python "utf-7" codec.
+Unicode-Escape Codecs
+"""""""""""""""""""""
 These are the "Unicode Escape" codec APIs:
+.. % --- Unicode-Escape Codecs ----------------------------------------------
+.. cfunction:: PyObject* PyUnicode_DecodeUnicodeEscape(const char *s, Py_ssize_t size, const char *errors)
+.. c:function:: PyObject* PyUnicode_DecodeUnicodeEscape(const char *s, Py_ssize_t size, const char *errors)
    Create a Unicode object by decoding *size* bytes of the Unicode-Escape encoded
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_EncodeUnicodeEscape(const Py_UNICODE *s, Py_ssize_t size)
    Encode the :ctype:`Py_UNICODE` buffer of the given size using Unicode-Escape and
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PyUnicode_EncodeUnicodeEscape(const Py_UNICODE *s, Py_ssize_t size)
+   Encode the :c:type:`Py_UNICODE` buffer of the given *size* using Unicode-Escape and
    return a Python string object.  Return *NULL* if an exception was raised by the
    codec.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_AsUnicodeEscapeString(PyObject *unicode)
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PyUnicode_AsUnicodeEscapeString(PyObject *unicode)
    Encode a Unicode object using Unicode-Escape and return the result as Python
 …
    raised by the codec.
+Raw-Unicode-Escape Codecs
+"""""""""""""""""""""""""
 These are the "Raw Unicode Escape" codec APIs:
+.. % --- Raw-Unicode-Escape Codecs ------------------------------------------
+.. cfunction:: PyObject* PyUnicode_DecodeRawUnicodeEscape(const char *s, Py_ssize_t size, const char *errors)
+.. c:function:: PyObject* PyUnicode_DecodeRawUnicodeEscape(const char *s, Py_ssize_t size, const char *errors)
    Create a Unicode object by decoding *size* bytes of the Raw-Unicode-Escape
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_EncodeRawUnicodeEscape(const Py_UNICODE *s, Py_ssize_t size, const char *errors)
    Encode the :ctype:`Py_UNICODE` buffer of the given size using Raw-Unicode-Escape
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PyUnicode_EncodeRawUnicodeEscape(const Py_UNICODE *s, Py_ssize_t size, const char *errors)
+   Encode the :c:type:`Py_UNICODE` buffer of the given *size* using Raw-Unicode-Escape
    and return a Python string object.  Return *NULL* if an exception was raised by
    the codec.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_AsRawUnicodeEscapeString(PyObject *unicode)
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PyUnicode_AsRawUnicodeEscapeString(PyObject *unicode)
    Encode a Unicode object using Raw-Unicode-Escape and return the result as
 …
    was raised by the codec.
+Latin-1 Codecs
+""""""""""""""
 These are the Latin-1 codec APIs: Latin-1 corresponds to the first 256 Unicode
 ordinals and only these are accepted by the codecs during encoding.
+.. % --- Latin-1 Codecs -----------------------------------------------------
+.. cfunction:: PyObject* PyUnicode_DecodeLatin1(const char *s, Py_ssize_t size, const char *errors)
+.. c:function:: PyObject* PyUnicode_DecodeLatin1(const char *s, Py_ssize_t size, const char *errors)
    Create a Unicode object by decoding *size* bytes of the Latin-1 encoded string
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_EncodeLatin1(const Py_UNICODE *s, Py_ssize_t size, const char *errors)
    Encode the :ctype:`Py_UNICODE` buffer of the given size using Latin-1 and return
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PyUnicode_EncodeLatin1(const Py_UNICODE *s, Py_ssize_t size, const char *errors)
+   Encode the :c:type:`Py_UNICODE` buffer of the given *size* using Latin-1 and return
    a Python string object.  Return *NULL* if an exception was raised by the codec.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_AsLatin1String(PyObject *unicode)
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PyUnicode_AsLatin1String(PyObject *unicode)
    Encode a Unicode object using Latin-1 and return the result as Python string
 …
    by the codec.
+ASCII Codecs
+""""""""""""
 These are the ASCII codec APIs.  Only 7-bit ASCII data is accepted. All other
 codes generate errors.
+.. % --- ASCII Codecs -------------------------------------------------------
+.. cfunction:: PyObject* PyUnicode_DecodeASCII(const char *s, Py_ssize_t size, const char *errors)
+.. c:function:: PyObject* PyUnicode_DecodeASCII(const char *s, Py_ssize_t size, const char *errors)
    Create a Unicode object by decoding *size* bytes of the ASCII encoded string
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_EncodeASCII(const Py_UNICODE *s, Py_ssize_t size, const char *errors)
    Encode the :ctype:`Py_UNICODE` buffer of the given size using ASCII and return a
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PyUnicode_EncodeASCII(const Py_UNICODE *s, Py_ssize_t size, const char *errors)
+   Encode the :c:type:`Py_UNICODE` buffer of the given *size* using ASCII and return a
    Python string object.  Return *NULL* if an exception was raised by the codec.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_AsASCIIString(PyObject *unicode)
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PyUnicode_AsASCIIString(PyObject *unicode)
    Encode a Unicode object using ASCII and return the result as Python string
 …
    by the codec.
+These are the mapping codec APIs:
+.. % --- Character Map Codecs -----------------------------------------------
+Character Map Codecs
+""""""""""""""""""""
 This codec is special in that it can be used to implement many different codecs
 …
 characters to different code points.
+.. cfunction:: PyObject* PyUnicode_DecodeCharmap(const char *s, Py_ssize_t size, PyObject *mapping, const char *errors)
+These are the mapping codec APIs:
+.. c:function:: PyObject* PyUnicode_DecodeCharmap(const char *s, Py_ssize_t size, PyObject *mapping, const char *errors)
    Create a Unicode object by decoding *size* bytes of the encoded string *s* using
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_EncodeCharmap(const Py_UNICODE *s, Py_ssize_t size, PyObject *mapping, const char *errors)
    Encode the :ctype:`Py_UNICODE` buffer of the given size using the given
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PyUnicode_EncodeCharmap(const Py_UNICODE *s, Py_ssize_t size, PyObject *mapping, const char *errors)
+   Encode the :c:type:`Py_UNICODE` buffer of the given *size* using the given
    *mapping* object and return a Python string object. Return *NULL* if an
    exception was raised by the codec.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_AsCharmapString(PyObject *unicode, PyObject *mapping)
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PyUnicode_AsCharmapString(PyObject *unicode, PyObject *mapping)
    Encode a Unicode object using the given *mapping* object and return the result
 …
 .. cfunction:: PyObject* PyUnicode_TranslateCharmap(const Py_UNICODE *s, Py_ssize_t size, PyObject *table, const char *errors)
    Translate a :ctype:`Py_UNICODE` buffer of the given length by applying a
+.. c:function:: PyObject* PyUnicode_TranslateCharmap(const Py_UNICODE *s, Py_ssize_t size, PyObject *table, const char *errors)
+   Translate a :c:type:`Py_UNICODE` buffer of the given *size* by applying a
    character mapping *table* to it and return the resulting Unicode object.  Return
    *NULL* when an exception was raised by the codec.
 …
    .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+MBCS codecs for Windows
+"""""""""""""""""""""""
 These are the MBCS codec APIs. They are currently only available on Windows and
 …
 the user settings on the machine running the codec.
+.. % --- MBCS codecs for Windows --------------------------------------------
+.. cfunction:: PyObject* PyUnicode_DecodeMBCS(const char *s, Py_ssize_t size, const char *errors)
+.. c:function:: PyObject* PyUnicode_DecodeMBCS(const char *s, Py_ssize_t size, const char *errors)
    Create a Unicode object by decoding *size* bytes of the MBCS encoded string *s*.
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_DecodeMBCSStateful(const char *s, int size, const char *errors, int *consumed)
    If *consumed* is *NULL*, behave like :cfunc:`PyUnicode_DecodeMBCS`. If
    *consumed* is not *NULL*, :cfunc:`PyUnicode_DecodeMBCSStateful` will not decode
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PyUnicode_DecodeMBCSStateful(const char *s, int size, const char *errors, int *consumed)
+   If *consumed* is *NULL*, behave like :c:func:`PyUnicode_DecodeMBCS`. If
+   *consumed* is not *NULL*, :c:func:`PyUnicode_DecodeMBCSStateful` will not decode
    trailing lead byte and the number of bytes that have been decoded will be stored
    in *consumed*.
 …
 .. cfunction:: PyObject* PyUnicode_EncodeMBCS(const Py_UNICODE *s, Py_ssize_t size, const char *errors)
    Encode the :ctype:`Py_UNICODE` buffer of the given size using MBCS and return a
+.. c:function:: PyObject* PyUnicode_EncodeMBCS(const Py_UNICODE *s, Py_ssize_t size, const char *errors)
+   Encode the :c:type:`Py_UNICODE` buffer of the given *size* using MBCS and return a
    Python string object.  Return *NULL* if an exception was raised by the codec.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *size*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_AsMBCSString(PyObject *unicode)
+      This function used an :c:type:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PyUnicode_AsMBCSString(PyObject *unicode)
    Encode a Unicode object using MBCS and return the result as Python string
 …
    by the codec.
+.. % --- Methods & Slots ----------------------------------------------------
+Methods & Slots
+"""""""""""""""
 .. _unicodemethodsandslots:
 …
 .. cfunction:: PyObject* PyUnicode_Concat(PyObject *left, PyObject *right)
+.. c:function:: PyObject* PyUnicode_Concat(PyObject *left, PyObject *right)
    Concat two strings giving a new Unicode string.
 .. cfunction:: PyObject* PyUnicode_Split(PyObject *s, PyObject *sep, Py_ssize_t maxsplit)
    Split a string giving a list of Unicode strings.  If sep is *NULL*, splitting
+.. c:function:: PyObject* PyUnicode_Split(PyObject *s, PyObject *sep, Py_ssize_t maxsplit)
+   Split a string giving a list of Unicode strings.  If *sep* is *NULL*, splitting
    will be done at all whitespace substrings.  Otherwise, splits occur at the given
    separator.  At most *maxsplit* splits will be done.  If negative, no limit is
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *maxsplit*. This might require
       changes in your code for properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_Splitlines(PyObject *s, int keepend)
+      This function used an :c:type:`int` type for *maxsplit*. This might require
+      changes in your code for properly supporting 64-bit systems.
+.. c:function:: PyObject* PyUnicode_Splitlines(PyObject *s, int keepend)
    Split a Unicode string at line breaks, returning a list of Unicode strings.
 …
 .. cfunction:: PyObject* PyUnicode_Translate(PyObject *str, PyObject *table, const char *errors)
+.. c:function:: PyObject* PyUnicode_Translate(PyObject *str, PyObject *table, const char *errors)
    Translate a string by applying a character mapping table to it and return the
 …
 .. cfunction:: PyObject* PyUnicode_Join(PyObject *separator, PyObject *seq)
    Join a sequence of strings using the given separator and return the resulting
+.. c:function:: PyObject* PyUnicode_Join(PyObject *separator, PyObject *seq)
+   Join a sequence of strings using the given *separator* and return the resulting
    Unicode string.
 .. cfunction:: int PyUnicode_Tailmatch(PyObject *str, PyObject *substr, Py_ssize_t start, Py_ssize_t end, int direction)
    Return 1 if *substr* matches *str*[*start*:*end*] at the given tail end
+.. c:function:: int PyUnicode_Tailmatch(PyObject *str, PyObject *substr, Py_ssize_t start, Py_ssize_t end, int direction)
+   Return 1 if *substr* matches ``str[start:end]`` at the given tail end
    (*direction* == -1 means to do a prefix match, *direction* == 1 a suffix match),
 otherwise. Return ``-1`` if an error occurred.
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *start* and *end*. This
+      This function used an :c:type:`int` type for *start* and *end*. This
       might require changes in your code for properly supporting 64-bit
       systems.
 .. cfunction:: Py_ssize_t PyUnicode_Find(PyObject *str, PyObject *substr, Py_ssize_t start, Py_ssize_t end, int direction)
    Return the first position of *substr* in *str*[*start*:*end*] using the given
+.. c:function:: Py_ssize_t PyUnicode_Find(PyObject *str, PyObject *substr, Py_ssize_t start, Py_ssize_t end, int direction)
+   Return the first position of *substr* in ``str[start:end]`` using the given
    *direction* (*direction* == 1 means to do a forward search, *direction* == -1 a
    backward search).  The return value is the index of the first match; a value of
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *start* and *end*. This
+      This function used an :c:type:`int` type for *start* and *end*. This
       might require changes in your code for properly supporting 64-bit
       systems.
 .. cfunction:: Py_ssize_t PyUnicode_Count(PyObject *str, PyObject *substr, Py_ssize_t start, Py_ssize_t end)
+.. c:function:: Py_ssize_t PyUnicode_Count(PyObject *str, PyObject *substr, Py_ssize_t start, Py_ssize_t end)
    Return the number of non-overlapping occurrences of *substr* in
 …
    .. versionchanged:: 2.5
       This function returned an :ctype:`int` type and used an :ctype:`int`
+      This function returned an :c:type:`int` type and used an :c:type:`int`
       type for *start* and *end*. This might require changes in your code for
       properly supporting 64-bit systems.
 .. cfunction:: PyObject* PyUnicode_Replace(PyObject *str, PyObject *substr, PyObject *replstr, Py_ssize_t maxcount)
+.. c:function:: PyObject* PyUnicode_Replace(PyObject *str, PyObject *substr, PyObject *replstr, Py_ssize_t maxcount)
    Replace at most *maxcount* occurrences of *substr* in *str* with *replstr* and
 …
    .. versionchanged:: 2.5
       This function used an :ctype:`int` type for *maxcount*. This might
+      This function used an :c:type:`int` type for *maxcount*. This might
       require changes in your code for properly supporting 64-bit systems.
 .. cfunction:: int PyUnicode_Compare(PyObject *left, PyObject *right)
+.. c:function:: int PyUnicode_Compare(PyObject *left, PyObject *right)
    Compare two strings and return -1, 0, 1 for less than, equal, and greater than,
 …
 .. cfunction:: int PyUnicode_RichCompare(PyObject *left,  PyObject *right,  int op)
+.. c:function:: int PyUnicode_RichCompare(PyObject *left,  PyObject *right,  int op)
    Rich compare two unicode strings and return one of the following:
 …
 .. cfunction:: PyObject* PyUnicode_Format(PyObject *format, PyObject *args)
+.. c:function:: PyObject* PyUnicode_Format(PyObject *format, PyObject *args)
    Return a new string object from *format* and *args*; this is analogous to
 …
 .. cfunction:: int PyUnicode_Contains(PyObject *container, PyObject *element)
+.. c:function:: int PyUnicode_Contains(PyObject *container, PyObject *element)
    Check whether *element* is contained in *container* and return true or false

python/vendor/current/Doc/c-api/utilities.rst

r2	r388
20	20	conversion.rst
21	21	reflection.rst
	22	codec.rst

python/vendor/current/Doc/c-api/veryhigh.rst

-              r2
+              r388
 following the functions which accept them as parameters.
 Note also that several of these functions take :ctype:`FILE\*` parameters.  One
 particular issue which needs to be handled carefully is that the :ctype:`FILE`
+Note also that several of these functions take :c:type:`FILE\*` parameters.  One
+particular issue which needs to be handled carefully is that the :c:type:`FILE`
 structure for different C libraries can be different and incompatible.  Under
 Windows (at least), it is possible for dynamically linked extensions to actually
 use different libraries, so care should be taken that :ctype:`FILE\*` parameters
+use different libraries, so care should be taken that :c:type:`FILE\*` parameters
 are only passed to these functions if it is certain that they were created by
 the same library that the Python runtime is using.
 .. cfunction:: int Py_Main(int argc, char **argv)
+.. c:function:: int Py_Main(int argc, char **argv)
    The main program for the standard interpreter.  This is made available for
    programs which embed Python.  The *argc* and *argv* parameters should be
    prepared exactly as those which are passed to a C program's :cfunc:`main`
+   prepared exactly as those which are passed to a C program's :c:func:`main`
    function.  It is important to note that the argument list may be modified (but
    the contents of the strings pointed to by the argument list are not). The return
    value will be the integer passed to the :func:`sys.exit` function, ``1`` if the
    interpreter exits due to an exception, or ``2`` if the parameter list does not
    represent a valid Python command line.
    Note that if an otherwise unhandled :exc:`SystemError` is raised, this
+   value will be ``0`` if the interpreter exits normally (ie, without an
+   exception), ``1`` if the interpreter exits due to an exception, or ``2``
+   if the parameter list does not represent a valid Python command line.
+   Note that if an otherwise unhandled :exc:`SystemExit` is raised, this
    function will not return ``1``, but exit the process, as long as
    ``Py_InspectFlag`` is not set.
 .. cfunction:: int PyRun_AnyFile(FILE *fp, const char *filename)
    This is a simplified interface to :cfunc:`PyRun_AnyFileExFlags` below, leaving
+.. c:function:: int PyRun_AnyFile(FILE *fp, const char *filename)
+   This is a simplified interface to :c:func:`PyRun_AnyFileExFlags` below, leaving
    *closeit* set to ``0`` and *flags* set to *NULL*.
 .. cfunction:: int PyRun_AnyFileFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
    This is a simplified interface to :cfunc:`PyRun_AnyFileExFlags` below, leaving
+.. c:function:: int PyRun_AnyFileFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
+   This is a simplified interface to :c:func:`PyRun_AnyFileExFlags` below, leaving
    the *closeit* argument set to ``0``.
 .. cfunction:: int PyRun_AnyFileEx(FILE *fp, const char *filename, int closeit)
    This is a simplified interface to :cfunc:`PyRun_AnyFileExFlags` below, leaving
+.. c:function:: int PyRun_AnyFileEx(FILE *fp, const char *filename, int closeit)
+   This is a simplified interface to :c:func:`PyRun_AnyFileExFlags` below, leaving
    the *flags* argument set to *NULL*.
 .. cfunction:: int PyRun_AnyFileExFlags(FILE *fp, const char *filename, int closeit, PyCompilerFlags *flags)
+.. c:function:: int PyRun_AnyFileExFlags(FILE *fp, const char *filename, int closeit, PyCompilerFlags *flags)
    If *fp* refers to a file associated with an interactive device (console or
    terminal input or Unix pseudo-terminal), return the value of
    :cfunc:`PyRun_InteractiveLoop`, otherwise return the result of
    :cfunc:`PyRun_SimpleFile`.  If *filename* is *NULL*, this function uses
+   :c:func:`PyRun_InteractiveLoop`, otherwise return the result of
+   :c:func:`PyRun_SimpleFile`.  If *filename* is *NULL*, this function uses
    ``"???"`` as the filename.
 .. cfunction:: int PyRun_SimpleString(const char *command)
    This is a simplified interface to :cfunc:`PyRun_SimpleStringFlags` below,
+.. c:function:: int PyRun_SimpleString(const char *command)
+   This is a simplified interface to :c:func:`PyRun_SimpleStringFlags` below,
    leaving the *PyCompilerFlags\** argument set to NULL.
 .. cfunction:: int PyRun_SimpleStringFlags(const char *command, PyCompilerFlags *flags)
+.. c:function:: int PyRun_SimpleStringFlags(const char *command, PyCompilerFlags *flags)
    Executes the Python source code from *command* in the :mod:`__main__` module
 …
    meaning of *flags*, see below.
    Note that if an otherwise unhandled :exc:`SystemError` is raised, this
+   Note that if an otherwise unhandled :exc:`SystemExit` is raised, this
    function will not return ``-1``, but exit the process, as long as
    ``Py_InspectFlag`` is not set.
 .. cfunction:: int PyRun_SimpleFile(FILE *fp, const char *filename)
    This is a simplified interface to :cfunc:`PyRun_SimpleFileExFlags` below,
+.. c:function:: int PyRun_SimpleFile(FILE *fp, const char *filename)
+   This is a simplified interface to :c:func:`PyRun_SimpleFileExFlags` below,
    leaving *closeit* set to ``0`` and *flags* set to *NULL*.
 .. cfunction:: int PyRun_SimpleFileFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
    This is a simplified interface to :cfunc:`PyRun_SimpleFileExFlags` below,
+.. c:function:: int PyRun_SimpleFileFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
+   This is a simplified interface to :c:func:`PyRun_SimpleFileExFlags` below,
    leaving *closeit* set to ``0``.
 .. cfunction:: int PyRun_SimpleFileEx(FILE *fp, const char *filename, int closeit)
    This is a simplified interface to :cfunc:`PyRun_SimpleFileExFlags` below,
+.. c:function:: int PyRun_SimpleFileEx(FILE *fp, const char *filename, int closeit)
+   This is a simplified interface to :c:func:`PyRun_SimpleFileExFlags` below,
    leaving *flags* set to *NULL*.
 .. cfunction:: int PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit, PyCompilerFlags *flags)
    Similar to :cfunc:`PyRun_SimpleStringFlags`, but the Python source code is read
+.. c:function:: int PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit, PyCompilerFlags *flags)
+   Similar to :c:func:`PyRun_SimpleStringFlags`, but the Python source code is read
    from *fp* instead of an in-memory string. *filename* should be the name of the
    file.  If *closeit* is true, the file is closed before PyRun_SimpleFileExFlags
 …
 .. cfunction:: int PyRun_InteractiveOne(FILE *fp, const char *filename)
    This is a simplified interface to :cfunc:`PyRun_InteractiveOneFlags` below,
+.. c:function:: int PyRun_InteractiveOne(FILE *fp, const char *filename)
+   This is a simplified interface to :c:func:`PyRun_InteractiveOneFlags` below,
    leaving *flags* set to *NULL*.
 .. cfunction:: int PyRun_InteractiveOneFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
    Read and execute a single statement from a file associated with an interactive
    device according to the *flags* argument.  If *filename* is *NULL*, ``"???"`` is
    used instead.  The user will be prompted using ``sys.ps1`` and ``sys.ps2``.
    Returns ``0`` when the input was executed successfully, ``-1`` if there was an
    exception, or an error code from the :file:`errcode.h` include file distributed
    as part of Python if there was a parse error.  (Note that :file:`errcode.h` is
    not included by :file:`Python.h`, so must be included specifically if needed.)
 .. cfunction:: int PyRun_InteractiveLoop(FILE *fp, const char *filename)
    This is a simplified interface to :cfunc:`PyRun_InteractiveLoopFlags` below,
+.. c:function:: int PyRun_InteractiveOneFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
+   Read and execute a single statement from a file associated with an
+   interactive device according to the *flags* argument.  The user will be
+   prompted using ``sys.ps1`` and ``sys.ps2``.  Returns ``0`` when the input was
+   executed successfully, ``-1`` if there was an exception, or an error code
+   from the :file:`errcode.h` include file distributed as part of Python if
+   there was a parse error.  (Note that :file:`errcode.h` is not included by
+   :file:`Python.h`, so must be included specifically if needed.)
+.. c:function:: int PyRun_InteractiveLoop(FILE *fp, const char *filename)
+   This is a simplified interface to :c:func:`PyRun_InteractiveLoopFlags` below,
    leaving *flags* set to *NULL*.
 .. cfunction:: int PyRun_InteractiveLoopFlags(FILE *fp,  const char *filename, PyCompilerFlags *flags)
+.. c:function:: int PyRun_InteractiveLoopFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
    Read and execute statements from a file associated with an interactive device
    until EOF is reached.  If *filename* is *NULL*, ``"???"`` is used instead.  The
    user will be prompted using ``sys.ps1`` and ``sys.ps2``.  Returns ``0`` at EOF.
 .. cfunction:: struct _node* PyParser_SimpleParseString(const char *str, int start)
+   until EOF is reached.  The user will be prompted using ``sys.ps1`` and
+   ``sys.ps2``.  Returns ``0`` at EOF.
+.. c:function:: struct _node* PyParser_SimpleParseString(const char *str, int start)
    This is a simplified interface to
    :cfunc:`PyParser_SimpleParseStringFlagsFilename` below, leaving  *filename* set
+   :c:func:`PyParser_SimpleParseStringFlagsFilename` below, leaving  *filename* set
    to *NULL* and *flags* set to ``0``.
 .. cfunction:: struct _node* PyParser_SimpleParseStringFlags( const char *str, int start, int flags)
+.. c:function:: struct _node* PyParser_SimpleParseStringFlags( const char *str, int start, int flags)
    This is a simplified interface to
    :cfunc:`PyParser_SimpleParseStringFlagsFilename` below, leaving  *filename* set
+   :c:func:`PyParser_SimpleParseStringFlagsFilename` below, leaving  *filename* set
    to *NULL*.
 .. cfunction:: struct _node* PyParser_SimpleParseStringFlagsFilename( const char *str, const char *filename, int start, int flags)
+.. c:function:: struct _node* PyParser_SimpleParseStringFlagsFilename( const char *str, const char *filename, int start, int flags)
    Parse Python source code from *str* using the start token *start* according to
 …
 .. cfunction:: struct _node* PyParser_SimpleParseFile(FILE *fp, const char *filename, int start)
    This is a simplified interface to :cfunc:`PyParser_SimpleParseFileFlags` below,
+.. c:function:: struct _node* PyParser_SimpleParseFile(FILE *fp, const char *filename, int start)
+   This is a simplified interface to :c:func:`PyParser_SimpleParseFileFlags` below,
    leaving *flags* set to ``0``
 .. cfunction:: struct _node* PyParser_SimpleParseFileFlags(FILE *fp, const char *filename, int start, int flags)
    Similar to :cfunc:`PyParser_SimpleParseStringFlagsFilename`, but the Python
+.. c:function:: struct _node* PyParser_SimpleParseFileFlags(FILE *fp, const char *filename, int start, int flags)
+   Similar to :c:func:`PyParser_SimpleParseStringFlagsFilename`, but the Python
    source code is read from *fp* instead of an in-memory string.
 .. cfunction:: PyObject* PyRun_String(const char *str, int start, PyObject *globals, PyObject *locals)
    This is a simplified interface to :cfunc:`PyRun_StringFlags` below, leaving
+.. c:function:: PyObject* PyRun_String(const char *str, int start, PyObject *globals, PyObject *locals)
+   This is a simplified interface to :c:func:`PyRun_StringFlags` below, leaving
    *flags* set to *NULL*.
 .. cfunction:: PyObject* PyRun_StringFlags(const char *str, int start, PyObject *globals, PyObject *locals, PyCompilerFlags *flags)
+.. c:function:: PyObject* PyRun_StringFlags(const char *str, int start, PyObject *globals, PyObject *locals, PyCompilerFlags *flags)
    Execute Python source code from *str* in the context specified by the
 …
 .. cfunction:: PyObject* PyRun_File(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals)
    This is a simplified interface to :cfunc:`PyRun_FileExFlags` below, leaving
+.. c:function:: PyObject* PyRun_File(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals)
+   This is a simplified interface to :c:func:`PyRun_FileExFlags` below, leaving
    *closeit* set to ``0`` and *flags* set to *NULL*.
 .. cfunction:: PyObject* PyRun_FileEx(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals, int closeit)
    This is a simplified interface to :cfunc:`PyRun_FileExFlags` below, leaving
+.. c:function:: PyObject* PyRun_FileEx(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals, int closeit)
+   This is a simplified interface to :c:func:`PyRun_FileExFlags` below, leaving
    *flags* set to *NULL*.
 .. cfunction:: PyObject* PyRun_FileFlags(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals, PyCompilerFlags *flags)
    This is a simplified interface to :cfunc:`PyRun_FileExFlags` below, leaving
+.. c:function:: PyObject* PyRun_FileFlags(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals, PyCompilerFlags *flags)
+   This is a simplified interface to :c:func:`PyRun_FileExFlags` below, leaving
    *closeit* set to ``0``.
 .. cfunction:: PyObject* PyRun_FileExFlags(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals, int closeit, PyCompilerFlags *flags)
    Similar to :cfunc:`PyRun_StringFlags`, but the Python source code is read from
+.. c:function:: PyObject* PyRun_FileExFlags(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals, int closeit, PyCompilerFlags *flags)
+   Similar to :c:func:`PyRun_StringFlags`, but the Python source code is read from
    *fp* instead of an in-memory string. *filename* should be the name of the file.
    If *closeit* is true, the file is closed before :cfunc:`PyRun_FileExFlags`
+   If *closeit* is true, the file is closed before :c:func:`PyRun_FileExFlags`
    returns.
 .. cfunction:: PyObject* Py_CompileString(const char *str, const char *filename, int start)
    This is a simplified interface to :cfunc:`Py_CompileStringFlags` below, leaving
+.. c:function:: PyObject* Py_CompileString(const char *str, const char *filename, int start)
+   This is a simplified interface to :c:func:`Py_CompileStringFlags` below, leaving
    *flags* set to *NULL*.
 .. cfunction:: PyObject* Py_CompileStringFlags(const char *str, const char *filename, int start, PyCompilerFlags *flags)
+.. c:function:: PyObject* Py_CompileStringFlags(const char *str, const char *filename, int start, PyCompilerFlags *flags)
    Parse and compile the Python source code in *str*, returning the resulting code
 …
 .. cfunction:: PyObject* PyEval_EvalCode(PyCodeObject *co, PyObject *globals, PyObject *locals)
    This is a simplified interface to :cfunc:`PyEval_EvalCodeEx`, with just
+.. c:function:: PyObject* PyEval_EvalCode(PyCodeObject *co, PyObject *globals, PyObject *locals)
+   This is a simplified interface to :c:func:`PyEval_EvalCodeEx`, with just
    the code object, and the dictionaries of global and local variables.
    The other arguments are set to *NULL*.
 .. cfunction:: PyObject* PyEval_EvalCodeEx(PyCodeObject *co, PyObject *globals, PyObject *locals, PyObject **args, int argcount, PyObject **kws, int kwcount, PyObject **defs, int defcount, PyObject *closure)
+.. c:function:: PyObject* PyEval_EvalCodeEx(PyCodeObject *co, PyObject *globals, PyObject *locals, PyObject **args, int argcount, PyObject **kws, int kwcount, PyObject **defs, int defcount, PyObject *closure)
    Evaluate a precompiled code object, given a particular environment for its
 …
 .. cfunction:: PyObject* PyEval_EvalFrame(PyFrameObject *f)
+.. c:function:: PyObject* PyEval_EvalFrame(PyFrameObject *f)
    Evaluate an execution frame.  This is a simplified interface to
 …
 .. cfunction:: PyObject* PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
+.. c:function:: PyObject* PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
    This is the main, unvarnished function of Python interpretation.  It is
 …
    The additional *throwflag* parameter can mostly be ignored - if true, then
    it causes an exception to immediately be thrown; this is used for the
    :meth:`throw` methods of generator objects.
 .. cfunction:: int PyEval_MergeCompilerFlags(PyCompilerFlags *cf)
+   :meth:`~generator.throw` methods of generator objects.
+.. c:function:: int PyEval_MergeCompilerFlags(PyCompilerFlags *cf)
    This function changes the flags of the current evaluation frame, and returns
 …
 .. cvar:: int Py_eval_input
+.. c:var:: int Py_eval_input
    .. index:: single: Py_CompileString()
    The start symbol from the Python grammar for isolated expressions; for use with
    :cfunc:`Py_CompileString`.
 .. cvar:: int Py_file_input
+   :c:func:`Py_CompileString`.
+.. c:var:: int Py_file_input
    .. index:: single: Py_CompileString()
    The start symbol from the Python grammar for sequences of statements as read
    from a file or other source; for use with :cfunc:`Py_CompileString`.  This is
+   from a file or other source; for use with :c:func:`Py_CompileString`.  This is
    the symbol to use when compiling arbitrarily long Python source code.
 .. cvar:: int Py_single_input
+.. c:var:: int Py_single_input
    .. index:: single: Py_CompileString()
    The start symbol from the Python grammar for a single statement; for use with
    :cfunc:`Py_CompileString`. This is the symbol used for the interactive
+   :c:func:`Py_CompileString`. This is the symbol used for the interactive
    interpreter loop.
 .. ctype:: struct PyCompilerFlags
+.. c:type:: struct PyCompilerFlags
    This is the structure used to hold compiler flags.  In cases where code is only
 …
 .. cvar:: int CO_FUTURE_DIVISION
+.. c:var:: int CO_FUTURE_DIVISION
    This bit can be set in *flags* to cause division operator ``/`` to be

python/vendor/current/Doc/c-api/weakref.rst

-              r2
+              r388
 .. cfunction:: int PyWeakref_Check(ob)
+.. c:function:: int PyWeakref_Check(ob)
    Return true if *ob* is either a reference or proxy object.
 …
 .. cfunction:: int PyWeakref_CheckRef(ob)
+.. c:function:: int PyWeakref_CheckRef(ob)
    Return true if *ob* is a reference object.
 …
 .. cfunction:: int PyWeakref_CheckProxy(ob)
+.. c:function:: int PyWeakref_CheckProxy(ob)
    Return true if *ob* is a proxy object.
 …
 .. cfunction:: PyObject* PyWeakref_NewRef(PyObject *ob, PyObject *callback)
+.. c:function:: PyObject* PyWeakref_NewRef(PyObject *ob, PyObject *callback)
    Return a weak reference object for the object *ob*.  This will always return
 …
 .. cfunction:: PyObject* PyWeakref_NewProxy(PyObject *ob, PyObject *callback)
+.. c:function:: PyObject* PyWeakref_NewProxy(PyObject *ob, PyObject *callback)
    Return a weak reference proxy object for the object *ob*.  This will always
 …
 .. cfunction:: PyObject* PyWeakref_GetObject(PyObject *ref)
+.. c:function:: PyObject* PyWeakref_GetObject(PyObject *ref)
    Return the referenced object from a weak reference, *ref*.  If the referent is
    no longer live, returns ``None``.
+   no longer live, returns :const:`Py_None`.
    .. versionadded:: 2.2
+   .. warning::
+.. cfunction:: PyObject* PyWeakref_GET_OBJECT(PyObject *ref)
+      This function returns a **borrowed reference** to the referenced object.
+      This means that you should always call :c:func:`Py_INCREF` on the object
+      except if you know that it cannot be destroyed while you are still
+      using it.
+   Similar to :cfunc:`PyWeakref_GetObject`, but implemented as a macro that does no
+.. c:function:: PyObject* PyWeakref_GET_OBJECT(PyObject *ref)
+   Similar to :c:func:`PyWeakref_GetObject`, but implemented as a macro that does no
    error checking.

Context Navigation

Legend:

Download in other formats: