/* Frame object implementation */

#include "Python.h"

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

#include "pycore_code.h" // CO_FAST_LOCAL, etc.

#include "pycore_function.h" // _PyFunction_FromConstructor()

#include "pycore_moduleobject.h" // _PyModule_GetDict()

#include "pycore_modsupport.h" // _PyArg_CheckPositional()

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

#include "pycore_opcode_metadata.h" // _PyOpcode_Deopt, _PyOpcode_Caches

#include "frameobject.h" // PyFrameObject

#include "pycore_frame.h"

#include "opcode.h" // EXTENDED_ARG

#define OFF(x) offsetof(PyFrameObject, x)

// Returns borrowed reference or NULL

static PyObject *

framelocalsproxy_getval(_PyInterpreterFrame *frame, PyCodeObject *co, int i)

{

PyObject **fast = _PyFrame_GetLocalsArray(frame);

_PyLocals_Kind kind = _PyLocals_GetKind(co->co_localspluskinds, i);

PyObject *value = fast[i];

PyObject *cell = NULL;

if (value == NULL) {

return NULL;

}

if (kind == CO_FAST_FREE || kind & CO_FAST_CELL) {

// The cell was set when the frame was created from

// the function's closure.

// GH-128396: With PEP 709, it's possible to have a fast variable in

// an inlined comprehension that has the same name as the cell variable

// in the frame, where the `kind` obtained from frame can not guarantee

// that the variable is a cell.

// If the variable is not a cell, we are okay with it and we can simply

// return the value.

if (PyCell_Check(value)) {

cell = value;

}

}

if (cell != NULL) {

value = PyCell_GET(cell);

}

if (value == NULL) {

return NULL;

}

return value;

}

static int

framelocalsproxy_getkeyindex(PyFrameObject *frame, PyObject* key, bool read)

{

/*

* Returns -2 (!) if an error occurred; exception will be set.

* Returns the fast locals index of the key on success:

* - if read == true, returns the index if the value is not NULL

* - if read == false, returns the index if the value is not hidden

* Otherwise returns -1.

*/

PyCodeObject *co = _PyFrame_GetCode(frame->f_frame);

// Ensure that the key is hashable.

Py_hash_t key_hash = PyObject_Hash(key);

if (key_hash == -1) {

return -2;

}

bool found = false;

// We do 2 loops here because it's highly possible the key is interned

// and we can do a pointer comparison.

for (int i = 0; i < co->co_nlocalsplus; i++) {

PyObject *name = PyTuple_GET_ITEM(co->co_localsplusnames, i);

if (name == key) {

if (read) {

if (framelocalsproxy_getval(frame->f_frame, co, i) != NULL) {

return i;

}

} else {

if (!(_PyLocals_GetKind(co->co_localspluskinds, i) & CO_FAST_HIDDEN)) {

return i;

}

}

found = true;

}

}

if (found) {

// This is an attempt to read an unset local variable or

// write to a variable that is hidden from regular write operations

return -1;

}

// This is unlikely, but we need to make sure. This means the key

// is not interned.

for (int i = 0; i < co->co_nlocalsplus; i++) {

PyObject *name = PyTuple_GET_ITEM(co->co_localsplusnames, i);

Py_hash_t name_hash = PyObject_Hash(name);

assert(name_hash != -1); // keys are exact unicode

if (name_hash != key_hash) {

continue;

}

int same = PyObject_RichCompareBool(name, key, Py_EQ);

if (same < 0) {

return -2;

}

if (same) {

if (read) {

if (framelocalsproxy_getval(frame->f_frame, co, i) != NULL) {

return i;

}

} else {

if (!(_PyLocals_GetKind(co->co_localspluskinds, i) & CO_FAST_HIDDEN)) {

return i;

}

}

}

}

return -1;

}

static PyObject *

framelocalsproxy_getitem(PyObject *self, PyObject *key)

{

PyFrameObject* frame = ((PyFrameLocalsProxyObject*)self)->frame;

PyCodeObject* co = _PyFrame_GetCode(frame->f_frame);

int i = framelocalsproxy_getkeyindex(frame, key, true);

if (i == -2) {

return NULL;

}

if (i >= 0) {

PyObject *value = framelocalsproxy_getval(frame->f_frame, co, i);

assert(value != NULL);

return Py_NewRef(value);

}

// Okay not in the fast locals, try extra locals

PyObject *extra = frame->f_extra_locals;

if (extra != NULL) {

PyObject *value = PyDict_GetItem(extra, key);

if (value != NULL) {

return Py_NewRef(value);

}

}

PyErr_Format(PyExc_KeyError, "local variable '%R' is not defined", key);

return NULL;

}

static int

framelocalsproxy_setitem(PyObject *self, PyObject *key, PyObject *value)

{

/* Merge locals into fast locals */

PyFrameObject* frame = ((PyFrameLocalsProxyObject*)self)->frame;

PyObject** fast = _PyFrame_GetLocalsArray(frame->f_frame);

PyCodeObject* co = _PyFrame_GetCode(frame->f_frame);

int i = framelocalsproxy_getkeyindex(frame, key, false);

if (i == -2) {

return -1;

}

if (i >= 0) {

if (value == NULL) {

PyErr_SetString(PyExc_ValueError, "cannot remove local variables from FrameLocalsProxy");

return -1;

}

_Py_Executors_InvalidateDependency(PyInterpreterState_Get(), co, 1);

_PyLocals_Kind kind = _PyLocals_GetKind(co->co_localspluskinds, i);

PyObject *oldvalue = fast[i];

PyObject *cell = NULL;

if (kind == CO_FAST_FREE) {

// The cell was set when the frame was created from

// the function's closure.

assert(oldvalue != NULL && PyCell_Check(oldvalue));

cell = oldvalue;

} else if (kind & CO_FAST_CELL && oldvalue != NULL) {

if (PyCell_Check(oldvalue)) {

cell = oldvalue;

}

}

if (cell != NULL) {

oldvalue = PyCell_GET(cell);

if (value != oldvalue) {

PyCell_SET(cell, Py_XNewRef(value));

Py_XDECREF(oldvalue);

}

} else if (value != oldvalue) {

Py_XSETREF(fast[i], Py_NewRef(value));

}

return 0;

}

// Okay not in the fast locals, try extra locals

PyObject *extra = frame->f_extra_locals;

if (extra == NULL) {

if (value == NULL) {

_PyErr_SetKeyError(key);

return -1;

}

extra = PyDict_New();

if (extra == NULL) {

return -1;

}

frame->f_extra_locals = extra;

}

assert(PyDict_Check(extra));

if (value == NULL) {

return PyDict_DelItem(extra, key);

} else {

return PyDict_SetItem(extra, key, value);

}

}

static int

framelocalsproxy_merge(PyObject* self, PyObject* other)

{

if (!PyDict_Check(other) && !PyFrameLocalsProxy_Check(other)) {

return -1;

}

PyObject *keys = PyMapping_Keys(other);

if (keys == NULL) {

return -1;

}

PyObject *iter = PyObject_GetIter(keys);

Py_DECREF(keys);

if (iter == NULL) {

return -1;

}

PyObject *key = NULL;

PyObject *value = NULL;

while ((key = PyIter_Next(iter)) != NULL) {

value = PyObject_GetItem(other, key);

if (value == NULL) {

Py_DECREF(key);

Py_DECREF(iter);

return -1;

}

if (framelocalsproxy_setitem(self, key, value) < 0) {

Py_DECREF(key);

Py_DECREF(value);

Py_DECREF(iter);

return -1;

}

Py_DECREF(key);

Py_DECREF(value);

}

Py_DECREF(iter);

if (PyErr_Occurred()) {

return -1;

}

return 0;

}

static PyObject *

framelocalsproxy_keys(PyObject *self, void *Py_UNUSED(ignored))

{

PyFrameObject *frame = ((PyFrameLocalsProxyObject*)self)->frame;

PyCodeObject *co = _PyFrame_GetCode(frame->f_frame);

PyObject *names = PyList_New(0);

if (names == NULL) {

return NULL;

}

for (int i = 0; i < co->co_nlocalsplus; i++) {

PyObject *val = framelocalsproxy_getval(frame->f_frame, co, i);

if (val) {

PyObject *name = PyTuple_GET_ITEM(co->co_localsplusnames, i);

if (PyList_Append(names, name) < 0) {

Py_DECREF(names);

return NULL;

}

}

}

// Iterate through the extra locals

if (frame->f_extra_locals) {

assert(PyDict_Check(frame->f_extra_locals));

Py_ssize_t i = 0;

PyObject *key = NULL;

PyObject *value = NULL;

while (PyDict_Next(frame->f_extra_locals, &i, &key, &value)) {

if (PyList_Append(names, key) < 0) {

Py_DECREF(names);

return NULL;

}

}

}

return names;

}

static void

framelocalsproxy_dealloc(PyObject *self)

{

PyObject_GC_UnTrack(self);

Py_CLEAR(((PyFrameLocalsProxyObject*)self)->frame);

Py_TYPE(self)->tp_free(self);

}

static PyObject *

framelocalsproxy_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

if (PyTuple_GET_SIZE(args) != 1) {

PyErr_Format(PyExc_TypeError,

"FrameLocalsProxy expected 1 argument, got %zd",

PyTuple_GET_SIZE(args));

return NULL;

}

PyObject *item = PyTuple_GET_ITEM(args, 0);

if (!PyFrame_Check(item)) {

PyErr_Format(PyExc_TypeError, "expect frame, not %T", item);

return NULL;

}

PyFrameObject *frame = (PyFrameObject*)item;

if (kwds != NULL && PyDict_Size(kwds) != 0) {

PyErr_SetString(PyExc_TypeError,

"FrameLocalsProxy takes no keyword arguments");

return 0;

}

PyFrameLocalsProxyObject *self = (PyFrameLocalsProxyObject *)type->tp_alloc(type, 0);

if (self == NULL) {

return NULL;

}

((PyFrameLocalsProxyObject*)self)->frame = (PyFrameObject*)Py_NewRef(frame);

return (PyObject *)self;

}

static int

framelocalsproxy_tp_clear(PyObject *self)

{

Py_CLEAR(((PyFrameLocalsProxyObject*)self)->frame);

return 0;

}

static int

framelocalsproxy_visit(PyObject *self, visitproc visit, void *arg)

{

Py_VISIT(((PyFrameLocalsProxyObject*)self)->frame);

return 0;

}

static PyObject *

framelocalsproxy_iter(PyObject *self)

{

PyObject* keys = framelocalsproxy_keys(self, NULL);

if (keys == NULL) {

return NULL;

}

PyObject* iter = PyObject_GetIter(keys);

Py_XDECREF(keys);

return iter;

}

static PyObject *

framelocalsproxy_richcompare(PyObject *self, PyObject *other, int op)

{

if (PyFrameLocalsProxy_Check(other)) {

bool result = ((PyFrameLocalsProxyObject*)self)->frame == ((PyFrameLocalsProxyObject*)other)->frame;

if (op == Py_EQ) {

return PyBool_FromLong(result);

} else if (op == Py_NE) {

return PyBool_FromLong(!result);

}

} else if (PyDict_Check(other)) {

PyObject *dct = PyDict_New();

if (dct == NULL) {

return NULL;

}

if (PyDict_Update(dct, self) < 0) {

Py_DECREF(dct);

return NULL;

}

PyObject *result = PyObject_RichCompare(dct, other, op);

Py_DECREF(dct);

return result;

}

Py_RETURN_NOTIMPLEMENTED;

}

static PyObject *

framelocalsproxy_repr(PyObject *self)

{

int i = Py_ReprEnter(self);

if (i != 0) {

return i > 0 ? PyUnicode_FromString("{...}") : NULL;

}

PyObject *dct = PyDict_New();

if (dct == NULL) {

Py_ReprLeave(self);

return NULL;

}

if (PyDict_Update(dct, self) < 0) {

Py_DECREF(dct);

Py_ReprLeave(self);

return NULL;

}

PyObject *repr = PyObject_Repr(dct);

Py_DECREF(dct);

Py_ReprLeave(self);

return repr;

}

static PyObject*

framelocalsproxy_or(PyObject *self, PyObject *other)

{

if (!PyDict_Check(other) && !PyFrameLocalsProxy_Check(other)) {

Py_RETURN_NOTIMPLEMENTED;

}

PyObject *result = PyDict_New();

if (result == NULL) {

return NULL;

}

if (PyDict_Update(result, self) < 0) {

Py_DECREF(result);

return NULL;

}

if (PyDict_Update(result, other) < 0) {

Py_DECREF(result);

return NULL;

}

return result;

}

static PyObject*

framelocalsproxy_inplace_or(PyObject *self, PyObject *other)

{

if (!PyDict_Check(other) && !PyFrameLocalsProxy_Check(other)) {

Py_RETURN_NOTIMPLEMENTED;

}

if (framelocalsproxy_merge(self, other) < 0) {

Py_RETURN_NOTIMPLEMENTED;

}

return Py_NewRef(self);

}

static PyObject*

framelocalsproxy_values(PyObject *self, void *Py_UNUSED(ignored))

{

PyFrameObject *frame = ((PyFrameLocalsProxyObject*)self)->frame;

PyCodeObject *co = _PyFrame_GetCode(frame->f_frame);

PyObject *values = PyList_New(0);

if (values == NULL) {

return NULL;

}

for (int i = 0; i < co->co_nlocalsplus; i++) {

PyObject *value = framelocalsproxy_getval(frame->f_frame, co, i);

if (value) {

if (PyList_Append(values, value) < 0) {

Py_DECREF(values);

return NULL;

}

}

}

// Iterate through the extra locals

if (frame->f_extra_locals) {

Py_ssize_t j = 0;

PyObject *key = NULL;

PyObject *value = NULL;

while (PyDict_Next(frame->f_extra_locals, &j, &key, &value)) {

if (PyList_Append(values, value) < 0) {

Py_DECREF(values);

return NULL;

}

}

}

return values;

}

static PyObject *

framelocalsproxy_items(PyObject *self, void *Py_UNUSED(ignored))

{

PyFrameObject *frame = ((PyFrameLocalsProxyObject*)self)->frame;

PyCodeObject *co = _PyFrame_GetCode(frame->f_frame);

PyObject *items = PyList_New(0);

if (items == NULL) {

return NULL;

}

for (int i = 0; i < co->co_nlocalsplus; i++) {

PyObject *name = PyTuple_GET_ITEM(co->co_localsplusnames, i);

PyObject *value = framelocalsproxy_getval(frame->f_frame, co, i);

if (value) {

PyObject *pair = PyTuple_Pack(2, name, value);

if (pair == NULL) {

Py_DECREF(items);

return NULL;

}

if (PyList_Append(items, pair) < 0) {

Py_DECREF(items);

Py_DECREF(pair);

return NULL;

}

Py_DECREF(pair);

}

}

// Iterate through the extra locals

if (frame->f_extra_locals) {

Py_ssize_t j = 0;

PyObject *key = NULL;

PyObject *value = NULL;

while (PyDict_Next(frame->f_extra_locals, &j, &key, &value)) {

PyObject *pair = PyTuple_Pack(2, key, value);

if (pair == NULL) {

Py_DECREF(items);

return NULL;

}

if (PyList_Append(items, pair) < 0) {

Py_DECREF(items);

Py_DECREF(pair);

return NULL;

}

Py_DECREF(pair);

}

}

return items;

}

static Py_ssize_t

framelocalsproxy_length(PyObject *self)

{

PyFrameObject *frame = ((PyFrameLocalsProxyObject*)self)->frame;

PyCodeObject *co = _PyFrame_GetCode(frame->f_frame);

Py_ssize_t size = 0;

if (frame->f_extra_locals != NULL) {

assert(PyDict_Check(frame->f_extra_locals));

size += PyDict_Size(frame->f_extra_locals);

}

for (int i = 0; i < co->co_nlocalsplus; i++) {

if (framelocalsproxy_getval(frame->f_frame, co, i) != NULL) {

size++;

}

}

return size;

}

static int

framelocalsproxy_contains(PyObject *self, PyObject *key)

{

PyFrameObject *frame = ((PyFrameLocalsProxyObject*)self)->frame;

int i = framelocalsproxy_getkeyindex(frame, key, true);

if (i == -2) {

return -1;

}

if (i >= 0) {

return 1;

}

PyObject *extra = ((PyFrameObject*)frame)->f_extra_locals;

if (extra != NULL) {

return PyDict_Contains(extra, key);

}

return 0;

}

static PyObject* framelocalsproxy___contains__(PyObject *self, PyObject *key)

{

int result = framelocalsproxy_contains(self, key);

if (result < 0) {

return NULL;

}

return PyBool_FromLong(result);

}

static PyObject*

framelocalsproxy_update(PyObject *self, PyObject *other)

{

if (framelocalsproxy_merge(self, other) < 0) {

PyErr_SetString(PyExc_TypeError, "update() argument must be dict or another FrameLocalsProxy");

return NULL;

}

Py_RETURN_NONE;

}

static PyObject*

framelocalsproxy_get(PyObject* self, PyObject *const *args, Py_ssize_t nargs)

{

if (nargs < 1 || nargs > 2) {

PyErr_SetString(PyExc_TypeError, "get expected 1 or 2 arguments");

return NULL;

}

PyObject *key = args[0];

PyObject *default_value = Py_None;

if (nargs == 2) {

default_value = args[1];

}

PyObject *result = framelocalsproxy_getitem(self, key);

if (result == NULL) {

if (PyErr_ExceptionMatches(PyExc_KeyError)) {

PyErr_Clear();

return Py_XNewRef(default_value);

}

return NULL;

}

return result;

}

static PyObject*

framelocalsproxy_setdefault(PyObject* self, PyObject *const *args, Py_ssize_t nargs)

{

if (nargs < 1 || nargs > 2) {

PyErr_SetString(PyExc_TypeError, "setdefault expected 1 or 2 arguments");

return NULL;

}

PyObject *key = args[0];

PyObject *default_value = Py_None;

if (nargs == 2) {

default_value = args[1];

}

PyObject *result = framelocalsproxy_getitem(self, key);

if (result == NULL) {

if (PyErr_ExceptionMatches(PyExc_KeyError)) {

PyErr_Clear();

if (framelocalsproxy_setitem(self, key, default_value) < 0) {

return NULL;

}

return Py_XNewRef(default_value);

}

return NULL;

}

return result;

}

static PyObject*

framelocalsproxy_pop(PyObject* self, PyObject *const *args, Py_ssize_t nargs)

{

if (!_PyArg_CheckPositional("pop", nargs, 1, 2)) {

return NULL;

}

PyObject *key = args[0];

PyObject *default_value = NULL;

if (nargs == 2) {

default_value = args[1];

}

PyFrameObject *frame = ((PyFrameLocalsProxyObject*)self)->frame;

int i = framelocalsproxy_getkeyindex(frame, key, false);

if (i == -2) {

return NULL;

}

if (i >= 0) {

PyErr_SetString(PyExc_ValueError, "cannot remove local variables from FrameLocalsProxy");

return NULL;

}

PyObject *result = NULL;

if (frame->f_extra_locals == NULL) {

if (default_value != NULL) {

return Py_XNewRef(default_value);

} else {

_PyErr_SetKeyError(key);

return NULL;

}

}

if (PyDict_Pop(frame->f_extra_locals, key, &result) < 0) {

return NULL;

}

if (result == NULL) {

if (default_value != NULL) {

return Py_XNewRef(default_value);

} else {

_PyErr_SetKeyError(key);

return NULL;

}

}

return result;

}

static PyObject*

framelocalsproxy_copy(PyObject *self, PyObject *Py_UNUSED(ignored))

{

PyObject* result = PyDict_New();

if (result == NULL) {

return NULL;

}

if (PyDict_Update(result, self) < 0) {

Py_DECREF(result);

return NULL;

}

return result;

}

static PyObject*

framelocalsproxy_reversed(PyObject *self, void *Py_UNUSED(ignored))

{

PyObject *result = framelocalsproxy_keys(self, NULL);

if (result == NULL) {

return NULL;

}

if (PyList_Reverse(result) < 0) {

Py_DECREF(result);

return NULL;

}

return result;

}

static PyNumberMethods framelocalsproxy_as_number = {

.nb_or = framelocalsproxy_or,

.nb_inplace_or = framelocalsproxy_inplace_or,

};

static PySequenceMethods framelocalsproxy_as_sequence = {

.sq_contains = framelocalsproxy_contains,

};

static PyMappingMethods framelocalsproxy_as_mapping = {

framelocalsproxy_length, // mp_length

framelocalsproxy_getitem, // mp_subscript

framelocalsproxy_setitem, // mp_ass_subscript

};

static PyMethodDef framelocalsproxy_methods[] = {

{"__contains__", framelocalsproxy___contains__, METH_O | METH_COEXIST,

NULL},

{"__getitem__", framelocalsproxy_getitem, METH_O | METH_COEXIST,

NULL},

{"update", framelocalsproxy_update, METH_O,

NULL},

{"__reversed__", _PyCFunction_CAST(framelocalsproxy_reversed), METH_NOARGS,

NULL},

{"copy", _PyCFunction_CAST(framelocalsproxy_copy), METH_NOARGS,

NULL},

{"keys", _PyCFunction_CAST(framelocalsproxy_keys), METH_NOARGS,

NULL},

{"values", _PyCFunction_CAST(framelocalsproxy_values), METH_NOARGS,

NULL},

{"items", _PyCFunction_CAST(framelocalsproxy_items), METH_NOARGS,

NULL},

{"get", _PyCFunction_CAST(framelocalsproxy_get), METH_FASTCALL,

NULL},

{"pop", _PyCFunction_CAST(framelocalsproxy_pop), METH_FASTCALL,

NULL},

{"setdefault", _PyCFunction_CAST(framelocalsproxy_setdefault), METH_FASTCALL,

NULL},

{NULL, NULL} /* sentinel */

};

PyTypeObject PyFrameLocalsProxy_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

.tp_name = "FrameLocalsProxy",

.tp_basicsize = sizeof(PyFrameLocalsProxyObject),

.tp_dealloc = (destructor)framelocalsproxy_dealloc,

.tp_repr = &framelocalsproxy_repr,

.tp_as_number = &framelocalsproxy_as_number,

.tp_as_sequence = &framelocalsproxy_as_sequence,

.tp_as_mapping = &framelocalsproxy_as_mapping,

.tp_getattro = PyObject_GenericGetAttr,

.tp_setattro = PyObject_GenericSetAttr,

.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_MAPPING,

.tp_traverse = framelocalsproxy_visit,

.tp_clear = framelocalsproxy_tp_clear,

.tp_richcompare = framelocalsproxy_richcompare,

.tp_iter = framelocalsproxy_iter,

.tp_methods = framelocalsproxy_methods,

.tp_alloc = PyType_GenericAlloc,

.tp_new = framelocalsproxy_new,

.tp_free = PyObject_GC_Del,

};

PyObject *

_PyFrameLocalsProxy_New(PyFrameObject *frame)

{

PyObject* args = PyTuple_Pack(1, frame);

if (args == NULL) {

return NULL;

}

PyObject* proxy = (PyObject*)framelocalsproxy_new(&PyFrameLocalsProxy_Type, args, NULL);

Py_DECREF(args);

return proxy;

}

static PyMemberDef frame_memberlist[] = {

{"f_trace_lines", Py_T_BOOL, OFF(f_trace_lines), 0},

{NULL} /* Sentinel */

};

static PyObject *

frame_getlocals(PyFrameObject *f, void *closure)

{

if (f == NULL) {

PyErr_BadInternalCall();

return NULL;

}

assert(!_PyFrame_IsIncomplete(f->f_frame));

PyCodeObject *co = _PyFrame_GetCode(f->f_frame);

if (!(co->co_flags & CO_OPTIMIZED) && !_PyFrame_HasHiddenLocals(f->f_frame)) {

if (f->f_frame->f_locals == NULL) {

// We found cases when f_locals is NULL for non-optimized code.

// We fill the f_locals with an empty dict to avoid crash until

// we find the root cause.

f->f_frame->f_locals = PyDict_New();

if (f->f_frame->f_locals == NULL) {

return NULL;

}

}

return Py_NewRef(f->f_frame->f_locals);

}

return _PyFrameLocalsProxy_New(f);

}

int

PyFrame_GetLineNumber(PyFrameObject *f)

{

assert(f != NULL);

if (f->f_lineno == -1) {

// We should calculate it once. If we can't get the line number,

// set f->f_lineno to 0.

f->f_lineno = PyUnstable_InterpreterFrame_GetLine(f->f_frame);

if (f->f_lineno < 0) {

f->f_lineno = 0;

return -1;

}

}

if (f->f_lineno > 0) {

return f->f_lineno;

}

return PyUnstable_InterpreterFrame_GetLine(f->f_frame);

}

static PyObject *

frame_getlineno(PyFrameObject *f, void *closure)

{

int lineno = PyFrame_GetLineNumber(f);

if (lineno < 0) {

Py_RETURN_NONE;

}

else {

return PyLong_FromLong(lineno);

}

}

static PyObject *

frame_getlasti(PyFrameObject *f, void *closure)

{

int lasti = _PyInterpreterFrame_LASTI(f->f_frame);

if (lasti < 0) {

return PyLong_FromLong(-1);

}

return PyLong_FromLong(lasti * sizeof(_Py_CODEUNIT));

}

static PyObject *

frame_getglobals(PyFrameObject *f, void *closure)

{

PyObject *globals = f->f_frame->f_globals;

if (globals == NULL) {

globals = Py_None;

}

return Py_NewRef(globals);

}

static PyObject *

frame_getbuiltins(PyFrameObject *f, void *closure)

{

PyObject *builtins = f->f_frame->f_builtins;

if (builtins == NULL) {

builtins = Py_None;

}

return Py_NewRef(builtins);

}

static PyObject *

frame_getcode(PyFrameObject *f, void *closure)

{

if (PySys_Audit("object.__getattr__", "Os", f, "f_code") < 0) {

return NULL;

}

return (PyObject *)PyFrame_GetCode(f);

}

static PyObject *

frame_getback(PyFrameObject *f, void *closure)

{

PyObject *res = (PyObject *)PyFrame_GetBack(f);

if (res == NULL && !PyErr_Occurred()) {

Py_RETURN_NONE;

}

return res;

}

static PyObject *

frame_gettrace_opcodes(PyFrameObject *f, void *closure)

{

PyObject *result = f->f_trace_opcodes ? Py_True : Py_False;

return Py_NewRef(result);

}

static int

frame_settrace_opcodes(PyFrameObject *f, PyObject* value, void *Py_UNUSED(ignored))

{

if (!PyBool_Check(value)) {

PyErr_SetString(PyExc_TypeError,

"attribute value type must be bool");

return -1;

}

if (value == Py_True) {

f->f_trace_opcodes = 1;

if (f->f_trace) {

return _PyEval_SetOpcodeTrace(f, true);

}

}

else {

f->f_trace_opcodes = 0;

return _PyEval_SetOpcodeTrace(f, false);

}

return 0;

}

/* Model the evaluation stack, to determine which jumps