Changeset 388 for python/vendor/current/Doc/extending

python/vendor/current/Doc/extending/building.rst

-              r2
+              r388
 driver script. In the example above, the\ ``ext_modules`` argument to
 :func:`setup` is a list of extension modules, each of which is an instance of
+the :class:`Extension`. In the example, the instance defines an extension named
+``demo`` which is build by compiling a single source file, :file:`demo.c`.
+the :class:`~distutils.extension.Extension`. In the example, the instance
+defines an extension named ``demo`` which is build by compiling a single source
+file, :file:`demo.c`.
 In many cases, building an extension is more complex, since additional

python/vendor/current/Doc/extending/embedding.rst

-              r2
+              r388
 So if you are embedding Python, you are providing your own main program.  One of
 the things this main program has to do is initialize the Python interpreter.  At
 the very least, you have to call the function :cfunc:`Py_Initialize`.  There are
+the very least, you have to call the function :c:func:`Py_Initialize`.  There are
 optional calls to pass command line arguments to Python.  Then later you can
 call the interpreter from any part of the application.
 There are several different ways to call the interpreter: you can pass a string
 containing Python statements to :cfunc:`PyRun_SimpleString`, or you can pass a
+containing Python statements to :c:func:`PyRun_SimpleString`, or you can pass a
 stdio file pointer and a file name (for identification in error messages only)
 to :cfunc:`PyRun_SimpleFile`.  You can also call the lower-level operations
+to :c:func:`PyRun_SimpleFile`.  You can also call the lower-level operations
 described in the previous chapters to construct and use Python objects.
 …
    main(int argc, char *argv[])
+   {
+     Py_SetProgramName(argv[0]);  /* optional but recommended */
      Py_Initialize();
      PyRun_SimpleString("from time import time,ctime\n"
 …
+   }
+The above code first initializes the Python interpreter with
+:cfunc:`Py_Initialize`, followed by the execution of a hard-coded Python script
+that print the date and time.  Afterwards, the :cfunc:`Py_Finalize` call shuts
+The :c:func:`Py_SetProgramName` function should be called before
+:c:func:`Py_Initialize` to inform the interpreter about paths to Python run-time
+libraries.  Next, the Python interpreter is initialized with
+:c:func:`Py_Initialize`, followed by the execution of a hard-coded Python script
+that prints the date and time.  Afterwards, the :c:func:`Py_Finalize` call shuts
 the interpreter down, followed by the end of the program.  In a real program,
 you may want to get the Python script from another source, perhaps a text-editor
 routine, a file, or a database.  Getting the Python code from a file can better
 be done by using the :cfunc:`PyRun_SimpleFile` function, which saves you the
+be done by using the :c:func:`PyRun_SimpleFile` function, which saves you the
 trouble of allocating memory space and loading the file contents.
 …
 in ``argv[2]``.  Its integer arguments are the other values of the ``argv``
 array.  If you compile and link this program (let's call the finished executable
+:program:`call`), and use it to execute a Python script, such as::
+:program:`call`), and use it to execute a Python script, such as:
+.. code-block:: python
    def multiply(a,b):
 …
 After initializing the interpreter, the script is loaded using
 :cfunc:`PyImport_Import`.  This routine needs a Python string as its argument,
 which is constructed using the :cfunc:`PyString_FromString` data conversion
+:c:func:`PyImport_Import`.  This routine needs a Python string as its argument,
+which is constructed using the :c:func:`PyString_FromString` data conversion
 routine. ::
 …
 Once the script is loaded, the name we're looking for is retrieved using
 :cfunc:`PyObject_GetAttrString`.  If the name exists, and the object returned is
+:c:func:`PyObject_GetAttrString`.  If the name exists, and the object returned is
 callable, you can safely assume that it is a function.  The program then
 proceeds by constructing a tuple of arguments as normal.  The call to the Python
 …
    };
 Insert the above code just above the :cfunc:`main` function. Also, insert the
 following two statements directly after :cfunc:`Py_Initialize`::
+Insert the above code just above the :c:func:`main` function. Also, insert the
+following two statements directly after :c:func:`Py_Initialize`::
    numargs = argc;
 …
 These two lines initialize the ``numargs`` variable, and make the
 :func:`emb.numargs` function accessible to the embedded Python interpreter.
+With these extensions, the Python script can do things like ::
+With these extensions, the Python script can do things like
+.. code-block:: python
    import emb
 …
 .. _link-reqs:
+Linking Requirements
+====================
+While the :program:`configure` script shipped with the Python sources will
+correctly build Python to export the symbols needed by dynamically linked
+extensions, this is not automatically inherited by applications which embed the
+Python library statically, at least on Unix.  This is an issue when the
+application is linked to the static runtime library (:file:`libpython.a`) and
+needs to load dynamic extensions (implemented as :file:`.so` files).
+The problem is that some entry points are defined by the Python runtime solely
+for extension modules to use.  If the embedding application does not use any of
+these entry points, some linkers will not include those entries in the symbol
+table of the finished executable.  Some additional options are needed to inform
+the linker not to remove these symbols.
+Determining the right options to use for any given platform can be quite
+difficult, but fortunately the Python configuration already has those values.
+To retrieve them from an installed Python interpreter, start an interactive
+interpreter and have a short session like this::
+   >>> import distutils.sysconfig
+   >>> distutils.sysconfig.get_config_var('LINKFORSHARED')
+Compiling and Linking under Unix-like systems
+=============================================
+It is not necessarily trivial to find the right flags to pass to your
+compiler (and linker) in order to embed the Python interpreter into your
+application, particularly because Python needs to load library modules
+implemented as C dynamic extensions (:file:`.so` files) linked against
+it.
+To find out the required compiler and linker flags, you can execute the
+:file:`python{X.Y}-config` script which is generated as part of the
+installation process (a :file:`python-config` script may also be
+available).  This script has several options, of which the following will
+be directly useful to you:
+* ``pythonX.Y-config --cflags`` will give you the recommended flags when
+  compiling::
+   $ /opt/bin/python2.7-config --cflags
+   -I/opt/include/python2.7 -fno-strict-aliasing -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes
+* ``pythonX.Y-config --ldflags`` will give you the recommended flags when
+  linking::
+   $ /opt/bin/python2.7-config --ldflags
+   -L/opt/lib/python2.7/config -lpthread -ldl -lutil -lm -lpython2.7 -Xlinker -export-dynamic
+.. note::
+   To avoid confusion between several Python installations (and especially
+   between the system Python and your own compiled Python), it is recommended
+   that you use the absolute path to :file:`python{X.Y}-config`, as in the above
+   example.
+If this procedure doesn't work for you (it is not guaranteed to work for
+all Unix-like platforms; however, we welcome :ref:`bug reports <reporting-bugs>`)
+you will have to read your system's documentation about dynamic linking and/or
+examine Python's :file:`Makefile` (use :func:`sysconfig.get_makefile_filename`
+to find its location) and compilation
+options.  In this case, the :mod:`sysconfig` module is a useful tool to
+programmatically extract the configuration values that you will want to
+combine together.  For example:
+.. code-block:: python
+   >>> import sysconfig
+   >>> sysconfig.get_config_var('LIBS')
+   '-lpthread -ldl  -lutil'
+   >>> sysconfig.get_config_var('LINKFORSHARED')
    '-Xlinker -export-dynamic'
+.. index:: module: distutils.sysconfig
+The contents of the string presented will be the options that should be used.
+If the string is empty, there's no need to add any additional options.  The
+:const:`LINKFORSHARED` definition corresponds to the variable of the same name
+in Python's top-level :file:`Makefile`.
+.. XXX similar documentation for Windows missing

python/vendor/current/Doc/extending/extending.rst

-              r2
+              r388
 Let's create an extension module called ``spam`` (the favorite food of Monty
 Python fans...) and let's say we want to create a Python interface to the C
 library function :cfunc:`system`. [#]_ This function takes a null-terminated
+library function :c:func:`system`. [#]_ This function takes a null-terminated
 character string as argument and returns an integer.  We want this function to
 be callable from Python as follows::
 …
 includes a few standard header files: ``<stdio.h>``, ``<string.h>``,
 ``<errno.h>``, and ``<stdlib.h>``.  If the latter header file does not exist on
 your system, it declares the functions :cfunc:`malloc`, :cfunc:`free` and
 :cfunc:`realloc` directly.
+your system, it declares the functions :c:func:`malloc`, :c:func:`free` and
+:c:func:`realloc` directly.
 The next thing we add to our module file is the C function that will be called
 …
 and *args*.
+The *self* argument is only used when the C function implements a built-in
+method, not a function. In the example, *self* will always be a *NULL* pointer,
+since we are defining a function, not a method.  (This is done so that the
+interpreter doesn't have to understand two different types of C functions.)
+The *self* argument points to the module object for module-level functions;
+for a method it would point to the object instance.
 The *args* argument will be a pointer to a Python tuple object containing the
 …
 argument list.  The arguments are Python objects --- in order to do anything
 with them in our C function we have to convert them to C values.  The function
 :cfunc:`PyArg_ParseTuple` in the Python API checks the argument types and
+:c:func:`PyArg_ParseTuple` in the Python API checks the argument types and
 converts them to C values.  It uses a template string to determine the required
 types of the arguments as well as the types of the C variables into which to
 store the converted values.  More about this later.
 :cfunc:`PyArg_ParseTuple` returns true (nonzero) if all arguments have the right
+:c:func:`PyArg_ParseTuple` returns true (nonzero) if all arguments have the right
 type and its components have been stored in the variables whose addresses are
 passed.  It returns false (zero) if an invalid argument list was passed.  In the
 …
 The Python API defines a number of functions to set various types of exceptions.
 The most common one is :cfunc:`PyErr_SetString`.  Its arguments are an exception
+The most common one is :c:func:`PyErr_SetString`.  Its arguments are an exception
 object and a C string.  The exception object is usually a predefined object like
 :cdata:`PyExc_ZeroDivisionError`.  The C string indicates the cause of the error
+:c:data:`PyExc_ZeroDivisionError`.  The C string indicates the cause of the error
 and is converted to a Python string object and stored as the "associated value"
 of the exception.
 Another useful function is :cfunc:`PyErr_SetFromErrno`, which only takes an
+Another useful function is :c:func:`PyErr_SetFromErrno`, which only takes an
 exception argument and constructs the associated value by inspection of the
 global variable :cdata:`errno`.  The most general function is
 :cfunc:`PyErr_SetObject`, which takes two object arguments, the exception and
 its associated value.  You don't need to :cfunc:`Py_INCREF` the objects passed
+global variable :c:data:`errno`.  The most general function is
+:c:func:`PyErr_SetObject`, which takes two object arguments, the exception and
+its associated value.  You don't need to :c:func:`Py_INCREF` the objects passed
 to any of these functions.
 You can test non-destructively whether an exception has been set with
 :cfunc:`PyErr_Occurred`.  This returns the current exception object, or *NULL*
+:c:func:`PyErr_Occurred`.  This returns the current exception object, or *NULL*
 if no exception has occurred.  You normally don't need to call
 :cfunc:`PyErr_Occurred` to see whether an error occurred in a function call,
+:c:func:`PyErr_Occurred` to see whether an error occurred in a function call,
 since you should be able to tell from the return value.
 When a function *f* that calls another function *g* detects that the latter
 fails, *f* should itself return an error value (usually *NULL* or ``-1``).  It
 should *not* call one of the :cfunc:`PyErr_\*` functions --- one has already
+should *not* call one of the :c:func:`PyErr_\*` functions --- one has already
 been called by *g*. *f*'s caller is then supposed to also return an error
 indication to *its* caller, again *without* calling :cfunc:`PyErr_\*`, and so on
+indication to *its* caller, again *without* calling :c:func:`PyErr_\*`, and so on
 --- the most detailed cause of the error was already reported by the function
 that first detected it.  Once the error reaches the Python interpreter's main
 …
 (There are situations where a module can actually give a more detailed error
 message by calling another :cfunc:`PyErr_\*` function, and in such cases it is
+message by calling another :c:func:`PyErr_\*` function, and in such cases it is
 fine to do so.  As a general rule, however, this is not necessary, and can cause
 information about the cause of the error to be lost: most operations can fail
 …
 To ignore an exception set by a function call that failed, the exception
 condition must be cleared explicitly by calling :cfunc:`PyErr_Clear`.  The only
 time C code should call :cfunc:`PyErr_Clear` is if it doesn't want to pass the
+condition must be cleared explicitly by calling :c:func:`PyErr_Clear`.  The only
+time C code should call :c:func:`PyErr_Clear` is if it doesn't want to pass the
 error on to the interpreter but wants to handle it completely by itself
 (possibly by trying something else, or pretending nothing went wrong).
 Every failing :cfunc:`malloc` call must be turned into an exception --- the
 direct caller of :cfunc:`malloc` (or :cfunc:`realloc`) must call
 :cfunc:`PyErr_NoMemory` and return a failure indicator itself.  All the
 object-creating functions (for example, :cfunc:`PyInt_FromLong`) already do
 this, so this note is only relevant to those who call :cfunc:`malloc` directly.
 Also note that, with the important exception of :cfunc:`PyArg_ParseTuple` and
+Every failing :c:func:`malloc` call must be turned into an exception --- the
+direct caller of :c:func:`malloc` (or :c:func:`realloc`) must call
+:c:func:`PyErr_NoMemory` and return a failure indicator itself.  All the
+object-creating functions (for example, :c:func:`PyInt_FromLong`) already do
+this, so this note is only relevant to those who call :c:func:`malloc` directly.
+Also note that, with the important exception of :c:func:`PyArg_ParseTuple` and
 friends, functions that return an integer status usually return a positive value
 or zero for success and ``-1`` for failure, like Unix system calls.
 Finally, be careful to clean up garbage (by making :cfunc:`Py_XDECREF` or
 :cfunc:`Py_DECREF` calls for objects you have already created) when you return
+Finally, be careful to clean up garbage (by making :c:func:`Py_XDECREF` or
+:c:func:`Py_DECREF` calls for objects you have already created) when you return
 an error indicator!
 The choice of which exception to raise is entirely yours.  There are predeclared
 C objects corresponding to all built-in Python exceptions, such as
 :cdata:`PyExc_ZeroDivisionError`, which you can use directly. Of course, you
 should choose exceptions wisely --- don't use :cdata:`PyExc_TypeError` to mean
 that a file couldn't be opened (that should probably be :cdata:`PyExc_IOError`).
 If something's wrong with the argument list, the :cfunc:`PyArg_ParseTuple`
 function usually raises :cdata:`PyExc_TypeError`.  If you have an argument whose
+:c:data:`PyExc_ZeroDivisionError`, which you can use directly. Of course, you
+should choose exceptions wisely --- don't use :c:data:`PyExc_TypeError` to mean
+that a file couldn't be opened (that should probably be :c:data:`PyExc_IOError`).
+If something's wrong with the argument list, the :c:func:`PyArg_ParseTuple`
+function usually raises :c:data:`PyExc_TypeError`.  If you have an argument whose
 value must be in a particular range or must satisfy other conditions,
 :cdata:`PyExc_ValueError` is appropriate.
+:c:data:`PyExc_ValueError` is appropriate.
 You can also define a new exception that is unique to your module. For this, you
 …
    static PyObject *SpamError;
 and initialize it in your module's initialization function (:cfunc:`initspam`)
+and initialize it in your module's initialization function (:c:func:`initspam`)
 with an exception object (leaving out the error checking for now)::
 …
 Note that the Python name for the exception object is :exc:`spam.error`.  The
 :cfunc:`PyErr_NewException` function may create a class with the base class
+:c:func:`PyErr_NewException` function may create a class with the base class
 being :exc:`Exception` (unless another class is passed in instead of *NULL*),
 described in :ref:`bltin-exceptions`.
 Note also that the :cdata:`SpamError` variable retains a reference to the newly
+Note also that the :c:data:`SpamError` variable retains a reference to the newly
 created exception class; this is intentional!  Since the exception could be
 removed from the module by external code, an owned reference to the class is
 needed to ensure that it will not be discarded, causing :cdata:`SpamError` to
+needed to ensure that it will not be discarded, causing :c:data:`SpamError` to
 become a dangling pointer. Should it become a dangling pointer, C code which
 raises the exception could cause a core dump or other unintended side effects.
 We discuss the use of PyMODINIT_FUNC as a function return type later in this
+We discuss the use of ``PyMODINIT_FUNC`` as a function return type later in this
 sample.
+The :exc:`spam.error` exception can be raised in your extension module using a
+call to :c:func:`PyErr_SetString` as shown below::
+   static PyObject *
+   spam_system(PyObject *self, PyObject *args)
+   {
+       const char *command;
+       int sts;
+       if (!PyArg_ParseTuple(args, "s", &command))
+           return NULL;
+       sts = system(command);
+       if (sts < 0) {
+           PyErr_SetString(SpamError, "System command failed");
+           return NULL;
+       }
+       return PyLong_FromLong(sts);
+   }
 …
 It returns *NULL* (the error indicator for functions returning object pointers)
 if an error is detected in the argument list, relying on the exception set by
 :cfunc:`PyArg_ParseTuple`.  Otherwise the string value of the argument has been
 copied to the local variable :cdata:`command`.  This is a pointer assignment and
+:c:func:`PyArg_ParseTuple`.  Otherwise the string value of the argument has been
+copied to the local variable :c:data:`command`.  This is a pointer assignment and
 you are not supposed to modify the string to which it points (so in Standard C,
 the variable :cdata:`command` should properly be declared as ``const char
+the variable :c:data:`command` should properly be declared as ``const char
 *command``).
 The next statement is a call to the Unix function :cfunc:`system`, passing it
 the string we just got from :cfunc:`PyArg_ParseTuple`::
+The next statement is a call to the Unix function :c:func:`system`, passing it
+the string we just got from :c:func:`PyArg_ParseTuple`::
    sts = system(command);
 Our :func:`spam.system` function must return the value of :cdata:`sts` as a
 Python object.  This is done using the function :cfunc:`Py_BuildValue`, which is
 something like the inverse of :cfunc:`PyArg_ParseTuple`: it takes a format
+Our :func:`spam.system` function must return the value of :c:data:`sts` as a
+Python object.  This is done using the function :c:func:`Py_BuildValue`, which is
+something like the inverse of :c:func:`PyArg_ParseTuple`: it takes a format
 string and an arbitrary number of C values, and returns a new Python object.
 More info on :cfunc:`Py_BuildValue` is given later. ::
+More info on :c:func:`Py_BuildValue` is given later. ::
    return Py_BuildValue("i", sts);
 …
 If you have a C function that returns no useful argument (a function returning
 :ctype:`void`), the corresponding Python function must return ``None``.   You
 need this idiom to do so (which is implemented by the :cmacro:`Py_RETURN_NONE`
+:c:type:`void`), the corresponding Python function must return ``None``.   You
+need this idiom to do so (which is implemented by the :c:macro:`Py_RETURN_NONE`
 macro)::
 …
    return Py_None;
 :cdata:`Py_None` is the C name for the special Python object ``None``.  It is a
+:c:data:`Py_None` is the C name for the special Python object ``None``.  It is a
 genuine Python object rather than a *NULL* pointer, which means "error" in most
 contexts, as we have seen.
 …
 =====================================================
 I promised to show how :cfunc:`spam_system` is called from Python programs.
+I promised to show how :c:func:`spam_system` is called from Python programs.
 First, we need to list its name and address in a "method table"::
 …
 the calling convention to be used for the C function.  It should normally always
 be ``METH_VARARGS`` or ``METH_VARARGS | METH_KEYWORDS``; a value of ``0`` means
 that an obsolete variant of :cfunc:`PyArg_ParseTuple` is used.
+that an obsolete variant of :c:func:`PyArg_ParseTuple` is used.
 When using only ``METH_VARARGS``, the function should expect the Python-level
 parameters to be passed in as a tuple acceptable for parsing via
 :cfunc:`PyArg_ParseTuple`; more information on this function is provided below.
+:c:func:`PyArg_ParseTuple`; more information on this function is provided below.
 The :const:`METH_KEYWORDS` bit may be set in the third field if keyword
 arguments should be passed to the function.  In this case, the C function should
 accept a third ``PyObject *`` parameter which will be a dictionary of keywords.
 Use :cfunc:`PyArg_ParseTupleAndKeywords` to parse the arguments to such a
+Use :c:func:`PyArg_ParseTupleAndKeywords` to parse the arguments to such a
 function.
 The method table must be passed to the interpreter in the module's
 initialization function.  The initialization function must be named
 :cfunc:`initname`, where *name* is the name of the module, and should be the
+:c:func:`initname`, where *name* is the name of the module, and should be the
 only non-\ ``static`` item defined in the module file::
 …
 When the Python program imports module :mod:`spam` for the first time,
 :cfunc:`initspam` is called. (See below for comments about embedding Python.)
 It calls :cfunc:`Py_InitModule`, which creates a "module object" (which is
+:c:func:`initspam` is called. (See below for comments about embedding Python.)
+It calls :c:func:`Py_InitModule`, which creates a "module object" (which is
 inserted in the dictionary ``sys.modules`` under the key ``"spam"``), and
 inserts built-in function objects into the newly created module based upon the
 table (an array of :ctype:`PyMethodDef` structures) that was passed as its
 second argument. :cfunc:`Py_InitModule` returns a pointer to the module object
+table (an array of :c:type:`PyMethodDef` structures) that was passed as its
+second argument. :c:func:`Py_InitModule` returns a pointer to the module object
 that it creates (which is unused here).  It may abort with a fatal error for
 certain errors, or return *NULL* if the module could not be initialized
 satisfactorily.
 When embedding Python, the :cfunc:`initspam` function is not called
 automatically unless there's an entry in the :cdata:`_PyImport_Inittab` table.
+When embedding Python, the :c:func:`initspam` function is not called
+automatically unless there's an entry in the :c:data:`_PyImport_Inittab` table.
 The easiest way to handle this is to statically initialize your
 statically-linked modules by directly calling :cfunc:`initspam` after the call
 to :cfunc:`Py_Initialize`::
+statically-linked modules by directly calling :c:func:`initspam` after the call
+to :c:func:`Py_Initialize`::
    int
 …
        initspam();
+       ...
 An example may be found in the file :file:`Demo/embed/demo.c` in the Python
 source distribution.
 …
    Removing entries from ``sys.modules`` or importing compiled modules into
    multiple interpreters within a process (or following a :cfunc:`fork` without an
    intervening :cfunc:`exec`) can create problems for some extension modules.
+   multiple interpreters within a process (or following a :c:func:`fork` without an
+   intervening :c:func:`exec`) can create problems for some extension modules.
    Extension module authors should exercise caution when initializing internal data
    structures. Note also that the :func:`reload` function can be used with
    extension modules, and will call the module initialization function
    (:cfunc:`initspam` in the example), but will not load the module again if it was
+   (:c:func:`initspam` in the example), but will not load the module again if it was
    loaded from a dynamically loadable object file (:file:`.so` on Unix,
    :file:`.dll` on Windows).
 …
 A more substantial example module is included in the Python source distribution
 as :file:`Modules/xxmodule.c`.  This file may be used as a  template or simply
+read as an example.  The :program:`modulator.py` script included in the source
+distribution or Windows install provides  a simple graphical user interface for
+declaring the functions and objects which a module should implement, and can
+generate a template which can be filled in.  The script lives in the
+:file:`Tools/modulator/` directory; see the :file:`README` file there for more
+information.
+read as an example.
 …
 you the Python function object.  You should provide a function (or some other
 interface) to do this.  When this function is called, save a pointer to the
 Python function object (be careful to :cfunc:`Py_INCREF` it!) in a global
+Python function object (be careful to :c:func:`Py_INCREF` it!) in a global
 variable --- or wherever you see fit. For example, the following function might
 be part of a module definition::
 …
 This function must be registered with the interpreter using the
 :const:`METH_VARARGS` flag; this is described in section :ref:`methodtable`.  The
 :cfunc:`PyArg_ParseTuple` function and its arguments are documented in section
+:c:func:`PyArg_ParseTuple` function and its arguments are documented in section
 :ref:`parsetuple`.
 The macros :cfunc:`Py_XINCREF` and :cfunc:`Py_XDECREF` increment/decrement the
+The macros :c:func:`Py_XINCREF` and :c:func:`Py_XDECREF` increment/decrement the
 reference count of an object and are safe in the presence of *NULL* pointers
 (but note that *temp* will not be  *NULL* in this context).  More info on them
 …
 Later, when it is time to call the function, you call the C function
 :cfunc:`PyObject_CallObject`.  This function has two arguments, both pointers to
+:c:func:`PyObject_CallObject`.  This function has two arguments, both pointers to
 arbitrary Python objects: the Python function, and the argument list.  The
 argument list must always be a tuple object, whose length is the number of
 arguments.  To call the Python function with no arguments, pass in NULL, or
 an empty tuple; to call it with one argument, pass a singleton tuple.
 :cfunc:`Py_BuildValue` returns a tuple when its format string consists of zero
+:c:func:`Py_BuildValue` returns a tuple when its format string consists of zero
 or more format codes between parentheses.  For example::
 …
    Py_DECREF(arglist);
 :cfunc:`PyObject_CallObject` returns a Python object pointer: this is the return
 value of the Python function.  :cfunc:`PyObject_CallObject` is
+:c:func:`PyObject_CallObject` returns a Python object pointer: this is the return
+value of the Python function.  :c:func:`PyObject_CallObject` is
 "reference-count-neutral" with respect to its arguments.  In the example a new
 tuple was created to serve as the argument list, which is :cfunc:`Py_DECREF`\
 -ed immediately after the call.
 The return value of :cfunc:`PyObject_CallObject` is "new": either it is a brand
+tuple was created to serve as the argument list, which is :c:func:`Py_DECREF`\
+-ed immediately after the :c:func:`PyObject_CallObject` call.
+The return value of :c:func:`PyObject_CallObject` is "new": either it is a brand
 new object, or it is an existing object whose reference count has been
 incremented.  So, unless you want to save it in a global variable, you should
 somehow :cfunc:`Py_DECREF` the result, even (especially!) if you are not
+somehow :c:func:`Py_DECREF` the result, even (especially!) if you are not
 interested in its value.
 Before you do this, however, it is important to check that the return value
 isn't *NULL*.  If it is, the Python function terminated by raising an exception.
 If the C code that called :cfunc:`PyObject_CallObject` is called from Python, it
+If the C code that called :c:func:`PyObject_CallObject` is called from Python, it
 should now return an error indication to its Python caller, so the interpreter
 can print a stack trace, or the calling Python code can handle the exception.
 If this is not possible or desirable, the exception should be cleared by calling
 :cfunc:`PyErr_Clear`.  For example::
+:c:func:`PyErr_Clear`.  For example::
    if (result == NULL)
 …
 Depending on the desired interface to the Python callback function, you may also
 have to provide an argument list to :cfunc:`PyObject_CallObject`.  In some cases
+have to provide an argument list to :c:func:`PyObject_CallObject`.  In some cases
 the argument list is also provided by the Python program, through the same
 interface that specified the callback function.  It can then be saved and used
 in the same manner as the function object.  In other cases, you may have to
 construct a new tuple to pass as the argument list.  The simplest way to do this
 is to call :cfunc:`Py_BuildValue`.  For example, if you want to pass an integral
+is to call :c:func:`Py_BuildValue`.  For example, if you want to pass an integral
 event code, you might use the following code::
 …
 Note the placement of ``Py_DECREF(arglist)`` immediately after the call, before
 the error check!  Also note that strictly speaking this code is not complete:
 :cfunc:`Py_BuildValue` may run out of memory, and this should be checked.
+:c:func:`Py_BuildValue` may run out of memory, and this should be checked.
 You may also call a function with keyword arguments by using
 :cfunc:`PyObject_Call`, which supports arguments and keyword arguments.  As in
 the above example, we use :cfunc:`Py_BuildValue` to construct the dictionary. ::
+:c:func:`PyObject_Call`, which supports arguments and keyword arguments.  As in
+the above example, we use :c:func:`Py_BuildValue` to construct the dictionary. ::
    PyObject *dict;
 …
 .. index:: single: PyArg_ParseTuple()
 The :cfunc:`PyArg_ParseTuple` function is declared as follows::
+The :c:func:`PyArg_ParseTuple` function is declared as follows::
    int PyArg_ParseTuple(PyObject *arg, char *format, ...);
 …
 determined by the format string.
 Note that while :cfunc:`PyArg_ParseTuple` checks that the Python arguments have
+Note that while :c:func:`PyArg_ParseTuple` checks that the Python arguments have
 the required types, it cannot check the validity of the addresses of C variables
 passed to the call: if you make mistakes there, your code will probably crash or
 …
 .. index:: single: PyArg_ParseTupleAndKeywords()
 The :cfunc:`PyArg_ParseTupleAndKeywords` function is declared as follows::
+The :c:func:`PyArg_ParseTupleAndKeywords` function is declared as follows::
    int PyArg_ParseTupleAndKeywords(PyObject *arg, PyObject *kwdict,
 …
 The *arg* and *format* parameters are identical to those of the
 :cfunc:`PyArg_ParseTuple` function.  The *kwdict* parameter is the dictionary of
+:c:func:`PyArg_ParseTuple` function.  The *kwdict* parameter is the dictionary of
 keywords received as the third parameter from the Python runtime.  The *kwlist*
 parameter is a *NULL*-terminated list of strings which identify the parameters;
 the names are matched with the type information from *format* from left to
 right.  On success, :cfunc:`PyArg_ParseTupleAndKeywords` returns true, otherwise
+right.  On success, :c:func:`PyArg_ParseTupleAndKeywords` returns true, otherwise
 it returns false and raises an appropriate exception.
 …
 =========================
 This function is the counterpart to :cfunc:`PyArg_ParseTuple`.  It is declared
+This function is the counterpart to :c:func:`PyArg_ParseTuple`.  It is declared
 as follows::
 …
 It recognizes a set of format units similar to the ones recognized by
 :cfunc:`PyArg_ParseTuple`, but the arguments (which are input to the function,
+:c:func:`PyArg_ParseTuple`, but the arguments (which are input to the function,
 not output) must not be pointers, just values.  It returns a new Python object,
 suitable for returning from a C function called from Python.
 One difference with :cfunc:`PyArg_ParseTuple`: while the latter requires its
+One difference with :c:func:`PyArg_ParseTuple`: while the latter requires its
 first argument to be a tuple (since Python argument lists are always represented
 as tuples internally), :cfunc:`Py_BuildValue` does not always build a tuple.  It
+as tuples internally), :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
 …
 In languages like C or C++, the programmer is responsible for dynamic allocation
 and deallocation of memory on the heap.  In C, this is done using the functions
 :cfunc:`malloc` and :cfunc:`free`.  In C++, the operators ``new`` and
+:c:func:`malloc` and :c:func:`free`.  In C++, the operators ``new`` and
 ``delete`` are used with essentially the same meaning and we'll restrict
 the following discussion to the C case.
 Every block of memory allocated with :cfunc:`malloc` should eventually be
 returned to the pool of available memory by exactly one call to :cfunc:`free`.
 It is important to call :cfunc:`free` at the right time.  If a block's address
 is forgotten but :cfunc:`free` is not called for it, the memory it occupies
+Every block of memory allocated with :c:func:`malloc` should eventually be
+returned to the pool of available memory by exactly one call to :c:func:`free`.
+It is important to call :c:func:`free` at the right time.  If a block's address
+is forgotten but :c:func:`free` is not called for it, the memory it occupies
 cannot be reused until the program terminates.  This is called a :dfn:`memory
 leak`.  On the other hand, if a program calls :cfunc:`free` for a block and then
+leak`.  On the other hand, if a program calls :c:func:`free` for a block and then
 continues to use the block, it creates a conflict with re-use of the block
 through another :cfunc:`malloc` call.  This is called :dfn:`using freed memory`.
+through another :c:func:`malloc` call.  This is called :dfn:`using freed memory`.
 It has the same bad consequences as referencing uninitialized data --- core
 dumps, wrong results, mysterious crashes.
 …
 strategy that minimizes this kind of errors.
 Since Python makes heavy use of :cfunc:`malloc` and :cfunc:`free`, it needs a
+Since Python makes heavy use of :c:func:`malloc` and :c:func:`free`, it needs a
 strategy to avoid memory leaks as well as the use of freed memory.  The chosen
 method is called :dfn:`reference counting`.  The principle is simple: every
 …
 strategy, hence my use of "automatic" to distinguish the two.)  The big
 advantage of automatic garbage collection is that the user doesn't need to call
 :cfunc:`free` explicitly.  (Another claimed advantage is an improvement in speed
+:c:func:`free` explicitly.  (Another claimed advantage is an improvement in speed
 or memory usage --- this is no hard fact however.)  The disadvantage is that for
 C, there is no truly portable automatic garbage collector, while reference
 counting can be implemented portably (as long as the functions :cfunc:`malloc`
 and :cfunc:`free` are available --- which the C Standard guarantees). Maybe some
+counting can be implemented portably (as long as the functions :c:func:`malloc`
+and :c:func:`free` are available --- which the C Standard guarantees). Maybe some
 day a sufficiently portable automatic garbage collector will be available for C.
 Until then, we'll have to live with reference counts.
 …
 as there are no finalizers implemented in Python (:meth:`__del__` methods).
 When there are such finalizers, the detector exposes the cycles through the
 :mod:`gc` module (specifically, the
+``garbage`` variable in that module).  The :mod:`gc` module also exposes a way
 to run the detector (the :func:`collect` function), as well as configuration
+:mod:`gc` module (specifically, the :attr:`~gc.garbage` variable in that module).
+The :mod:`gc` module also exposes a way to run the detector (the
+:func:`~gc.collect` function), as well as configuration
 interfaces and the ability to disable the detector at runtime.  The cycle
 detector is considered an optional component; though it is included by default,
 …
 There are two macros, ``Py_INCREF(x)`` and ``Py_DECREF(x)``, which handle the
 incrementing and decrementing of the reference count. :cfunc:`Py_DECREF` also
+incrementing and decrementing of the reference count. :c:func:`Py_DECREF` also
 frees the object when the count reaches zero. For flexibility, it doesn't call
 :cfunc:`free` directly --- rather, it makes a call through a function pointer in
+:c:func:`free` directly --- rather, it makes a call through a function pointer in
 the object's :dfn:`type object`.  For this purpose (and others), every object
 also contains a pointer to its type object.
 …
 :dfn:`own a reference` to an object.  An object's reference count is now defined
 as the number of owned references to it.  The owner of a reference is
 responsible for calling :cfunc:`Py_DECREF` when the reference is no longer
+responsible for calling :c:func:`Py_DECREF` when the reference is no longer
 needed.  Ownership of a reference can be transferred.  There are three ways to
 dispose of an owned reference: pass it on, store it, or call :cfunc:`Py_DECREF`.
+dispose of an owned reference: pass it on, store it, or call :c:func:`Py_DECREF`.
 Forgetting to dispose of an owned reference creates a memory leak.
 It is also possible to :dfn:`borrow` [#]_ a reference to an object.  The
 borrower of a reference should not call :cfunc:`Py_DECREF`.  The borrower must
+borrower of a reference should not call :c:func:`Py_DECREF`.  The borrower must
 not hold on to the object longer than the owner from which it was borrowed.
 Using a borrowed reference after the owner has disposed of it risks using freed
 …
 A borrowed reference can be changed into an owned reference by calling
 :cfunc:`Py_INCREF`.  This does not affect the status of the owner from which the
+:c:func:`Py_INCREF`.  This does not affect the status of the owner from which the
 reference was borrowed --- it creates a new owned reference, and gives full
 owner responsibilities (the new owner must dispose of the reference properly, as
 …
 Most functions that return a reference to an object pass on ownership with the
 reference.  In particular, all functions whose function it is to create a new
 object, such as :cfunc:`PyInt_FromLong` and :cfunc:`Py_BuildValue`, pass
+object, such as :c:func:`PyInt_FromLong` and :c:func:`Py_BuildValue`, pass
 ownership to the receiver.  Even if the object is not actually new, you still
 receive ownership of a new reference to that object.  For instance,
 :cfunc:`PyInt_FromLong` maintains a cache of popular values and can return a
+:c:func:`PyInt_FromLong` maintains a cache of popular values and can return a
 reference to a cached item.
 Many functions that extract objects from other objects also transfer ownership
 with the reference, for instance :cfunc:`PyObject_GetAttrString`.  The picture
+with the reference, for instance :c:func:`PyObject_GetAttrString`.  The picture
 is less clear, here, however, since a few common routines are exceptions:
 :cfunc:`PyTuple_GetItem`, :cfunc:`PyList_GetItem`, :cfunc:`PyDict_GetItem`, and
 :cfunc:`PyDict_GetItemString` all return references that you borrow from the
+:c:func:`PyTuple_GetItem`, :c:func:`PyList_GetItem`, :c:func:`PyDict_GetItem`, and
+:c:func:`PyDict_GetItemString` all return references that you borrow from the
 tuple, list or dictionary.
 The function :cfunc:`PyImport_AddModule` also returns a borrowed reference, even
+The function :c:func:`PyImport_AddModule` also returns a borrowed reference, even
 though it may actually create the object it returns: this is possible because an
 owned reference to the object is stored in ``sys.modules``.
 …
 When you pass an object reference into another function, in general, the
 function borrows the reference from you --- if it needs to store it, it will use
 :cfunc:`Py_INCREF` to become an independent owner.  There are exactly two
 important exceptions to this rule: :cfunc:`PyTuple_SetItem` and
 :cfunc:`PyList_SetItem`.  These functions take over ownership of the item passed
 to them --- even if they fail!  (Note that :cfunc:`PyDict_SetItem` and friends
+:c:func:`Py_INCREF` to become an independent owner.  There are exactly two
+important exceptions to this rule: :c:func:`PyTuple_SetItem` and
+:c:func:`PyList_SetItem`.  These functions take over ownership of the item passed
+to them --- even if they fail!  (Note that :c:func:`PyDict_SetItem` and friends
 don't take over ownership --- they are "normal.")
 …
 reference's lifetime is guaranteed until the function returns.  Only when such a
 borrowed reference must be stored or passed on, it must be turned into an owned
 reference by calling :cfunc:`Py_INCREF`.
+reference by calling :c:func:`Py_INCREF`.
 The object reference returned from a C function that is called from Python must
 …
 interpreter, which can cause the owner of a reference to dispose of it.
 The first and most important case to know about is using :cfunc:`Py_DECREF` on
+The first and most important case to know about is using :c:func:`Py_DECREF` on
 an unrelated object while borrowing a reference to a list item.  For instance::
 …
 Looks harmless, right?  But it's not!
 Let's follow the control flow into :cfunc:`PyList_SetItem`.  The list owns
+Let's follow the control flow into :c:func:`PyList_SetItem`.  The list owns
 references to all its items, so when item 1 is replaced, it has to dispose of
 the original item 1.  Now let's suppose the original item 1 was an instance of a
 …
 Since it is written in Python, the :meth:`__del__` method can execute arbitrary
 Python code.  Could it perhaps do something to invalidate the reference to
 ``item`` in :cfunc:`bug`?  You bet!  Assuming that the list passed into
 :cfunc:`bug` is accessible to the :meth:`__del__` method, it could execute a
+``item`` in :c:func:`bug`?  You bet!  Assuming that the list passed into
+:c:func:`bug` is accessible to the :meth:`__del__` method, it could execute a
 statement to the effect of ``del list[0]``, and assuming this was the last
 reference to that object, it would free the memory associated with it, thereby
 …
 other's way, because there is a global lock protecting Python's entire object
 space.  However, it is possible to temporarily release this lock using the macro
 :cmacro:`Py_BEGIN_ALLOW_THREADS`, and to re-acquire it using
 :cmacro:`Py_END_ALLOW_THREADS`.  This is common around blocking I/O calls, to
+:c:macro:`Py_BEGIN_ALLOW_THREADS`, and to re-acquire it using
+:c:macro:`Py_END_ALLOW_THREADS`.  This is common around blocking I/O calls, to
 let other threads use the processor while waiting for the I/O to complete.
 Obviously, the following function has the same problem as the previous one::
 …
 It is better to test for *NULL* only at the "source:" when a pointer that may be
 *NULL* is received, for example, from :cfunc:`malloc` or from a function that
+*NULL* is received, for example, from :c:func:`malloc` or from a function that
 may raise an exception.
 The macros :cfunc:`Py_INCREF` and :cfunc:`Py_DECREF` do not check for *NULL*
 pointers --- however, their variants :cfunc:`Py_XINCREF` and :cfunc:`Py_XDECREF`
+The macros :c:func:`Py_INCREF` and :c:func:`Py_DECREF` do not check for *NULL*
+pointers --- however, their variants :c:func:`Py_XINCREF` and :c:func:`Py_XDECREF`
 do.
 …
 .. _using-cobjects:
+.. _using-capsules:
 Providing a C API for an Extension Module
 …
 Python provides a special mechanism to pass C-level information (pointers) from
 one extension module to another one: CObjects. A CObject is a Python data type
 which stores a pointer (:ctype:`void \*`).  CObjects can only be created and
+one extension module to another one: Capsules. A Capsule is a Python data type
+which stores a pointer (:c:type:`void \*`).  Capsules can only be created and
 accessed via their C API, but they can be passed around like any other Python
 object. In particular,  they can be assigned to a name in an extension module's
 namespace. Other extension modules can then import this module, retrieve the
 value of this name, and then retrieve the pointer from the CObject.
 There are many ways in which CObjects can be used to export the C API of an
 extension module. Each name could get its own CObject, or all C API pointers
 could be stored in an array whose address is published in a CObject. And the
+value of this name, and then retrieve the pointer from the Capsule.
+There are many ways in which Capsules can be used to export the C API of an
+extension module. Each function could get its own Capsule, or all C API pointers
+could be stored in an array whose address is published in a Capsule. And the
 various tasks of storing and retrieving the pointers can be distributed in
 different ways between the module providing the code and the client modules.
+Whichever method you choose, it's important to name your Capsules properly.
+The function :c:func:`PyCapsule_New` takes a name parameter
+(:c:type:`const char \*`); you're permitted to pass in a *NULL* name, but
+we strongly encourage you to specify a name.  Properly named Capsules provide
+a degree of runtime type-safety; there is no feasible way to tell one unnamed
+Capsule from another.
+In particular, Capsules used to expose C APIs should be given a name following
+this convention::
+    modulename.attributename
+The convenience function :c:func:`PyCapsule_Import` makes it easy to
+load a C API provided via a Capsule, but only if the Capsule's name
+matches this convention.  This behavior gives C API users a high degree
+of certainty that the Capsule they load contains the correct C API.
 The following example demonstrates an approach that puts most of the burden on
 the writer of the exporting module, which is appropriate for commonly used
 library modules. It stores all C API pointers (just one in the example!) in an
 array of :ctype:`void` pointers which becomes the value of a CObject. The header
+array of :c:type:`void` pointers which becomes the value of a Capsule. The header
 file corresponding to the module provides a macro that takes care of importing
 the module and retrieving its C API pointers; client modules only have to call
 …
 The exporting module is a modification of the :mod:`spam` module from section
 :ref:`extending-simpleexample`. The function :func:`spam.system` does not call
 the C library function :cfunc:`system` directly, but a function
 :cfunc:`PySpam_System`, which would of course do something more complicated in
+the C library function :c:func:`system` directly, but a function
+:c:func:`PySpam_System`, which would of course do something more complicated in
 reality (such as adding "spam" to every command). This function
 :cfunc:`PySpam_System` is also exported to other extension modules.
 The function :cfunc:`PySpam_System` is a plain C function, declared
+:c:func:`PySpam_System` is also exported to other extension modules.
+The function :c:func:`PySpam_System` is a plain C function, declared
 ``static`` like everything else::
 …
+   }
 The function :cfunc:`spam_system` is modified in a trivial way::
+The function :c:func:`spam_system` is modified in a trivial way::
    static PyObject *
 …
        PySpam_API[PySpam_System_NUM] = (void *)PySpam_System;
        /* Create a CObject containing the API pointer array's address */
        c_api_object = PyCObject_FromVoidPtr((void *)PySpam_API, NULL);
+       /* Create a Capsule containing the API pointer array's address */
+       c_api_object = PyCapsule_New((void *)PySpam_API, "spam._C_API", NULL);
        if (c_api_object != NULL)
 …
     (*(PySpam_System_RETURN (*)PySpam_System_PROTO) PySpam_API[PySpam_System_NUM])
+   /* Return -1 and set exception on error, 0 on success. */
+   /* Return -1 on error, 0 on success.
+    * PyCapsule_Import will set an exception if there's an error.
+    */
    static int
    import_spam(void)
+   {
+       PyObject *c_api_object;
+       PyObject *module;
+       module = PyImport_ImportModule("spam");
+       if (module == NULL)
+           return -1;
+       c_api_object = PyObject_GetAttrString(module, "_C_API");
+       if (c_api_object == NULL) {
+           Py_DECREF(module);
+           return -1;
+       }
+       if (PyCObject_Check(c_api_object))
+           PySpam_API = (void **)PyCObject_AsVoidPtr(c_api_object);
+       Py_DECREF(c_api_object);
+       Py_DECREF(module);
+       return 0;
+       PySpam_API = (void **)PyCapsule_Import("spam._C_API", 0);
+       return (PySpam_API != NULL) ? 0 : -1;
+   }
 …
 All that a client module must do in order to have access to the function
 :cfunc:`PySpam_System` is to call the function (or rather macro)
 :cfunc:`import_spam` in its initialization function::
+:c:func:`PySpam_System` is to call the function (or rather macro)
+:c:func:`import_spam` in its initialization function::
    PyMODINIT_FUNC
 …
 that is exported, so it has to be learned only once.
 Finally it should be mentioned that CObjects offer additional functionality,
+Finally it should be mentioned that Capsules offer additional functionality,
 which is especially useful for memory allocation and deallocation of the pointer
 stored in a CObject. The details are described in the Python/C API Reference
 Manual in the section :ref:`cobjects` and in the implementation of CObjects (files
 :file:`Include/cobject.h` and :file:`Objects/cobject.c` in the Python source
+stored in a Capsule. The details are described in the Python/C API Reference
+Manual in the section :ref:`capsules` and in the implementation of Capsules (files
+:file:`Include/pycapsule.h` and :file:`Objects/pycapsule.c` in the Python source
 code distribution).

python/vendor/current/Doc/extending/index.rst

-              r2
+              r388
 ##################################################
-:Release: |version|
-:Date: |today|
 This document describes how to write modules in C or C++ to extend the Python
 interpreter with new modules.  Those modules can define new functions but also
+new object types and their methods.  The document also describes how to embed
 the Python interpreter in another application, for use as an extension language.
+Finally, it shows how to compile and link extension modules so that they can be
+loaded dynamically (at run time) into the interpreter, if the underlying
 operating system supports this feature.
+interpreter with new modules.  Those modules can not only define new functions
+but also new object types and their methods.  The document also describes how
+to embed the Python interpreter in another application, for use as an extension
+language.  Finally, it shows how to compile and link extension modules so that
+they can be loaded dynamically (at run time) into the interpreter, if the
+underlying operating system supports this feature.
 This document assumes basic knowledge about Python.  For an informal

python/vendor/current/Doc/extending/newtypes.rst

-              r2
+              r388
 The Python runtime sees all Python objects as variables of type
 :ctype:`PyObject\*`.  A :ctype:`PyObject` is not a very magnificent object - it
+:c:type:`PyObject\*`.  A :c:type:`PyObject` is not a very magnificent object - it
 just contains the refcount and a pointer to the object's "type object".  This is
 where the action is; the type object determines which (C) functions get called
 when, for instance, an attribute gets looked up on an object or it is multiplied
+by another object.  These C functions are called "type methods" to distinguish
+them from things like ``[].append`` (which we call "object methods").
+by another object.  These C functions are called "type methods".
 So, if you want to define a new object type, you need to create a new type
 …
    };
 Now if you go and look up the definition of :ctype:`PyTypeObject` in
+Now if you go and look up the definition of :c:type:`PyTypeObject` in
 :file:`object.h` you'll see that it has many more fields that the definition
 above.  The remaining fields will be filled with zeros by the C compiler, and
 …
 as the type of a type object is "type", but this isn't strictly conforming C and
 some compilers complain.  Fortunately, this member will be filled in for us by
 :cfunc:`PyType_Ready`. ::
+:c:func:`PyType_Ready`. ::
 ,                          /* ob_size */
 …
 This is so that Python knows how much memory to allocate when you call
 :cfunc:`PyObject_New`.
+:c:func:`PyObject_New`.
 .. note::
    If you want your type to be subclassable from Python, and your type has the same
    :attr:`tp_basicsize` as its base type, you may have problems with multiple
+   :c:member:`~PyTypeObject.tp_basicsize` as its base type, you may have problems with multiple
    inheritance.  A Python subclass of your type will have to list your type first
    in its :attr:`__bases__`, or else it will not be able to call your type's
+   in its :attr:`~class.__bases__`, or else it will not be able to call your type's
    :meth:`__new__` method without getting an error.  You can avoid this problem by
    ensuring that your type has a larger value for :attr:`tp_basicsize` than its
+   ensuring that your type has a larger value for :c:member:`~PyTypeObject.tp_basicsize` than its
    base type does.  Most of the time, this will be true anyway, because either your
    base type will be :class:`object`, or else you will be adding data members to
 …
 members defined by the current version of Python.
 We provide a doc string for the type in :attr:`tp_doc`. ::
+We provide a doc string for the type in :c:member:`~PyTypeObject.tp_doc`. ::
    "Noddy objects",           /* tp_doc */
 …
 For now, all we want to be able to do is to create new :class:`Noddy` objects.
 To enable object creation, we have to provide a :attr:`tp_new` implementation.
+To enable object creation, we have to provide a :c:member:`~PyTypeObject.tp_new` implementation.
 In this case, we can just use the default implementation provided by the API
 function :cfunc:`PyType_GenericNew`.  We'd like to just assign this to the
 :attr:`tp_new` slot, but we can't, for portability sake, On some platforms or
+function :c:func:`PyType_GenericNew`.  We'd like to just assign this to the
+:c:member:`~PyTypeObject.tp_new` slot, but we can't, for portability sake, On some platforms or
 compilers, we can't statically initialize a structure member with a function
 defined in another C module, so, instead, we'll assign the :attr:`tp_new` slot
+defined in another C module, so, instead, we'll assign the :c:member:`~PyTypeObject.tp_new` slot
 in the module initialization function just before calling
 :cfunc:`PyType_Ready`::
+:c:func:`PyType_Ready`::
    noddy_NoddyType.tp_new = PyType_GenericNew;
 …
 Everything else in the file should be familiar, except for some code in
 :cfunc:`initnoddy`::
+:c:func:`initnoddy`::
    if (PyType_Ready(&noddy_NoddyType) < 0)
 …
 We've added an extra include::
    #include "structmember.h"
+   #include <structmember.h>
 This include provides declarations that we use to handle attributes, as
 …
+   }
 which is assigned to the :attr:`tp_dealloc` member::
+which is assigned to the :c:member:`~PyTypeObject.tp_dealloc` member::
    (destructor)Noddy_dealloc, /*tp_dealloc*/
 This method decrements the reference counts of the two Python attributes. We use
 :cfunc:`Py_XDECREF` here because the :attr:`first` and :attr:`last` members
 could be *NULL*.  It then calls the :attr:`tp_free` member of the object's type
+:c:func:`Py_XDECREF` here because the :attr:`first` and :attr:`last` members
+could be *NULL*.  It then calls the :c:member:`~PyTypeObject.tp_free` member of the object's type
 to free the object's memory.  Note that the object's type might not be
 :class:`NoddyType`, because the object may be an instance of a subclass.
 …
+   }
 and install it in the :attr:`tp_new` member::
+and install it in the :c:member:`~PyTypeObject.tp_new` member::
    Noddy_new,                 /* tp_new */
 …
 to make sure that the initial values of the members :attr:`first` and
 :attr:`last` are not *NULL*. If we didn't care whether the initial values were
 *NULL*, we could have used :cfunc:`PyType_GenericNew` as our new method, as we
 did before.  :cfunc:`PyType_GenericNew` initializes all of the instance variable
+*NULL*, we could have used :c:func:`PyType_GenericNew` as our new method, as we
+did before.  :c:func:`PyType_GenericNew` initializes all of the instance variable
 members to *NULL*.
 …
 methods. Note that if the type supports subclassing, the type passed may not be
 the type being defined.  The new method calls the tp_alloc slot to allocate
 memory. We don't fill the :attr:`tp_alloc` slot ourselves. Rather
 :cfunc:`PyType_Ready` fills it for us by inheriting it from our base class,
+memory. We don't fill the :c:member:`~PyTypeObject.tp_alloc` slot ourselves. Rather
+:c:func:`PyType_Ready` fills it for us by inheriting it from our base class,
 which is :class:`object` by default.  Most types use the default allocation.
 .. note::
    If you are creating a co-operative :attr:`tp_new` (one that calls a base type's
    :attr:`tp_new` or :meth:`__new__`), you must *not* try to determine what method
+   If you are creating a co-operative :c:member:`~PyTypeObject.tp_new` (one that calls a base type's
+   :c:member:`~PyTypeObject.tp_new` or :meth:`__new__`), you must *not* try to determine what method
    to call using method resolution order at runtime.  Always statically determine
    what type you are going to call, and call its :attr:`tp_new` directly, or via
+   what type you are going to call, and call its :c:member:`~PyTypeObject.tp_new` directly, or via
    ``type->tp_base->tp_new``.  If you do not do this, Python subclasses of your
    type that also inherit from other Python-defined classes may not work correctly.
 …
+   }
 by filling the :attr:`tp_init` slot. ::
+by filling the :c:member:`~PyTypeObject.tp_init` slot. ::
    (initproc)Noddy_init,         /* tp_init */
 The :attr:`tp_init` slot is exposed in Python as the :meth:`__init__` method. It
+The :c:member:`~PyTypeObject.tp_init` slot is exposed in Python as the :meth:`__init__` method. It
 is used to initialize an object after it's created. Unlike the new method, we
 can't guarantee that the initializer is called.  The initializer isn't called
 …
   back into our type's code
 * when decrementing a reference count in a :attr:`tp_dealloc` handler when
+* when decrementing a reference count in a :c:member:`~PyTypeObject.tp_dealloc` handler when
   garbage-collections is not supported [#]_
 …
    };
 and put the definitions in the :attr:`tp_members` slot::
+and put the definitions in the :c:member:`~PyTypeObject.tp_members` slot::
    Noddy_members,             /* tp_members */
 Each member definition has a member name, type, offset, access flags and
 documentation string. See the "Generic Attribute Management" section below for
+documentation string. See the :ref:`Generic-Attribute-Management` section below for
 details.
 …
    };
 and assign them to the :attr:`tp_methods` slot::
+and assign them to the :c:member:`~PyTypeObject.tp_methods` slot::
    Noddy_methods,             /* tp_methods */
 …
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
 We rename :cfunc:`initnoddy` to :cfunc:`initnoddy2` and update the module name
 passed to :cfunc:`Py_InitModule3`.
+We rename :c:func:`initnoddy` to :c:func:`initnoddy2` and update the module name
+passed to :c:func:`Py_InitModule3`.
 Finally, we update our :file:`setup.py` file to build the new module::
 …
 attribute value is not a string.
 We create an array of :ctype:`PyGetSetDef` structures::
+We create an array of :c:type:`PyGetSetDef` structures::
    static PyGetSetDef Noddy_getseters[] = {
 …
    };
 and register it in the :attr:`tp_getset` slot::
+and register it in the :c:member:`~PyTypeObject.tp_getset` slot::
    Noddy_getseters,           /* tp_getset */
 …
 to register our attribute getters and setters.
 The last item in a :ctype:`PyGetSetDef` structure is the closure mentioned
+The last item in a :c:type:`PyGetSetDef` structure is the closure mentioned
 above. In this case, we aren't using the closure, so we just pass *NULL*.
 …
    };
 We also need to update the :attr:`tp_init` handler to only allow strings [#]_ to
+We also need to update the :c:member:`~PyTypeObject.tp_init` handler to only allow strings [#]_ to
 be passed::
 …
 With these changes, we can assure that the :attr:`first` and :attr:`last`
 members are never *NULL* so we can remove checks for *NULL* values in almost all
 cases. This means that most of the :cfunc:`Py_XDECREF` calls can be converted to
 :cfunc:`Py_DECREF` calls. The only place we can't change these calls is in the
+cases. This means that most of the :c:func:`Py_XDECREF` calls can be converted to
+:c:func:`Py_DECREF` calls. The only place we can't change these calls is in the
 deallocator, where there is the possibility that the initialization of these
 members failed in the constructor.
 …
 For each subobject that can participate in cycles, we need to call the
 :cfunc:`visit` function, which is passed to the traversal method. The
 :cfunc:`visit` function takes as arguments the subobject and the extra argument
+:c:func:`visit` function, which is passed to the traversal method. The
+:c:func:`visit` function takes as arguments the subobject and the extra argument
 *arg* passed to the traversal method.  It returns an integer value that must be
 returned if it is non-zero.
 Python 2.4 and higher provide a :cfunc:`Py_VISIT` macro that automates calling
 visit functions.  With :cfunc:`Py_VISIT`, :cfunc:`Noddy_traverse` can be
+Python 2.4 and higher provide a :c:func:`Py_VISIT` macro that automates calling
+visit functions.  With :c:func:`Py_VISIT`, :c:func:`Noddy_traverse` can be
 simplified::
 …
 .. note::
    Note that the :attr:`tp_traverse` implementation must name its arguments exactly
    *visit* and *arg* in order to use :cfunc:`Py_VISIT`.  This is to encourage
+   Note that the :c:member:`~PyTypeObject.tp_traverse` implementation must name its arguments exactly
+   *visit* and *arg* in order to use :c:func:`Py_VISIT`.  This is to encourage
    uniformity across these boring implementations.
 …
+   }
 Notice the use of a temporary variable in :cfunc:`Noddy_clear`. We use the
+Notice the use of a temporary variable in :c:func:`Noddy_clear`. We use the
 temporary variable so that we can set each member to *NULL* before decrementing
 its reference count.  We do this because, as was discussed earlier, if the
 …
 the object.  In addition, because we now support garbage collection, we also
 have to worry about code being run that triggers garbage collection.  If garbage
 collection is run, our :attr:`tp_traverse` handler could get called. We can't
 take a chance of having :cfunc:`Noddy_traverse` called when a member's reference
+collection is run, our :c:member:`~PyTypeObject.tp_traverse` handler could get called. We can't
+take a chance of having :c:func:`Noddy_traverse` called when a member's reference
 count has dropped to zero and its value hasn't been set to *NULL*.
 Python 2.4 and higher provide a :cfunc:`Py_CLEAR` that automates the careful
 decrementing of reference counts.  With :cfunc:`Py_CLEAR`, the
 :cfunc:`Noddy_clear` function can be simplified::
+Python 2.4 and higher provide a :c:func:`Py_CLEAR` that automates the careful
+decrementing of reference counts.  With :c:func:`Py_CLEAR`, the
+:c:func:`Noddy_clear` function can be simplified::
    static int
 …
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
 That's pretty much it.  If we had written custom :attr:`tp_alloc` or
 :attr:`tp_free` slots, we'd need to modify them for cyclic-garbage collection.
+That's pretty much it.  If we had written custom :c:member:`~PyTypeObject.tp_alloc` or
+:c:member:`~PyTypeObject.tp_free` slots, we'd need to modify them for cyclic-garbage collection.
 Most extensions will use the versions automatically provided.
 …
 The primary difference for derived type objects is that the base type's object
 structure must be the first value. The base type will already include the
 :cfunc:`PyObject_HEAD` at the beginning of its structure.
+:c:func:`PyObject_HEAD` at the beginning of its structure.
 When a Python object is a :class:`Shoddy` instance, its *PyObject\** pointer can
 …
 This pattern is important when writing a type with custom :attr:`new` and
 :attr:`dealloc` methods. The :attr:`new` method should not actually create the
 memory for the object with :attr:`tp_alloc`, that will be handled by the base
 class when calling its :attr:`tp_new`.
 When filling out the :cfunc:`PyTypeObject` for the :class:`Shoddy` type, you see
 a slot for :cfunc:`tp_base`. Due to cross platform compiler issues, you can't
 fill that field directly with the :cfunc:`PyList_Type`; it can be done later in
 the module's :cfunc:`init` function. ::
+memory for the object with :c:member:`~PyTypeObject.tp_alloc`, that will be handled by the base
+class when calling its :c:member:`~PyTypeObject.tp_new`.
+When filling out the :c:func:`PyTypeObject` for the :class:`Shoddy` type, you see
+a slot for :c:func:`tp_base`. Due to cross platform compiler issues, you can't
+fill that field directly with the :c:func:`PyList_Type`; it can be done later in
+the module's :c:func:`init` function. ::
    PyMODINIT_FUNC
 …
+   }
 Before calling :cfunc:`PyType_Ready`, the type structure must have the
 :attr:`tp_base` slot filled in. When we are deriving a new type, it is not
 necessary to fill out the :attr:`tp_alloc` slot with :cfunc:`PyType_GenericNew`
+Before calling :c:func:`PyType_Ready`, the type structure must have the
+:c:member:`~PyTypeObject.tp_base` slot filled in. When we are deriving a new type, it is not
+necessary to fill out the :c:member:`~PyTypeObject.tp_alloc` slot with :c:func:`PyType_GenericNew`
 -- the allocate function from the base type will be inherited.
 After that, calling :cfunc:`PyType_Ready` and adding the type object to the
+After that, calling :c:func:`PyType_Ready` and adding the type object to the
 module is the same as with the basic :class:`Noddy` examples.
 …
 implement and what they do.
 Here is the definition of :ctype:`PyTypeObject`, with some fields only used in
+Here is the definition of :c:type:`PyTypeObject`, with some fields only used in
 debug builds omitted:
 …
 These fields tell the runtime how much memory to allocate when new objects of
 this type are created.  Python has some built-in support for variable length
 structures (think: strings, lists) which is where the :attr:`tp_itemsize` field
+structures (think: strings, lists) which is where the :c:member:`~PyTypeObject.tp_itemsize` field
 comes in.  This will be dealt with later. ::
 …
 errors from the interpreter.  The proper way to protect against this is to save
 a pending exception before performing the unsafe action, and restoring it when
 done.  This can be done using the :cfunc:`PyErr_Fetch` and
 :cfunc:`PyErr_Restore` functions::
+done.  This can be done using the :c:func:`PyErr_Fetch` and
+:c:func:`PyErr_Restore` functions::
    static void
 …
 :func:`str` function, and the :keyword:`print` statement.  For most objects, the
 :keyword:`print` statement is equivalent to the :func:`str` function, but it is
 possible to special-case printing to a :ctype:`FILE\*` if necessary; this should
+possible to special-case printing to a :c:type:`FILE\*` if necessary; this should
 only be done if efficiency is identified as a problem and profiling suggests
 that creating a temporary string object to be written to a file is too
 …
 These handlers are all optional, and most types at most need to implement the
 :attr:`tp_str` and :attr:`tp_repr` handlers. ::
+:c:member:`~PyTypeObject.tp_str` and :c:member:`~PyTypeObject.tp_repr` handlers. ::
    reprfunc tp_repr;
 …
    printfunc tp_print;
 The :attr:`tp_repr` handler should return a string object containing a
+The :c:member:`~PyTypeObject.tp_repr` handler should return a string object containing a
 representation of the instance for which it is called.  Here is a simple
 example::
 …
+   }
 If no :attr:`tp_repr` handler is specified, the interpreter will supply a
 representation that uses the type's :attr:`tp_name` and a uniquely-identifying
+If no :c:member:`~PyTypeObject.tp_repr` handler is specified, the interpreter will supply a
+representation that uses the type's :c:member:`~PyTypeObject.tp_name` and a uniquely-identifying
 value for the object.
 The :attr:`tp_str` handler is to :func:`str` what the :attr:`tp_repr` handler
+The :c:member:`~PyTypeObject.tp_str` handler is to :func:`str` what the :c:member:`~PyTypeObject.tp_repr` handler
 described above is to :func:`repr`; that is, it is called when Python code calls
 :func:`str` on an instance of your object.  Its implementation is very similar
 to the :attr:`tp_repr` function, but the resulting string is intended for human
 consumption.  If :attr:`tp_str` is not specified, the :attr:`tp_repr` handler is
+to the :c:member:`~PyTypeObject.tp_repr` function, but the resulting string is intended for human
+consumption.  If :c:member:`~PyTypeObject.tp_str` is not specified, the :c:member:`~PyTypeObject.tp_repr` handler is
 used instead.
 …
 Python supports two pairs of attribute handlers; a type that supports attributes
 only needs to implement the functions for one pair.  The difference is that one
 pair takes the name of the attribute as a :ctype:`char\*`, while the other
 accepts a :ctype:`PyObject\*`.  Each type can use whichever pair makes more
+pair takes the name of the attribute as a :c:type:`char\*`, while the other
+accepts a :c:type:`PyObject\*`.  Each type can use whichever pair makes more
 sense for the implementation's convenience. ::
 …
 If accessing attributes of an object is always a simple operation (this will be
 explained shortly), there are generic implementations which can be used to
 provide the :ctype:`PyObject\*` version of the attribute management functions.
+provide the :c:type:`PyObject\*` version of the attribute management functions.
 The actual need for type-specific attribute handlers almost completely
 disappeared starting with Python 2.2, though there are many examples which have
 …
+.. _generic-attribute-management:
 Generic Attribute Management
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 …
 attributes simple?  There are only a couple of conditions that must be met:
 #. The name of the attributes must be known when :cfunc:`PyType_Ready` is
+#. The name of the attributes must be known when :c:func:`PyType_Ready` is
    called.
 …
 attributes, when the values are computed, or how relevant data is stored.
 When :cfunc:`PyType_Ready` is called, it uses three tables referenced by the
+When :c:func:`PyType_Ready` is called, it uses three tables referenced by the
 type object to create :term:`descriptor`\s which are placed in the dictionary of the
 type object.  Each descriptor controls access to one attribute of the instance
 object.  Each of the tables is optional; if all three are *NULL*, instances of
 the type will only have attributes that are inherited from their base type, and
 should leave the :attr:`tp_getattro` and :attr:`tp_setattro` fields *NULL* as
+should leave the :c:member:`~PyTypeObject.tp_getattro` and :c:member:`~PyTypeObject.tp_setattro` fields *NULL* as
 well, allowing the base type to handle attributes.
 …
    struct PyGetSetDef *tp_getset;
 If :attr:`tp_methods` is not *NULL*, it must refer to an array of
 :ctype:`PyMethodDef` structures.  Each entry in the table is an instance of this
+If :c:member:`~PyTypeObject.tp_methods` is not *NULL*, it must refer to an array of
+:c:type:`PyMethodDef` structures.  Each entry in the table is an instance of this
 structure::
 …
    single: RESTRICTED
 An interesting advantage of using the :attr:`tp_members` table to build
+An interesting advantage of using the :c:member:`~PyTypeObject.tp_members` table to build
 descriptors that are used at runtime is that any attribute defined this way can
 have an associated doc string simply by providing the text in the table.  An
 …
 class object, and get the doc string using its :attr:`__doc__` attribute.
 As with the :attr:`tp_methods` table, a sentinel entry with a :attr:`name` value
+As with the :c:member:`~PyTypeObject.tp_methods` table, a sentinel entry with a :attr:`name` value
 of *NULL* is required.
 …
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 For simplicity, only the :ctype:`char\*` version will be demonstrated here; the
 type of the name parameter is the only difference between the :ctype:`char\*`
 and :ctype:`PyObject\*` flavors of the interface. This example effectively does
+For simplicity, only the :c:type:`char\*` version will be demonstrated here; the
+type of the name parameter is the only difference between the :c:type:`char\*`
+and :c:type:`PyObject\*` flavors of the interface. This example effectively does
 the same thing as the generic example above, but does not use the generic
 support added in Python 2.2.  The value in showing this is two-fold: it
 …
 what needs to be done.
 The :attr:`tp_getattr` handler is called when the object requires an attribute
+The :c:member:`~PyTypeObject.tp_getattr` handler is called when the object requires an attribute
 look-up.  It is called in the same situations where the :meth:`__getattr__`
 method of a class would be called.
 A likely way to handle this is (1) to implement a set of functions (such as
 :cfunc:`newdatatype_getSize` and :cfunc:`newdatatype_setSize` in the example
+:c:func:`newdatatype_getSize` and :c:func:`newdatatype_setSize` in the example
 below), (2) provide a method table listing these functions, and (3) provide a
 getattr function that returns the result of a lookup in that table.  The method
 table uses the same structure as the :attr:`tp_methods` field of the type
+table uses the same structure as the :c:member:`~PyTypeObject.tp_methods` field of the type
 object.
 …
+   }
 The :attr:`tp_setattr` handler is called when the :meth:`__setattr__` or
+The :c:member:`~PyTypeObject.tp_setattr` handler is called when the :meth:`__setattr__` or
 :meth:`__delattr__` method of a class instance would be called.  When an
 attribute should be deleted, the third parameter will be *NULL*.  Here is an
 example that simply raises an exception; if this were really all you wanted, the
 :attr:`tp_setattr` handler should be set to *NULL*. ::
+:c:member:`~PyTypeObject.tp_setattr` handler should be set to *NULL*. ::
    static int
 …
    cmpfunc tp_compare;
 The :attr:`tp_compare` handler is called when comparisons are needed and the
+The :c:member:`~PyTypeObject.tp_compare` handler is called when comparisons are needed and the
 object does not implement the specific rich comparison method which matches the
 requested comparison.  (It is always used if defined and the
 :cfunc:`PyObject_Compare` or :cfunc:`PyObject_Cmp` functions are used, or if
+:c:func:`PyObject_Compare` or :c:func:`PyObject_Cmp` functions are used, or if
 :func:`cmp` is used from Python.) It is analogous to the :meth:`__cmp__` method.
 This function should return ``-1`` if *obj1* is less than *obj2*, ``0`` if they
 …
 future, other return values may be assigned a different meaning.)
 A :attr:`tp_compare` handler may raise an exception.  In this case it should
+A :c:member:`~PyTypeObject.tp_compare` handler may raise an exception.  In this case it should
 return a negative value.  The caller has to test for the exception using
 :cfunc:`PyErr_Occurred`.
+:c:func:`PyErr_Occurred`.
 Here is a sample implementation::
 …
 to indicate the presence of a slot, but a slot may still be unfilled.) ::
    PyNumberMethods   tp_as_number;
    PySequenceMethods tp_as_sequence;
    PyMappingMethods  tp_as_mapping;
+   PyNumberMethods   *tp_as_number;
+   PySequenceMethods *tp_as_sequence;
+   PyMappingMethods  *tp_as_mapping;
 If you wish your object to be able to act like a number, a sequence, or a
 mapping object, then you place the address of a structure that implements the C
 type :ctype:`PyNumberMethods`, :ctype:`PySequenceMethods`, or
 :ctype:`PyMappingMethods`, respectively. It is up to you to fill in this
+type :c:type:`PyNumberMethods`, :c:type:`PySequenceMethods`, or
+:c:type:`PyMappingMethods`, respectively. It is up to you to fill in this
 structure with appropriate values. You can find examples of the use of each of
 these in the :file:`Objects` directory of the Python source distribution. ::
 …
 This function is called when an instance of your data type is "called", for
 example, if ``obj1`` is an instance of your data type and the Python script
 contains ``obj1('hello')``, the :attr:`tp_call` handler is invoked.
+contains ``obj1('hello')``, the :c:member:`~PyTypeObject.tp_call` handler is invoked.
 This function takes three arguments:
 …
 #. *arg2* is a tuple containing the arguments to the call.  You can use
    :cfunc:`PyArg_ParseTuple` to extract the arguments.
+   :c:func:`PyArg_ParseTuple` to extract the arguments.
 #. *arg3* is a dictionary of keyword arguments that were passed. If this is
    non-*NULL* and you support keyword arguments, use
    :cfunc:`PyArg_ParseTupleAndKeywords` to extract the arguments.  If you do not
+   :c:func:`PyArg_ParseTupleAndKeywords` to extract the arguments.  If you do not
    want to support keyword arguments and this is non-*NULL*, raise a
    :exc:`TypeError` with a message saying that keyword arguments are not supported.
 …
 For an object to be weakly referencable, the extension must include a
 :ctype:`PyObject\*` field in the instance structure for the use of the weak
+:c:type:`PyObject\*` field in the instance structure for the use of the weak
 reference mechanism; it must be initialized to *NULL* by the object's
 constructor.  It must also set the :attr:`tp_weaklistoffset` field of the
+constructor.  It must also set the :c:member:`~PyTypeObject.tp_weaklistoffset` field of the
 corresponding type object to the offset of the field. For example, the instance
 type is defined with the following structure::
 …
 The only further addition is that the destructor needs to call the weak
+reference manager to clear any weak references.  This should be done before any
+other parts of the destruction have occurred, but is only required if the weak
+reference list is non-*NULL*::
+reference manager to clear any weak references.  This is only required if the
+weak reference list is non-*NULL*::
    static void
 …
 When you need to verify that an object is an instance of the type you are
 implementing, use the :cfunc:`PyObject_TypeCheck` function. A sample of its use
+implementing, use the :c:func:`PyObject_TypeCheck` function. A sample of its use
 might be something like the following::
 …
    float.
 .. [#] We relied on this in the :attr:`tp_dealloc` handler in this example, because our
+.. [#] We relied on this in the :c:member:`~PyTypeObject.tp_dealloc` handler in this example, because our
    type doesn't support garbage collection. Even if a type supports garbage
    collection, there are calls that can be made to "untrack" the object from

python/vendor/current/Doc/extending/windows.rst

-              r2
+              r388
    not necessarily have to match the module name, but the name of the
    initialization function should match the module name --- you can only import a
    module :mod:`spam` if its initialization function is called :cfunc:`initspam`,
    and it should call :cfunc:`Py_InitModule` with the string ``"spam"`` as its
+   module :mod:`spam` if its initialization function is called :c:func:`initspam`,
+   and it should call :c:func:`Py_InitModule` with the string ``"spam"`` as its
    first argument (use the minimal :file:`example.c` in this directory as a guide).
    By convention, it lives in a file called :file:`spam.c` or :file:`spammodule.c`.
 …
 #. Copy :file:`example.sln` and :file:`example.vcproj`, rename them to
       :file:`spam.\*`, and edit them by hand, or
+   :file:`spam.\*`, and edit them by hand, or
 #. Create a brand new project; instructions are below.
 …
    PyObject_HEAD_INIT(&PyType_Type)
+Change it to::
+Static type object initializers in extension modules may cause
+compiles to fail with an error message like "initializer not a
+constant".  This shows up when building DLL under MSVC.  Change it to::
    PyObject_HEAD_INIT(NULL)
 …
 and add the following to the module initialization function::
+   MyObject_Type.ob_type = &PyType_Type;
+Refer to section 3 of the `Python FAQ <http://www.python.org/doc/faq>`_ for
+details on why you must do this.
+   if (PyType_Ready(&MyObject_Type) < 0)
+        return NULL;
 …
 The first command created three files: :file:`spam.obj`, :file:`spam.dll` and
 :file:`spam.lib`.  :file:`Spam.dll` does not contain any Python functions (such
 as :cfunc:`PyArg_ParseTuple`), but it does know how to find the Python code
+as :c:func:`PyArg_ParseTuple`), but it does know how to find the Python code
 thanks to :file:`pythonXY.lib`.

Context Navigation

Legend:

python/vendor/current/Doc/extending/building.rst

python/vendor/current/Doc/extending/embedding.rst

python/vendor/current/Doc/extending/extending.rst

python/vendor/current/Doc/extending/index.rst

python/vendor/current/Doc/extending/newtypes.rst

python/vendor/current/Doc/extending/windows.rst

Download in other formats: