AppPkg/Applications/Python/Python-2.7.10/Include/ceval.h

   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 */