1 #ifndef Py_CEVAL_H 2 #define Py_CEVAL_H 3 #ifdef __cplusplus 4 extern "C" { 5 #endif 6 7 8 /* Interface to random parts in ceval.c */ 9 10 PyAPI_FUNC(PyObject *) PyEval_CallObjectWithKeywords( 11 PyObject *, PyObject *, PyObject *); 12 13 /* Inline this */ 14 #define PyEval_CallObject(func,arg) \ 15 PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL) 16 17 PyAPI_FUNC(PyObject *) PyEval_CallFunction(PyObject *obj, 18 const char *format, ...); 19 PyAPI_FUNC(PyObject *) PyEval_CallMethod(PyObject *obj, 20 const char *methodname, 21 const char *format, ...); 22 23 PyAPI_FUNC(void) PyEval_SetProfile(Py_tracefunc, PyObject *); 24 PyAPI_FUNC(void) PyEval_SetTrace(Py_tracefunc, PyObject *); 25 26 struct _frame; /* Avoid including frameobject.h */ 27 28 PyAPI_FUNC(PyObject *) PyEval_GetBuiltins(void); 29 PyAPI_FUNC(PyObject *) PyEval_GetGlobals(void); 30 PyAPI_FUNC(PyObject *) PyEval_GetLocals(void); 31 PyAPI_FUNC(struct _frame *) PyEval_GetFrame(void); 32 PyAPI_FUNC(int) PyEval_GetRestricted(void); 33 34 /* Look at the current frame's (if any) code's co_flags, and turn on 35 the corresponding compiler flags in cf->cf_flags. Return 1 if any 36 flag was set, else return 0. */ 37 PyAPI_FUNC(int) PyEval_MergeCompilerFlags(PyCompilerFlags *cf); 38 39 PyAPI_FUNC(int) Py_FlushLine(void); 40 41 PyAPI_FUNC(int) Py_AddPendingCall(int (*func)(void *), void *arg); 42 PyAPI_FUNC(int) Py_MakePendingCalls(void); 43 44 /* Protection against deeply nested recursive calls */ 45 PyAPI_FUNC(void) Py_SetRecursionLimit(int); 46 PyAPI_FUNC(int) Py_GetRecursionLimit(void); 47 48 #define Py_EnterRecursiveCall(where) \ 49 (_Py_MakeRecCheck(PyThreadState_GET()->recursion_depth) && \ 50 _Py_CheckRecursiveCall(where)) 51 #define Py_LeaveRecursiveCall() \ 52 (--PyThreadState_GET()->recursion_depth) 53 PyAPI_FUNC(int) _Py_CheckRecursiveCall(char *where); 54 PyAPI_DATA(int) _Py_CheckRecursionLimit; 55 #ifdef USE_STACKCHECK 56 # define _Py_MakeRecCheck(x) (++(x) > --_Py_CheckRecursionLimit) 57 #else 58 # define _Py_MakeRecCheck(x) (++(x) > _Py_CheckRecursionLimit) 59 #endif 60 61 PyAPI_FUNC(const char *) PyEval_GetFuncName(PyObject *); 62 PyAPI_FUNC(const char *) PyEval_GetFuncDesc(PyObject *); 63 64 PyAPI_FUNC(PyObject *) PyEval_GetCallStats(PyObject *); 65 PyAPI_FUNC(PyObject *) PyEval_EvalFrame(struct _frame *); 66 PyAPI_FUNC(PyObject *) PyEval_EvalFrameEx(struct _frame *f, int exc); 67 68 /* this used to be handled on a per-thread basis - now just two globals */ 69 PyAPI_DATA(volatile int) _Py_Ticker; 70 PyAPI_DATA(int) _Py_CheckInterval; 71 72 /* Interface for threads. 73 74 A module that plans to do a blocking system call (or something else 75 that lasts a long time and doesn't touch Python data) can allow other 76 threads to run as follows: 77 78 ...preparations here... 79 Py_BEGIN_ALLOW_THREADS 80 ...blocking system call here... 81 Py_END_ALLOW_THREADS 82 ...interpret result here... 83 84 The Py_BEGIN_ALLOW_THREADS/Py_END_ALLOW_THREADS pair expands to a 85 {}-surrounded block. 86 To leave the block in the middle (e.g., with return), you must insert 87 a line containing Py_BLOCK_THREADS before the return, e.g. 88 89 if (...premature_exit...) { 90 Py_BLOCK_THREADS 91 PyErr_SetFromErrno(PyExc_IOError); 92 return NULL; 93 } 94 95 An alternative is: 96 97 Py_BLOCK_THREADS 98 if (...premature_exit...) { 99 PyErr_SetFromErrno(PyExc_IOError); 100 return NULL; 101 } 102 Py_UNBLOCK_THREADS 103 104 For convenience, that the value of 'errno' is restored across 105 Py_END_ALLOW_THREADS and Py_BLOCK_THREADS. 106 107 WARNING: NEVER NEST CALLS TO Py_BEGIN_ALLOW_THREADS AND 108 Py_END_ALLOW_THREADS!!! 109 110 The function PyEval_InitThreads() should be called only from 111 initthread() in "threadmodule.c". 112 113 Note that not yet all candidates have been converted to use this 114 mechanism! 115 */ 116 117 PyAPI_FUNC(PyThreadState *) PyEval_SaveThread(void); 118 PyAPI_FUNC(void) PyEval_RestoreThread(PyThreadState *); 119 120 #ifdef WITH_THREAD 121 122 PyAPI_FUNC(int) PyEval_ThreadsInitialized(void); 123 PyAPI_FUNC(void) PyEval_InitThreads(void); 124 PyAPI_FUNC(void) PyEval_AcquireLock(void); 125 PyAPI_FUNC(void) PyEval_ReleaseLock(void); 126 PyAPI_FUNC(void) PyEval_AcquireThread(PyThreadState *tstate); 127 PyAPI_FUNC(void) PyEval_ReleaseThread(PyThreadState *tstate); 128 PyAPI_FUNC(void) PyEval_ReInitThreads(void); 129 130 #define Py_BEGIN_ALLOW_THREADS { \ 131 PyThreadState *_save; \ 132 _save = PyEval_SaveThread(); 133 #define Py_BLOCK_THREADS PyEval_RestoreThread(_save); 134 #define Py_UNBLOCK_THREADS _save = PyEval_SaveThread(); 135 #define Py_END_ALLOW_THREADS PyEval_RestoreThread(_save); \ 136 } 137 138 #else /* !WITH_THREAD */ 139 140 #define Py_BEGIN_ALLOW_THREADS { 141 #define Py_BLOCK_THREADS 142 #define Py_UNBLOCK_THREADS 143 #define Py_END_ALLOW_THREADS } 144 145 #endif /* !WITH_THREAD */ 146 147 PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, Py_ssize_t *); 148 149 150 #ifdef __cplusplus 151 } 152 #endif 153 #endif /* !Py_CEVAL_H */ 154
