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 /* DLL-level Backwards compatibility: */

    14 #undef PyEval_CallObject

    15 PyAPI_FUNC(PyObject *) PyEval_CallObject(PyObject *, PyObject *);

    16 

    17 /* Inline this */

    18 #define PyEval_CallObject(func,arg) \

    19         PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)

    20 

    21 PyAPI_FUNC(PyObject *) PyEval_CallFunction(PyObject *obj,

    22                                            const char *format, ...);

    23 PyAPI_FUNC(PyObject *) PyEval_CallMethod(PyObject *obj,

    24                                          const char *methodname,

    25                                          const char *format, ...);

    26 

    27 PyAPI_FUNC(void) PyEval_SetProfile(Py_tracefunc, PyObject *);

    28 PyAPI_FUNC(void) PyEval_SetTrace(Py_tracefunc, PyObject *);

    29 

    30 struct _frame; /* Avoid including frameobject.h */

    31 

    32 PyAPI_FUNC(PyObject *) PyEval_GetBuiltins(void);

    33 PyAPI_FUNC(PyObject *) PyEval_GetGlobals(void);

    34 PyAPI_FUNC(PyObject *) PyEval_GetLocals(void);

    35 PyAPI_FUNC(struct _frame *) PyEval_GetFrame(void);

    36 PyAPI_FUNC(int) PyEval_GetRestricted(void);

    37 

    38 /* Look at the current frame's (if any) code's co_flags, and turn on

    39    the corresponding compiler flags in cf->cf_flags.  Return 1 if any

    40    flag was set, else return 0. */

    41 PyAPI_FUNC(int) PyEval_MergeCompilerFlags(PyCompilerFlags *cf);

    42 

    43 PyAPI_FUNC(int) Py_FlushLine(void);

    44 

    45 PyAPI_FUNC(int) Py_AddPendingCall(int (*func)(void *), void *arg);

    46 PyAPI_FUNC(int) Py_MakePendingCalls(void);

    47 

    48 /* Protection against deeply nested recursive calls */

    49 PyAPI_FUNC(void) Py_SetRecursionLimit(int);

    50 PyAPI_FUNC(int) Py_GetRecursionLimit(void);

    51 

    52 #define Py_EnterRecursiveCall(where)                                    \

    53 	    (_Py_MakeRecCheck(PyThreadState_GET()->recursion_depth) &&  \

    54 	     _Py_CheckRecursiveCall(where))

    55 #define Py_LeaveRecursiveCall()				\

    56 	    (--PyThreadState_GET()->recursion_depth)

    57 PyAPI_FUNC(int) _Py_CheckRecursiveCall(char *where);

    58 PyAPI_DATA(int) _Py_CheckRecursionLimit;

    59 #ifdef USE_STACKCHECK

    60 #  define _Py_MakeRecCheck(x)  (++(x) > --_Py_CheckRecursionLimit)

    61 #else

    62 #  define _Py_MakeRecCheck(x)  (++(x) > _Py_CheckRecursionLimit)

    63 #endif

    64 

    65 PyAPI_FUNC(const char *) PyEval_GetFuncName(PyObject *);

    66 PyAPI_FUNC(const char *) PyEval_GetFuncDesc(PyObject *);

    67 

    68 PyAPI_FUNC(PyObject *) PyEval_GetCallStats(PyObject *);

    69 PyAPI_FUNC(PyObject *) PyEval_EvalFrame(struct _frame *);

    70 PyAPI_FUNC(PyObject *) PyEval_EvalFrameEx(struct _frame *f, int exc);

    71 

    72 /* this used to be handled on a per-thread basis - now just two globals */

    73 PyAPI_DATA(volatile int) _Py_Ticker;

    74 PyAPI_DATA(int) _Py_CheckInterval;

    75 

    76 /* Interface for threads.

    77 

    78    A module that plans to do a blocking system call (or something else

    79    that lasts a long time and doesn't touch Python data) can allow other

    80    threads to run as follows:

    81 

    82 	...preparations here...

    83 	Py_BEGIN_ALLOW_THREADS

    84 	...blocking system call here...

    85 	Py_END_ALLOW_THREADS

    86 	...interpret result here...

    87 

    88    The Py_BEGIN_ALLOW_THREADS/Py_END_ALLOW_THREADS pair expands to a

    89    {}-surrounded block.

    90    To leave the block in the middle (e.g., with return), you must insert

    91    a line containing Py_BLOCK_THREADS before the return, e.g.

    92 

    93 	if (...premature_exit...) {

    94 		Py_BLOCK_THREADS

    95 		PyErr_SetFromErrno(PyExc_IOError);

    96 		return NULL;

    97 	}

    98 

    99    An alternative is:

   100 

   101 	Py_BLOCK_THREADS

   102 	if (...premature_exit...) {

   103 		PyErr_SetFromErrno(PyExc_IOError);

   104 		return NULL;

   105 	}

   106 	Py_UNBLOCK_THREADS

   107 

   108    For convenience, that the value of 'errno' is restored across

   109    Py_END_ALLOW_THREADS and Py_BLOCK_THREADS.

   110 

   111    WARNING: NEVER NEST CALLS TO Py_BEGIN_ALLOW_THREADS AND

   112    Py_END_ALLOW_THREADS!!!

   113 

   114    The function PyEval_InitThreads() should be called only from

   115    initthread() in "threadmodule.c".

   116 

   117    Note that not yet all candidates have been converted to use this

   118    mechanism!

   119 */

   120 

   121 PyAPI_FUNC(PyThreadState *) PyEval_SaveThread(void);

   122 PyAPI_FUNC(void) PyEval_RestoreThread(PyThreadState *);

   123 

   124 #ifdef WITH_THREAD

   125 

   126 PyAPI_FUNC(int)  PyEval_ThreadsInitialized(void);

   127 PyAPI_FUNC(void) PyEval_InitThreads(void);

   128 PyAPI_FUNC(void) PyEval_AcquireLock(void);

   129 PyAPI_FUNC(void) PyEval_ReleaseLock(void);

   130 PyAPI_FUNC(void) PyEval_AcquireThread(PyThreadState *tstate);

   131 PyAPI_FUNC(void) PyEval_ReleaseThread(PyThreadState *tstate);

   132 PyAPI_FUNC(void) PyEval_ReInitThreads(void);

   133 

   134 #define Py_BEGIN_ALLOW_THREADS { \

   135 			PyThreadState *_save; \

   136 			_save = PyEval_SaveThread();

   137 #define Py_BLOCK_THREADS	PyEval_RestoreThread(_save);

   138 #define Py_UNBLOCK_THREADS	_save = PyEval_SaveThread();

   139 #define Py_END_ALLOW_THREADS	PyEval_RestoreThread(_save); \

   140 		 }

   141 

   142 #else /* !WITH_THREAD */

   143 

   144 #define Py_BEGIN_ALLOW_THREADS {

   145 #define Py_BLOCK_THREADS

   146 #define Py_UNBLOCK_THREADS

   147 #define Py_END_ALLOW_THREADS }

   148 

   149 #endif /* !WITH_THREAD */

   150 

   151 PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, Py_ssize_t *);

   152 

   153 

   154 #ifdef __cplusplus

   155 }

   156 #endif

   157 #endif /* !Py_CEVAL_H */