linuxport: Merging in the fruits of my labors (Python VFS)
[xbmc:xbmc-antiquated.git] / xbmc / lib / libPython / Python / 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
57     struct _ts *next;
58     PyInterpreterState *interp;
59
60     struct _frame *frame;
61     int recursion_depth;
62     int tracing;
63     int use_tracing;
64
65     Py_tracefunc c_profilefunc;
66     Py_tracefunc c_tracefunc;
67     PyObject *c_profileobj;
68     PyObject *c_traceobj;
69
70     PyObject *curexc_type;
71     PyObject *curexc_value;
72     PyObject *curexc_traceback;
73
74     PyObject *exc_type;
75     PyObject *exc_value;
76     PyObject *exc_traceback;
77
78     PyObject *dict;
79
80     /* tick_counter is incremented whenever the check_interval ticker
81      * reaches zero. The purpose is to give a useful measure of the number
82      * of interpreted bytecode instructions in a given thread.  This
83      * extremely lightweight statistic collector may be of interest to
84      * profilers (like psyco.jit()), although nothing in the core uses it.
85      */
86     int tick_counter;
87
88     int gilstate_counter;
89
90     PyObject *async_exc; /* Asynchronous exception to raise */
91     long thread_id; /* Thread id where this tstate was created */
92
93     /* XXX signal handlers should also be here */
94
95 } PyThreadState;
96
97
98 PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_New(void);
99 PyAPI_FUNC(void) PyInterpreterState_Clear(PyInterpreterState *);
100 PyAPI_FUNC(void) PyInterpreterState_Delete(PyInterpreterState *);
101
102 PyAPI_FUNC(PyThreadState *) PyThreadState_New(PyInterpreterState *);
103 PyAPI_FUNC(void) PyThreadState_Clear(PyThreadState *);
104 PyAPI_FUNC(void) PyThreadState_Delete(PyThreadState *);
105 #ifdef WITH_THREAD
106 PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void);
107 #endif
108
109 PyAPI_FUNC(PyThreadState *) PyThreadState_Get(void);
110 PyAPI_FUNC(PyThreadState *) PyThreadState_Swap(PyThreadState *);
111 PyAPI_FUNC(PyObject *) PyThreadState_GetDict(void);
112 PyAPI_FUNC(int) PyThreadState_SetAsyncExc(long, PyObject *);
113
114
115 /* Variable and macro for in-line access to current thread state */
116
117 PyAPI_DATA(PyThreadState *) _PyThreadState_Current;
118
119 #ifdef Py_DEBUG
120 #define PyThreadState_GET() PyThreadState_Get()
121 #else
122 #define PyThreadState_GET() (_PyThreadState_Current)
123 #endif
124
125 typedef
126     enum {PyGILState_LOCKED, PyGILState_UNLOCKED}
127         PyGILState_STATE;
128
129 /* Ensure that the current thread is ready to call the Python
130    C API, regardless of the current state of Python, or of its
131    thread lock.  This may be called as many times as desired
132    by a thread so long as each call is matched with a call to
133    PyGILState_Release().  In general, other thread-state APIs may
134    be used between _Ensure() and _Release() calls, so long as the
135    thread-state is restored to its previous state before the Release().
136    For example, normal use of the Py_BEGIN_ALLOW_THREADS/
137    Py_END_ALLOW_THREADS macros are acceptable.
138
139    The return value is an opaque "handle" to the thread state when
140    PyGILState_Ensure() was called, and must be passed to
141    PyGILState_Release() to ensure Python is left in the same state. Even
142    though recursive calls are allowed, these handles can *not* be shared -
143    each unique call to PyGILState_Ensure must save the handle for its
144    call to PyGILState_Release.
145
146    When the function returns, the current thread will hold the GIL.
147
148    Failure is a fatal error.
149 */
150 PyAPI_FUNC(PyGILState_STATE) PyGILState_Ensure(void);
151
152 /* Release any resources previously acquired.  After this call, Python's
153    state will be the same as it was prior to the corresponding
154    PyGILState_Ensure() call (but generally this state will be unknown to
155    the caller, hence the use of the GILState API.)
156
157    Every call to PyGILState_Ensure must be matched by a call to
158    PyGILState_Release on the same thread.
159 */
160 PyAPI_FUNC(void) PyGILState_Release(PyGILState_STATE);
161
162 /* Helper/diagnostic function - get the current thread state for
163    this thread.  May return NULL if no GILState API has been used
164    on the current thread.  Note the main thread always has such a
165    thread-state, even if no auto-thread-state call has been made
166    on the main thread.
167 */
168 PyAPI_FUNC(PyThreadState *) PyGILState_GetThisThreadState(void);
169
170 /* Routines for advanced debuggers, requested by David Beazley.
171    Don't use unless you know what you are doing! */
172 PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Head(void);
173 PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Next(PyInterpreterState *);
174 PyAPI_FUNC(PyThreadState *) PyInterpreterState_ThreadHead(PyInterpreterState *);
175 PyAPI_FUNC(PyThreadState *) PyThreadState_Next(PyThreadState *);
176
177 typedef struct _frame *(*PyThreadFrameGetter)(PyThreadState *self_);
178
179 /* hook for PyEval_GetFrame(), requested for Psyco */
180 PyAPI_DATA(PyThreadFrameGetter) _PyThreadState_GetFrame;
181
182 #ifdef __cplusplus
183 }
184 #endif
185 #endif /* !Py_PYSTATE_H */