Various terminology changes.

Author: ZeroIntensity

Doc/c-api/init.rst

@@ -963,7 +963,7 @@ a file, so that other Python threads can run in the meantime.
 
 The Python interpreter keeps some thread-specific bookkeeping information
 inside a data structure called :c:type:`PyThreadState`, known as a :term:`thread state`.
-There's also one :term:`thread-local variable <active thread state>` pointing to the
+There's also one :term:`thread-local variable <current thread state>` pointing to the
 current :c:type:`PyThreadState`: it can be retrieved using :c:func:`PyThreadState_Get`.
 
 A thread can only have one :term:`attached thread state` at a time. An attached
@@ -1204,13 +1204,13 @@ code, or when embedding the Python interpreter:
 
 .. c:function:: PyThreadState* PyEval_SaveThread()
 
-   Detach the :term:`active thread state` (if it has been created) and
+   Detach the :term:`current thread state` (if it has been created) and
    return it.
 
 
 .. c:function:: void PyEval_RestoreThread(PyThreadState *tstate)
 
-   Set the :term:`active thread state` to *tstate*, which must not be ``NULL``.
+   Set the :term:`current thread state` to *tstate*, which must not be ``NULL``.
    The passed :term:`thread state` **should not** be :term:`attached <attached thread state>`,
    otherwise deadlock ensues.
 
@@ -1226,7 +1226,7 @@ code, or when embedding the Python interpreter:
 
 .. c:function:: PyThreadState* PyThreadState_Get()
 
-   Return the :term:`active thread state`. If the :term:`active thread state` is ``NULL``
+   Return the :term:`current thread state`. If the :term:`current thread state` is ``NULL``
    (such as when inside of :c:macro:`Py_BEGIN_ALLOW_THREADS` block), then this issues a fatal
    error (so that the caller needn't check for ``NULL``).
 
@@ -1246,13 +1246,13 @@ code, or when embedding the Python interpreter:
 
 .. c:function:: PyThreadState* PyThreadState_Swap(PyThreadState *tstate)
 
-   Set the :term:`active thread state` to *tstate*, and return
+   Set the :term:`current thread state` to *tstate*, and return
    the old value.
    
    If there is an :term:`attached thread state` for the current
    thread, it will be detached. Upon returning from this function, 
    *tstate* will become :term:`attached <attached thread state>` instead
-   if it's not ``NULL``. If it is ``NULL``, then the :term:`active thread state`
+   if it's not ``NULL``. If it is ``NULL``, then the :term:`current thread state`
    will be ``NULL``.
 
 
@@ -1304,7 +1304,7 @@ with sub-interpreters:
 
 .. c:function:: PyThreadState* PyGILState_GetThisThreadState()
 
-   Get the :term:`active thread state` for this thread.  May return ``NULL`` if no
+   Get the :term:`current thread state` for this thread.  May return ``NULL`` if no
    GILState API has been used on the current thread.  Note that the main thread
    always has such a thread-state, even if no auto-thread-state call has been
    made on the main thread.  This is mainly a helper/diagnostic function.
@@ -1419,7 +1419,7 @@ All of the following functions must be called after :c:func:`Py_Initialize`.
 
 .. c:function:: void PyThreadState_DeleteCurrent(void)
 
-   Destroy the :term:`attached thread state` and set the :term:`active thread state`
+   Destroy the :term:`attached thread state` and set the :term:`current thread state`
    to ``NULL``. The :term:`thread state <attached thread state>` must have been reset
    with a previous call to :c:func:`PyThreadState_Clear`.
 

Doc/c-api/sys.rst

@@ -346,8 +346,8 @@ accessible to C code.  They all work with the current interpreter thread's
    silently abort the operation by raising an error subclassed from
    :class:`Exception` (other errors will not be silenced).
 
-   The hook function is always called with a :term:`thread state` by the Python
-   interpreter that raised the event.
+   The hook function is always called with an :term:`attached thread state` by
+   the Python interpreter that raised the event.
 
    See :pep:`578` for a detailed description of auditing.  Functions in the
    runtime and standard library that raise events are listed in the

Doc/c-api/time.rst

@@ -83,8 +83,8 @@ require the caller to have an :term:`attached thread state`.
 On success, the functions return ``0``.
 
 On failure, they set ``*result`` to ``0`` and return ``-1``, *without* setting
-an exception. To get the cause of the error, attach a :term:`thread state`, and call the
-regular (non-``Raw``) function. Note that the regular function may succeed after
+an exception. To get the cause of the error, :term:`attach <attached thread state>` a :term:`thread state`,
+and call the regular (non-``Raw``) function. Note that the regular function may succeed after
 the ``Raw`` one failed.
 
 .. c:function:: int PyTime_MonotonicRaw(PyTime_t *result)

Doc/glossary.rst

@@ -36,13 +36,6 @@ Glossary
       and loaders (in the :mod:`importlib.abc` module).  You can create your own
       ABCs with the :mod:`abc` module.
 
-   active thread state
-
-      The :c:data:`PyThreadState` pointer to a :term:`thread state` for the current thread.
-      The per-thread pointer might be ``NULL``, in which case Python code should not
-      get executed. If the active thread state is non-``NULL``, then the :term:`thread state`
-      that it points to is considered to be :term:`attached <attached thread state>`.  
-
    annotate function
       A function that can be called to retrieve the :term:`annotations <annotation>`
       of an object. This function is accessible as the :attr:`~object.__annotate__`
@@ -141,10 +134,11 @@ Glossary
 
    attached thread state
 
-      A :term:`thread state` that is :term:`active <active thread state>`
-      for the current thread.
+      A :term:`thread state` that is :term:`active <current thread state>`
+      for the current thread. If no thread state is attached, then the
+      :term:`current thread state` is ``NULL``.
 
-      On most builds of Python, an attached thread state means that the
+      On most builds of Python, having an attached thread state means that the
       caller holds the :term:`GIL` for the current interpreter.    
 
    attribute
@@ -348,6 +342,13 @@ Glossary
       tasks (see :mod:`asyncio`) associate each task with a context which
       becomes the current context whenever the task starts or resumes execution.
 
+   current thread state
+
+      The :c:data:`PyThreadState` pointer to a :term:`thread state` for the current thread.
+      The per-thread pointer might be ``NULL``, in which case Python code should not
+      get executed. If the current thread state is non-``NULL``, then the :term:`thread state`
+      that it points to is considered to be :term:`attached <attached thread state>`.  
+
    decorator
       A function returning another function, usually applied as a function
       transformation using the ``@wrapper`` syntax.  Common examples for
@@ -1303,7 +1304,7 @@ Glossary
    thread state
       In Python's C API, a thread state is a structure that holds
       information about the current thread. A thread state must be
-      :term:`active <active thread state>` for the current thread in order to call most of the C API.
+      :term:`active <current thread state>` for the current thread in order to call most of the C API.
 
       See :ref:`Thread State and the Global Interpreter Lock <threads>` for more
       information.

Misc/NEWS.d/next/C_API/2024-11-26-22-06-10.gh-issue-127314.SsRrIu.rst

@@ -1,2 +1,2 @@
-Improve error message when calling the C API without an active thread state
+Improve error message when calling the C API without an current thread state
 on the :term:`free-threaded <free threading>` build.