1/* Thread and interpreter state structures and their interfaces */
2
3
4#ifndef Py_PYSTATE_H
5#define Py_PYSTATE_H
6#ifdef __cplusplus
7extern "C" {
8#endif
9
10/* This limitation is for performance and simplicity. If needed it can be
11removed (with effort). */
12#define MAX_CO_EXTRA_USERS 255
13
14/* Forward declarations for PyFrameObject, PyThreadState
15 and PyInterpreterState */
16struct _ts;
17struct _is;
18
19/* struct _ts is defined in cpython/pystate.h */
20typedef struct _ts PyThreadState;
21/* struct _is is defined in internal/pycore_interp.h */
22typedef struct _is PyInterpreterState;
23
24PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_New(void);
25PyAPI_FUNC(void) PyInterpreterState_Clear(PyInterpreterState *);
26PyAPI_FUNC(void) PyInterpreterState_Delete(PyInterpreterState *);
27
28#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000
29/* New in 3.9 */
30/* Get the current interpreter state.
31
32 Issue a fatal error if there no current Python thread state or no current
33 interpreter. It cannot return NULL.
34
35 The caller must hold the GIL. */
36PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Get(void);
37#endif
38
39#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03080000
40/* New in 3.8 */
41PyAPI_FUNC(PyObject *) PyInterpreterState_GetDict(PyInterpreterState *);
42#endif
43
44#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000
45/* New in 3.7 */
46PyAPI_FUNC(int64_t) PyInterpreterState_GetID(PyInterpreterState *);
47#endif
48#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
49
50/* State unique per thread */
51
52/* New in 3.3 */
53PyAPI_FUNC(int) PyState_AddModule(PyObject*, struct PyModuleDef*);
54PyAPI_FUNC(int) PyState_RemoveModule(struct PyModuleDef*);
55#endif
56PyAPI_FUNC(PyObject*) PyState_FindModule(struct PyModuleDef*);
57
58PyAPI_FUNC(PyThreadState *) PyThreadState_New(PyInterpreterState *);
59PyAPI_FUNC(void) PyThreadState_Clear(PyThreadState *);
60PyAPI_FUNC(void) PyThreadState_Delete(PyThreadState *);
61
62/* Get the current thread state.
63
64 When the current thread state is NULL, this issues a fatal error (so that
65 the caller needn't check for NULL).
66
67 The caller must hold the GIL.
68
69 See also PyThreadState_GET() and _PyThreadState_GET(). */
70PyAPI_FUNC(PyThreadState *) PyThreadState_Get(void);
71
72/* Get the current Python thread state.
73
74 Macro using PyThreadState_Get() or _PyThreadState_GET() depending if
75 pycore_pystate.h is included or not (this header redefines the macro).
76
77 If PyThreadState_Get() is used, issue a fatal error if the current thread
78 state is NULL.
79
80 See also PyThreadState_Get() and _PyThreadState_GET(). */
81#define PyThreadState_GET() PyThreadState_Get()
82
83PyAPI_FUNC(PyThreadState *) PyThreadState_Swap(PyThreadState *);
84PyAPI_FUNC(PyObject *) PyThreadState_GetDict(void);
85PyAPI_FUNC(int) PyThreadState_SetAsyncExc(unsigned long, PyObject *);
86
87#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000
88/* New in 3.9 */
89PyAPI_FUNC(PyInterpreterState*) PyThreadState_GetInterpreter(PyThreadState *tstate);
90PyAPI_FUNC(PyFrameObject*) PyThreadState_GetFrame(PyThreadState *tstate);
91PyAPI_FUNC(uint64_t) PyThreadState_GetID(PyThreadState *tstate);
92#endif
93
94typedef
95 enum {PyGILState_LOCKED, PyGILState_UNLOCKED}
96 PyGILState_STATE;
97
98
99/* Ensure that the current thread is ready to call the Python
100 C API, regardless of the current state of Python, or of its
101 thread lock. This may be called as many times as desired
102 by a thread so long as each call is matched with a call to
103 PyGILState_Release(). In general, other thread-state APIs may
104 be used between _Ensure() and _Release() calls, so long as the
105 thread-state is restored to its previous state before the Release().
106 For example, normal use of the Py_BEGIN_ALLOW_THREADS/
107 Py_END_ALLOW_THREADS macros are acceptable.
108
109 The return value is an opaque "handle" to the thread state when
110 PyGILState_Ensure() was called, and must be passed to
111 PyGILState_Release() to ensure Python is left in the same state. Even
112 though recursive calls are allowed, these handles can *not* be shared -
113 each unique call to PyGILState_Ensure must save the handle for its
114 call to PyGILState_Release.
115
116 When the function returns, the current thread will hold the GIL.
117
118 Failure is a fatal error.
119*/
120PyAPI_FUNC(PyGILState_STATE) PyGILState_Ensure(void);
121
122/* Release any resources previously acquired. After this call, Python's
123 state will be the same as it was prior to the corresponding
124 PyGILState_Ensure() call (but generally this state will be unknown to
125 the caller, hence the use of the GILState API.)
126
127 Every call to PyGILState_Ensure must be matched by a call to
128 PyGILState_Release on the same thread.
129*/
130PyAPI_FUNC(void) PyGILState_Release(PyGILState_STATE);
131
132/* Helper/diagnostic function - get the current thread state for
133 this thread. May return NULL if no GILState API has been used
134 on the current thread. Note that the main thread always has such a
135 thread-state, even if no auto-thread-state call has been made
136 on the main thread.
137*/
138PyAPI_FUNC(PyThreadState *) PyGILState_GetThisThreadState(void);
139
140
141#ifndef Py_LIMITED_API
142# define Py_CPYTHON_PYSTATE_H
143# include "cpython/pystate.h"
144# undef Py_CPYTHON_PYSTATE_H
145#endif
146
147#ifdef __cplusplus
148}
149#endif
150#endif /* !Py_PYSTATE_H */
151

source code of include/python3.10/pystate.h