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
8extern "C" {
9#endif
10
11/* State shared between threads */
12
13struct _ts; /* Forward */
14struct _is; /* Forward */
15
16typedef 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
42struct _frame; /* Avoid including frameobject.h */
43
44/* Py_tracefunc return -1 when raising an exception, or 0 for success. */
45typedef 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
56typedef 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
106PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_New(void);
107PyAPI_FUNC(void) PyInterpreterState_Clear(PyInterpreterState *);
108PyAPI_FUNC(void) PyInterpreterState_Delete(PyInterpreterState *);
109
110PyAPI_FUNC(PyThreadState *) PyThreadState_New(PyInterpreterState *);
111PyAPI_FUNC(PyThreadState *) _PyThreadState_Prealloc(PyInterpreterState *);
112PyAPI_FUNC(void) _PyThreadState_Init(PyThreadState *);
113PyAPI_FUNC(void) PyThreadState_Clear(PyThreadState *);
114PyAPI_FUNC(void) PyThreadState_Delete(PyThreadState *);
115#ifdef WITH_THREAD
116PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void);
117#endif
118
119PyAPI_FUNC(PyThreadState *) PyThreadState_Get(void);
120PyAPI_FUNC(PyThreadState *) PyThreadState_Swap(PyThreadState *);
121PyAPI_FUNC(PyObject *) PyThreadState_GetDict(void);
122PyAPI_FUNC(int) PyThreadState_SetAsyncExc(long, PyObject *);
123
124
125/* Variable and macro for in-line access to current thread state */
126
127PyAPI_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
135typedef
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*/
160PyAPI_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*/
170PyAPI_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*/
178PyAPI_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*/
183PyAPI_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! */
187PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Head(void);
188PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Next(PyInterpreterState *);
189PyAPI_FUNC(PyThreadState *) PyInterpreterState_ThreadHead(PyInterpreterState *);
190PyAPI_FUNC(PyThreadState *) PyThreadState_Next(PyThreadState *);
191
192typedef struct _frame *(*PyThreadFrameGetter)(PyThreadState *self_);
193
194/* hook for PyEval_GetFrame(), requested for Psyco */
195PyAPI_DATA(PyThreadFrameGetter) _PyThreadState_GetFrame;
196
197#ifdef __cplusplus
198}
199#endif
200#endif /* !Py_PYSTATE_H */
201