#include "Python.h"

#include "compile.h"

#include "frameobject.h"

#include "opcode.h"

#include "structmember.h"

#undef MIN

#undef MAX

#define MIN(a, b) ((a) < (b) ? (a) : (b))

#define MAX(a, b) ((a) > (b) ? (a) : (b))

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

static PyMemberDef frame_memberlist[] = {

{"f_back", T_OBJECT, OFF(f_back), RO},

{"f_code", T_OBJECT, OFF(f_code), RO},

{"f_builtins", T_OBJECT, OFF(f_builtins),RO},

{"f_globals", T_OBJECT, OFF(f_globals), RO},

{"f_lasti", T_INT, OFF(f_lasti), RO},

{"f_restricted",T_INT, OFF(f_restricted),RO},

{"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)},

{NULL} /* Sentinel */

};

static PyObject *

frame_getlocals(PyFrameObject *f, void *closure)

{

PyFrame_FastToLocals(f);

Py_INCREF(f->f_locals);

return f->f_locals;

}

static PyObject *

frame_getlineno(PyFrameObject *f, void *closure)

{

int lineno;

if (f->f_trace)

lineno = f->f_lineno;

else

lineno = PyCode_Addr2Line(f->f_code, f->f_lasti);

return PyInt_FromLong(lineno);

}

static int

frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno)

{

int new_lineno = 0; /* The new value of f_lineno */

int new_lasti = 0; /* The new value of f_lasti */

int new_iblock = 0; /* The new value of f_iblock */

char *code = NULL; /* The bytecode for the frame... */

int code_len = 0; /* ...and its length */

char *lnotab = NULL; /* Iterating over co_lnotab */

int lnotab_len = 0; /* (ditto) */

int offset = 0; /* (ditto) */

int line = 0; /* (ditto) */

int addr = 0; /* (ditto) */

int min_addr = 0; /* Scanning the SETUPs and POPs */

int max_addr = 0; /* (ditto) */

int delta_iblock = 0; /* (ditto) */

int min_delta_iblock = 0; /* (ditto) */

int min_iblock = 0; /* (ditto) */

int f_lasti_setup_addr = 0; /* Policing no-jump-into-finally */

int new_lasti_setup_addr = 0; /* (ditto) */

int blockstack[CO_MAXBLOCKS]; /* Walking the 'finally' blocks */

int in_finally[CO_MAXBLOCKS]; /* (ditto) */

int blockstack_top = 0; /* (ditto) */

int setup_op = 0; /* (ditto) */

/* f_lineno must be an integer. */

if (!PyInt_Check(p_new_lineno)) {

PyErr_SetString(PyExc_ValueError,

"lineno must be an integer");

return -1;

}

/* You can only do this from within a trace function, not via

if (!f->f_trace)

{

PyErr_Format(PyExc_ValueError,

"f_lineno can only be set by a trace function");

return -1;

}

/* Fail if the line comes before the start of the code block. */

new_lineno = (int) PyInt_AsLong(p_new_lineno);

if (new_lineno < f->f_code->co_firstlineno) {

PyErr_Format(PyExc_ValueError,

"line %d comes before the current code block",

new_lineno);

return -1;

}

/* Find the bytecode offset for the start of the given line, or the

PyString_AsStringAndSize(f->f_code->co_lnotab, &lnotab, &lnotab_len);

addr = 0;

line = f->f_code->co_firstlineno;

new_lasti = -1;

for (offset = 0; offset < lnotab_len; offset += 2) {

addr += lnotab[offset];

line += lnotab[offset+1];

if (line >= new_lineno) {

new_lasti = addr;

new_lineno = line;

break;

}

}

/* If we didn't reach the requested line, return an error. */

if (new_lasti == -1) {

PyErr_Format(PyExc_ValueError,

"line %d comes after the current code block",

new_lineno);

return -1;

}

/* We're now ready to look at the bytecode. */

PyString_AsStringAndSize(f->f_code->co_code, &code, &code_len);

min_addr = MIN(new_lasti, f->f_lasti);

max_addr = MAX(new_lasti, f->f_lasti);

/* You can't jump onto a line with an 'except' statement on it -

if (code[new_lasti] == DUP_TOP || code[new_lasti] == POP_TOP) {

PyErr_SetString(PyExc_ValueError,

"can't jump to 'except' line as there's no exception");

return -1;

}

/* You can't jump into or out of a 'finally' block because the 'try'

f_lasti_setup_addr = -1;

new_lasti_setup_addr = -1;

memset(blockstack, '\0', sizeof(blockstack));

memset(in_finally, '\0', sizeof(in_finally));

blockstack_top = 0;

for (addr = 0; addr < code_len; addr++) {

unsigned char op = code[addr];

switch (op) {

case SETUP_LOOP:

case SETUP_EXCEPT:

case SETUP_FINALLY:

blockstack[blockstack_top++] = addr;

in_finally[blockstack_top-1] = 0;

break;

case POP_BLOCK:

assert(blockstack_top > 0);

setup_op = code[blockstack[blockstack_top-1]];

if (setup_op == SETUP_FINALLY) {

in_finally[blockstack_top-1] = 1;

}

else {

blockstack_top--;

}

break;

case END_FINALLY:

/* Ignore END_FINALLYs for SETUP_EXCEPTs - they exist

if (blockstack_top > 0) {

setup_op = code[blockstack[blockstack_top-1]];

if (setup_op == SETUP_FINALLY) {

blockstack_top--;

}

}

break;

}

/* For the addresses we're interested in, see whether they're

if (addr == new_lasti || addr == f->f_lasti) {

int i = 0;

int setup_addr = -1;

for (i = blockstack_top-1; i >= 0; i--) {

if (in_finally[i]) {

setup_addr = blockstack[i];

break;

}

}

if (setup_addr != -1) {

if (addr == new_lasti) {

new_lasti_setup_addr = setup_addr;

}

if (addr == f->f_lasti) {

f_lasti_setup_addr = setup_addr;

}

}

}

if (op >= HAVE_ARGUMENT) {

addr += 2;

}

}

/* Verify that the blockstack tracking code didn't get lost. */

assert(blockstack_top == 0);

/* After all that, are we jumping into / out of a 'finally' block? */

if (new_lasti_setup_addr != f_lasti_setup_addr) {

PyErr_SetString(PyExc_ValueError,

"can't jump into or out of a 'finally' block");

return -1;

}

/* Police block-jumping (you can't jump into the middle of a block)

delta_iblock = 0;

for (addr = min_addr; addr < max_addr; addr++) {

unsigned char op = code[addr];

switch (op) {

case SETUP_LOOP:

case SETUP_EXCEPT:

case SETUP_FINALLY:

delta_iblock++;

break;

case POP_BLOCK:

delta_iblock--;

break;

}

min_delta_iblock = MIN(min_delta_iblock, delta_iblock);

if (op >= HAVE_ARGUMENT) {

addr += 2;

}

}

/* Derive the absolute iblock values from the deltas. */

min_iblock = f->f_iblock + min_delta_iblock;

if (new_lasti > f->f_lasti) {

/* Forwards jump. */

new_iblock = f->f_iblock + delta_iblock;

}

else {

/* Backwards jump. */

new_iblock = f->f_iblock - delta_iblock;

}

/* Are we jumping into a block? */

if (new_iblock > min_iblock) {

PyErr_SetString(PyExc_ValueError,

"can't jump into the middle of a block");

return -1;

}

/* Pop any blocks that we're jumping out of. */

while (f->f_iblock > new_iblock) {

PyTryBlock *b = &f->f_blockstack[--f->f_iblock];

while ((f->f_stacktop - f->f_valuestack) > b->b_level) {

PyObject *v = (*--f->f_stacktop);

Py_DECREF(v);

}

}

/* Finally set the new f_lineno and f_lasti and return OK. */

f->f_lineno = new_lineno;

f->f_lasti = new_lasti;

return 0;

}

static PyObject *

frame_gettrace(PyFrameObject *f, void *closure)

{

PyObject* trace = f->f_trace;

if (trace == NULL)

trace = Py_None;

Py_INCREF(trace);

return trace;

}

static int

frame_settrace(PyFrameObject *f, PyObject* v, void *closure)

{

/* We rely on f_lineno being accurate when f_trace is set. */

PyObject* old_value = f->f_trace;

Py_XINCREF(v);

f->f_trace = v;

if (v != NULL)

f->f_lineno = PyCode_Addr2Line(f->f_code, f->f_lasti);

Py_XDECREF(old_value);

return 0;

}

static PyGetSetDef frame_getsetlist[] = {

{"f_locals", (getter)frame_getlocals, NULL, NULL},

{"f_lineno", (getter)frame_getlineno,

(setter)frame_setlineno, NULL},

{"f_trace", (getter)frame_gettrace, (setter)frame_settrace, NULL},

{0}

};

static PyFrameObject *free_list = NULL;

static int numfree = 0; /* number of frames currently in free_list */

#define MAXFREELIST 200 /* max value for numfree */

static void

frame_dealloc(PyFrameObject *f)

{

int i, slots;

PyObject **fastlocals;

PyObject **p;

PyObject_GC_UnTrack(f);

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

Py_XDECREF(*fastlocals);

}

/* Free stack */

if (f->f_stacktop != NULL) {

for (p = f->f_valuestack; p < f->f_stacktop; p++)

Py_XDECREF(*p);

}

Py_XDECREF(f->f_back);

Py_DECREF(f->f_code);

Py_DECREF(f->f_builtins);

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

if (numfree < MAXFREELIST) {

++numfree;

f->f_back = free_list;

free_list = f;

}

else

PyObject_GC_Del(f);

Py_TRASHCAN_SAFE_END(f)

}

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;

}

}

}

PyTypeObject PyFrame_Type = {

PyObject_HEAD_INIT(&PyType_Type)

0,

"frame",

sizeof(PyFrameObject),

sizeof(PyObject *),

(destructor)frame_dealloc, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

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

PyObject_GenericGetAttr, /* tp_getattro */

PyObject_GenericSetAttr, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */

0, /* tp_doc */

(traverseproc)frame_traverse, /* tp_traverse */

(inquiry)frame_clear, /* tp_clear */

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

};

static PyObject *builtin_object;

int _PyFrame_Init()

{

builtin_object = PyString_InternFromString("__builtins__");

return (builtin_object != NULL);

}

PyFrameObject *

PyFrame_New(PyThreadState *tstate, PyCodeObject *code, PyObject *globals,

PyObject *locals)

{

PyFrameObject *back = tstate->frame;

PyFrameObject *f;

PyObject *builtins;

int extras, ncells, nfrees, i;

#ifdef Py_DEBUG

if (code == NULL || globals == NULL || !PyDict_Check(globals) ||

(locals != NULL && !PyMapping_Check(locals))) {

PyErr_BadInternalCall();

return NULL;

}

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

if (PyModule_Check(builtins)) {

builtins = PyModule_GetDict(builtins);

assert(!builtins || PyDict_Check(builtins));

}

else if (!PyDict_Check(builtins))

builtins = NULL;

}

if (builtins == NULL) {

/* No builtins! Make up a minimal one

builtins = PyDict_New();

if (builtins == NULL ||

PyDict_SetItemString(

builtins, "None", Py_None) < 0)

return NULL;

}

else

Py_INCREF(builtins);

}

else {

/* If we share the globals, we share the builtins.

builtins = back->f_builtins;

assert(builtins != NULL && PyDict_Check(builtins));

Py_INCREF(builtins);

}

if (free_list == NULL) {

f = PyObject_GC_NewVar(PyFrameObject, &PyFrame_Type, extras);

if (f == NULL) {

Py_DECREF(builtins);

return NULL;

}

}

else {

assert(numfree > 0);

--numfree;

f = free_list;

free_list = free_list->f_back;

if (f->ob_size < extras) {

f = PyObject_GC_Resize(PyFrameObject, f, extras);

if (f == NULL) {

Py_DECREF(builtins);

return NULL;

}

}

_Py_NewReference((PyObject *)f);

}

f->f_builtins = builtins;

Py_XINCREF(back);

f->f_back = back;

Py_INCREF(code);

f->f_code = code;

Py_INCREF(globals);

f->f_globals = globals;

/* Most functions have CO_NEWLOCALS and CO_OPTIMIZED set. */

if ((code->co_flags & (CO_NEWLOCALS | CO_OPTIMIZED)) ==

(CO_NEWLOCALS | CO_OPTIMIZED))

locals = NULL; /* PyFrame_FastToLocals() will set. */

else if (code->co_flags & CO_NEWLOCALS) {

locals = PyDict_New();

if (locals == NULL) {

Py_DECREF(f);

return NULL;

}

}

else {

if (locals == NULL)

locals = globals;

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 = -1;

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;

extras = f->f_nlocals + ncells + nfrees;

/* Tim said it's ok to replace memset */

for (i=0; i<extras; i++)

f->f_localsplus[i] = NULL;

f->f_valuestack = f->f_localsplus + extras;

f->f_stacktop = f->f_valuestack;

_PyObject_GC_TRACK(f);

return f;

}

PyFrame_BlockSetup(PyFrameObject *f, int type, int handler, int level)

{

PyTryBlock *b;

if (f->f_iblock >= CO_MAXBLOCKS)

Py_FatalError("XXX block stack overflow");

b = &f->f_blockstack[f->f_iblock++];

b->b_type = type;

b->b_level = level;

b->b_handler = handler;

}

PyTryBlock *

PyFrame_BlockPop(PyFrameObject *f)

{

PyTryBlock *b;

if (f->f_iblock <= 0)

Py_FatalError("XXX block stack underflow");

b = &f->f_blockstack[--f->f_iblock];

return b;

}

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_GET_ITEM(map, j);

PyObject *value = values[j];

if (deref)

value = PyCell_GET(value);

if (value == NULL) {

if (PyObject_DelItem(dict, key) != 0)

PyErr_Clear();

}

else {

if (PyObject_SetItem(dict, key, value) != 0)

PyErr_Clear();

}

}

}

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_GET_ITEM(map, j);

PyObject *value = PyObject_GetItem(dict, key);

if (value == NULL)

PyErr_Clear();

if (deref) {

if (value || clear) {

if (PyCell_GET(values[j]) != value) {

if (PyCell_Set(values[j], value) < 0)

PyErr_Clear();

}

}

} else if (value != NULL || clear) {

if (values[j] != value) {

Py_XINCREF(value);

Py_XDECREF(values[j]);

values[j] = value;

}

}

Py_XDECREF(value);

}

}

PyFrame_FastToLocals(PyFrameObject *f)

{

/* Merge fast locals into f->f_locals */

PyObject *locals, *map;

PyObject **fast;

PyObject *error_type, *error_value, *error_traceback;

int j;

if (f == NULL)

return;

locals = f->f_locals;

if (locals == NULL) {

locals = f->f_locals = PyDict_New();

if (locals == NULL) {

PyErr_Clear(); /* Can't report it :-( */

return;

}

}

map = f->f_code->co_varnames;

if (!PyTuple_Check(map))

return;

PyErr_Fetch(&error_type, &error_value, &error_traceback);

fast = f->f_localsplus;

j = PyTuple_Size(map);

if (j > f->f_nlocals)

j = f->f_nlocals;

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

return;

}

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

}

PyErr_Restore(error_type, error_value, error_traceback);

}

PyFrame_LocalsToFast(PyFrameObject *f, int clear)

{

/* Merge f->f_locals into fast locals */

PyObject *locals, *map;

PyObject **fast;

PyObject *error_type, *error_value, *error_traceback;

int j;

if (f == NULL)

return;

locals = f->f_locals;

map = f->f_code->co_varnames;

if (locals == NULL)

return;

if (!PyTuple_Check(map))

return;

PyErr_Fetch(&error_type, &error_value, &error_traceback);

fast = f->f_localsplus;

j = PyTuple_Size(map);

if (j > f->f_nlocals)

j = f->f_nlocals;

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

}

PyErr_Restore(error_type, error_value, error_traceback);

}

PyFrame_Fini(void)

{

while (free_list != NULL) {

PyFrameObject *f = free_list;

free_list = free_list->f_back;

PyObject_GC_Del(f);

--numfree;

}

assert(numfree == 0);

Py_XDECREF(builtin_object);

builtin_object = NULL;

}