cpython/Objects/frameobject.c

477 lines
12 KiB
C
Raw Normal View History

1991-02-19 08:39:46 -04:00
1990-12-20 11:06:42 -04:00
/* Frame object implementation */
1997-04-29 11:49:28 -03:00
#include "Python.h"
1990-12-20 11:06:42 -04:00
#include "compile.h"
#include "frameobject.h"
#include "opcode.h"
#include "structmember.h"
1997-04-29 11:49:28 -03:00
#define OFF(x) offsetof(PyFrameObject, x)
1990-12-20 11:06:42 -04:00
static struct memberlist frame_memberlist[] = {
1994-08-30 05:27:36 -03:00
{"f_back", T_OBJECT, OFF(f_back), RO},
{"f_code", T_OBJECT, OFF(f_code), RO},
{"f_builtins", T_OBJECT, OFF(f_builtins),RO},
1994-08-30 05:27:36 -03:00
{"f_globals", T_OBJECT, OFF(f_globals), RO},
{"f_lasti", T_INT, OFF(f_lasti), RO},
{"f_lineno", T_INT, OFF(f_lineno), RO},
{"f_restricted",T_INT, OFF(f_restricted),RO},
1994-08-30 05:27:36 -03:00
{"f_trace", T_OBJECT, OFF(f_trace)},
{"f_exc_type", T_OBJECT, OFF(f_exc_type)},
{"f_exc_value", T_OBJECT, OFF(f_exc_value)},
{"f_exc_traceback", T_OBJECT, OFF(f_exc_traceback)},
1990-12-20 11:06:42 -04:00
{NULL} /* Sentinel */
};
1997-04-29 11:49:28 -03:00
static PyObject *
2001-08-02 01:15:00 -03:00
frame_getlocals(PyFrameObject *f, void *closure)
1990-12-20 11:06:42 -04:00
{
2001-08-02 01:15:00 -03:00
PyFrame_FastToLocals(f);
Py_INCREF(f->f_locals);
return f->f_locals;
1990-12-20 11:06:42 -04:00
}
2001-08-02 01:15:00 -03:00
static struct getsetlist frame_getsetlist[] = {
{"f_locals", (getter)frame_getlocals, NULL, NULL},
{0}
};
1994-08-30 05:27:36 -03:00
/* Stack frames are allocated and deallocated at a considerable rate.
In an attempt to improve the speed of function calls, we maintain a
separate free list of stack frames (just like integers are
allocated in a special way -- see intobject.c). When a stack frame
is on the free list, only the following members have a meaning:
ob_type == &Frametype
f_back next item on free list, or NULL
f_nlocals number of locals
f_stacksize size of value stack
ob_size size of localsplus
Note that the value and block stacks are preserved -- this can save
another malloc() call or two (and two free() calls as well!).
Also note that, unlike for integers, each frame object is a
malloc'ed object in its own right -- it is only the actual calls to
malloc() that we are trying to save here, not the administration.
After all, while a typical program may make millions of calls, a
call depth of more than 20 or 30 is probably already exceptional
unless the program contains run-away recursion. I hope.
*/
1997-04-29 11:49:28 -03:00
static PyFrameObject *free_list = NULL;
1990-12-20 11:06:42 -04:00
static void
2000-07-09 02:40:56 -03:00
frame_dealloc(PyFrameObject *f)
1990-12-20 11:06:42 -04:00
{
int i, slots;
PyObject **fastlocals;
PyObject **p;
Py_TRASHCAN_SAFE_BEGIN(f)
_PyObject_GC_UNTRACK(f);
/* Kill all local variables */
slots = f->f_nlocals + f->f_ncells + f->f_nfreevars;
fastlocals = f->f_localsplus;
for (i = slots; --i >= 0; ++fastlocals) {
1997-04-29 11:49:28 -03:00
Py_XDECREF(*fastlocals);
}
/* Free stack */
if (f->f_stacktop != NULL) {
for (p = f->f_valuestack; p < f->f_stacktop; p++)
Py_XDECREF(*p);
}
1997-04-29 11:49:28 -03:00
Py_XDECREF(f->f_back);
Py_XDECREF(f->f_code);
Py_XDECREF(f->f_builtins);
Py_XDECREF(f->f_globals);
Py_XDECREF(f->f_locals);
Py_XDECREF(f->f_trace);
Py_XDECREF(f->f_exc_type);
Py_XDECREF(f->f_exc_value);
Py_XDECREF(f->f_exc_traceback);
f->f_back = free_list;
free_list = f;
Py_TRASHCAN_SAFE_END(f)
1990-12-20 11:06:42 -04:00
}
2001-07-12 10:27:11 -03:00
static int
frame_traverse(PyFrameObject *f, visitproc visit, void *arg)
{
PyObject **fastlocals, **p;
int i, err, slots;
#define VISIT(o) if (o) {if ((err = visit((PyObject *)(o), arg))) return err;}
VISIT(f->f_back);
VISIT(f->f_code);
VISIT(f->f_builtins);
VISIT(f->f_globals);
VISIT(f->f_locals);
VISIT(f->f_trace);
VISIT(f->f_exc_type);
VISIT(f->f_exc_value);
VISIT(f->f_exc_traceback);
/* locals */
slots = f->f_nlocals + f->f_ncells + f->f_nfreevars;
fastlocals = f->f_localsplus;
for (i = slots; --i >= 0; ++fastlocals) {
VISIT(*fastlocals);
}
/* stack */
if (f->f_stacktop != NULL) {
for (p = f->f_valuestack; p < f->f_stacktop; p++)
VISIT(*p);
}
return 0;
}
static void
frame_clear(PyFrameObject *f)
{
PyObject **fastlocals, **p;
int i, slots;
Py_XDECREF(f->f_exc_type);
f->f_exc_type = NULL;
Py_XDECREF(f->f_exc_value);
f->f_exc_value = NULL;
Py_XDECREF(f->f_exc_traceback);
f->f_exc_traceback = NULL;
Py_XDECREF(f->f_trace);
f->f_trace = NULL;
/* locals */
slots = f->f_nlocals + f->f_ncells + f->f_nfreevars;
fastlocals = f->f_localsplus;
for (i = slots; --i >= 0; ++fastlocals) {
if (*fastlocals != NULL) {
Py_XDECREF(*fastlocals);
*fastlocals = NULL;
}
}
/* stack */
if (f->f_stacktop != NULL) {
for (p = f->f_valuestack; p < f->f_stacktop; p++) {
Py_XDECREF(*p);
*p = NULL;
}
}
}
1997-04-29 11:49:28 -03:00
PyTypeObject PyFrame_Type = {
PyObject_HEAD_INIT(&PyType_Type)
1990-12-20 11:06:42 -04:00
0,
"frame",
sizeof(PyFrameObject),
sizeof(PyObject *),
2001-07-12 10:27:11 -03:00
(destructor)frame_dealloc, /* tp_dealloc */
0, /* tp_print */
2001-08-02 01:15:00 -03:00
0, /* tp_getattr */
0, /* tp_setattr */
2001-07-12 10:27:11 -03:00
0, /* tp_compare */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
2001-08-02 01:15:00 -03:00
PyObject_GenericGetAttr, /* tp_getattro */
PyObject_GenericSetAttr, /* tp_setattro */
2001-07-12 10:27:11 -03:00
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
2001-07-12 10:27:11 -03:00
0, /* tp_doc */
(traverseproc)frame_traverse, /* tp_traverse */
(inquiry)frame_clear, /* tp_clear */
2001-08-02 01:15:00 -03:00
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
frame_memberlist, /* tp_members */
frame_getsetlist, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
1990-12-20 11:06:42 -04:00
};
1997-04-29 11:49:28 -03:00
PyFrameObject *
PEP 227 implementation The majority of the changes are in the compiler. The mainloop changes primarily to implement the new opcodes and to pass a function's closure to eval_code2(). Frames and functions got new slots to hold the closure. Include/compile.h Add co_freevars and co_cellvars slots to code objects. Update PyCode_New() to take freevars and cellvars as arguments Include/funcobject.h Add func_closure slot to function objects. Add GetClosure()/SetClosure() functions (and corresponding macros) for getting at the closure. Include/frameobject.h PyFrame_New() now takes a closure. Include/opcode.h Add four new opcodes: MAKE_CLOSURE, LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF. Remove comment about old requirement for opcodes to fit in 7 bits. compile.c Implement changes to code objects for co_freevars and co_cellvars. Modify symbol table to use st_cur_name (string object for the name of the current scope) and st_cur_children (list of nested blocks). Also define st_nested, which might more properly be called st_cur_nested. Add several DEF_XXX flags to track def-use information for free variables. New or modified functions of note: com_make_closure(struct compiling *, PyCodeObject *) Emit LOAD_CLOSURE opcodes as needed to pass cells for free variables into nested scope. com_addop_varname(struct compiling *, int, char *) Emits opcodes for LOAD_DEREF and STORE_DEREF. get_ref_type(struct compiling *, char *name) Return NAME_CLOSURE if ref type is FREE or CELL symtable_load_symbols(struct compiling *) Decides what variables are cell or free based on def-use info. Can now raise SyntaxError if nested scopes are mixed with exec or from blah import *. make_scope_info(PyObject *, PyObject *, int, int) Helper functions for symtable scope stack. symtable_update_free_vars(struct symtable *) After a code block has been analyzed, it must check each of its children for free variables that are not defined in the block. If a variable is free in a child and not defined in the parent, then it is defined by block the enclosing the current one or it is a global. This does the right logic. symtable_add_use() is now a macro for symtable_add_def() symtable_assign(struct symtable *, node *) Use goto instead of for (;;) Fixed bug in symtable where name of keyword argument in function call was treated as assignment in the scope of the call site. Ex: def f(): g(a=2) # a was considered a local of f ceval.c eval_code2() now take one more argument, a closure. Implement LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF, MAKE_CLOSURE> Also: When name error occurs for global variable, report that the name was global in the error mesage. Objects/frameobject.c Initialize f_closure to be a tuple containing space for cellvars and freevars. f_closure is NULL if neither are present. Objects/funcobject.c Add support for func_closure. Python/import.c Change the magic number. Python/marshal.c Track changes to code objects.
2001-01-25 16:06:59 -04:00
PyFrame_New(PyThreadState *tstate, PyCodeObject *code, PyObject *globals,
PyObject *locals)
1990-12-20 11:06:42 -04:00
{
PyFrameObject *back = tstate->frame;
1997-04-29 11:49:28 -03:00
static PyObject *builtin_object;
PyFrameObject *f;
PyObject *builtins;
int extras, ncells, nfrees;
if (builtin_object == NULL) {
1997-01-18 03:58:41 -04:00
builtin_object = PyString_InternFromString("__builtins__");
if (builtin_object == NULL)
return NULL;
}
1997-04-29 11:49:28 -03:00
if ((back != NULL && !PyFrame_Check(back)) ||
code == NULL || !PyCode_Check(code) ||
globals == NULL || !PyDict_Check(globals) ||
(locals != NULL && !PyDict_Check(locals))) {
PyErr_BadInternalCall();
1990-12-20 11:06:42 -04:00
return NULL;
}
PEP 227 implementation The majority of the changes are in the compiler. The mainloop changes primarily to implement the new opcodes and to pass a function's closure to eval_code2(). Frames and functions got new slots to hold the closure. Include/compile.h Add co_freevars and co_cellvars slots to code objects. Update PyCode_New() to take freevars and cellvars as arguments Include/funcobject.h Add func_closure slot to function objects. Add GetClosure()/SetClosure() functions (and corresponding macros) for getting at the closure. Include/frameobject.h PyFrame_New() now takes a closure. Include/opcode.h Add four new opcodes: MAKE_CLOSURE, LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF. Remove comment about old requirement for opcodes to fit in 7 bits. compile.c Implement changes to code objects for co_freevars and co_cellvars. Modify symbol table to use st_cur_name (string object for the name of the current scope) and st_cur_children (list of nested blocks). Also define st_nested, which might more properly be called st_cur_nested. Add several DEF_XXX flags to track def-use information for free variables. New or modified functions of note: com_make_closure(struct compiling *, PyCodeObject *) Emit LOAD_CLOSURE opcodes as needed to pass cells for free variables into nested scope. com_addop_varname(struct compiling *, int, char *) Emits opcodes for LOAD_DEREF and STORE_DEREF. get_ref_type(struct compiling *, char *name) Return NAME_CLOSURE if ref type is FREE or CELL symtable_load_symbols(struct compiling *) Decides what variables are cell or free based on def-use info. Can now raise SyntaxError if nested scopes are mixed with exec or from blah import *. make_scope_info(PyObject *, PyObject *, int, int) Helper functions for symtable scope stack. symtable_update_free_vars(struct symtable *) After a code block has been analyzed, it must check each of its children for free variables that are not defined in the block. If a variable is free in a child and not defined in the parent, then it is defined by block the enclosing the current one or it is a global. This does the right logic. symtable_add_use() is now a macro for symtable_add_def() symtable_assign(struct symtable *, node *) Use goto instead of for (;;) Fixed bug in symtable where name of keyword argument in function call was treated as assignment in the scope of the call site. Ex: def f(): g(a=2) # a was considered a local of f ceval.c eval_code2() now take one more argument, a closure. Implement LOAD_CLOSURE, LOAD_DEREF, STORE_DEREF, MAKE_CLOSURE> Also: When name error occurs for global variable, report that the name was global in the error mesage. Objects/frameobject.c Initialize f_closure to be a tuple containing space for cellvars and freevars. f_closure is NULL if neither are present. Objects/funcobject.c Add support for func_closure. Python/import.c Change the magic number. Python/marshal.c Track changes to code objects.
2001-01-25 16:06:59 -04:00
ncells = PyTuple_GET_SIZE(code->co_cellvars);
nfrees = PyTuple_GET_SIZE(code->co_freevars);
extras = code->co_stacksize + code->co_nlocals + ncells + nfrees;
if (back == NULL || back->f_globals != globals) {
builtins = PyDict_GetItem(globals, builtin_object);
if (builtins != NULL && PyModule_Check(builtins))
builtins = PyModule_GetDict(builtins);
}
else {
/* If we share the globals, we share the builtins.
Save a lookup and a call. */
builtins = back->f_builtins;
}
if (builtins != NULL && !PyDict_Check(builtins))
builtins = NULL;
if (free_list == NULL) {
f = PyObject_GC_NewVar(PyFrameObject, &PyFrame_Type, extras);
if (f == NULL)
return NULL;
}
else {
f = free_list;
free_list = free_list->f_back;
if (f->ob_size < extras) {
f = PyObject_GC_Resize(PyFrameObject, f, extras);
if (f == NULL)
return NULL;
}
else
extras = f->ob_size;
_Py_NewReference((PyObject *)f);
}
if (builtins == NULL) {
/* No builtins! Make up a minimal one. */
builtins = PyDict_New();
if (builtins == NULL || /* Give them 'None', at least. */
PyDict_SetItemString(builtins, "None", Py_None) < 0) {
Py_DECREF(f);
return NULL;
}
}
else
Py_XINCREF(builtins);
f->f_builtins = builtins;
1997-04-29 11:49:28 -03:00
Py_XINCREF(back);
f->f_back = back;
1997-04-29 11:49:28 -03:00
Py_INCREF(code);
f->f_code = code;
1997-04-29 11:49:28 -03:00
Py_INCREF(globals);
f->f_globals = globals;
1995-07-26 13:14:30 -03:00
if (code->co_flags & CO_NEWLOCALS) {
if (code->co_flags & CO_OPTIMIZED)
locals = NULL; /* Let fast_2_locals handle it */
else {
1997-04-29 11:49:28 -03:00
locals = PyDict_New();
1995-07-26 13:14:30 -03:00
if (locals == NULL) {
1997-04-29 11:49:28 -03:00
Py_DECREF(f);
1995-07-26 13:14:30 -03:00
return NULL;
}
}
}
else {
if (locals == NULL)
locals = globals;
1997-04-29 11:49:28 -03:00
Py_INCREF(locals);
}
f->f_locals = locals;
f->f_trace = NULL;
f->f_exc_type = f->f_exc_value = f->f_exc_traceback = NULL;
f->f_tstate = tstate;
f->f_lasti = 0;
f->f_lineno = code->co_firstlineno;
f->f_restricted = (builtins != tstate->interp->builtins);
f->f_iblock = 0;
f->f_nlocals = code->co_nlocals;
f->f_stacksize = code->co_stacksize;
f->f_ncells = ncells;
f->f_nfreevars = nfrees;
1990-12-20 11:06:42 -04:00
while (--extras >= 0)
f->f_localsplus[extras] = NULL;
f->f_valuestack = f->f_localsplus + (f->f_nlocals + ncells + nfrees);
f->f_stacktop = f->f_valuestack;
_PyObject_GC_TRACK(f);
return f;
}
1990-12-20 11:06:42 -04:00
/* Block management */
void
2000-07-09 02:40:56 -03:00
PyFrame_BlockSetup(PyFrameObject *f, int type, int handler, int level)
1990-12-20 11:06:42 -04:00
{
1997-04-29 11:49:28 -03:00
PyTryBlock *b;
if (f->f_iblock >= CO_MAXBLOCKS)
1997-04-29 11:49:28 -03:00
Py_FatalError("XXX block stack overflow");
1990-12-20 11:06:42 -04:00
b = &f->f_blockstack[f->f_iblock++];
b->b_type = type;
b->b_level = level;
b->b_handler = handler;
}
1997-04-29 11:49:28 -03:00
PyTryBlock *
2000-07-09 02:40:56 -03:00
PyFrame_BlockPop(PyFrameObject *f)
1990-12-20 11:06:42 -04:00
{
1997-04-29 11:49:28 -03:00
PyTryBlock *b;
if (f->f_iblock <= 0)
1997-04-29 11:49:28 -03:00
Py_FatalError("XXX block stack underflow");
1990-12-20 11:06:42 -04:00
b = &f->f_blockstack[--f->f_iblock];
return b;
}
1994-08-30 05:27:36 -03:00
/* Convert between "fast" version of locals and dictionary version */
2001-04-14 14:55:09 -03:00
static void
map_to_dict(PyObject *map, int nmap, PyObject *dict, PyObject **values,
int deref)
{
int j;
for (j = nmap; --j >= 0; ) {
PyObject *key = PyTuple_GetItem(map, j);
PyObject *value = values[j];
if (deref)
value = PyCell_GET(value);
if (value == NULL) {
PyErr_Clear();
if (PyDict_DelItem(dict, key) != 0)
PyErr_Clear();
}
else {
if (PyDict_SetItem(dict, key, value) != 0)
PyErr_Clear();
}
}
}
2001-04-14 14:55:41 -03:00
static void
dict_to_map(PyObject *map, int nmap, PyObject *dict, PyObject **values,
int deref, int clear)
{
int j;
for (j = nmap; --j >= 0; ) {
PyObject *key = PyTuple_GetItem(map, j);
PyObject *value = PyDict_GetItem(dict, key);
Py_XINCREF(value);
if (deref) {
if (value || clear) {
if (PyCell_Set(values[j], value) < 0)
PyErr_Clear();
}
} else if (value != NULL || clear) {
Py_XDECREF(values[j]);
values[j] = value;
}
}
}
1994-08-30 05:27:36 -03:00
void
2000-07-09 02:40:56 -03:00
PyFrame_FastToLocals(PyFrameObject *f)
1994-08-30 05:27:36 -03:00
{
/* Merge fast locals into f->f_locals */
1997-04-29 11:49:28 -03:00
PyObject *locals, *map;
PyObject **fast;
PyObject *error_type, *error_value, *error_traceback;
1994-08-30 05:27:36 -03:00
int j;
if (f == NULL)
return;
locals = f->f_locals;
if (locals == NULL) {
1997-04-29 11:49:28 -03:00
locals = f->f_locals = PyDict_New();
if (locals == NULL) {
1997-04-29 11:49:28 -03:00
PyErr_Clear(); /* Can't report it :-( */
return;
}
}
if (f->f_nlocals == 0)
1995-07-26 13:14:30 -03:00
return;
map = f->f_code->co_varnames;
1997-04-29 11:49:28 -03:00
if (!PyDict_Check(locals) || !PyTuple_Check(map))
1994-08-30 05:27:36 -03:00
return;
1997-04-29 11:49:28 -03:00
PyErr_Fetch(&error_type, &error_value, &error_traceback);
fast = f->f_localsplus;
1997-04-29 11:49:28 -03:00
j = PyTuple_Size(map);
if (j > f->f_nlocals)
j = f->f_nlocals;
map_to_dict(map, j, locals, fast, 0);
if (f->f_ncells || f->f_nfreevars) {
if (!(PyTuple_Check(f->f_code->co_cellvars)
&& PyTuple_Check(f->f_code->co_freevars))) {
Py_DECREF(locals);
return;
1994-08-30 05:27:36 -03:00
}
map_to_dict(f->f_code->co_cellvars,
PyTuple_GET_SIZE(f->f_code->co_cellvars),
locals, fast + f->f_nlocals, 1);
map_to_dict(f->f_code->co_freevars,
PyTuple_GET_SIZE(f->f_code->co_freevars),
locals, fast + f->f_nlocals + f->f_ncells, 1);
1994-08-30 05:27:36 -03:00
}
1997-04-29 11:49:28 -03:00
PyErr_Restore(error_type, error_value, error_traceback);
1994-08-30 05:27:36 -03:00
}
void
2000-07-09 02:40:56 -03:00
PyFrame_LocalsToFast(PyFrameObject *f, int clear)
1994-08-30 05:27:36 -03:00
{
/* Merge f->f_locals into fast locals */
1997-04-29 11:49:28 -03:00
PyObject *locals, *map;
PyObject **fast;
PyObject *error_type, *error_value, *error_traceback;
1994-08-30 05:27:36 -03:00
int j;
if (f == NULL)
return;
locals = f->f_locals;
map = f->f_code->co_varnames;
if (locals == NULL || f->f_code->co_nlocals == 0)
1994-08-30 05:27:36 -03:00
return;
1997-04-29 11:49:28 -03:00
if (!PyDict_Check(locals) || !PyTuple_Check(map))
1994-08-30 05:27:36 -03:00
return;
1997-04-29 11:49:28 -03:00
PyErr_Fetch(&error_type, &error_value, &error_traceback);
fast = f->f_localsplus;
1997-04-29 11:49:28 -03:00
j = PyTuple_Size(map);
if (j > f->f_nlocals)
j = f->f_nlocals;
dict_to_map(f->f_code->co_varnames, j, locals, fast, 0, clear);
if (f->f_ncells || f->f_nfreevars) {
if (!(PyTuple_Check(f->f_code->co_cellvars)
&& PyTuple_Check(f->f_code->co_freevars)))
return;
dict_to_map(f->f_code->co_cellvars,
PyTuple_GET_SIZE(f->f_code->co_cellvars),
locals, fast + f->f_nlocals, 1, clear);
dict_to_map(f->f_code->co_freevars,
PyTuple_GET_SIZE(f->f_code->co_freevars),
locals, fast + f->f_nlocals + f->f_ncells, 1, clear);
1994-08-30 05:27:36 -03:00
}
1997-04-29 11:49:28 -03:00
PyErr_Restore(error_type, error_value, error_traceback);
1994-08-30 05:27:36 -03:00
}
/* Clear out the free list */
void
2000-07-09 02:40:56 -03:00
PyFrame_Fini(void)
{
while (free_list != NULL) {
PyFrameObject *f = free_list;
free_list = free_list->f_back;
PyObject_GC_Del(f);
}
}