#include "ceval.h"

#include "pycore_long.h"

Py_GetRecursionLimit(void)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

return interp->ceval.recursion_limit;

}

Py_SetRecursionLimit(int new_limit)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

_PyEval_StopTheWorld(interp);

interp->ceval.recursion_limit = new_limit;

_Py_FOR_EACH_TSTATE_BEGIN(interp, p) {

int depth = p->py_recursion_limit - p->py_recursion_remaining;

p->py_recursion_limit = new_limit;

p->py_recursion_remaining = new_limit - depth;

}

_Py_FOR_EACH_TSTATE_END(interp);

_PyEval_StartTheWorld(interp);

}

_Py_ReachedRecursionLimitWithMargin(PyThreadState *tstate, int margin_count)

{

uintptr_t here_addr = _Py_get_machine_stack_pointer();

_PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate;

#if _Py_STACK_GROWS_DOWN

if (here_addr > _tstate->c_stack_soft_limit + margin_count * _PyOS_STACK_MARGIN_BYTES) {

if (here_addr <= _tstate->c_stack_soft_limit - margin_count * _PyOS_STACK_MARGIN_BYTES) {

return 0;

}

if (_tstate->c_stack_hard_limit == 0) {

_Py_InitializeRecursionLimits(tstate);

}

#if _Py_STACK_GROWS_DOWN

return here_addr <= _tstate->c_stack_soft_limit + margin_count * _PyOS_STACK_MARGIN_BYTES &&

here_addr >= _tstate->c_stack_soft_limit - 2 * _PyOS_STACK_MARGIN_BYTES;

return here_addr > _tstate->c_stack_soft_limit - margin_count * _PyOS_STACK_MARGIN_BYTES &&

here_addr <= _tstate->c_stack_soft_limit + 2 * _PyOS_STACK_MARGIN_BYTES;

}

_Py_EnterRecursiveCallUnchecked(PyThreadState *tstate)

{

uintptr_t here_addr = _Py_get_machine_stack_pointer();

_PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate;

#if _Py_STACK_GROWS_DOWN

if (here_addr < _tstate->c_stack_hard_limit) {

if (here_addr > _tstate->c_stack_hard_limit) {

Py_FatalError("Unchecked stack overflow.");

}

}

#if defined(__s390x__)

# define Py_C_STACK_SIZE 320000

#elif defined(_WIN32)

// Don't define Py_C_STACK_SIZE, ask the O/S

#elif defined(__ANDROID__)

# define Py_C_STACK_SIZE 1200000

#elif defined(__sparc__)

# define Py_C_STACK_SIZE 1600000

#elif defined(__hppa__) || defined(__powerpc64__)

# define Py_C_STACK_SIZE 2000000

# define Py_C_STACK_SIZE 4000000

#if defined(__EMSCRIPTEN__)

#include "emscripten/stack.h"

#define pthread_attr_t workaround_pthread_attr_t

#define pthread_getattr_np workaround_pthread_getattr_np

#define pthread_attr_getguardsize workaround_pthread_attr_getguardsize

#define pthread_attr_getstack workaround_pthread_attr_getstack

#define pthread_attr_destroy workaround_pthread_attr_destroy

typedef struct {

void *_a_stackaddr;

size_t _a_stacksize, _a_guardsize;

} pthread_attr_t;

extern __attribute__((__visibility__("hidden"))) unsigned __default_guardsize;

int pthread_getattr_np(pthread_t thread, pthread_attr_t *attr) {

attr->_a_stackaddr = (void*)emscripten_stack_get_base();

attr->_a_stacksize = emscripten_stack_get_base() - emscripten_stack_get_end();

attr->_a_guardsize = __default_guardsize;

return 0;

}

int pthread_attr_getguardsize(const pthread_attr_t *restrict a, size_t *restrict size)

{

*size = a->_a_guardsize;

return 0;

}

int pthread_attr_getstack(const pthread_attr_t *restrict a, void **restrict addr, size_t *restrict size)

{

if (!a) return EINVAL;

*size = a->_a_stacksize;

*addr = (void *)(a->_a_stackaddr - *size);

return 0;

}

int pthread_attr_destroy(pthread_attr_t *a)

{

return 0;

}

static void

hardware_stack_limits(uintptr_t *base, uintptr_t *top, uintptr_t sp)

{

#ifdef WIN32

ULONG_PTR low, high;

GetCurrentThreadStackLimits(&low, &high);

*top = (uintptr_t)high;

ULONG guarantee = 0;

SetThreadStackGuarantee(&guarantee);

*base = (uintptr_t)low + guarantee;

#elif defined(__APPLE__)

pthread_t this_thread = pthread_self();

void *stack_addr = pthread_get_stackaddr_np(this_thread); // top of the stack

size_t stack_size = pthread_get_stacksize_np(this_thread);

*top = (uintptr_t)stack_addr;

*base = ((uintptr_t)stack_addr) - stack_size;

/// XXX musl supports HAVE_PTHRED_GETATTR_NP, but the resulting stack size

/// (on alpine at least) is much smaller than expected and imposes undue limits

/// compared to the old stack size estimation. (We assume musl is not glibc.)

# if defined(HAVE_PTHREAD_GETATTR_NP) && !defined(_AIX) && \

!defined(__NetBSD__) && (defined(__GLIBC__) || !defined(__linux__))

size_t stack_size, guard_size;

void *stack_addr;

pthread_attr_t attr;

int err = pthread_getattr_np(pthread_self(), &attr);

if (err == 0) {

err = pthread_attr_getguardsize(&attr, &guard_size);

err |= pthread_attr_getstack(&attr, &stack_addr, &stack_size);

err |= pthread_attr_destroy(&attr);

}

if (err == 0) {

*base = ((uintptr_t)stack_addr) + guard_size;

*top = (uintptr_t)stack_addr + stack_size;

return;

}

// Add some space for caller function then round to minimum page size

// This is a guess at the top of the stack, but should be a reasonably

// good guess if called from _PyThreadState_Attach when creating a thread.

// If the thread is attached deep in a call stack, then the guess will be poor.

#if _Py_STACK_GROWS_DOWN

uintptr_t top_addr = _Py_SIZE_ROUND_UP(sp + 8*sizeof(void*), SYSTEM_PAGE_SIZE);

*top = top_addr;

*base = top_addr - Py_C_STACK_SIZE;

uintptr_t base_addr = _Py_SIZE_ROUND_DOWN(sp - 8*sizeof(void*), SYSTEM_PAGE_SIZE);

*base = base_addr;

*top = base_addr + Py_C_STACK_SIZE;

}

static void

tstate_set_stack(PyThreadState *tstate,

uintptr_t base, uintptr_t top)

{

assert(base < top);

assert((top - base) >= _PyOS_MIN_STACK_SIZE);

#ifdef _Py_THREAD_SANITIZER

// Thread sanitizer crashes if we use more than half the stack.

uintptr_t stacksize = top - base;

# if _Py_STACK_GROWS_DOWN

base += stacksize/2;

top -= stacksize/2;

_PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate;

#if _Py_STACK_GROWS_DOWN

_tstate->c_stack_top = top;

_tstate->c_stack_hard_limit = base + _PyOS_STACK_MARGIN_BYTES;

_tstate->c_stack_soft_limit = base + _PyOS_STACK_MARGIN_BYTES * 2;

# ifndef NDEBUG

// Sanity checks

_PyThreadStateImpl *ts = (_PyThreadStateImpl *)tstate;

assert(ts->c_stack_hard_limit <= ts->c_stack_soft_limit);

assert(ts->c_stack_soft_limit < ts->c_stack_top);

_tstate->c_stack_top = base;

_tstate->c_stack_hard_limit = top - _PyOS_STACK_MARGIN_BYTES;

_tstate->c_stack_soft_limit = top - _PyOS_STACK_MARGIN_BYTES * 2;

# ifndef NDEBUG

// Sanity checks

_PyThreadStateImpl *ts = (_PyThreadStateImpl *)tstate;

assert(ts->c_stack_hard_limit >= ts->c_stack_soft_limit);

assert(ts->c_stack_soft_limit > ts->c_stack_top);

}

_Py_InitializeRecursionLimits(PyThreadState *tstate)

{

uintptr_t base, top;

uintptr_t here_addr = _Py_get_machine_stack_pointer();

hardware_stack_limits(&base, &top, here_addr);

assert(top != 0);

tstate_set_stack(tstate, base, top);

_PyThreadStateImpl *ts = (_PyThreadStateImpl *)tstate;

ts->c_stack_init_base = base;

ts->c_stack_init_top = top;

}

PyUnstable_ThreadState_SetStackProtection(PyThreadState *tstate,

void *stack_start_addr, size_t stack_size)

{

if (stack_size < _PyOS_MIN_STACK_SIZE) {

PyErr_Format(PyExc_ValueError,

"stack_size must be at least %zu bytes",

_PyOS_MIN_STACK_SIZE);

return -1;

}

uintptr_t base = (uintptr_t)stack_start_addr;

uintptr_t top = base + stack_size;

tstate_set_stack(tstate, base, top);

return 0;

}

PyUnstable_ThreadState_ResetStackProtection(PyThreadState *tstate)

{

_PyThreadStateImpl *ts = (_PyThreadStateImpl *)tstate;

if (ts->c_stack_init_top != 0) {

tstate_set_stack(tstate,

ts->c_stack_init_base,

ts->c_stack_init_top);

return;

}

_Py_InitializeRecursionLimits(tstate);

}

_Py_CheckRecursiveCall(PyThreadState *tstate, const char *where)

{

_PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate;

uintptr_t here_addr = _Py_get_machine_stack_pointer();

assert(_tstate->c_stack_soft_limit != 0);

assert(_tstate->c_stack_hard_limit != 0);

#if _Py_STACK_GROWS_DOWN

assert(here_addr >= _tstate->c_stack_hard_limit - _PyOS_STACK_MARGIN_BYTES);

if (here_addr < _tstate->c_stack_hard_limit) {

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

int kbytes_used = (int)(_tstate->c_stack_top - here_addr)/1024;

assert(here_addr <= _tstate->c_stack_hard_limit + _PyOS_STACK_MARGIN_BYTES);

if (here_addr > _tstate->c_stack_hard_limit) {

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

int kbytes_used = (int)(here_addr - _tstate->c_stack_top)/1024;

char buffer[80];

snprintf(buffer, 80, "Unrecoverable stack overflow (used %d kB)%s", kbytes_used, where);

Py_FatalError(buffer);

}

if (tstate->recursion_headroom) {

return 0;

}

else {

#if _Py_STACK_GROWS_DOWN

int kbytes_used = (int)(_tstate->c_stack_top - here_addr)/1024;

int kbytes_used = (int)(here_addr - _tstate->c_stack_top)/1024;

tstate->recursion_headroom++;

_PyErr_Format(tstate, PyExc_RecursionError,

"Stack overflow (used %d kB)%s",

kbytes_used,

where);

tstate->recursion_headroom--;

return -1;

}

}

const binaryfunc _PyEval_BinaryOps[] = {

[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,

[NB_SUBSCR] = PyObject_GetItem,

};

const conversion_func _PyEval_ConversionFuncs[4] = {

[FVC_STR] = PyObject_Str,

[FVC_REPR] = PyObject_Repr,

[FVC_ASCII] = PyObject_ASCII

};

const _Py_SpecialMethod _Py_SpecialMethods[] = {

[SPECIAL___ENTER__] = {

.name = &_Py_ID(__enter__),

.error = (

"'%T' object does not support the context manager protocol "

"(missed __enter__ method)"

),

.error_suggestion = (

"'%T' object does not support the context manager protocol "

"(missed __enter__ method) but it supports the asynchronous "

"context manager protocol. Did you mean to use 'async with'?"

)

},

[SPECIAL___EXIT__] = {

.name = &_Py_ID(__exit__),

.error = (

"'%T' object does not support the context manager protocol "

"(missed __exit__ method)"

),

.error_suggestion = (

"'%T' object does not support the context manager protocol "

"(missed __exit__ method) but it supports the asynchronous "

"context manager protocol. Did you mean to use 'async with'?"

)

},

[SPECIAL___AENTER__] = {

.name = &_Py_ID(__aenter__),

.error = (

"'%T' object does not support the asynchronous "

"context manager protocol (missed __aenter__ method)"

),

.error_suggestion = (

"'%T' object does not support the asynchronous context manager "

"protocol (missed __aenter__ method) but it supports the context "

"manager protocol. Did you mean to use 'with'?"

)

},

[SPECIAL___AEXIT__] = {

.name = &_Py_ID(__aexit__),

.error = (

"'%T' object does not support the asynchronous "

"context manager protocol (missed __aexit__ method)"

),

.error_suggestion = (

"'%T' object does not support the asynchronous context manager "

"protocol (missed __aexit__ method) but it supports the context "

"manager protocol. Did you mean to use 'with'?"

)

}

};

const size_t _Py_FunctionAttributeOffsets[] = {

[MAKE_FUNCTION_CLOSURE] = offsetof(PyFunctionObject, func_closure),

[MAKE_FUNCTION_ANNOTATIONS] = offsetof(PyFunctionObject, func_annotations),

[MAKE_FUNCTION_KWDEFAULTS] = offsetof(PyFunctionObject, func_kwdefaults),

[MAKE_FUNCTION_DEFAULTS] = offsetof(PyFunctionObject, func_defaults),

[MAKE_FUNCTION_ANNOTATE] = offsetof(PyFunctionObject, func_annotate),

};

PyObject *

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

// 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).

_PyCStackRef self, method;

_PyThreadState_PushCStackRef(tstate, &self);

_PyThreadState_PushCStackRef(tstate, &method);

self.ref = PyStackRef_FromPyObjectBorrow(map);

int res = _PyObject_GetMethodStackRef(tstate, &self.ref, &_Py_ID(get), &method.ref);

if (res < 0) {

goto fail;

}

PyObject *get = PyStackRef_AsPyObjectBorrow(method.ref);

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 *self_obj = PyStackRef_AsPyObjectBorrow(self.ref);

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

PyObject *value = NULL;

if (!PyStackRef_IsNull(self.ref)) {

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:

values = Py_NewRef(Py_None);

goto done;

}

PyTuple_SET_ITEM(values, i, value);

}

// Success:

done:

_PyThreadState_PopCStackRef(tstate, &method);

_PyThreadState_PopCStackRef(tstate, &self);

Py_DECREF(seen);

Py_DECREF(dummy);

return values;

fail:

_PyThreadState_PopCStackRef(tstate, &method);

_PyThreadState_PopCStackRef(tstate, &self);

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

// Only check for duplicates if seen is not NULL.

if (seen != NULL) {

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;

(void)PyObject_GetOptionalAttr(subject, name, &attr);

return attr;

}

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

Py_ssize_t nargs, PyObject *kwargs)

{

if (!PyType_Check(type)) {

const char *e = "class pattern must refer to a class";

_PyErr_Format(tstate, PyExc_TypeError, e);

return NULL;

}

assert(PyTuple_CheckExact(kwargs));

// First, an isinstance check:

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

return NULL;

}

// Short circuit if there aren't any arguments:

Py_ssize_t nkwargs = PyTuple_GET_SIZE(kwargs);

Py_ssize_t nattrs = nargs + nkwargs;

if (!nattrs) {

return PyTuple_New(0);

}

// So far so good:

PyObject *seen = NULL;

// Only check for duplicates if there is at least one positional attribute

// and two or more attributes in total. Duplicate keyword attributes are

// detected during the compile stage and raise a SyntaxError.

if (nargs > 0 && nattrs > 1) {

seen = PySet_New(NULL);

if (seen == NULL) {

return NULL;

}

}

PyObject *attrs = PyTuple_New(nattrs);

if (attrs == NULL) {

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

if (PyObject_GetOptionalAttr(type, &_Py_ID(__match_args__), &match_args) < 0) {

goto fail;

}

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 {

// _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.

match_args = PyTuple_New(0);

match_self = PyType_HasFeature((PyTypeObject*)type,

_Py_TPFLAGS_MATCH_SELF);

}

assert(PyTuple_CheckExact(match_args));

Py_ssize_t allowed = match_self ? 1 : PyTuple_GET_SIZE(match_args);

if (allowed < nargs) {

const char *plural = (allowed == 1) ? "" : "s";

_PyErr_Format(tstate, PyExc_TypeError,

"%s() accepts %zd positional sub-pattern%s (%zd given)",

((PyTypeObject*)type)->tp_name,

allowed, plural, nargs);

goto fail;

}

if (match_self) {

// Easy. Copy the subject itself, and move on to kwargs.

assert(PyTuple_GET_ITEM(attrs, 0) == NULL);

PyTuple_SET_ITEM(attrs, 0, Py_NewRef(subject));

}

else {

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

PyObject *name = PyTuple_GET_ITEM(match_args, i);

if (!PyUnicode_CheckExact(name)) {

_PyErr_Format(tstate, PyExc_TypeError,

"__match_args__ elements must be strings "

"(got %s)", Py_TYPE(name)->tp_name);

goto fail;

}

PyObject *attr = match_class_attr(tstate, subject, type, name,

seen);

if (attr == NULL) {

goto fail;

}

assert(PyTuple_GET_ITEM(attrs, i) == NULL);

PyTuple_SET_ITEM(attrs, i, attr);

}

}

Py_CLEAR(match_args);

}

// Finally, the keyword subpatterns:

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

PyObject *name = PyTuple_GET_ITEM(kwargs, i);

PyObject *attr = match_class_attr(tstate, subject, type, name, seen);

if (attr == NULL) {

goto fail;

}

assert(PyTuple_GET_ITEM(attrs, nargs + i) == NULL);

PyTuple_SET_ITEM(attrs, nargs + i, attr);

}

Py_XDECREF(seen);

return attrs;

fail:

// We really don't care whether an error was raised or not... that's our

// caller's problem. All we know is that the match failed.

Py_XDECREF(match_args);

Py_XDECREF(seen);

Py_DECREF(attrs);

return NULL;

}

static int do_raise(PyThreadState *tstate, PyObject *exc, PyObject *cause);

PyObject *

PyEval_EvalCode(PyObject *co, PyObject *globals, PyObject *locals)

{

PyThreadState *tstate = _PyThreadState_GET();

if (locals == NULL) {

locals = globals;

}

PyObject *builtins = _PyDict_LoadBuiltinsFromGlobals(globals);

if (builtins == NULL) {

return NULL;

}

PyFrameConstructor desc = {

.fc_globals = globals,

.fc_builtins = builtins,

.fc_name = ((PyCodeObject *)co)->co_name,

.fc_qualname = ((PyCodeObject *)co)->co_name,

.fc_code = co,

.fc_defaults = NULL,

.fc_kwdefaults = NULL,

.fc_closure = NULL

};

PyFunctionObject *func = _PyFunction_FromConstructor(&desc);

_Py_DECREF_BUILTINS(builtins);

if (func == NULL) {

return NULL;

}

EVAL_CALL_STAT_INC(EVAL_CALL_LEGACY);

PyObject *res = _PyEval_Vector(tstate, func, locals, NULL, 0, NULL);

Py_DECREF(func);

return res;

}

PyObject *

PyEval_EvalFrame(PyFrameObject *f)

{

/* Function kept for backward compatibility */

PyThreadState *tstate = _PyThreadState_GET();

return _PyEval_EvalFrame(tstate, f->f_frame, 0);

}

PyObject *

PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)

{

PyThreadState *tstate = _PyThreadState_GET();

return _PyEval_EvalFrame(tstate, f->f_frame, throwflag);

}

#include "ceval_macros.h"

PyObject *

_Py_VectorCall_StackRefSteal(

_PyStackRef kwnames)

{

PyObject *res;

STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);

if (CONVERSION_FAILED(args_o)) {

res = NULL;

goto cleanup;

}

PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);

PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames);

int positional_args = total_args;

if (kwnames_o != NULL) {

positional_args -= (int)PyTuple_GET_SIZE(kwnames_o);

}

res = PyObject_Vectorcall(

callable_o, args_o,

positional_args | PY_VECTORCALL_ARGUMENTS_OFFSET,

kwnames_o);

STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);

assert((res != NULL) ^ (PyErr_Occurred() != NULL));

cleanup:

PyStackRef_XCLOSE(kwnames);

// arguments is a pointer into the GC visible stack,

// so we must NULL out values as we clear them.

for (int i = total_args-1; i >= 0; i--) {

_PyStackRef tmp = arguments[i];

arguments[i] = PyStackRef_NULL;

PyStackRef_CLOSE(tmp);

}

PyStackRef_CLOSE(callable);

return res;

}

_Py_VectorCallInstrumentation_StackRefSteal(

PyThreadState* tstate)

{

PyObject* res;

STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);

if (CONVERSION_FAILED(args_o)) {

res = NULL;

goto cleanup;

}

PyObject* callable_o = PyStackRef_AsPyObjectBorrow(callable);

PyObject* kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames);

int positional_args = total_args;

if (kwnames_o != NULL) {

positional_args -= (int)PyTuple_GET_SIZE(kwnames_o);

}

res = PyObject_Vectorcall(

callable_o, args_o,

positional_args | PY_VECTORCALL_ARGUMENTS_OFFSET,

kwnames_o);

STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);

if (call_instrumentation) {

PyObject* arg = total_args == 0 ?

&_PyInstrumentation_MISSING : PyStackRef_AsPyObjectBorrow(arguments[0]);

if (res == NULL) {

_Py_call_instrumentation_exc2(

tstate, PY_MONITORING_EVENT_C_RAISE,

frame, this_instr, callable_o, arg);

}

else {

int err = _Py_call_instrumentation_2args(

tstate, PY_MONITORING_EVENT_C_RETURN,

frame, this_instr, callable_o, arg);

if (err < 0) {

Py_CLEAR(res);

}

}

}

assert((res != NULL) ^ (PyErr_Occurred() != NULL));

cleanup:

PyStackRef_XCLOSE(kwnames);

// arguments is a pointer into the GC visible stack,

// so we must NULL out values as we clear them.

for (int i = total_args - 1; i >= 0; i--) {

_PyStackRef tmp = arguments[i];

arguments[i] = PyStackRef_NULL;

PyStackRef_CLOSE(tmp);

}

PyStackRef_CLOSE(callable);

return res;

}

PyObject *

_Py_BuiltinCallFast_StackRef(

_PyStackRef callable,

_PyStackRef *arguments,

int total_args)

{

PyObject *res;

STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);

if (CONVERSION_FAILED(args_o)) {

return NULL;

}

PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);

PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o);

res = _PyCFunctionFast_CAST(cfunc)(

PyCFunction_GET_SELF(callable_o),

args_o,

total_args

);

STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);

assert((res != NULL) ^ (PyErr_Occurred() != NULL));

return res;

}

PyObject *

_Py_BuiltinCallFastWithKeywords_StackRef(

_PyStackRef callable,

_PyStackRef *arguments,

int total_args)

{

PyObject *res;

STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);

if (CONVERSION_FAILED(args_o)) {

return NULL;

}

PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);

PyCFunctionFastWithKeywords cfunc =

_PyCFunctionFastWithKeywords_CAST(PyCFunction_GET_FUNCTION(callable_o));

res = cfunc(PyCFunction_GET_SELF(callable_o), args_o, total_args, NULL);

STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);

assert((res != NULL) ^ (PyErr_Occurred() != NULL));

return res;

}

PyObject *

_PyCallMethodDescriptorFast_StackRef(

int total_args)

{

PyObject *res;

STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);

if (CONVERSION_FAILED(args_o)) {

return NULL;

}

assert(self == PyStackRef_AsPyObjectBorrow(arguments[0]));

res = cfunc(self, (args_o + 1), total_args - 1);

STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);

assert((res != NULL) ^ (PyErr_Occurred() != NULL));

return res;

}

PyObject *

_PyCallMethodDescriptorFastWithKeywords_StackRef(

int total_args)

{

PyObject *res;

STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);

if (CONVERSION_FAILED(args_o)) {

return NULL;

}

assert(self == PyStackRef_AsPyObjectBorrow(arguments[0]));

res = cfunc(self, (args_o + 1), total_args-1, NULL);

STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);

assert((res != NULL) ^ (PyErr_Occurred() != NULL));

return res;

}

PyObject *

_Py_CallBuiltinClass_StackRef(

_PyStackRef callable,

_PyStackRef *arguments,

int total_args)

{

PyObject *res;

STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);

if (CONVERSION_FAILED(args_o)) {

return NULL;

}

PyTypeObject *tp = (PyTypeObject *)PyStackRef_AsPyObjectBorrow(callable);

res = tp->tp_vectorcall((PyObject *)tp, args_o, total_args | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);

STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);

assert((res != NULL) ^ (PyErr_Occurred() != NULL));

return res;

}

PyObject *

_Py_BuildString_StackRefSteal(

_PyStackRef *arguments,

int total_args)

{

PyObject *res;

STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);

if (CONVERSION_FAILED(args_o)) {

res = NULL;

goto cleanup;

}

res = _PyUnicode_JoinArray(&_Py_STR(empty), args_o, total_args);

STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);

assert((res != NULL) ^ (PyErr_Occurred() != NULL));

cleanup:

// arguments is a pointer into the GC visible stack,

// so we must NULL out values as we clear them.

for (int i = total_args-1; i >= 0; i--) {

_PyStackRef tmp = arguments[i];

arguments[i] = PyStackRef_NULL;

PyStackRef_CLOSE(tmp);

}

return res;

}

PyObject *

_Py_BuildMap_StackRefSteal(

_PyStackRef *arguments,

int half_args)

{

PyObject *res;

STACKREFS_TO_PYOBJECTS(arguments, half_args*2, args_o);

if (CONVERSION_FAILED(args_o)) {

res = NULL;

goto cleanup;

}

res = _PyDict_FromItems(

args_o, 2,

args_o+1, 2,

half_args

);

STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);

assert((res != NULL) ^ (PyErr_Occurred() != NULL));

cleanup:

// arguments is a pointer into the GC visible stack,

// so we must NULL out values as we clear them.

for (int i = half_args*2-1; i >= 0; i--) {

_PyStackRef tmp = arguments[i];

arguments[i] = PyStackRef_NULL;

PyStackRef_CLOSE(tmp);

}

return res;

}

_Py_LoadAttr_StackRefSteal(

PyThreadState *tstate, _PyStackRef owner,

PyObject *name, _PyStackRef *self_or_null)

{

// Use _PyCStackRefs to ensure that both method and self are visible to

// the GC. Even though self_or_null is on the evaluation stack, it may be

// after the stackpointer and therefore not visible to the GC.

_PyCStackRef method, self;

_PyThreadState_PushCStackRef(tstate, &method);

_PyThreadState_PushCStackRef(tstate, &self);

self.ref = owner; // steal reference to owner

// NOTE: method.ref is initialized to PyStackRef_NULL and remains null on

// error, so we don't need to explicitly use the return code from the call.

_PyObject_GetMethodStackRef(tstate, &self.ref, name, &method.ref);

*self_or_null = _PyThreadState_PopCStackRefSteal(tstate, &self);

return _PyThreadState_PopCStackRefSteal(tstate, &method);

}

#ifdef Py_DEBUG

_Py_assert_within_stack_bounds(

_PyInterpreterFrame *frame, _PyStackRef *stack_pointer,

const char *filename, int lineno

) {

if (frame->owner == FRAME_OWNED_BY_INTERPRETER) {

return;

}

int level = (int)(stack_pointer - _PyFrame_Stackbase(frame));

if (level < 0) {

printf("Stack underflow (depth = %d) at %s:%d\n", level, filename, lineno);

fflush(stdout);

abort();