#ifndef Py_CEVAL_H#define Py_CEVAL_H#ifdef __cplusplusextern "C" {#endif  /* Interface to random parts in ceval.c */ PyAPI_FUNC(PyObject *) PyEval_CallObjectWithKeywords(	PyObject *, PyObject *, PyObject *); /* DLL-level Backwards compatibility: */#undef PyEval_CallObjectPyAPI_FUNC(PyObject *) PyEval_CallObject(PyObject *, PyObject *); /* Inline this */#define PyEval_CallObject(func,arg) \        PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL) PyAPI_FUNC(PyObject *) PyEval_CallFunction(PyObject *obj,                                           const char *format, ...);PyAPI_FUNC(PyObject *) PyEval_CallMethod(PyObject *obj,                                         const char *methodname,                                         const char *format, ...); PyAPI_FUNC(void) PyEval_SetProfile(Py_tracefunc, PyObject *);PyAPI_FUNC(void) PyEval_SetTrace(Py_tracefunc, PyObject *); struct _frame; /* Avoid including frameobject.h */ PyAPI_FUNC(PyObject *) PyEval_GetBuiltins(void);PyAPI_FUNC(PyObject *) PyEval_GetGlobals(void);PyAPI_FUNC(PyObject *) PyEval_GetLocals(void);PyAPI_FUNC(struct _frame *) PyEval_GetFrame(void);PyAPI_FUNC(int) PyEval_GetRestricted(void); /* Look at the current frame's (if any) code's co_flags, and turn on   the corresponding compiler flags in cf->cf_flags.  Return 1 if any   flag was set, else return 0. */PyAPI_FUNC(int) PyEval_MergeCompilerFlags(PyCompilerFlags *cf); PyAPI_FUNC(int) Py_FlushLine(void); PyAPI_FUNC(int) Py_AddPendingCall(int (*func)(void *), void *arg);PyAPI_FUNC(int) Py_MakePendingCalls(void); /* Protection against deeply nested recursive calls */PyAPI_FUNC(void) Py_SetRecursionLimit(int);PyAPI_FUNC(int) Py_GetRecursionLimit(void); #define Py_EnterRecursiveCall(where)                                    \	    (_Py_MakeRecCheck(PyThreadState_GET()->recursion_depth) &&  \	     _Py_CheckRecursiveCall(where))#define Py_LeaveRecursiveCall()				\	    (--PyThreadState_GET()->recursion_depth)PyAPI_FUNC(int) _Py_CheckRecursiveCall(char *where);PyAPI_DATA(int) _Py_CheckRecursionLimit;#ifdef USE_STACKCHECK#  define _Py_MakeRecCheck(x)  (++(x) > --_Py_CheckRecursionLimit)#else#  define _Py_MakeRecCheck(x)  (++(x) > _Py_CheckRecursionLimit)#endif PyAPI_FUNC(const char *) PyEval_GetFuncName(PyObject *);PyAPI_FUNC(const char *) PyEval_GetFuncDesc(PyObject *); PyAPI_FUNC(PyObject *) PyEval_GetCallStats(PyObject *);PyAPI_FUNC(PyObject *) PyEval_EvalFrame(struct _frame *);PyAPI_FUNC(PyObject *) PyEval_EvalFrameEx(struct _frame *f, int exc); /* this used to be handled on a per-thread basis - now just two globals */PyAPI_DATA(volatile int) _Py_Ticker;PyAPI_DATA(int) _Py_CheckInterval; /* Interface for threads.    A module that plans to do a blocking system call (or something else   that lasts a long time and doesn't touch Python data) can allow other   threads to run as follows: 	...preparations here...	Py_BEGIN_ALLOW_THREADS	...blocking system call here...	Py_END_ALLOW_THREADS	...interpret result here...    The Py_BEGIN_ALLOW_THREADS/Py_END_ALLOW_THREADS pair expands to a   {}-surrounded block.   To leave the block in the middle (e.g., with return), you must insert   a line containing Py_BLOCK_THREADS before the return, e.g. 	if (...premature_exit...) {		Py_BLOCK_THREADS		PyErr_SetFromErrno(PyExc_IOError);		return NULL;	}    An alternative is: 	Py_BLOCK_THREADS	if (...premature_exit...) {		PyErr_SetFromErrno(PyExc_IOError);		return NULL;	}	Py_UNBLOCK_THREADS    For convenience, that the value of 'errno' is restored across   Py_END_ALLOW_THREADS and Py_BLOCK_THREADS.    WARNING: NEVER NEST CALLS TO Py_BEGIN_ALLOW_THREADS AND   Py_END_ALLOW_THREADS!!!    The function PyEval_InitThreads() should be called only from   initthread() in "threadmodule.c".    Note that not yet all candidates have been converted to use this   mechanism!*/ PyAPI_FUNC(PyThreadState *) PyEval_SaveThread(void);PyAPI_FUNC(void) PyEval_RestoreThread(PyThreadState *); #ifdef WITH_THREAD PyAPI_FUNC(int)  PyEval_ThreadsInitialized(void);PyAPI_FUNC(void) PyEval_InitThreads(void);PyAPI_FUNC(void) PyEval_AcquireLock(void);PyAPI_FUNC(void) PyEval_ReleaseLock(void);PyAPI_FUNC(void) PyEval_AcquireThread(PyThreadState *tstate);PyAPI_FUNC(void) PyEval_ReleaseThread(PyThreadState *tstate);PyAPI_FUNC(void) PyEval_ReInitThreads(void); #define Py_BEGIN_ALLOW_THREADS { \			PyThreadState *_save; \			_save = PyEval_SaveThread();#define Py_BLOCK_THREADS	PyEval_RestoreThread(_save);#define Py_UNBLOCK_THREADS	_save = PyEval_SaveThread();#define Py_END_ALLOW_THREADS	PyEval_RestoreThread(_save); \		 } #else /* !WITH_THREAD */ #define Py_BEGIN_ALLOW_THREADS {#define Py_BLOCK_THREADS#define Py_UNBLOCK_THREADS#define Py_END_ALLOW_THREADS } #endif /* !WITH_THREAD */ PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, Py_ssize_t *);  #ifdef __cplusplus}#endif#endif /* !Py_CEVAL_H */