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 /* XXX signal handlers should also be here */ 99 100 } PyThreadState; 101 102 103 PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_New(void); 104 PyAPI_FUNC(void) PyInterpreterState_Clear(PyInterpreterState *); 105 PyAPI_FUNC(void) PyInterpreterState_Delete(PyInterpreterState *); 106 107 PyAPI_FUNC(PyThreadState *) PyThreadState_New(PyInterpreterState *); 108 PyAPI_FUNC(PyThreadState *) _PyThreadState_Prealloc(PyInterpreterState *); 109 PyAPI_FUNC(void) _PyThreadState_Init(PyThreadState *); 110 PyAPI_FUNC(void) PyThreadState_Clear(PyThreadState *); 111 PyAPI_FUNC(void) PyThreadState_Delete(PyThreadState *); 112 #ifdef WITH_THREAD 113 PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void); 114 PyAPI_FUNC(void) _PyGILState_Reinit(void); 115 #endif 116 117 PyAPI_FUNC(PyThreadState *) PyThreadState_Get(void); 118 PyAPI_FUNC(PyThreadState *) PyThreadState_Swap(PyThreadState *); 119 PyAPI_FUNC(PyObject *) PyThreadState_GetDict(void); 120 PyAPI_FUNC(int) PyThreadState_SetAsyncExc(long, PyObject *); 121 122 123 /* Variable and macro for in-line access to current thread state */ 124 125 PyAPI_DATA(PyThreadState *) _PyThreadState_Current; 126 127 #ifdef Py_DEBUG 128 #define PyThreadState_GET() PyThreadState_Get() 129 #else 130 #define PyThreadState_GET() (_PyThreadState_Current) 131 #endif 132 133 typedef 134 enum {PyGILState_LOCKED, PyGILState_UNLOCKED} 135 PyGILState_STATE; 136 137 /* Ensure that the current thread is ready to call the Python 138 C API, regardless of the current state of Python, or of its 139 thread lock. This may be called as many times as desired 140 by a thread so long as each call is matched with a call to 141 PyGILState_Release(). In general, other thread-state APIs may 142 be used between _Ensure() and _Release() calls, so long as the 143 thread-state is restored to its previous state before the Release(). 144 For example, normal use of the Py_BEGIN_ALLOW_THREADS/ 145 Py_END_ALLOW_THREADS macros are acceptable. 146 147 The return value is an opaque "handle" to the thread state when 148 PyGILState_Ensure() was called, and must be passed to 149 PyGILState_Release() to ensure Python is left in the same state. Even 150 though recursive calls are allowed, these handles can *not* be shared - 151 each unique call to PyGILState_Ensure must save the handle for its 152 call to PyGILState_Release. 153 154 When the function returns, the current thread will hold the GIL. 155 156 Failure is a fatal error. 157 */ 158 PyAPI_FUNC(PyGILState_STATE) PyGILState_Ensure(void); 159 160 /* Release any resources previously acquired. After this call, Python's 161 state will be the same as it was prior to the corresponding 162 PyGILState_Ensure() call (but generally this state will be unknown to 163 the caller, hence the use of the GILState API.) 164 165 Every call to PyGILState_Ensure must be matched by a call to 166 PyGILState_Release on the same thread. 167 */ 168 PyAPI_FUNC(void) PyGILState_Release(PyGILState_STATE); 169 170 /* Helper/diagnostic function - get the current thread state for 171 this thread. May return NULL if no GILState API has been used 172 on the current thread. Note the main thread always has such a 173 thread-state, even if no auto-thread-state call has been made 174 on the main thread. 175 */ 176 PyAPI_FUNC(PyThreadState *) PyGILState_GetThisThreadState(void); 177 178 /* The implementation of sys._current_frames() Returns a dict mapping 179 thread id to that thread's current frame. 180 */ 181 PyAPI_FUNC(PyObject *) _PyThread_CurrentFrames(void); 182 183 /* Routines for advanced debuggers, requested by David Beazley. 184 Don't use unless you know what you are doing! */ 185 PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Head(void); 186 PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Next(PyInterpreterState *); 187 PyAPI_FUNC(PyThreadState *) PyInterpreterState_ThreadHead(PyInterpreterState *); 188 PyAPI_FUNC(PyThreadState *) PyThreadState_Next(PyThreadState *); 189 190 typedef struct _frame *(*PyThreadFrameGetter)(PyThreadState *self_); 191 192 /* hook for PyEval_GetFrame(), requested for Psyco */ 193 PyAPI_DATA(PyThreadFrameGetter) _PyThreadState_GetFrame; 194 195 #ifdef __cplusplus 196 } 197 #endif 198 #endif /* !Py_PYSTATE_H */ 199