Home | History | Annotate | Download | only in python2.7 
      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     int trash_delete_nesting;
     99     PyObject *trash_delete_later;
    100 
    101     /* XXX signal handlers should also be here */
    102 
    103 } PyThreadState;
    104 
    105 
    106 PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_New(void);
    107 PyAPI_FUNC(void) PyInterpreterState_Clear(PyInterpreterState *);
    108 PyAPI_FUNC(void) PyInterpreterState_Delete(PyInterpreterState *);
    109 
    110 PyAPI_FUNC(PyThreadState *) PyThreadState_New(PyInterpreterState *);
    111 PyAPI_FUNC(PyThreadState *) _PyThreadState_Prealloc(PyInterpreterState *);
    112 PyAPI_FUNC(void) _PyThreadState_Init(PyThreadState *);
    113 PyAPI_FUNC(void) PyThreadState_Clear(PyThreadState *);
    114 PyAPI_FUNC(void) PyThreadState_Delete(PyThreadState *);
    115 #ifdef WITH_THREAD
    116 PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void);
    117 #endif
    118 
    119 PyAPI_FUNC(PyThreadState *) PyThreadState_Get(void);
    120 PyAPI_FUNC(PyThreadState *) PyThreadState_Swap(PyThreadState *);
    121 PyAPI_FUNC(PyObject *) PyThreadState_GetDict(void);
    122 PyAPI_FUNC(int) PyThreadState_SetAsyncExc(long, PyObject *);
    123 
    124 
    125 /* Variable and macro for in-line access to current thread state */
    126 
    127 PyAPI_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 
    135 typedef
    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 */
    160 PyAPI_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 */
    170 PyAPI_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 */
    178 PyAPI_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 */
    183 PyAPI_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! */
    187 PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Head(void);
    188 PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Next(PyInterpreterState *);
    189 PyAPI_FUNC(PyThreadState *) PyInterpreterState_ThreadHead(PyInterpreterState *);
    190 PyAPI_FUNC(PyThreadState *) PyThreadState_Next(PyThreadState *);
    191 
    192 typedef struct _frame *(*PyThreadFrameGetter)(PyThreadState *self_);
    193 
    194 /* hook for PyEval_GetFrame(), requested for Psyco */
    195 PyAPI_DATA(PyThreadFrameGetter) _PyThreadState_GetFrame;
    196 
    197 #ifdef __cplusplus
    198 }
    199 #endif
    200 #endif /* !Py_PYSTATE_H */
    201