1 | |
2 | /* Thread and interpreter state structures and their interfaces */ |
3 | |
4 | |
5 | #ifndef Py_PYSTATE_H |
6 | #define Py_PYSTATE_H |
7 | #ifdef __cplusplus |
8 | extern "C" { |
9 | #endif |
10 | |
11 | /* State shared between threads */ |
12 | |
13 | struct _ts; /* Forward */ |
14 | struct _is; /* Forward */ |
15 | |
16 | typedef struct _is { |
17 | |
18 | struct _is *next; |
19 | struct _ts *tstate_head; |
20 | |
21 | PyObject *modules; |
22 | PyObject *sysdict; |
23 | PyObject *builtins; |
24 | PyObject *modules_reloading; |
25 | |
26 | PyObject *codec_search_path; |
27 | PyObject *codec_search_cache; |
28 | PyObject *codec_error_registry; |
29 | |
30 | #ifdef HAVE_DLOPEN |
31 | int dlopenflags; |
32 | #endif |
33 | #ifdef WITH_TSC |
34 | int tscdump; |
35 | #endif |
36 | |
37 | } PyInterpreterState; |
38 | |
39 | |
40 | /* State unique per thread */ |
41 | |
42 | struct _frame; /* Avoid including frameobject.h */ |
43 | |
44 | /* Py_tracefunc return -1 when raising an exception, or 0 for success. */ |
45 | typedef int (*Py_tracefunc)(PyObject *, struct _frame *, int, PyObject *); |
46 | |
47 | /* The following values are used for 'what' for tracefunc functions: */ |
48 | #define PyTrace_CALL 0 |
49 | #define PyTrace_EXCEPTION 1 |
50 | #define PyTrace_LINE 2 |
51 | #define PyTrace_RETURN 3 |
52 | #define PyTrace_C_CALL 4 |
53 | #define PyTrace_C_EXCEPTION 5 |
54 | #define PyTrace_C_RETURN 6 |
55 | |
56 | typedef struct _ts { |
57 | /* See Python/ceval.c for comments explaining most fields */ |
58 | |
59 | struct _ts *next; |
60 | PyInterpreterState *interp; |
61 | |
62 | struct _frame *frame; |
63 | int recursion_depth; |
64 | /* 'tracing' keeps track of the execution depth when tracing/profiling. |
65 | This is to prevent the actual trace/profile code from being recorded in |
66 | the trace/profile. */ |
67 | int tracing; |
68 | int use_tracing; |
69 | |
70 | Py_tracefunc c_profilefunc; |
71 | Py_tracefunc c_tracefunc; |
72 | PyObject *c_profileobj; |
73 | PyObject *c_traceobj; |
74 | |
75 | PyObject *curexc_type; |
76 | PyObject *curexc_value; |
77 | PyObject *curexc_traceback; |
78 | |
79 | PyObject *exc_type; |
80 | PyObject *exc_value; |
81 | PyObject *exc_traceback; |
82 | |
83 | PyObject *dict; /* Stores per-thread state */ |
84 | |
85 | /* tick_counter is incremented whenever the check_interval ticker |
86 | * reaches zero. The purpose is to give a useful measure of the number |
87 | * of interpreted bytecode instructions in a given thread. This |
88 | * extremely lightweight statistic collector may be of interest to |
89 | * profilers (like psyco.jit()), although nothing in the core uses it. |
90 | */ |
91 | int tick_counter; |
92 | |
93 | int gilstate_counter; |
94 | |
95 | PyObject *async_exc; /* Asynchronous exception to raise */ |
96 | long thread_id; /* Thread id where this tstate was created */ |
97 | |
98 | int trash_delete_nesting; |
99 | PyObject *trash_delete_later; |
100 | |
101 | /* XXX signal handlers should also be here */ |
102 | |
103 | } PyThreadState; |
104 | |
105 | |
106 | PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_New(void); |
107 | PyAPI_FUNC(void) PyInterpreterState_Clear(PyInterpreterState *); |
108 | PyAPI_FUNC(void) PyInterpreterState_Delete(PyInterpreterState *); |
109 | |
110 | PyAPI_FUNC(PyThreadState *) PyThreadState_New(PyInterpreterState *); |
111 | PyAPI_FUNC(PyThreadState *) _PyThreadState_Prealloc(PyInterpreterState *); |
112 | PyAPI_FUNC(void) _PyThreadState_Init(PyThreadState *); |
113 | PyAPI_FUNC(void) PyThreadState_Clear(PyThreadState *); |
114 | PyAPI_FUNC(void) PyThreadState_Delete(PyThreadState *); |
115 | #ifdef WITH_THREAD |
116 | PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void); |
117 | #endif |
118 | |
119 | PyAPI_FUNC(PyThreadState *) PyThreadState_Get(void); |
120 | PyAPI_FUNC(PyThreadState *) PyThreadState_Swap(PyThreadState *); |
121 | PyAPI_FUNC(PyObject *) PyThreadState_GetDict(void); |
122 | PyAPI_FUNC(int) PyThreadState_SetAsyncExc(long, PyObject *); |
123 | |
124 | |
125 | /* Variable and macro for in-line access to current thread state */ |
126 | |
127 | PyAPI_DATA(PyThreadState *) _PyThreadState_Current; |
128 | |
129 | #ifdef Py_DEBUG |
130 | #define PyThreadState_GET() PyThreadState_Get() |
131 | #else |
132 | #define PyThreadState_GET() (_PyThreadState_Current) |
133 | #endif |
134 | |
135 | typedef |
136 | enum {PyGILState_LOCKED, PyGILState_UNLOCKED} |
137 | PyGILState_STATE; |
138 | |
139 | /* Ensure that the current thread is ready to call the Python |
140 | C API, regardless of the current state of Python, or of its |
141 | thread lock. This may be called as many times as desired |
142 | by a thread so long as each call is matched with a call to |
143 | PyGILState_Release(). In general, other thread-state APIs may |
144 | be used between _Ensure() and _Release() calls, so long as the |
145 | thread-state is restored to its previous state before the Release(). |
146 | For example, normal use of the Py_BEGIN_ALLOW_THREADS/ |
147 | Py_END_ALLOW_THREADS macros are acceptable. |
148 | |
149 | The return value is an opaque "handle" to the thread state when |
150 | PyGILState_Ensure() was called, and must be passed to |
151 | PyGILState_Release() to ensure Python is left in the same state. Even |
152 | though recursive calls are allowed, these handles can *not* be shared - |
153 | each unique call to PyGILState_Ensure must save the handle for its |
154 | call to PyGILState_Release. |
155 | |
156 | When the function returns, the current thread will hold the GIL. |
157 | |
158 | Failure is a fatal error. |
159 | */ |
160 | PyAPI_FUNC(PyGILState_STATE) PyGILState_Ensure(void); |
161 | |
162 | /* Release any resources previously acquired. After this call, Python's |
163 | state will be the same as it was prior to the corresponding |
164 | PyGILState_Ensure() call (but generally this state will be unknown to |
165 | the caller, hence the use of the GILState API.) |
166 | |
167 | Every call to PyGILState_Ensure must be matched by a call to |
168 | PyGILState_Release on the same thread. |
169 | */ |
170 | PyAPI_FUNC(void) PyGILState_Release(PyGILState_STATE); |
171 | |
172 | /* Helper/diagnostic function - get the current thread state for |
173 | this thread. May return NULL if no GILState API has been used |
174 | on the current thread. Note that the main thread always has such a |
175 | thread-state, even if no auto-thread-state call has been made |
176 | on the main thread. |
177 | */ |
178 | PyAPI_FUNC(PyThreadState *) PyGILState_GetThisThreadState(void); |
179 | |
180 | /* The implementation of sys._current_frames() Returns a dict mapping |
181 | thread id to that thread's current frame. |
182 | */ |
183 | PyAPI_FUNC(PyObject *) _PyThread_CurrentFrames(void); |
184 | |
185 | /* Routines for advanced debuggers, requested by David Beazley. |
186 | Don't use unless you know what you are doing! */ |
187 | PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Head(void); |
188 | PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Next(PyInterpreterState *); |
189 | PyAPI_FUNC(PyThreadState *) PyInterpreterState_ThreadHead(PyInterpreterState *); |
190 | PyAPI_FUNC(PyThreadState *) PyThreadState_Next(PyThreadState *); |
191 | |
192 | typedef struct _frame *(*PyThreadFrameGetter)(PyThreadState *self_); |
193 | |
194 | /* hook for PyEval_GetFrame(), requested for Psyco */ |
195 | PyAPI_DATA(PyThreadFrameGetter) _PyThreadState_GetFrame; |
196 | |
197 | #ifdef __cplusplus |
198 | } |
199 | #endif |
200 | #endif /* !Py_PYSTATE_H */ |
201 | |