Include/pystate.h

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