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

#if !defined(Py_BUILD_CORE)

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

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);

}

}

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

static int

is_tstate_valid(PyThreadState *tstate)

{

assert(!_PyMem_IsPtrFreed(tstate));

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

return 1;

}

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>

#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

_PyEval_ThreadsInitialized(PyInterpreterState *interp)

{

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

}

PyEval_ThreadsInitialized(void)

{

// Fatal error if there is no current interpreter

PyInterpreterState *interp = PyInterpreterState_Get();

return _PyEval_ThreadsInitialized(interp);

}

_PyEval_ThreadsInitialized(_PyRuntimeState *runtime)

{

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

}

PyEval_ThreadsInitialized(void)

{

_PyRuntimeState *runtime = &_PyRuntime;

return _PyEval_ThreadsInitialized(runtime);

}

_PyEval_InitGIL(PyThreadState *tstate)

{

#ifndef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS

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

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

return _PyStatus_OK();

}

#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS

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

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

assert(!gil_created(gil));

PyThread_init_thread();

create_gil(gil);

take_gil(tstate);

assert(gil_created(gil));

return _PyStatus_OK();

}

_PyEval_FiniGIL(PyInterpreterState *interp)

{

#ifndef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS

if (!_Py_IsMainInterpreter(interp)) {

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

return;

}

#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS

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

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

if (!gil_created(gil)) {

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

return;

}

destroy_gil(gil);

assert(!gil_created(gil));

}

PyEval_InitThreads(void)

{

/* Do nothing: kept for backward compatibility */

}

_PyEval_Fini(void)

{

#ifdef Py_STATS

_Py_PrintSpecializationStats(1);

}

PyEval_AcquireLock(void)

{

_PyRuntimeState *runtime = &_PyRuntime;

PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime);

_Py_EnsureTstateNotNULL(tstate);

take_gil(tstate);

}

PyEval_ReleaseLock(void)

{

_PyRuntimeState *runtime = &_PyRuntime;

PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime);

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

struct _ceval_runtime_state *ceval = &runtime->ceval;

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

drop_gil(ceval, ceval2, tstate);

}

_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);

}

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);

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

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

}

}

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

_PyEval_ReInitThreads(PyThreadState *tstate)

{

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

#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS

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

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

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();

}

_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);

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

_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));

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

drop_gil(ceval, ceval2, tstate);

return tstate;

}

PyEval_RestoreThread(PyThreadState *tstate)

{

_Py_EnsureTstateNotNULL(tstate);

take_gil(tstate);

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

_PyThreadState_Swap(gilstate, tstate);

}

_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;

int force = 0;

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

SIGNAL_PENDING_SIGNALS(interp, force);

}

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;

}

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;

}

_PyEval_AddPendingCall(PyInterpreterState *interp,

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

{

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

/* Ensure that _PyEval_InitPendingCalls() was called

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;

}

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

{

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

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

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;

}

_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(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

int res = handle_signals(tstate);

if (res != 0) {

return res;

}

res = make_pending_calls(tstate->interp);

if (res != 0) {

return res;

}

return 0;

}

_PyEval_InitRuntimeState(struct _ceval_runtime_state *ceval)

{

#ifndef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS

_gil_initialize(&ceval->gil);

}

_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);

}

_PyEval_FiniState(struct _ceval_state *ceval)

{

struct _pending_calls *pending = &ceval->pending;

if (pending->lock != NULL) {

PyThread_free_lock(pending->lock);

pending->lock = NULL;

}

}

Py_GetRecursionLimit(void)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

return interp->ceval.recursion_limit;

}

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;

}

}

_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;

}

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,

};

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;

}

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;

}

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.