FazBrowse GitHub Viewer
|
Trending
|
URL:
|
Home
Tools:
[Download Repo ZIP]
[View Raw Code]
[Original HTTPS Page]
cpython/Include/pystate.h at 3af7263037de1d0ef63b070fc7bfc2cf042eaebe · python/cpython · GitHub
python
/
cpython
Public
Uh oh!
There was an error while loading.
Please reload this page
.
Notifications
You must be signed in to change notification settings
Fork
36.1k
Star
77.2k
Code
Issues
5k+
Pull requests
2.7k
Actions
Projects
Security and quality
0
Insights
Additional navigation options
Code
Issues
Pull requests
Actions
Projects
Security and quality
Insights
Expand file tree
Breadcrumbs
cpython
/
Include
/
pystate.h
Copy path
More file actions
More file actions
Latest commit
History
History
History
132 lines (101 loc) · 4.53 KB
Breadcrumbs
cpython
/
Include
/
pystate.h
Copy path
File metadata and controls
132 lines (101 loc) · 4.53 KB
Raw
Copy raw file
Download raw file
Open symbols panel
Edit and raw actions
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
/* Thread and interpreter state structures and their interfaces */
#ifndef
Py_PYSTATE_H
#define
Py_PYSTATE_H
#ifdef
__cplusplus
extern
"C"
{
#endif
/* This limitation is for performance and simplicity. If needed it can be
removed (with effort). */
#define
MAX_CO_EXTRA_USERS
255
PyAPI_FUNC
(
PyInterpreterState
*
)
PyInterpreterState_New
(
void
);
PyAPI_FUNC
(
void
)
PyInterpreterState_Clear
(
PyInterpreterState
*
);
PyAPI_FUNC
(
void
)
PyInterpreterState_Delete
(
PyInterpreterState
*
);
#if
!defined(
Py_LIMITED_API
)
||
Py_LIMITED_API
+
0
>=
0x03090000
/* New in 3.9 */
/* Get the current interpreter state.
Issue a fatal error if there no current Python thread state or no current
interpreter. It cannot return NULL.
The caller must hold the GIL. */
PyAPI_FUNC
(
PyInterpreterState
*
)
PyInterpreterState_Get
(
void
);
#endif
#if
!defined(
Py_LIMITED_API
)
||
Py_LIMITED_API
+
0
>=
0x03080000
/* New in 3.8 */
PyAPI_FUNC
(
PyObject
*
)
PyInterpreterState_GetDict
(
PyInterpreterState
*
);
#endif
#if
!defined(
Py_LIMITED_API
)
||
Py_LIMITED_API
+
0
>=
0x03070000
/* New in 3.7 */
PyAPI_FUNC
(
int64_t
)
PyInterpreterState_GetID
(
PyInterpreterState
*
);
#endif
#if
!defined(
Py_LIMITED_API
)
||
Py_LIMITED_API
+
0
>=
0x03030000
/* State unique per thread */
/* New in 3.3 */
PyAPI_FUNC
(
int
)
PyState_AddModule
(
PyObject
*
,
PyModuleDef
*
);
PyAPI_FUNC
(
int
)
PyState_RemoveModule
(
PyModuleDef
*
);
#endif
PyAPI_FUNC
(
PyObject
*
)
PyState_FindModule
(
PyModuleDef
*
);
PyAPI_FUNC
(
PyThreadState
*
)
PyThreadState_New
(
PyInterpreterState
*
);
PyAPI_FUNC
(
void
)
PyThreadState_Clear
(
PyThreadState
*
);
PyAPI_FUNC
(
void
)
PyThreadState_Delete
(
PyThreadState
*
);
/* Get the current thread state.
When the current thread state is NULL, this issues a fatal error (so that
the caller needn't check for NULL).
The caller must hold the GIL.
See also PyThreadState_GetUnchecked() and _PyThreadState_GET(). */
PyAPI_FUNC
(
PyThreadState
*
)
PyThreadState_Get
(
void
);
// Alias to PyThreadState_Get()
#define
PyThreadState_GET
() PyThreadState_Get()
PyAPI_FUNC
(
PyThreadState
*
)
PyThreadState_Swap
(
PyThreadState
*
);
PyAPI_FUNC
(
PyObject
*
)
PyThreadState_GetDict
(
void
);
PyAPI_FUNC
(
int
)
PyThreadState_SetAsyncExc
(
unsigned long
,
PyObject
*
);
#if
!defined(
Py_LIMITED_API
)
||
Py_LIMITED_API
+
0
>=
0x03090000
/* New in 3.9 */
PyAPI_FUNC
(
PyInterpreterState
*
)
PyThreadState_GetInterpreter
(
PyThreadState
*
tstate
);
PyAPI_FUNC
(
PyFrameObject
*
)
PyThreadState_GetFrame
(
PyThreadState
*
tstate
);
PyAPI_FUNC
(
uint64_t
)
PyThreadState_GetID
(
PyThreadState
*
tstate
);
#endif
typedef
enum
{
PyGILState_LOCKED
,
PyGILState_UNLOCKED
}
PyGILState_STATE
;
/* Ensure that the current thread is ready to call the Python
C API, regardless of the current state of Python, or of its
thread lock. This may be called as many times as desired
by a thread so long as each call is matched with a call to
PyGILState_Release(). In general, other thread-state APIs may
be used between _Ensure() and _Release() calls, so long as the
thread-state is restored to its previous state before the Release().
For example, normal use of the Py_BEGIN_ALLOW_THREADS/
Py_END_ALLOW_THREADS macros are acceptable.
The return value is an opaque "handle" to the thread state when
PyGILState_Ensure() was called, and must be passed to
PyGILState_Release() to ensure Python is left in the same state. Even
though recursive calls are allowed, these handles can *not* be shared -
each unique call to PyGILState_Ensure must save the handle for its
call to PyGILState_Release.
When the function returns, the current thread will hold the GIL.
Failure is a fatal error.
*/
PyAPI_FUNC
(
PyGILState_STATE
)
PyGILState_Ensure
(
void
);
/* Release any resources previously acquired. After this call, Python's
state will be the same as it was prior to the corresponding
PyGILState_Ensure() call (but generally this state will be unknown to
the caller, hence the use of the GILState API.)
Every call to PyGILState_Ensure must be matched by a call to
PyGILState_Release on the same thread.
*/
PyAPI_FUNC
(
void
)
PyGILState_Release
(
PyGILState_STATE
);
/* Helper/diagnostic function - get the current thread state for
this thread. May return NULL if no GILState API has been used
on the current thread. Note that the main thread always has such a
thread-state, even if no auto-thread-state call has been made
on the main thread.
*/
PyAPI_FUNC
(
PyThreadState
*
)
PyGILState_GetThisThreadState
(
void
);
#ifndef
Py_LIMITED_API
# define
Py_CPYTHON_PYSTATE_H
# include
"cpython/pystate.h"
# undef
Py_CPYTHON_PYSTATE_H
#endif
#ifdef
__cplusplus
}
#endif
#endif
/* !Py_PYSTATE_H */
Back
|
FazBrowse Home
|
New Git URL