2 /* Thread and interpreter state structures and their interfaces */
11 /* State shared between threads */
13 struct _ts
; /* Forward */
14 struct _is
; /* Forward */
19 struct _ts
*tstate_head
;
24 PyObject
*modules_reloading
;
26 PyObject
*codec_search_path
;
27 PyObject
*codec_search_cache
;
28 PyObject
*codec_error_registry
;
40 /* State unique per thread */
42 struct _frame
; /* Avoid including frameobject.h */
44 /* Py_tracefunc return -1 when raising an exception, or 0 for success. */
45 typedef int (*Py_tracefunc
)(PyObject
*, struct _frame
*, int, PyObject
*);
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
57 /* See Python/ceval.c for comments explaining most fields */
60 PyInterpreterState
*interp
;
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
70 Py_tracefunc c_profilefunc
;
71 Py_tracefunc c_tracefunc
;
72 PyObject
*c_profileobj
;
75 PyObject
*curexc_type
;
76 PyObject
*curexc_value
;
77 PyObject
*curexc_traceback
;
81 PyObject
*exc_traceback
;
83 PyObject
*dict
; /* Stores per-thread state */
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.
95 PyObject
*async_exc
; /* Asynchronous exception to raise */
96 long thread_id
; /* Thread id where this tstate was created */
98 /* XXX signal handlers should also be here */
103 PyAPI_FUNC(PyInterpreterState
*) PyInterpreterState_New(void);
104 PyAPI_FUNC(void) PyInterpreterState_Clear(PyInterpreterState
*);
105 PyAPI_FUNC(void) PyInterpreterState_Delete(PyInterpreterState
*);
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
*);
113 PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void);
116 PyAPI_FUNC(PyThreadState
*) PyThreadState_Get(void);
117 PyAPI_FUNC(PyThreadState
*) PyThreadState_Swap(PyThreadState
*);
118 PyAPI_FUNC(PyObject
*) PyThreadState_GetDict(void);
119 PyAPI_FUNC(int) PyThreadState_SetAsyncExc(long, PyObject
*);
122 /* Variable and macro for in-line access to current thread state */
124 PyAPI_DATA(PyThreadState
*) _PyThreadState_Current
;
127 #define PyThreadState_GET() PyThreadState_Get()
129 #define PyThreadState_GET() (_PyThreadState_Current)
133 enum {PyGILState_LOCKED
, PyGILState_UNLOCKED
}
136 /* Ensure that the current thread is ready to call the Python
137 C API, regardless of the current state of Python, or of its
138 thread lock. This may be called as many times as desired
139 by a thread so long as each call is matched with a call to
140 PyGILState_Release(). In general, other thread-state APIs may
141 be used between _Ensure() and _Release() calls, so long as the
142 thread-state is restored to its previous state before the Release().
143 For example, normal use of the Py_BEGIN_ALLOW_THREADS/
144 Py_END_ALLOW_THREADS macros are acceptable.
146 The return value is an opaque "handle" to the thread state when
147 PyGILState_Ensure() was called, and must be passed to
148 PyGILState_Release() to ensure Python is left in the same state. Even
149 though recursive calls are allowed, these handles can *not* be shared -
150 each unique call to PyGILState_Ensure must save the handle for its
151 call to PyGILState_Release.
153 When the function returns, the current thread will hold the GIL.
155 Failure is a fatal error.
157 PyAPI_FUNC(PyGILState_STATE
) PyGILState_Ensure(void);
159 /* Release any resources previously acquired. After this call, Python's
160 state will be the same as it was prior to the corresponding
161 PyGILState_Ensure() call (but generally this state will be unknown to
162 the caller, hence the use of the GILState API.)
164 Every call to PyGILState_Ensure must be matched by a call to
165 PyGILState_Release on the same thread.
167 PyAPI_FUNC(void) PyGILState_Release(PyGILState_STATE
);
169 /* Helper/diagnostic function - get the current thread state for
170 this thread. May return NULL if no GILState API has been used
171 on the current thread. Note the main thread always has such a
172 thread-state, even if no auto-thread-state call has been made
175 PyAPI_FUNC(PyThreadState
*) PyGILState_GetThisThreadState(void);
177 /* The implementation of sys._current_frames() Returns a dict mapping
178 thread id to that thread's current frame.
180 PyAPI_FUNC(PyObject
*) _PyThread_CurrentFrames(void);
182 /* Routines for advanced debuggers, requested by David Beazley.
183 Don't use unless you know what you are doing! */
184 PyAPI_FUNC(PyInterpreterState
*) PyInterpreterState_Head(void);
185 PyAPI_FUNC(PyInterpreterState
*) PyInterpreterState_Next(PyInterpreterState
*);
186 PyAPI_FUNC(PyThreadState
*) PyInterpreterState_ThreadHead(PyInterpreterState
*);
187 PyAPI_FUNC(PyThreadState
*) PyThreadState_Next(PyThreadState
*);
189 typedef struct _frame
*(*PyThreadFrameGetter
)(PyThreadState
*self_
);
191 /* hook for PyEval_GetFrame(), requested for Psyco */
192 PyAPI_DATA(PyThreadFrameGetter
) _PyThreadState_GetFrame
;
197 #endif /* !Py_PYSTATE_H */