/* Thread and interpreter state structures and their interfaces */
/* State shared between threads */
struct _ts
; /* Forward */
struct _is
; /* Forward */
PyObject
*codec_search_path
;
PyObject
*codec_search_cache
;
PyObject
*codec_error_registry
;
/* State unique per thread */
struct _frame
; /* Avoid including frameobject.h */
/* Py_tracefunc return -1 when raising an exception, or 0 for success. */
typedef int (*Py_tracefunc
)(PyObject
*, struct _frame
*, int, PyObject
*);
/* The following values are used for 'what' for tracefunc functions: */
#define PyTrace_EXCEPTION 1
#define PyTrace_C_EXCEPTION 5
#define PyTrace_C_RETURN 6
PyInterpreterState
*interp
;
Py_tracefunc c_profilefunc
;
Py_tracefunc c_tracefunc
;
PyObject
*curexc_traceback
;
/* tick_counter is incremented whenever the check_interval ticker
* reaches zero. The purpose is to give a useful measure of the number
* of interpreted bytecode instructions in a given thread. This
* extremely lightweight statistic collector may be of interest to
* profilers (like psyco.jit()), although nothing in the core uses it.
PyObject
*async_exc
; /* Asynchronous exception to raise */
long thread_id
; /* Thread id where this tstate was created */
/* XXX signal handlers should also be here */
PyAPI_FUNC(PyInterpreterState
*) PyInterpreterState_New(void);
PyAPI_FUNC(void) PyInterpreterState_Clear(PyInterpreterState
*);
PyAPI_FUNC(void) PyInterpreterState_Delete(PyInterpreterState
*);
PyAPI_FUNC(PyThreadState
*) PyThreadState_New(PyInterpreterState
*);
PyAPI_FUNC(void) PyThreadState_Clear(PyThreadState
*);
PyAPI_FUNC(void) PyThreadState_Delete(PyThreadState
*);
PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void);
PyAPI_FUNC(PyThreadState
*) PyThreadState_Get(void);
PyAPI_FUNC(PyThreadState
*) PyThreadState_Swap(PyThreadState
*);
PyAPI_FUNC(PyObject
*) PyThreadState_GetDict(void);
PyAPI_FUNC(int) PyThreadState_SetAsyncExc(long, PyObject
*);
/* Variable and macro for in-line access to current thread state */
PyAPI_DATA(PyThreadState
*) _PyThreadState_Current
;
#define PyThreadState_GET() PyThreadState_Get()
#define PyThreadState_GET() (_PyThreadState_Current)
enum {PyGILState_LOCKED
, PyGILState_UNLOCKED
}
/* 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 the main thread always has such a
thread-state, even if no auto-thread-state call has been made
PyAPI_FUNC(PyThreadState
*) PyGILState_GetThisThreadState(void);
/* Routines for advanced debuggers, requested by David Beazley.
Don't use unless you know what you are doing! */
PyAPI_FUNC(PyInterpreterState
*) PyInterpreterState_Head(void);
PyAPI_FUNC(PyInterpreterState
*) PyInterpreterState_Next(PyInterpreterState
*);
PyAPI_FUNC(PyThreadState
*) PyInterpreterState_ThreadHead(PyInterpreterState
*);
PyAPI_FUNC(PyThreadState
*) PyThreadState_Next(PyThreadState
*);
typedef struct _frame
*(*PyThreadFrameGetter
)(PyThreadState
*self_
);
/* hook for PyEval_GetFrame(), requested for Psyco */
PyAPI_DATA(PyThreadFrameGetter
) _PyThreadState_GetFrame
;
#endif /* !Py_PYSTATE_H */