#define _PY_INTERPRETER

#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_long.h" // _PyLong_GetZero()

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

#include "pycore_moduleobject.h" // PyModuleObject

#include "pycore_opcode.h" // EXTRA_CASES

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

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

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

#include "pycore_range.h" // _PyRangeIterObject

#include "pycore_sliceobject.h" // _PyBuildSlice_ConsumeRefs

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

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

#include "pycore_emscripten_signal.h" // _Py_CHECK_EMSCRIPTEN_SIGNALS

#include "pycore_dict.h"

#include "dictobject.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"

#if !defined(Py_DEBUG) && !defined(Py_TRACE_REFS)

#undef Py_DECREF

#define Py_DECREF(arg) \

do { \

_Py_DECREF_STAT_INC(); \

PyObject *op = _PyObject_CAST(arg); \

if (--op->ob_refcnt == 0) { \

destructor dealloc = Py_TYPE(op)->tp_dealloc; \

(*dealloc)(op); \

} \

} while (0)

#undef Py_XDECREF

#define Py_XDECREF(arg) \

do { \

PyObject *xop = _PyObject_CAST(arg); \

if (xop != NULL) { \

Py_DECREF(xop); \

} \

} while (0)

#undef Py_IS_TYPE

#define Py_IS_TYPE(ob, type) \

(_PyObject_CAST(ob)->ob_type == (type))

#undef _Py_DECREF_SPECIALIZED

#define _Py_DECREF_SPECIALIZED(arg, dealloc) \

do { \

_Py_DECREF_STAT_INC(); \

PyObject *op = _PyObject_CAST(arg); \

if (--op->ob_refcnt == 0) { \

destructor d = (destructor)(dealloc); \

d(op); \

} \

} while (0)

#if defined(_MSC_VER) && SIZEOF_INT == 4

#define _Py_atomic_load_relaxed_int32(ATOMIC_VAL) (assert(sizeof((ATOMIC_VAL)->_value) == 4), *((volatile int*)&((ATOMIC_VAL)->_value)))

#define _Py_atomic_load_relaxed_int32(ATOMIC_VAL) _Py_atomic_load_relaxed(ATOMIC_VAL)

#define HEAD_LOCK(runtime) \

PyThread_acquire_lock((runtime)->interpreters.mutex, WAIT_LOCK)

#define HEAD_UNLOCK(runtime) \

PyThread_release_lock((runtime)->interpreters.mutex)

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 void

dump_stack(_PyInterpreterFrame *frame, PyObject **stack_pointer)

{

PyObject **stack_base = _PyFrame_Stackbase(frame);

PyObject *type, *value, *traceback;

PyErr_Fetch(&type, &value, &traceback);

printf(" stack=[");

for (PyObject **ptr = stack_base; ptr < stack_pointer; ptr++) {

if (ptr != stack_base) {

printf(", ");

}

if (PyObject_Print(*ptr, stdout, 0) != 0) {

PyErr_Clear();

printf("<%s object at %p>",

Py_TYPE(*ptr)->tp_name, (void *)(*ptr));

}

}

printf("]\n");

fflush(stdout);

PyErr_Restore(type, value, traceback);

}

static void

lltrace_instruction(_PyInterpreterFrame *frame,

PyObject **stack_pointer,

_Py_CODEUNIT *next_instr)

{

dump_stack(frame, stack_pointer);

int oparg = _Py_OPARG(*next_instr);

int opcode = _Py_OPCODE(*next_instr);

const char *opname = _PyOpcode_OpName[opcode];

assert(opname != NULL);

int offset = (int)(next_instr - _PyCode_CODE(frame->f_code));

if (HAS_ARG(opcode)) {

printf("%d: %s %d\n", offset * 2, opname, oparg);

}

else {

printf("%d: %s\n", offset * 2, opname);

}

fflush(stdout);

}

static void

lltrace_resume_frame(_PyInterpreterFrame *frame)

{

PyObject *fobj = frame->f_funcobj;

if (fobj == NULL || !PyFunction_Check(fobj)) {

printf("\nResuming frame.");

return;

}

PyFunctionObject *f = (PyFunctionObject *)fobj;

PyObject *type, *value, *traceback;

PyErr_Fetch(&type, &value, &traceback);

PyObject *name = f->func_qualname;

if (name == NULL) {

name = f->func_name;

}

printf("\nResuming frame");

if (name) {

printf(" for ");

if (PyObject_Print(name, stdout, 0) < 0) {

PyErr_Clear();

}

}

if (f->func_module) {

printf(" in module ");

if (PyObject_Print(f->func_module, stdout, 0) < 0) {

PyErr_Clear();

}

}

printf("\n");

fflush(stdout);

PyErr_Restore(type, value, traceback);

}

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;

}

#ifdef HAVE_ERRNO_H

#include <errno.h>

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->py_recursion_limit - p->py_recursion_remaining;

p->py_recursion_limit = new_limit;

p->py_recursion_remaining = new_limit - depth;

}

}

_Py_CheckRecursiveCall(PyThreadState *tstate, const char *where)

{

#ifdef USE_STACKCHECK

if (PyOS_CheckStack()) {

++tstate->c_recursion_remaining;

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

return -1;

}

if (tstate->recursion_headroom) {

if (tstate->c_recursion_remaining < -50) {

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

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

}

}

else {

if (tstate->c_recursion_remaining <= 0) {

tstate->recursion_headroom++;

_PyErr_Format(tstate, PyExc_RecursionError,

"maximum recursion depth exceeded%s",

where);

tstate->recursion_headroom--;

++tstate->c_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.

match_args = PyTuple_New(0);

match_self = PyType_HasFeature((PyTypeObject*)type,

_Py_TPFLAGS_MATCH_SELF);

}

else {

goto fail;

}

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 %d positional sub-pattern%s (%d given)",

((PyTypeObject*)type)->tp_name,

allowed, plural, nargs);

goto fail;

}

if (match_self) {

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

PyList_Append(attrs, 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;

}

PyList_Append(attrs, attr);

Py_DECREF(attr);

}

}

Py_CLEAR(match_args);

}

// Finally, the keyword subpatterns:

for (Py_ssize_t i = 0; i < PyTuple_GET_SIZE(kwargs); i++) {

PyObject *name = PyTuple_GET_ITEM(kwargs, i);

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

if (attr == NULL) {

goto fail;

}

PyList_Append(attrs, attr);

Py_DECREF(attr);

}

Py_SETREF(attrs, PyList_AsTuple(attrs));

Py_DECREF(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_DECREF(seen);

Py_DECREF(attrs);

return NULL;

}

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

static int exception_group_match(

PyObject* exc_value, PyObject *match_type,

PyObject **match, PyObject **rest);

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

PyObject *

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

{

PyThreadState *tstate = _PyThreadState_GET();

if (locals == NULL) {

locals = globals;

}

PyObject *builtins = _PyEval_BuiltinsFromGlobals(tstate, globals); // borrowed ref

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

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

}

#ifdef WITH_DTRACE

#define OR_DTRACE_LINE | (PyDTrace_LINE_ENABLED() ? 255 : 0)

#define OR_DTRACE_LINE

#ifdef HAVE_COMPUTED_GOTOS

#ifndef USE_COMPUTED_GOTOS

#define USE_COMPUTED_GOTOS 1

#endif

#if defined(USE_COMPUTED_GOTOS) && USE_COMPUTED_GOTOS

#error "Computed gotos are not supported on this compiler."

#endif

#undef USE_COMPUTED_GOTOS

#define USE_COMPUTED_GOTOS 0

#ifdef Py_STATS

#define INSTRUCTION_START(op) \

do { \

frame->prev_instr = next_instr++; \

OPCODE_EXE_INC(op); \

if (_py_stats) _py_stats->opcode_stats[lastopcode].pair_count[op]++; \

lastopcode = op; \

} while (0)

#define INSTRUCTION_START(op) (frame->prev_instr = next_instr++)

#if USE_COMPUTED_GOTOS

#define TARGET(op) TARGET_##op: INSTRUCTION_START(op);

#define DISPATCH_GOTO() goto *opcode_targets[opcode]

#define TARGET(op) case op: INSTRUCTION_START(op);

#define DISPATCH_GOTO() goto dispatch_opcode

#ifdef LLTRACE

#define PRE_DISPATCH_GOTO() if (lltrace) { \

lltrace_instruction(frame, stack_pointer, next_instr); }

#define PRE_DISPATCH_GOTO() ((void)0)

#define DISPATCH() \

{ \

NEXTOPARG(); \

PRE_DISPATCH_GOTO(); \

assert(cframe.use_tracing == 0 || cframe.use_tracing == 255); \

opcode |= cframe.use_tracing OR_DTRACE_LINE; \

DISPATCH_GOTO(); \

}

#define DISPATCH_SAME_OPARG() \

{ \

opcode = _Py_OPCODE(*next_instr); \

PRE_DISPATCH_GOTO(); \

opcode |= cframe.use_tracing OR_DTRACE_LINE; \

DISPATCH_GOTO(); \

}

#define CHECK_EVAL_BREAKER() \

_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); \

if (_Py_atomic_load_relaxed_int32(eval_breaker)) { \

goto handle_eval_breaker; \

}

#ifndef Py_DEBUG

#define GETITEM(v, i) PyTuple_GET_ITEM((v), (i))

static inline PyObject *

GETITEM(PyObject *v, Py_ssize_t i) {

assert(PyTuple_Check(v));

assert(i >= 0);

assert(i < PyTuple_GET_SIZE(v));

return PyTuple_GET_ITEM(v, i);

}

#define INSTR_OFFSET() ((int)(next_instr - first_instr))

#define NEXTOPARG() do { \

_Py_CODEUNIT word = *next_instr; \

opcode = _Py_OPCODE(word); \

oparg = _Py_OPARG(word); \

} while (0)

#define JUMPTO(x) (next_instr = first_instr + (x))

#define JUMPBY(x) (next_instr += (x))

#define TRACING_NEXTOPARG() do { \

NEXTOPARG(); \

opcode = _PyOpcode_Deopt[opcode]; \

} while (0)

#define PREDICT_ID(op) PRED_##op

#if USE_COMPUTED_GOTOS

#define PREDICT(op) if (0) goto PREDICT_ID(op)

#define PREDICT(op) \

do { \

_Py_CODEUNIT word = *next_instr; \

opcode = _Py_OPCODE(word) | cframe.use_tracing OR_DTRACE_LINE; \

if (opcode == op) { \

oparg = _Py_OPARG(word); \

INSTRUCTION_START(op); \

goto PREDICT_ID(op); \

} \

} while(0)

#define PREDICTED(op) PREDICT_ID(op):

#define STACK_LEVEL() ((int)(stack_pointer - _PyFrame_Stackbase(frame)))

#define STACK_SIZE() (frame->f_code->co_stacksize)

#define EMPTY() (STACK_LEVEL() == 0)

#define TOP() (stack_pointer[-1])

#define SECOND() (stack_pointer[-2])

#define THIRD() (stack_pointer[-3])

#define FOURTH() (stack_pointer[-4])

#define PEEK(n) (stack_pointer[-(n)])

#define SET_TOP(v) (stack_pointer[-1] = (v))

#define SET_SECOND(v) (stack_pointer[-2] = (v))

#define BASIC_STACKADJ(n) (stack_pointer += n)

#define BASIC_PUSH(v) (*stack_pointer++ = (v))

#define BASIC_POP() (*--stack_pointer)

#ifdef Py_DEBUG

#define PUSH(v) do { \

BASIC_PUSH(v); \

assert(STACK_LEVEL() <= STACK_SIZE()); \

} while (0)

#define POP() (assert(STACK_LEVEL() > 0), BASIC_POP())

#define STACK_GROW(n) do { \

assert(n >= 0); \

BASIC_STACKADJ(n); \

assert(STACK_LEVEL() <= STACK_SIZE()); \

} while (0)

#define STACK_SHRINK(n) do { \

assert(n >= 0); \

assert(STACK_LEVEL() >= n); \

BASIC_STACKADJ(-(n)); \

} while (0)

#define PUSH(v) BASIC_PUSH(v)

#define POP() BASIC_POP()

#define STACK_GROW(n) BASIC_STACKADJ(n)

#define STACK_SHRINK(n) BASIC_STACKADJ(-(n))

#define GETLOCAL(i) (frame->localsplus[i])

#define SETLOCAL(i, value) do { PyObject *tmp = GETLOCAL(i); \

GETLOCAL(i) = value; \

Py_XDECREF(tmp); } while (0)

#define JUMP_TO_INSTRUCTION(op) goto PREDICT_ID(op)

#define DEOPT_IF(cond, instname) if (cond) { goto miss; }

#define GLOBALS() frame->f_globals

#define BUILTINS() frame->f_builtins

#define LOCALS() frame->f_locals

#define TRACE_FUNCTION_EXIT() \

if (cframe.use_tracing) { \

if (trace_function_exit(tstate, frame, retval)) { \

Py_DECREF(retval); \

goto exit_unwind; \

} \

}

#define DTRACE_FUNCTION_EXIT() \

if (PyDTrace_FUNCTION_RETURN_ENABLED()) { \

dtrace_function_return(frame); \

}

#define TRACE_FUNCTION_UNWIND() \

if (cframe.use_tracing) { \

/* Since we are already unwinding, \

* we don't care if this raises */ \

trace_function_exit(tstate, frame, NULL); \

}

#define TRACE_FUNCTION_ENTRY() \

if (cframe.use_tracing) { \

_PyFrame_SetStackPointer(frame, stack_pointer); \

int err = trace_function_entry(tstate, frame); \

stack_pointer = _PyFrame_GetStackPointer(frame); \

if (err) { \

goto error; \

} \

}

#define TRACE_FUNCTION_THROW_ENTRY() \

if (cframe.use_tracing) { \

assert(frame->stacktop >= 0); \

if (trace_function_entry(tstate, frame)) { \

goto exit_unwind; \

} \

}

#define DTRACE_FUNCTION_ENTRY() \

if (PyDTrace_FUNCTION_ENTRY_ENABLED()) { \

dtrace_function_entry(frame); \

}

#define ADAPTIVE_COUNTER_IS_ZERO(cache) \

(cache)->counter < (1<<ADAPTIVE_BACKOFF_BITS)

#define DECREMENT_ADAPTIVE_COUNTER(cache) \

(cache)->counter -= (1<<ADAPTIVE_BACKOFF_BITS)

static int

trace_function_entry(PyThreadState *tstate, _PyInterpreterFrame *frame)

{

if (tstate->c_tracefunc != NULL) {

/* tstate->c_tracefunc, if defined, is a

if (call_trace_protected(tstate->c_tracefunc,

tstate->c_traceobj,

tstate, frame,

PyTrace_CALL, Py_None)) {

/* Trace function raised an error */

return -1;

}

}

if (tstate->c_profilefunc != NULL) {

/* Similar for c_profilefunc, except it needn't

if (call_trace_protected(tstate->c_profilefunc,

tstate->c_profileobj,

tstate, frame,

PyTrace_CALL, Py_None)) {

/* Profile function raised an error */

return -1;

}

}

return 0;

}

static int

trace_function_exit(PyThreadState *tstate, _PyInterpreterFrame *frame, PyObject *retval)

{

if (tstate->c_tracefunc) {

if (call_trace_protected(tstate->c_tracefunc, tstate->c_traceobj,

tstate, frame, PyTrace_RETURN, retval)) {

return -1;

}

}

if (tstate->c_profilefunc) {

if (call_trace_protected(tstate->c_profilefunc, tstate->c_profileobj,

tstate, frame, PyTrace_RETURN, retval)) {

return -1;

}

}

return 0;

}

static _PyInterpreterFrame *

pop_frame(PyThreadState *tstate, _PyInterpreterFrame *frame)

{

_PyInterpreterFrame *prev_frame = frame->previous;

_PyEvalFrameClearAndPop(tstate, frame);

return prev_frame;

}

int _Py_CheckRecursiveCallPy(

PyThreadState *tstate)

{

if (tstate->recursion_headroom) {

if (tstate->py_recursion_remaining < -50) {

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

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

}

}

else {

if (tstate->py_recursion_remaining <= 0) {

tstate->recursion_headroom++;

_PyErr_Format(tstate, PyExc_RecursionError,

"maximum recursion depth exceeded");

tstate->recursion_headroom--;

return -1;

}

}

return 0;

}

static inline int _Py_EnterRecursivePy(PyThreadState *tstate) {