/* Execute compiled code */

/* XXX TO DO:

XXX speed up searching for keywords by using a dictionary

XXX document it!

*/

#include "Python.h"

#include "pycore_abstract.h" // _PyIndex_Check()

#include "pycore_call.h" // _PyObject_FastCallDictTstate()

#include "pycore_ceval.h" // _PyEval_SignalAsyncExc()

#include "pycore_code.h"

#include "pycore_function.h"

#include "pycore_initconfig.h" // _PyStatus_OK()

#include "pycore_long.h" // _PyLong_GetZero()

#include "pycore_object.h" // _PyObject_GC_TRACK()

#include "pycore_moduleobject.h" // PyModuleObject

#include "pycore_pyerrors.h" // _PyErr_Fetch()

#include "pycore_pylifecycle.h" // _PyErr_Print()

#include "pycore_pymem.h" // _PyMem_IsPtrFreed()

#include "pycore_pystate.h" // _PyInterpreterState_GET()

#include "pycore_sysmodule.h" // _PySys_Audit()

#include "pycore_tuple.h" // _PyTuple_ITEMS()

#include "code.h"

#include "pycore_dict.h"

#include "dictobject.h"

#include "frameobject.h"

#include "pycore_frame.h"

#include "opcode.h"

#include "pydtrace.h"

#include "setobject.h"

#include "structmember.h" // struct PyMemberDef, T_OFFSET_EX

#include <ctype.h>

#include <stdbool.h>

#ifdef Py_DEBUG

/* For debugging the interpreter: */

# define LLTRACE 1 /* Low-level trace feature */

#endif

#if !defined(Py_BUILD_CORE)

# error "ceval.c must be build with Py_BUILD_CORE define for best performance"

#endif

/* Forward declarations */

static PyObject *trace_call_function(

PyThreadState *tstate, PyObject *callable, PyObject **stack,

Py_ssize_t oparg, PyObject *kwnames);

static PyObject * do_call_core(

PyThreadState *tstate, PyObject *func,

PyObject *callargs, PyObject *kwdict, int use_tracing);

#ifdef LLTRACE

static int lltrace;

static int prtrace(PyThreadState *, PyObject *, const char *);

static void lltrace_instruction(_PyInterpreterFrame *frame, int opcode, int oparg)

{

if (HAS_ARG(opcode)) {

printf("%d: %d, %d\n",

frame->f_lasti, opcode, oparg);

}

else {

printf("%d: %d\n",

frame->f_lasti, opcode);

}

}

#endif

static int call_trace(Py_tracefunc, PyObject *,

PyThreadState *, _PyInterpreterFrame *,

int, PyObject *);

static int call_trace_protected(Py_tracefunc, PyObject *,

PyThreadState *, _PyInterpreterFrame *,

int, PyObject *);

static void call_exc_trace(Py_tracefunc, PyObject *,

PyThreadState *, _PyInterpreterFrame *);

static int maybe_call_line_trace(Py_tracefunc, PyObject *,

PyThreadState *, _PyInterpreterFrame *, int);

static void maybe_dtrace_line(_PyInterpreterFrame *, PyTraceInfo *, int);

static void dtrace_function_entry(_PyInterpreterFrame *);

static void dtrace_function_return(_PyInterpreterFrame *);

static PyObject * import_name(PyThreadState *, _PyInterpreterFrame *,

PyObject *, PyObject *, PyObject *);

static PyObject * import_from(PyThreadState *, PyObject *, PyObject *);

static int import_all_from(PyThreadState *, PyObject *, PyObject *);

static void format_exc_check_arg(PyThreadState *, PyObject *, const char *, PyObject *);

static void format_exc_unbound(PyThreadState *tstate, PyCodeObject *co, int oparg);

static int check_args_iterable(PyThreadState *, PyObject *func, PyObject *vararg);

static int check_except_type_valid(PyThreadState *tstate, PyObject* right);

static int check_except_star_type_valid(PyThreadState *tstate, PyObject* right);

static void format_kwargs_error(PyThreadState *, PyObject *func, PyObject *kwargs);

static void format_awaitable_error(PyThreadState *, PyTypeObject *, int);

static int get_exception_handler(PyCodeObject *, int, int*, int*, int*);

static _PyInterpreterFrame *

_PyEvalFramePushAndInit(PyThreadState *tstate, PyFunctionObject *func,

PyObject *locals, PyObject* const* args,

size_t argcount, PyObject *kwnames);

static void

_PyEvalFrameClearAndPop(PyThreadState *tstate, _PyInterpreterFrame *frame);

#define NAME_ERROR_MSG \

"name '%.200s' is not defined"

#define UNBOUNDLOCAL_ERROR_MSG \

"cannot access local variable '%s' where it is not associated with a value"

#define UNBOUNDFREE_ERROR_MSG \

"cannot access free variable '%s' where it is not associated with a" \

" value in enclosing scope"

#ifndef NDEBUG

/* Ensure that tstate is valid: sanity check for PyEval_AcquireThread() and

PyEval_RestoreThread(). Detect if tstate memory was freed. It can happen

when a thread continues to run after Python finalization, especially

daemon threads. */

static int

is_tstate_valid(PyThreadState *tstate)

{

assert(!_PyMem_IsPtrFreed(tstate));

assert(!_PyMem_IsPtrFreed(tstate->interp));

return 1;

}

#endif

/* This can set eval_breaker to 0 even though gil_drop_request became

1. We believe this is all right because the eval loop will release

the GIL eventually anyway. */

static inline void

COMPUTE_EVAL_BREAKER(PyInterpreterState *interp,

struct _ceval_runtime_state *ceval,

struct _ceval_state *ceval2)

{

_Py_atomic_store_relaxed(&ceval2->eval_breaker,

_Py_atomic_load_relaxed(&ceval2->gil_drop_request)

| (_Py_atomic_load_relaxed(&ceval->signals_pending)

&& _Py_ThreadCanHandleSignals(interp))

| (_Py_atomic_load_relaxed(&ceval2->pending.calls_to_do)

&& _Py_ThreadCanHandlePendingCalls())

| ceval2->pending.async_exc);

}

static inline void

SET_GIL_DROP_REQUEST(PyInterpreterState *interp)

{

struct _ceval_state *ceval2 = &interp->ceval;

_Py_atomic_store_relaxed(&ceval2->gil_drop_request, 1);

_Py_atomic_store_relaxed(&ceval2->eval_breaker, 1);

}

static inline void

RESET_GIL_DROP_REQUEST(PyInterpreterState *interp)

{

struct _ceval_runtime_state *ceval = &interp->runtime->ceval;

struct _ceval_state *ceval2 = &interp->ceval;

_Py_atomic_store_relaxed(&ceval2->gil_drop_request, 0);

COMPUTE_EVAL_BREAKER(interp, ceval, ceval2);

}

static inline void

SIGNAL_PENDING_CALLS(PyInterpreterState *interp)

{

struct _ceval_runtime_state *ceval = &interp->runtime->ceval;

struct _ceval_state *ceval2 = &interp->ceval;

_Py_atomic_store_relaxed(&ceval2->pending.calls_to_do, 1);

COMPUTE_EVAL_BREAKER(interp, ceval, ceval2);

}

static inline void

UNSIGNAL_PENDING_CALLS(PyInterpreterState *interp)

{

struct _ceval_runtime_state *ceval = &interp->runtime->ceval;

struct _ceval_state *ceval2 = &interp->ceval;

_Py_atomic_store_relaxed(&ceval2->pending.calls_to_do, 0);

COMPUTE_EVAL_BREAKER(interp, ceval, ceval2);

}

static inline void

SIGNAL_PENDING_SIGNALS(PyInterpreterState *interp, int force)

{

struct _ceval_runtime_state *ceval = &interp->runtime->ceval;

struct _ceval_state *ceval2 = &interp->ceval;

_Py_atomic_store_relaxed(&ceval->signals_pending, 1);

if (force) {

_Py_atomic_store_relaxed(&ceval2->eval_breaker, 1);

}

else {

/* eval_breaker is not set to 1 if thread_can_handle_signals() is false */

COMPUTE_EVAL_BREAKER(interp, ceval, ceval2);

}

}

static inline void

UNSIGNAL_PENDING_SIGNALS(PyInterpreterState *interp)

{

struct _ceval_runtime_state *ceval = &interp->runtime->ceval;

struct _ceval_state *ceval2 = &interp->ceval;

_Py_atomic_store_relaxed(&ceval->signals_pending, 0);

COMPUTE_EVAL_BREAKER(interp, ceval, ceval2);

}

static inline void

SIGNAL_ASYNC_EXC(PyInterpreterState *interp)

{

struct _ceval_state *ceval2 = &interp->ceval;

ceval2->pending.async_exc = 1;

_Py_atomic_store_relaxed(&ceval2->eval_breaker, 1);

}

static inline void

UNSIGNAL_ASYNC_EXC(PyInterpreterState *interp)

{

struct _ceval_runtime_state *ceval = &interp->runtime->ceval;

struct _ceval_state *ceval2 = &interp->ceval;

ceval2->pending.async_exc = 0;

COMPUTE_EVAL_BREAKER(interp, ceval, ceval2);

}

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

#include "ceval_gil.h"

void _Py_NO_RETURN

_Py_FatalError_TstateNULL(const char *func)

{

_Py_FatalErrorFunc(func,

"the function must be called with the GIL held, "

"but the GIL is released "

"(the current Python thread state is NULL)");

}

#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS

int

_PyEval_ThreadsInitialized(PyInterpreterState *interp)

{

return gil_created(&interp->ceval.gil);

}

int

PyEval_ThreadsInitialized(void)

{

// Fatal error if there is no current interpreter

PyInterpreterState *interp = PyInterpreterState_Get();

return _PyEval_ThreadsInitialized(interp);

}

#else

int

_PyEval_ThreadsInitialized(_PyRuntimeState *runtime)

{

return gil_created(&runtime->ceval.gil);

}

int

PyEval_ThreadsInitialized(void)

{

_PyRuntimeState *runtime = &_PyRuntime;

return _PyEval_ThreadsInitialized(runtime);

}

#endif

PyStatus

_PyEval_InitGIL(PyThreadState *tstate)

{

#ifndef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS

if (!_Py_IsMainInterpreter(tstate->interp)) {

/* Currently, the GIL is shared by all interpreters,

and only the main interpreter is responsible to create

and destroy it. */

return _PyStatus_OK();

}

#endif

#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS

struct _gil_runtime_state *gil = &tstate->interp->ceval.gil;

#else

struct _gil_runtime_state *gil = &tstate->interp->runtime->ceval.gil;

#endif

assert(!gil_created(gil));

PyThread_init_thread();

create_gil(gil);

take_gil(tstate);

assert(gil_created(gil));

return _PyStatus_OK();

}

void

_PyEval_FiniGIL(PyInterpreterState *interp)

{

#ifndef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS

if (!_Py_IsMainInterpreter(interp)) {

/* Currently, the GIL is shared by all interpreters,

and only the main interpreter is responsible to create

and destroy it. */

return;

}

#endif

#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS

struct _gil_runtime_state *gil = &interp->ceval.gil;

#else

struct _gil_runtime_state *gil = &interp->runtime->ceval.gil;

#endif

if (!gil_created(gil)) {

/* First Py_InitializeFromConfig() call: the GIL doesn't exist

yet: do nothing. */

return;

}

destroy_gil(gil);

assert(!gil_created(gil));

}

void

PyEval_InitThreads(void)

{

/* Do nothing: kept for backward compatibility */

}

void

_PyEval_Fini(void)

{

#ifdef Py_STATS

_Py_PrintSpecializationStats(1);

#endif

}

void

PyEval_AcquireLock(void)

{

_PyRuntimeState *runtime = &_PyRuntime;

PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime);

_Py_EnsureTstateNotNULL(tstate);

take_gil(tstate);

}

void

PyEval_ReleaseLock(void)

{

_PyRuntimeState *runtime = &_PyRuntime;

PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime);

/* This function must succeed when the current thread state is NULL.

We therefore avoid PyThreadState_Get() which dumps a fatal error

in debug mode. */

struct _ceval_runtime_state *ceval = &runtime->ceval;

struct _ceval_state *ceval2 = &tstate->interp->ceval;

drop_gil(ceval, ceval2, tstate);

}

void

_PyEval_ReleaseLock(PyThreadState *tstate)

{

struct _ceval_runtime_state *ceval = &tstate->interp->runtime->ceval;

struct _ceval_state *ceval2 = &tstate->interp->ceval;

drop_gil(ceval, ceval2, tstate);

}

void

PyEval_AcquireThread(PyThreadState *tstate)

{

_Py_EnsureTstateNotNULL(tstate);

take_gil(tstate);

struct _gilstate_runtime_state *gilstate = &tstate->interp->runtime->gilstate;

#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS

(void)_PyThreadState_Swap(gilstate, tstate);

#else

if (_PyThreadState_Swap(gilstate, tstate) != NULL) {

Py_FatalError("non-NULL old thread state");

}

#endif

}

void

PyEval_ReleaseThread(PyThreadState *tstate)

{

assert(is_tstate_valid(tstate));

_PyRuntimeState *runtime = tstate->interp->runtime;

PyThreadState *new_tstate = _PyThreadState_Swap(&runtime->gilstate, NULL);

if (new_tstate != tstate) {

Py_FatalError("wrong thread state");

}

struct _ceval_runtime_state *ceval = &runtime->ceval;

struct _ceval_state *ceval2 = &tstate->interp->ceval;

drop_gil(ceval, ceval2, tstate);

}

#ifdef HAVE_FORK

/* This function is called from PyOS_AfterFork_Child to destroy all threads

which are not running in the child process, and clear internal locks

which might be held by those threads. */

PyStatus

_PyEval_ReInitThreads(PyThreadState *tstate)

{

_PyRuntimeState *runtime = tstate->interp->runtime;

#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS

struct _gil_runtime_state *gil = &tstate->interp->ceval.gil;

#else

struct _gil_runtime_state *gil = &runtime->ceval.gil;

#endif

if (!gil_created(gil)) {

return _PyStatus_OK();

}

recreate_gil(gil);

take_gil(tstate);

struct _pending_calls *pending = &tstate->interp->ceval.pending;

if (_PyThread_at_fork_reinit(&pending->lock) < 0) {

return _PyStatus_ERR("Can't reinitialize pending calls lock");

}

/* Destroy all threads except the current one */

_PyThreadState_DeleteExcept(runtime, tstate);

return _PyStatus_OK();

}

#endif

/* This function is used to signal that async exceptions are waiting to be

raised. */

void

_PyEval_SignalAsyncExc(PyInterpreterState *interp)

{

SIGNAL_ASYNC_EXC(interp);

}

PyThreadState *

PyEval_SaveThread(void)

{

_PyRuntimeState *runtime = &_PyRuntime;

#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS

PyThreadState *old_tstate = _PyThreadState_GET();

PyThreadState *tstate = _PyThreadState_Swap(&runtime->gilstate, old_tstate);

#else

PyThreadState *tstate = _PyThreadState_Swap(&runtime->gilstate, NULL);

#endif

_Py_EnsureTstateNotNULL(tstate);

struct _ceval_runtime_state *ceval = &runtime->ceval;

struct _ceval_state *ceval2 = &tstate->interp->ceval;

#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS

assert(gil_created(&ceval2->gil));

#else

assert(gil_created(&ceval->gil));

#endif

drop_gil(ceval, ceval2, tstate);

return tstate;

}

void

PyEval_RestoreThread(PyThreadState *tstate)

{

_Py_EnsureTstateNotNULL(tstate);

take_gil(tstate);

struct _gilstate_runtime_state *gilstate = &tstate->interp->runtime->gilstate;

_PyThreadState_Swap(gilstate, tstate);

}

/* Mechanism whereby asynchronously executing callbacks (e.g. UNIX

signal handlers or Mac I/O completion routines) can schedule calls

to a function to be called synchronously.

The synchronous function is called with one void* argument.

It should return 0 for success or -1 for failure -- failure should

be accompanied by an exception.

If registry succeeds, the registry function returns 0; if it fails

(e.g. due to too many pending calls) it returns -1 (without setting

an exception condition).

Note that because registry may occur from within signal handlers,

or other asynchronous events, calling malloc() is unsafe!

Any thread can schedule pending calls, but only the main thread

will execute them.

There is no facility to schedule calls to a particular thread, but

that should be easy to change, should that ever be required. In

that case, the static variables here should go into the python

threadstate.

*/

void

_PyEval_SignalReceived(PyInterpreterState *interp)

{

#ifdef MS_WINDOWS

// bpo-42296: On Windows, _PyEval_SignalReceived() is called from a signal

// handler which can run in a thread different than the Python thread, in

// which case _Py_ThreadCanHandleSignals() is wrong. Ignore

// _Py_ThreadCanHandleSignals() and always set eval_breaker to 1.

//

// The next eval_frame_handle_pending() call will call

// _Py_ThreadCanHandleSignals() to recompute eval_breaker.

int force = 1;

#else

int force = 0;

#endif

/* bpo-30703: Function called when the C signal handler of Python gets a

signal. We cannot queue a callback using _PyEval_AddPendingCall() since

that function is not async-signal-safe. */

SIGNAL_PENDING_SIGNALS(interp, force);

}

/* Push one item onto the queue while holding the lock. */

static int

_push_pending_call(struct _pending_calls *pending,

int (*func)(void *), void *arg)

{

int i = pending->last;

int j = (i + 1) % NPENDINGCALLS;

if (j == pending->first) {

return -1; /* Queue full */

}

pending->calls[i].func = func;

pending->calls[i].arg = arg;

pending->last = j;

return 0;

}

/* Pop one item off the queue while holding the lock. */

static void

_pop_pending_call(struct _pending_calls *pending,

int (**func)(void *), void **arg)

{

int i = pending->first;

if (i == pending->last) {

return; /* Queue empty */

}

*func = pending->calls[i].func;

*arg = pending->calls[i].arg;

pending->first = (i + 1) % NPENDINGCALLS;

}

/* This implementation is thread-safe. It allows

scheduling to be made from any thread, and even from an executing

callback.

*/

int

_PyEval_AddPendingCall(PyInterpreterState *interp,

int (*func)(void *), void *arg)

{

struct _pending_calls *pending = &interp->ceval.pending;

/* Ensure that _PyEval_InitPendingCalls() was called

and that _PyEval_FiniPendingCalls() is not called yet. */

assert(pending->lock != NULL);

PyThread_acquire_lock(pending->lock, WAIT_LOCK);

int result = _push_pending_call(pending, func, arg);

PyThread_release_lock(pending->lock);

/* signal main loop */

SIGNAL_PENDING_CALLS(interp);

return result;

}

int

Py_AddPendingCall(int (*func)(void *), void *arg)

{

/* Best-effort to support subinterpreters and calls with the GIL released.

First attempt _PyThreadState_GET() since it supports subinterpreters.

If the GIL is released, _PyThreadState_GET() returns NULL . In this

case, use PyGILState_GetThisThreadState() which works even if the GIL

is released.

Sadly, PyGILState_GetThisThreadState() doesn't support subinterpreters:

see bpo-10915 and bpo-15751.

Py_AddPendingCall() doesn't require the caller to hold the GIL. */

PyThreadState *tstate = _PyThreadState_GET();

if (tstate == NULL) {

tstate = PyGILState_GetThisThreadState();

}

PyInterpreterState *interp;

if (tstate != NULL) {

interp = tstate->interp;

}

else {

/* Last resort: use the main interpreter */

interp = _PyInterpreterState_Main();

}

return _PyEval_AddPendingCall(interp, func, arg);

}

static int

handle_signals(PyThreadState *tstate)

{

assert(is_tstate_valid(tstate));

if (!_Py_ThreadCanHandleSignals(tstate->interp)) {

return 0;

}

UNSIGNAL_PENDING_SIGNALS(tstate->interp);

if (_PyErr_CheckSignalsTstate(tstate) < 0) {

/* On failure, re-schedule a call to handle_signals(). */

SIGNAL_PENDING_SIGNALS(tstate->interp, 0);

return -1;

}

return 0;

}

static int

make_pending_calls(PyInterpreterState *interp)

{

/* only execute pending calls on main thread */

if (!_Py_ThreadCanHandlePendingCalls()) {

return 0;

}

/* don't perform recursive pending calls */

static int busy = 0;

if (busy) {

return 0;

}

busy = 1;

/* unsignal before starting to call callbacks, so that any callback

added in-between re-signals */

UNSIGNAL_PENDING_CALLS(interp);

int res = 0;

/* perform a bounded number of calls, in case of recursion */

struct _pending_calls *pending = &interp->ceval.pending;

for (int i=0; i<NPENDINGCALLS; i++) {

int (*func)(void *) = NULL;

void *arg = NULL;

/* pop one item off the queue while holding the lock */

PyThread_acquire_lock(pending->lock, WAIT_LOCK);

_pop_pending_call(pending, &func, &arg);

PyThread_release_lock(pending->lock);

/* having released the lock, perform the callback */

if (func == NULL) {

break;

}

res = func(arg);

if (res) {

goto error;

}

}

busy = 0;

return res;

error:

busy = 0;

SIGNAL_PENDING_CALLS(interp);

return res;

}

void

_Py_FinishPendingCalls(PyThreadState *tstate)

{

assert(PyGILState_Check());

assert(is_tstate_valid(tstate));

struct _pending_calls *pending = &tstate->interp->ceval.pending;

if (!_Py_atomic_load_relaxed(&(pending->calls_to_do))) {

return;

}

if (make_pending_calls(tstate->interp) < 0) {

PyObject *exc, *val, *tb;

_PyErr_Fetch(tstate, &exc, &val, &tb);

PyErr_BadInternalCall();

_PyErr_ChainExceptions(exc, val, tb);

_PyErr_Print(tstate);

}

}

/* Py_MakePendingCalls() is a simple wrapper for the sake

of backward-compatibility. */

int

Py_MakePendingCalls(void)

{

assert(PyGILState_Check());

PyThreadState *tstate = _PyThreadState_GET();

assert(is_tstate_valid(tstate));

/* Python signal handler doesn't really queue a callback: it only signals

that a signal was received, see _PyEval_SignalReceived(). */

int res = handle_signals(tstate);

if (res != 0) {

return res;

}

res = make_pending_calls(tstate->interp);

if (res != 0) {

return res;

}

return 0;

}

/* The interpreter's recursion limit */

void

_PyEval_InitRuntimeState(struct _ceval_runtime_state *ceval)

{

#ifndef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS

_gil_initialize(&ceval->gil);

#endif

}

void

_PyEval_InitState(struct _ceval_state *ceval, PyThread_type_lock pending_lock)

{

struct _pending_calls *pending = &ceval->pending;

assert(pending->lock == NULL);

pending->lock = pending_lock;

#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS

_gil_initialize(&ceval->gil);

#endif

}

void

_PyEval_FiniState(struct _ceval_state *ceval)

{

struct _pending_calls *pending = &ceval->pending;

if (pending->lock != NULL) {

PyThread_free_lock(pending->lock);

pending->lock = NULL;

}

}

int

Py_GetRecursionLimit(void)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

return interp->ceval.recursion_limit;

}

void

Py_SetRecursionLimit(int new_limit)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

interp->ceval.recursion_limit = new_limit;

for (PyThreadState *p = interp->threads.head; p != NULL; p = p->next) {

int depth = p->recursion_limit - p->recursion_remaining;

p->recursion_limit = new_limit;

p->recursion_remaining = new_limit - depth;

}

}

/* The function _Py_EnterRecursiveCall() only calls _Py_CheckRecursiveCall()

if the recursion_depth reaches recursion_limit. */

int

_Py_CheckRecursiveCall(PyThreadState *tstate, const char *where)

{

/* Check against global limit first. */

int depth = tstate->recursion_limit - tstate->recursion_remaining;

if (depth < tstate->interp->ceval.recursion_limit) {

tstate->recursion_limit = tstate->interp->ceval.recursion_limit;

tstate->recursion_remaining = tstate->recursion_limit - depth;

assert(tstate->recursion_remaining > 0);

return 0;

}

#ifdef USE_STACKCHECK

if (PyOS_CheckStack()) {

++tstate->recursion_remaining;

_PyErr_SetString(tstate, PyExc_MemoryError, "Stack overflow");

return -1;

}

#endif

if (tstate->recursion_headroom) {

if (tstate->recursion_remaining < -50) {

/* Overflowing while handling an overflow. Give up. */

Py_FatalError("Cannot recover from stack overflow.");

}

}

else {

if (tstate->recursion_remaining <= 0) {

tstate->recursion_headroom++;

_PyErr_Format(tstate, PyExc_RecursionError,

"maximum recursion depth exceeded%s",

where);

tstate->recursion_headroom--;

++tstate->recursion_remaining;

return -1;

}

}

return 0;

}

static const binaryfunc binary_ops[] = {

[NB_ADD] = PyNumber_Add,

[NB_AND] = PyNumber_And,

[NB_FLOOR_DIVIDE] = PyNumber_FloorDivide,

[NB_LSHIFT] = PyNumber_Lshift,

[NB_MATRIX_MULTIPLY] = PyNumber_MatrixMultiply,

[NB_MULTIPLY] = PyNumber_Multiply,

[NB_REMAINDER] = PyNumber_Remainder,

[NB_OR] = PyNumber_Or,

[NB_POWER] = _PyNumber_PowerNoMod,

[NB_RSHIFT] = PyNumber_Rshift,

[NB_SUBTRACT] = PyNumber_Subtract,

[NB_TRUE_DIVIDE] = PyNumber_TrueDivide,

[NB_XOR] = PyNumber_Xor,

[NB_INPLACE_ADD] = PyNumber_InPlaceAdd,

[NB_INPLACE_AND] = PyNumber_InPlaceAnd,

[NB_INPLACE_FLOOR_DIVIDE] = PyNumber_InPlaceFloorDivide,

[NB_INPLACE_LSHIFT] = PyNumber_InPlaceLshift,

[NB_INPLACE_MATRIX_MULTIPLY] = PyNumber_InPlaceMatrixMultiply,

[NB_INPLACE_MULTIPLY] = PyNumber_InPlaceMultiply,

[NB_INPLACE_REMAINDER] = PyNumber_InPlaceRemainder,

[NB_INPLACE_OR] = PyNumber_InPlaceOr,

[NB_INPLACE_POWER] = _PyNumber_InPlacePowerNoMod,

[NB_INPLACE_RSHIFT] = PyNumber_InPlaceRshift,

[NB_INPLACE_SUBTRACT] = PyNumber_InPlaceSubtract,

[NB_INPLACE_TRUE_DIVIDE] = PyNumber_InPlaceTrueDivide,

[NB_INPLACE_XOR] = PyNumber_InPlaceXor,

};

// PEP 634: Structural Pattern Matching

// Return a tuple of values corresponding to keys, with error checks for

// duplicate/missing keys.

static PyObject*

match_keys(PyThreadState *tstate, PyObject *map, PyObject *keys)

{

assert(PyTuple_CheckExact(keys));

Py_ssize_t nkeys = PyTuple_GET_SIZE(keys);

if (!nkeys) {

// No keys means no items.

return PyTuple_New(0);

}

PyObject *seen = NULL;

PyObject *dummy = NULL;

PyObject *values = NULL;

PyObject *get = NULL;

// We use the two argument form of map.get(key, default) for two reasons:

// - Atomically check for a key and get its value without error handling.

// - Don't cause key creation or resizing in dict subclasses like

// collections.defaultdict that define __missing__ (or similar).

int meth_found = _PyObject_GetMethod(map, &_Py_ID(get), &get);

if (get == NULL) {

goto fail;

}

seen = PySet_New(NULL);

if (seen == NULL) {

goto fail;

}

// dummy = object()

dummy = _PyObject_CallNoArgs((PyObject *)&PyBaseObject_Type);

if (dummy == NULL) {

goto fail;

}

values = PyTuple_New(nkeys);

if (values == NULL) {

goto fail;

}

for (Py_ssize_t i = 0; i < nkeys; i++) {

PyObject *key = PyTuple_GET_ITEM(keys, i);

if (PySet_Contains(seen, key) || PySet_Add(seen, key)) {

if (!_PyErr_Occurred(tstate)) {

// Seen it before!

_PyErr_Format(tstate, PyExc_ValueError,

"mapping pattern checks duplicate key (%R)", key);

}

goto fail;

}

PyObject *args[] = { map, key, dummy };

PyObject *value = NULL;

if (meth_found) {

value = PyObject_Vectorcall(get, args, 3, NULL);

}

else {

value = PyObject_Vectorcall(get, &args[1], 2, NULL);

}

if (value == NULL) {

goto fail;

}

if (value == dummy) {

// key not in map!

Py_DECREF(value);

Py_DECREF(values);

// Return None:

Py_INCREF(Py_None);

values = Py_None;

goto done;

}

PyTuple_SET_ITEM(values, i, value);

}

// Success:

done:

Py_DECREF(get);

Py_DECREF(seen);

Py_DECREF(dummy);

return values;

fail:

Py_XDECREF(get);

Py_XDECREF(seen);

Py_XDECREF(dummy);

Py_XDECREF(values);

return NULL;

}

// Extract a named attribute from the subject, with additional bookkeeping to

// raise TypeErrors for repeated lookups. On failure, return NULL (with no

// error set). Use _PyErr_Occurred(tstate) to disambiguate.

static PyObject*

match_class_attr(PyThreadState *tstate, PyObject *subject, PyObject *type,

PyObject *name, PyObject *seen)

{

assert(PyUnicode_CheckExact(name));

assert(PySet_CheckExact(seen));

if (PySet_Contains(seen, name) || PySet_Add(seen, name)) {

if (!_PyErr_Occurred(tstate)) {

// Seen it before!

_PyErr_Format(tstate, PyExc_TypeError,

"%s() got multiple sub-patterns for attribute %R",

((PyTypeObject*)type)->tp_name, name);

}

return NULL;

}

PyObject *attr = PyObject_GetAttr(subject, name);

if (attr == NULL && _PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) {

_PyErr_Clear(tstate);

}

return attr;

}

// On success (match), return a tuple of extracted attributes. On failure (no

// match), return NULL. Use _PyErr_Occurred(tstate) to disambiguate.

static PyObject*

match_class(PyThreadState *tstate, PyObject *subject, PyObject *type,

Py_ssize_t nargs, PyObject *kwargs)

{

if (!PyType_Check(type)) {

const char *e = "called match pattern must be a type";

_PyErr_Format(tstate, PyExc_TypeError, e);

return NULL;

}

assert(PyTuple_CheckExact(kwargs));

// First, an isinstance check:

if (PyObject_IsInstance(subject, type) <= 0) {

return NULL;

}

// So far so good:

PyObject *seen = PySet_New(NULL);

if (seen == NULL) {

return NULL;

}

PyObject *attrs = PyList_New(0);

if (attrs == NULL) {

Py_DECREF(seen);

return NULL;

}

// NOTE: From this point on, goto fail on failure:

PyObject *match_args = NULL;

// First, the positional subpatterns:

if (nargs) {

int match_self = 0;

match_args = PyObject_GetAttrString(type, "__match_args__");

if (match_args) {

if (!PyTuple_CheckExact(match_args)) {

const char *e = "%s.__match_args__ must be a tuple (got %s)";

_PyErr_Format(tstate, PyExc_TypeError, e,

((PyTypeObject *)type)->tp_name,

Py_TYPE(match_args)->tp_name);

goto fail;

}

}

else if (_PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) {

_PyErr_Clear(tstate);

// _Py_TPFLAGS_MATCH_SELF is only acknowledged if the type does not

// define __match_args__. This is natural behavior for subclasses:

// it's as if __match_args__ is some "magic" value that is lost as

// soon as they redefine it.