2021-10-15 19:06:05 +08:00
|
|
|
/* Interface to random parts in ceval.c */
|
|
|
|
|
1993-07-28 17:05:47 +08:00
|
|
|
#ifndef Py_CEVAL_H
|
|
|
|
#define Py_CEVAL_H
|
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif
|
|
|
|
|
1991-02-19 20:39:46 +08:00
|
|
|
|
2021-10-15 19:06:05 +08:00
|
|
|
PyAPI_FUNC(PyObject *) PyEval_EvalCode(PyObject *, PyObject *, PyObject *);
|
|
|
|
|
|
|
|
PyAPI_FUNC(PyObject *) PyEval_EvalCodeEx(PyObject *co,
|
|
|
|
PyObject *globals,
|
|
|
|
PyObject *locals,
|
|
|
|
PyObject *const *args, int argc,
|
|
|
|
PyObject *const *kwds, int kwdc,
|
|
|
|
PyObject *const *defs, int defc,
|
|
|
|
PyObject *kwdefs, PyObject *closure);
|
2017-03-14 17:00:59 +08:00
|
|
|
|
|
|
|
/* PyEval_CallObjectWithKeywords(), PyEval_CallObject(), PyEval_CallFunction
|
2019-07-24 20:02:49 +08:00
|
|
|
* and PyEval_CallMethod are deprecated. Since they are officially part of the
|
|
|
|
* stable ABI (PEP 384), they must be kept for backward compatibility.
|
|
|
|
* PyObject_Call(), PyObject_CallFunction() and PyObject_CallMethod() are
|
|
|
|
* recommended to call a callable object.
|
2017-03-14 17:00:59 +08:00
|
|
|
*/
|
1990-12-20 23:06:42 +08:00
|
|
|
|
2019-07-24 20:02:49 +08:00
|
|
|
Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyEval_CallObjectWithKeywords(
|
2016-12-06 23:27:24 +08:00
|
|
|
PyObject *callable,
|
|
|
|
PyObject *args,
|
|
|
|
PyObject *kwargs);
|
1991-07-28 06:33:03 +09:00
|
|
|
|
2019-07-24 20:02:49 +08:00
|
|
|
/* Deprecated since PyEval_CallObjectWithKeywords is deprecated */
|
2016-12-06 23:27:24 +08:00
|
|
|
#define PyEval_CallObject(callable, arg) \
|
|
|
|
PyEval_CallObjectWithKeywords(callable, arg, (PyObject *)NULL)
|
1997-08-30 23:02:50 +08:00
|
|
|
|
2019-07-24 20:02:49 +08:00
|
|
|
Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyEval_CallFunction(
|
|
|
|
PyObject *callable, const char *format, ...);
|
|
|
|
Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyEval_CallMethod(
|
|
|
|
PyObject *obj, const char *name, const char *format, ...);
|
1998-08-09 04:53:36 +08:00
|
|
|
|
2002-08-12 15:21:58 +08:00
|
|
|
PyAPI_FUNC(PyObject *) PyEval_GetBuiltins(void);
|
|
|
|
PyAPI_FUNC(PyObject *) PyEval_GetGlobals(void);
|
|
|
|
PyAPI_FUNC(PyObject *) PyEval_GetLocals(void);
|
2020-04-28 22:32:48 +08:00
|
|
|
PyAPI_FUNC(PyFrameObject *) PyEval_GetFrame(void);
|
2001-07-16 10:29:45 +08:00
|
|
|
|
2002-08-12 15:21:58 +08:00
|
|
|
PyAPI_FUNC(int) Py_AddPendingCall(int (*func)(void *), void *arg);
|
|
|
|
PyAPI_FUNC(int) Py_MakePendingCalls(void);
|
1994-09-14 21:23:36 +08:00
|
|
|
|
2008-09-04 02:34:34 +08:00
|
|
|
/* Protection against deeply nested recursive calls
|
|
|
|
|
|
|
|
In Python 3.0, this protection has two levels:
|
|
|
|
* normal anti-recursion protection is triggered when the recursion level
|
2015-07-03 13:04:23 +08:00
|
|
|
exceeds the current recursion limit. It raises a RecursionError, and sets
|
2008-09-04 02:34:34 +08:00
|
|
|
the "overflowed" flag in the thread state structure. This flag
|
|
|
|
temporarily *disables* the normal protection; this allows cleanup code
|
2010-05-09 23:52:27 +08:00
|
|
|
to potentially outgrow the recursion limit while processing the
|
2015-07-03 13:04:23 +08:00
|
|
|
RecursionError.
|
2008-09-04 02:34:34 +08:00
|
|
|
* "last chance" anti-recursion protection is triggered when the recursion
|
|
|
|
level exceeds "current recursion limit + 50". By construction, this
|
|
|
|
protection can only be triggered when the "overflowed" flag is set. It
|
|
|
|
means the cleanup code has itself gone into an infinite loop, or the
|
2015-07-03 13:04:23 +08:00
|
|
|
RecursionError has been mistakingly ignored. When this protection is
|
2008-09-04 02:34:34 +08:00
|
|
|
triggered, the interpreter aborts with a Fatal Error.
|
|
|
|
|
|
|
|
In addition, the "overflowed" flag is automatically reset when the
|
|
|
|
recursion level drops below "current recursion limit - 50". This heuristic
|
|
|
|
is meant to ensure that the normal anti-recursion protection doesn't get
|
|
|
|
disabled too long.
|
|
|
|
|
|
|
|
Please note: this scheme has its own limitations. See:
|
|
|
|
http://mail.python.org/pipermail/python-dev/2008-August/082106.html
|
|
|
|
for some observations.
|
|
|
|
*/
|
2002-08-12 15:21:58 +08:00
|
|
|
PyAPI_FUNC(void) Py_SetRecursionLimit(int);
|
|
|
|
PyAPI_FUNC(int) Py_GetRecursionLimit(void);
|
1992-08-06 03:58:53 +08:00
|
|
|
|
2019-11-05 02:48:34 +08:00
|
|
|
PyAPI_FUNC(int) Py_EnterRecursiveCall(const char *where);
|
|
|
|
PyAPI_FUNC(void) Py_LeaveRecursiveCall(void);
|
2008-09-04 02:34:34 +08:00
|
|
|
|
2005-12-11 02:50:16 +08:00
|
|
|
PyAPI_FUNC(const char *) PyEval_GetFuncName(PyObject *);
|
|
|
|
PyAPI_FUNC(const char *) PyEval_GetFuncDesc(PyObject *);
|
2001-08-02 12:15:00 +08:00
|
|
|
|
2020-04-28 22:32:48 +08:00
|
|
|
PyAPI_FUNC(PyObject *) PyEval_EvalFrame(PyFrameObject *);
|
|
|
|
PyAPI_FUNC(PyObject *) PyEval_EvalFrameEx(PyFrameObject *f, int exc);
|
2003-02-06 07:13:00 +08:00
|
|
|
|
1992-08-06 03:58:53 +08:00
|
|
|
/* 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:
|
|
|
|
|
2010-05-09 23:52:27 +08:00
|
|
|
...preparations here...
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
|
|
...blocking system call here...
|
|
|
|
Py_END_ALLOW_THREADS
|
|
|
|
...interpret result here...
|
1992-08-06 03:58:53 +08:00
|
|
|
|
1995-01-12 19:45:45 +08:00
|
|
|
The Py_BEGIN_ALLOW_THREADS/Py_END_ALLOW_THREADS pair expands to a
|
|
|
|
{}-surrounded block.
|
1992-08-06 03:58:53 +08:00
|
|
|
To leave the block in the middle (e.g., with return), you must insert
|
2000-09-16 02:19:27 +08:00
|
|
|
a line containing Py_BLOCK_THREADS before the return, e.g.
|
1992-08-06 03:58:53 +08:00
|
|
|
|
2010-05-09 23:52:27 +08:00
|
|
|
if (...premature_exit...) {
|
|
|
|
Py_BLOCK_THREADS
|
2017-04-16 15:46:38 +08:00
|
|
|
PyErr_SetFromErrno(PyExc_OSError);
|
2010-05-09 23:52:27 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
1992-08-06 03:58:53 +08:00
|
|
|
|
|
|
|
An alternative is:
|
|
|
|
|
2010-05-09 23:52:27 +08:00
|
|
|
Py_BLOCK_THREADS
|
|
|
|
if (...premature_exit...) {
|
2017-04-16 15:46:38 +08:00
|
|
|
PyErr_SetFromErrno(PyExc_OSError);
|
2010-05-09 23:52:27 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
Py_UNBLOCK_THREADS
|
1992-08-06 03:58:53 +08:00
|
|
|
|
|
|
|
For convenience, that the value of 'errno' is restored across
|
2000-09-16 02:19:27 +08:00
|
|
|
Py_END_ALLOW_THREADS and Py_BLOCK_THREADS.
|
1992-08-06 03:58:53 +08:00
|
|
|
|
1995-01-12 19:45:45 +08:00
|
|
|
WARNING: NEVER NEST CALLS TO Py_BEGIN_ALLOW_THREADS AND
|
|
|
|
Py_END_ALLOW_THREADS!!!
|
1992-08-06 03:58:53 +08:00
|
|
|
|
|
|
|
Note that not yet all candidates have been converted to use this
|
|
|
|
mechanism!
|
|
|
|
*/
|
|
|
|
|
2002-08-12 15:21:58 +08:00
|
|
|
PyAPI_FUNC(PyThreadState *) PyEval_SaveThread(void);
|
|
|
|
PyAPI_FUNC(void) PyEval_RestoreThread(PyThreadState *);
|
1992-08-06 03:58:53 +08:00
|
|
|
|
2020-03-10 08:28:54 +08:00
|
|
|
Py_DEPRECATED(3.9) PyAPI_FUNC(int) PyEval_ThreadsInitialized(void);
|
|
|
|
Py_DEPRECATED(3.9) PyAPI_FUNC(void) PyEval_InitThreads(void);
|
2020-07-06 10:48:30 +08:00
|
|
|
/* PyEval_AcquireLock() and PyEval_ReleaseLock() are part of stable ABI.
|
|
|
|
* They will be removed from this header file in the future version.
|
|
|
|
* But they will be remained in ABI until Python 4.0.
|
|
|
|
*/
|
2019-05-28 23:16:33 +08:00
|
|
|
Py_DEPRECATED(3.2) PyAPI_FUNC(void) PyEval_AcquireLock(void);
|
2020-07-06 10:48:30 +08:00
|
|
|
Py_DEPRECATED(3.2) PyAPI_FUNC(void) PyEval_ReleaseLock(void);
|
2002-08-12 15:21:58 +08:00
|
|
|
PyAPI_FUNC(void) PyEval_AcquireThread(PyThreadState *tstate);
|
|
|
|
PyAPI_FUNC(void) PyEval_ReleaseThread(PyThreadState *tstate);
|
1997-07-19 07:56:58 +08:00
|
|
|
|
1995-01-12 19:45:45 +08:00
|
|
|
#define Py_BEGIN_ALLOW_THREADS { \
|
2010-05-09 23:52:27 +08:00
|
|
|
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); \
|
|
|
|
}
|
1992-08-06 03:58:53 +08:00
|
|
|
|
2015-11-04 01:45:05 +08:00
|
|
|
/* Masks and values used by FORMAT_VALUE opcode. */
|
|
|
|
#define FVC_MASK 0x3
|
|
|
|
#define FVC_NONE 0x0
|
|
|
|
#define FVC_STR 0x1
|
|
|
|
#define FVC_REPR 0x2
|
|
|
|
#define FVC_ASCII 0x3
|
|
|
|
#define FVS_MASK 0x4
|
|
|
|
#define FVS_HAVE_SPEC 0x4
|
2000-05-08 22:04:54 +08:00
|
|
|
|
2019-11-05 02:48:34 +08:00
|
|
|
#ifndef Py_LIMITED_API
|
|
|
|
# define Py_CPYTHON_CEVAL_H
|
2021-10-15 07:50:04 +08:00
|
|
|
# include "cpython/ceval.h"
|
2019-11-05 02:48:34 +08:00
|
|
|
# undef Py_CPYTHON_CEVAL_H
|
|
|
|
#endif
|
|
|
|
|
1993-07-28 17:05:47 +08:00
|
|
|
#ifdef __cplusplus
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif /* !Py_CEVAL_H */
|