update to new C roles and directives

1 files changed, 38 insertions, 38 deletions

diff --git a/Doc/c-api/import.rst b/Doc/c-api/import.rst
index 3da1415..1929041 100644
--- a/Doc/c-api/import.rst
+++ b/Doc/c-api/import.rst
@@ -6,14 +6,14 @@ Importing Modules
 =================
 
 
-.. cfunction:: PyObject* PyImport_ImportModule(const char *name)
+.. c:function:: PyObject* PyImport_ImportModule(const char *name)
 
    .. index::
       single: package variable; __all__
       single: __all__ (package variable)
       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*
    argument contains a dot (when it specifies a submodule of a package), the
@@ -34,20 +34,20 @@ Importing Modules
       Always uses absolute imports.
 
 
-.. cfunction:: PyObject* PyImport_ImportModuleNoBlock(const char *name)
+.. c:function:: PyObject* PyImport_ImportModuleNoBlock(const char *name)
 
-   This version of :cfunc:`PyImport_ImportModule` does not block. It's intended
+   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`.
 
    .. versionadded:: 2.6
 
 
-.. 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__
 
@@ -65,11 +65,11 @@ Importing Modules
       Failing imports remove incomplete module objects.
 
    .. 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
    function :func:`__import__`, as the standard :func:`__import__` function calls
@@ -83,7 +83,7 @@ Importing Modules
    .. versionadded:: 2.5
 
 
-.. cfunction:: PyObject* PyImport_Import(PyObject *name)
+.. c:function:: PyObject* PyImport_Import(PyObject *name)
 
    .. index::
       module: rexec
@@ -98,7 +98,7 @@ Importing Modules
       Always uses absolute imports.
 
 
-.. cfunction:: PyObject* PyImport_ReloadModule(PyObject *m)
+.. c:function:: PyObject* PyImport_ReloadModule(PyObject *m)
 
    .. index:: builtin: reload
 
@@ -108,7 +108,7 @@ Importing Modules
    with an exception set on failure (the module still exists in this case).
 
 
-.. 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
    may be of the form ``package.module``. First check the modules dictionary if
@@ -118,12 +118,12 @@ Importing Modules
    .. note::
 
       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
 
@@ -133,7 +133,7 @@ Importing Modules
    or *NULL* with an exception set if an error occurred.  Before Python 2.4, the
    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.
@@ -142,7 +142,7 @@ Importing Modules
    :cmember:`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
    structures not already created will still not be created.
@@ -151,26 +151,26 @@ Importing Modules
       *name* is removed from :attr:`sys.modules` in error cases.
 
 
-.. cfunction:: PyObject* PyImport_ExecCodeModuleEx(char *name, PyObject *co, char *pathname)
+.. c:function:: PyObject* PyImport_ExecCodeModuleEx(char *name, PyObject *co, char *pathname)
 
-   Like :cfunc:`PyImport_ExecCodeModule`, but the :attr:`__file__` attribute of
+   Like :c:func:`PyImport_ExecCodeModule`, but the :attr:`__file__` attribute of
    the module object is set to *pathname* if it is non-``NULL``.
 
 
-.. cfunction:: long PyImport_GetMagicNumber()
+.. c:function:: long PyImport_GetMagicNumber()
 
    Return the magic number for Python bytecode files (a.k.a. :file:`.pyc` and
    :file:`.pyo` files).  The magic number should be present in the first four bytes
    of the bytecode file, in little-endian byte order.
 
 
-.. cfunction:: PyObject* PyImport_GetModuleDict()
+.. c:function:: PyObject* PyImport_GetModuleDict()
 
    Return the dictionary used for the module administration (a.k.a.
    ``sys.modules``).  Note that this is a per-interpreter variable.
 
 
-.. 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
    *path*, possibly by fetching it from the :data:`sys.path_importer_cache`
@@ -183,41 +183,41 @@ Importing Modules
    .. versionadded:: 2.6
 
 
-.. 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
 
@@ -233,30 +233,30 @@ Importing Modules
       };
 
 
-.. cvar:: struct _frozen* PyImport_FrozenModules
+.. c:var:: struct _frozen* PyImport_FrozenModules
 
-   This pointer is initialized to point to an array of :ctype:`struct _frozen`
+   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
    tricks with this to provide a dynamically created collection of frozen modules.
 
 
-.. cfunction:: int PyImport_AppendInittab(const 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`.
+   :c:func:`Py_Initialize`.
 
 
-.. ctype:: struct _inittab
+.. 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::
 
@@ -266,11 +266,11 @@ Importing Modules
       };
 
 
-.. 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*
    array must end with a sentinel entry which contains *NULL* for the :attr:`name`
    field; failure to provide the sentinel value can result in a memory fault.
    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`.