/* Frame object implementation */

#include "Python.h"

#include "pycore_cell.h" // PyCell_GetRef()

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

#include "pycore_code.h" // CO_FAST_LOCAL

#include "pycore_dict.h" // _PyDict_LoadBuiltinsFromGlobals()

#include "pycore_frame.h" // PyFrameObject

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

#include "pycore_genobject.h" // _PyGen_GetGeneratorFromFrame()

#include "pycore_interpframe.h" // _PyFrame_GetLocalsArray()

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

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

#include "pycore_opcode_metadata.h" // _PyOpcode_Caches

#include "pycore_optimizer.h" // _Py_Executors_InvalidateDependency()

#include "pycore_unicodeobject.h" // _PyUnicode_Equal()

#include "frameobject.h" // PyFrameLocalsProxyObject

#include "opcode.h" // EXTENDED_ARG

#include "clinic/frameobject.c.h"

#define PyFrameObject_CAST(op) \

(assert(PyObject_TypeCheck((op), &PyFrame_Type)), (PyFrameObject *)(op))

#define PyFrameLocalsProxyObject_CAST(op) \

( \

assert(PyObject_TypeCheck((op), &PyFrameLocalsProxy_Type)), \

(PyFrameLocalsProxyObject *)(op) \

)

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

/*[clinic input]

class frame "PyFrameObject *" "&PyFrame_Type"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=2d1dbf2e06cf351f]*/

// Returns new reference or NULL

static PyObject *

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

{

_PyStackRef *fast = _PyFrame_GetLocalsArray(frame);

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

PyObject *value = PyStackRef_AsPyObjectBorrow(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_GetRef((PyCellObject *)cell);

}

else {

Py_XINCREF(value);

}

if (value == NULL) {

return NULL;

}

return value;

}

static bool

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

{

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

if (value == NULL) {

return false;

}

Py_DECREF(value);

return true;

}

static int

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

{

/*

* 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.

*

* If read == true and value_ptr is not NULL, *value_ptr is set to

* the value of the key if it is found (with a new reference).

*/

// value_ptr should only be given if we are reading the value

assert(read || value_ptr == NULL);

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

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

if (value != NULL) {

if (value_ptr != NULL) {

*value_ptr = value;

}

else {

Py_DECREF(value);

}

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

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

if (value != NULL) {

if (value_ptr != NULL) {

*value_ptr = value;

}

else {

Py_DECREF(value);

}

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_CAST(self)->frame;

PyObject *value = NULL;

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

if (i == -2) {

return NULL;

}

if (i >= 0) {

assert(value != NULL);

return value;

}

assert(value == NULL);

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

PyObject *extra = frame->f_extra_locals;

if (extra != NULL) {

if (PyDict_GetItemRef(extra, key, &value) < 0) {

return NULL;

}

if (value != NULL) {

return value;

}

}

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

return NULL;

}

static int

add_overwritten_fast_local(PyFrameObject *frame, PyObject *obj)

{

Py_ssize_t new_size;

if (frame->f_overwritten_fast_locals == NULL) {

new_size = 1;

}

else {

Py_ssize_t size = PyTuple_Size(frame->f_overwritten_fast_locals);

if (size == -1) {

return -1;

}

new_size = size + 1;

}

PyObject *new_tuple = PyTuple_New(new_size);

if (new_tuple == NULL) {

return -1;

}

for (Py_ssize_t i = 0; i < new_size - 1; i++) {

PyObject *o = PyTuple_GET_ITEM(frame->f_overwritten_fast_locals, i);

PyTuple_SET_ITEM(new_tuple, i, Py_NewRef(o));

}

PyTuple_SET_ITEM(new_tuple, new_size - 1, Py_NewRef(obj));

Py_XSETREF(frame->f_overwritten_fast_locals, new_tuple);

return 0;

}

static int

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

{

/* Merge locals into fast locals */

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

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

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

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

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

_PyStackRef 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(!PyStackRef_IsNull(oldvalue) && PyCell_Check(PyStackRef_AsPyObjectBorrow(oldvalue)));

cell = PyStackRef_AsPyObjectBorrow(oldvalue);

} else if (kind & CO_FAST_CELL && !PyStackRef_IsNull(oldvalue)) {

PyObject *as_obj = PyStackRef_AsPyObjectBorrow(oldvalue);

if (PyCell_Check(as_obj)) {

cell = as_obj;

}

}

if (cell != NULL) {

Py_XINCREF(value);

PyCell_SetTakeRef((PyCellObject *)cell, value);

} else if (value != PyStackRef_AsPyObjectBorrow(oldvalue)) {

PyObject *old_obj = PyStackRef_AsPyObjectBorrow(fast[i]);

if (old_obj != NULL && !_Py_IsImmortal(old_obj)) {

if (add_overwritten_fast_local(frame, old_obj) < 0) {

return -1;

}

PyStackRef_CLOSE(fast[i]);

}

fast[i] = PyStackRef_FromPyObjectNew(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, PyObject *Py_UNUSED(ignored))

{

PyFrameObject *frame = PyFrameLocalsProxyObject_CAST(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++) {

if (framelocalsproxy_hasval(frame->f_frame, co, i)) {

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)

{

PyFrameLocalsProxyObject *proxy = PyFrameLocalsProxyObject_CAST(self);

PyObject_GC_UnTrack(self);

Py_CLEAR(proxy->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)

{

PyFrameLocalsProxyObject *proxy = PyFrameLocalsProxyObject_CAST(self);

Py_CLEAR(proxy->frame);

return 0;

}

static int

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

{

PyFrameLocalsProxyObject *proxy = PyFrameLocalsProxyObject_CAST(self);

Py_VISIT(proxy->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 *lhs, PyObject *rhs, int op)

{

PyFrameLocalsProxyObject *self = PyFrameLocalsProxyObject_CAST(lhs);

if (PyFrameLocalsProxy_Check(rhs)) {

PyFrameLocalsProxyObject *other = (PyFrameLocalsProxyObject *)rhs;

bool result = self->frame == other->frame;

if (op == Py_EQ) {

return PyBool_FromLong(result);

} else if (op == Py_NE) {

return PyBool_FromLong(!result);

}

} else if (PyDict_Check(rhs)) {

PyObject *dct = PyDict_New();

if (dct == NULL) {

return NULL;

}

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

Py_DECREF(dct);

return NULL;

}

PyObject *result = PyObject_RichCompare(dct, rhs, 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, PyObject *Py_UNUSED(ignored))

{

PyFrameObject *frame = PyFrameLocalsProxyObject_CAST(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);

Py_DECREF(value);

return NULL;

}

Py_DECREF(value);

}

}

// 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, PyObject *Py_UNUSED(ignored))

{

PyFrameObject *frame = PyFrameLocalsProxyObject_CAST(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);

Py_DECREF(value);

return NULL;

}

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

Py_DECREF(items);

Py_DECREF(pair);

Py_DECREF(value);

return NULL;

}

Py_DECREF(pair);

Py_DECREF(value);

}

}

// 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_CAST(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_hasval(frame->f_frame, co, i)) {

size++;

}

}

return size;

}

static int

framelocalsproxy_contains(PyObject *self, PyObject *key)

{

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

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

if (i == -2) {

return -1;

}

if (i >= 0) {

return 1;

}

PyObject *extra = 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_CAST(self)->frame;

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

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, PyObject *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 = {

.mp_length = framelocalsproxy_length,

.mp_subscript = framelocalsproxy_getitem,

.mp_ass_subscript = framelocalsproxy_setitem,

};

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__", framelocalsproxy_reversed, METH_NOARGS, NULL},

{"copy", framelocalsproxy_copy, METH_NOARGS, NULL},

{"keys", framelocalsproxy_keys, METH_NOARGS, NULL},

{"values", 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 = 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 = 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 */

};

/*[clinic input]

@critical_section

@getter

frame.f_locals as frame_locals

Return the mapping used by the frame to look up local variables.

[clinic start generated code]*/

static PyObject *

frame_locals_get_impl(PyFrameObject *self)

/*[clinic end generated code: output=b4ace8bb4cae71f4 input=7bd444d0dc8ddf44]*/

{

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

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

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

if (self->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.

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

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

return NULL;

}

}

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

}

return _PyFrameLocalsProxy_New(self);

}

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;

}

}