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(void) PyThreadState_Clear(PyThreadState *);

   109 PyAPI_FUNC(void) PyThreadState_Delete(PyThreadState *);

   110 #ifdef WITH_THREAD

   111 PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void);

   112 #endif

   113 

   114 PyAPI_FUNC(PyThreadState *) PyThreadState_Get(void);

   115 PyAPI_FUNC(PyThreadState *) PyThreadState_Swap(PyThreadState *);

   116 PyAPI_FUNC(PyObject *) PyThreadState_GetDict(void);

   117 PyAPI_FUNC(int) PyThreadState_SetAsyncExc(long, PyObject *);

   118 

   119 

   120 /* Variable and macro for in-line access to current thread state */

   121 

   122 PyAPI_DATA(PyThreadState *) _PyThreadState_Current;

   123 

   124 #ifdef Py_DEBUG

   125 #define PyThreadState_GET() PyThreadState_Get()

   126 #else

   127 #define PyThreadState_GET() (_PyThreadState_Current)

   128 #endif

   129 

   130 typedef

   131     enum {PyGILState_LOCKED, PyGILState_UNLOCKED}

   132         PyGILState_STATE;

   133 

   134 /* Ensure that the current thread is ready to call the Python

   135    C API, regardless of the current state of Python, or of its

   136    thread lock.  This may be called as many times as desired

   137    by a thread so long as each call is matched with a call to

   138    PyGILState_Release().  In general, other thread-state APIs may

   139    be used between _Ensure() and _Release() calls, so long as the

   140    thread-state is restored to its previous state before the Release().

   141    For example, normal use of the Py_BEGIN_ALLOW_THREADS/

   142    Py_END_ALLOW_THREADS macros are acceptable.

   143 

   144    The return value is an opaque "handle" to the thread state when

   145    PyGILState_Ensure() was called, and must be passed to

   146    PyGILState_Release() to ensure Python is left in the same state. Even

   147    though recursive calls are allowed, these handles can *not* be shared -

   148    each unique call to PyGILState_Ensure must save the handle for its

   149    call to PyGILState_Release.

   150 

   151    When the function returns, the current thread will hold the GIL.

   152 

   153    Failure is a fatal error.

   154 */

   155 PyAPI_FUNC(PyGILState_STATE) PyGILState_Ensure(void);

   156 

   157 /* Release any resources previously acquired.  After this call, Python's

   158    state will be the same as it was prior to the corresponding

   159    PyGILState_Ensure() call (but generally this state will be unknown to

   160    the caller, hence the use of the GILState API.)

   161 

   162    Every call to PyGILState_Ensure must be matched by a call to

   163    PyGILState_Release on the same thread.

   164 */

   165 PyAPI_FUNC(void) PyGILState_Release(PyGILState_STATE);

   166 

   167 /* Helper/diagnostic function - get the current thread state for

   168    this thread.  May return NULL if no GILState API has been used

   169    on the current thread.  Note the main thread always has such a

   170    thread-state, even if no auto-thread-state call has been made

   171    on the main thread.

   172 */

   173 PyAPI_FUNC(PyThreadState *) PyGILState_GetThisThreadState(void);

   174 

   175 /* The implementation of sys._current_frames()  Returns a dict mapping

   176    thread id to that thread's current frame.

   177 */

   178 PyAPI_FUNC(PyObject *) _PyThread_CurrentFrames(void);

   179 

   180 /* Routines for advanced debuggers, requested by David Beazley.

   181    Don't use unless you know what you are doing! */

   182 PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Head(void);

   183 PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Next(PyInterpreterState *);

   184 PyAPI_FUNC(PyThreadState *) PyInterpreterState_ThreadHead(PyInterpreterState *);

   185 PyAPI_FUNC(PyThreadState *) PyThreadState_Next(PyThreadState *);

   186 

   187 typedef struct _frame *(*PyThreadFrameGetter)(PyThreadState *self_);

   188 

   189 /* hook for PyEval_GetFrame(), requested for Psyco */

   190 PyAPI_DATA(PyThreadFrameGetter) _PyThreadState_GetFrame;

   191 

   192 #ifdef __cplusplus

   193 }

   194 #endif

   195 #endif /* !Py_PYSTATE_H */