#include "Python.h"

#include "pycore_object.h"

#include "pycore_gc.h" // _PyObject_GC_IS_TRACKED()

#include "code.h"

#include "frameobject.h"

#include "opcode.h"

#include "structmember.h" // PyMemberDef

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

static PyMemberDef frame_memberlist[] = {

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

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

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

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

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

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

{"f_trace_opcodes", T_BOOL, OFF(f_trace_opcodes), 0},

{NULL} /* Sentinel */

};

static PyObject *

frame_getlocals(PyFrameObject *f, void *closure)

{

if (PyFrame_FastToLocalsWithError(f) < 0)

return NULL;

Py_INCREF(f->f_locals);

return f->f_locals;

}

PyFrame_GetLineNumber(PyFrameObject *f)

{

if (f->f_trace)

return f->f_lineno;

else

return PyCode_Addr2Line(f->f_code, f->f_lasti);

}

static PyObject *

frame_getlineno(PyFrameObject *f, void *closure)

{

return PyLong_FromLong(PyFrame_GetLineNumber(f));

}

static unsigned int

get_arg(const _Py_CODEUNIT *codestr, Py_ssize_t i)

{

_Py_CODEUNIT word;

unsigned int oparg = _Py_OPARG(codestr[i]);

if (i >= 1 && _Py_OPCODE(word = codestr[i-1]) == EXTENDED_ARG) {

oparg |= _Py_OPARG(word) << 8;

if (i >= 2 && _Py_OPCODE(word = codestr[i-2]) == EXTENDED_ARG) {

oparg |= _Py_OPARG(word) << 16;

if (i >= 3 && _Py_OPCODE(word = codestr[i-3]) == EXTENDED_ARG) {

oparg |= _Py_OPARG(word) << 24;

}

}

}

return oparg;

}

typedef struct _codetracker {

} codetracker;

static void

reset(codetracker *tracker)

{

tracker->offset = 0;

tracker->addr = 0;

tracker->line_addr = 0;

tracker->line = tracker->start_line;

}

static void

init_codetracker(codetracker *tracker, PyCodeObject *code_obj)

{

PyBytes_AsStringAndSize(code_obj->co_code,

(char **)&tracker->code, &tracker->code_len);

PyBytes_AsStringAndSize(code_obj->co_lnotab,

(char **)&tracker->lnotab, &tracker->lnotab_len);

tracker->start_line = code_obj->co_firstlineno;

reset(tracker);

}

static void

advance_tracker(codetracker *tracker)

{

tracker->addr += sizeof(_Py_CODEUNIT);

if (tracker->offset >= tracker->lnotab_len) {

return;

}

while (tracker->offset < tracker->lnotab_len &&

tracker->addr >= tracker->line_addr + tracker->lnotab[tracker->offset]) {

tracker->line_addr += tracker->lnotab[tracker->offset];

tracker->line += (signed char)tracker->lnotab[tracker->offset+1];

tracker->offset += 2;

}

}

static void

retreat_tracker(codetracker *tracker)

{

tracker->addr -= sizeof(_Py_CODEUNIT);

while (tracker->addr < tracker->line_addr) {

tracker->offset -= 2;

tracker->line_addr -= tracker->lnotab[tracker->offset];

tracker->line -= (signed char)tracker->lnotab[tracker->offset+1];

}

}

static int

move_to_addr(codetracker *tracker, int addr)

{

while (addr > tracker->addr) {

advance_tracker(tracker);

if (tracker->addr >= tracker->code_len) {

return -1;

}

}

while (addr < tracker->addr) {

retreat_tracker(tracker);

if (tracker->addr < 0) {

return -1;

}

}

return 0;

}

static int

first_line_not_before(codetracker *tracker, int line)

{

int result = INT_MAX;

reset(tracker);

while (tracker->addr < tracker->code_len) {

if (tracker->line == line) {

return line;

}

if (tracker->line > line && tracker->line < result) {

result = tracker->line;

}

advance_tracker(tracker);

}

if (result == INT_MAX) {

return -1;

}

return result;

}

static int

move_to_nearest_start_of_line(codetracker *tracker, int line)

{

if (line > tracker->line) {

while (line != tracker->line) {

advance_tracker(tracker);

if (tracker->addr >= tracker->code_len) {

return -1;

}

}

}

else {

while (line != tracker->line) {

retreat_tracker(tracker);

if (tracker->addr < 0) {

return -1;

}

}

while (tracker->addr > tracker->line_addr) {

retreat_tracker(tracker);

}

}

return 0;

}

typedef struct _blockitem

} blockitem;

typedef struct _blockstack

} blockstack;

static void

init_blockstack(blockstack *blocks)

{

blocks->depth = 0;

}

static void

push_block(blockstack *blocks, unsigned char kind,

int end_addr, int start_line)

{

assert(blocks->depth < CO_MAXBLOCKS);

blocks->stack[blocks->depth].kind = kind;

blocks->stack[blocks->depth].end_addr = end_addr;

blocks->stack[blocks->depth].start_line = start_line;

blocks->depth++;

}

static unsigned char

pop_block(blockstack *blocks)

{

assert(blocks->depth > 0);

blocks->depth--;

return blocks->stack[blocks->depth].kind;

}

static blockitem *

top_block(blockstack *blocks)

{

assert(blocks->depth > 0);

return &blocks->stack[blocks->depth-1];

}

static inline int

is_try_except(unsigned char op, int target_op)

{

return op == SETUP_FINALLY && (target_op == DUP_TOP || target_op == POP_TOP);

}

static inline int

is_async_for(unsigned char op, int target_op)

{

return op == SETUP_FINALLY && target_op == END_ASYNC_FOR;

}

static inline int

is_try_finally(unsigned char op, int target_op)

{

return op == SETUP_FINALLY && !is_try_except(op, target_op) && !is_async_for(op, target_op);

}

#define TRY_EXCEPT 250

static int

block_stack_for_line(codetracker *tracker, int line, blockstack *blocks)

{

if (line < tracker->start_line) {

return -1;

}

init_blockstack(blocks);

reset(tracker);

while (tracker->addr < tracker->code_len) {

if (tracker->line == line) {

return 0;

}

if (blocks->depth > 0 && tracker->addr == top_block(blocks)->end_addr) {

unsigned char kind = pop_block(blocks);

assert(kind != SETUP_FINALLY);

if (kind == TRY_EXCEPT) {

push_block(blocks, POP_EXCEPT, -1, tracker->line);

}

if (kind == SETUP_WITH || kind == SETUP_ASYNC_WITH) {

push_block(blocks, WITH_EXCEPT_START, -1, tracker->line);

}

}

unsigned char op = tracker->code[tracker->addr];

if (op == SETUP_FINALLY || op == SETUP_ASYNC_WITH || op == SETUP_WITH || op == FOR_ITER) {

unsigned int oparg = get_arg((const _Py_CODEUNIT *)tracker->code,

tracker->addr / sizeof(_Py_CODEUNIT));

int target_addr = tracker->addr + oparg + sizeof(_Py_CODEUNIT);

int target_op = tracker->code[target_addr];

if (is_async_for(op, target_op)) {

push_block(blocks, FOR_ITER, target_addr, tracker->line);

}

else if (op == FOR_ITER) {

push_block(blocks, FOR_ITER, target_addr-sizeof(_Py_CODEUNIT), tracker->line);

}

else if (is_try_except(op, target_op)) {

push_block(blocks, TRY_EXCEPT, target_addr-sizeof(_Py_CODEUNIT), tracker->line);

}

else if (is_try_finally(op, target_op)) {

int addr = tracker->addr;

// Skip over duplicate 'finally' blocks if line is after body.

move_to_addr(tracker, target_addr);

if (tracker->line > line) {

// Target is in body, rewind to start.

move_to_addr(tracker, addr);

push_block(blocks, op, target_addr, tracker->line);

}

else {

// Now in finally block.

push_block(blocks, RERAISE, -1, tracker->line);

}

}

else {

push_block(blocks, op, target_addr, tracker->line);

}

}

else if (op == RERAISE) {

assert(blocks->depth > 0);

unsigned char kind = top_block(blocks)->kind;

if (kind == RERAISE || kind == WITH_EXCEPT_START || kind == POP_EXCEPT) {

pop_block(blocks);

}

}

advance_tracker(tracker);

}

return -1;

}

static void

frame_stack_pop(PyFrameObject *f)

{

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

Py_DECREF(v);

}

static void

frame_block_unwind(PyFrameObject *f)

{

assert(f->f_iblock > 0);

f->f_iblock--;

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

intptr_t delta = (f->f_stacktop - f->f_valuestack) - b->b_level;

while (delta > 0) {

frame_stack_pop(f);

delta--;

}

}

static int

frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno, void *Py_UNUSED(ignored))

{

if (p_new_lineno == NULL) {

PyErr_SetString(PyExc_AttributeError, "cannot delete attribute");

return -1;

}

/* f_lineno must be an integer. */

if (!PyLong_CheckExact(p_new_lineno)) {

PyErr_SetString(PyExc_ValueError,

"lineno must be an integer");

return -1;

}

/* Upon the 'call' trace event of a new frame, f->f_lasti is -1 and

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

PyErr_Format(PyExc_ValueError,

"can't jump from the 'call' trace event of a new frame");

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;

}

/* Forbid jumps upon a 'return' trace event (except after executing a

if (f->f_stacktop == NULL) {

PyErr_SetString(PyExc_ValueError,

"can only jump from a 'line' trace event");

return -1;

}

codetracker tracker;

init_codetracker(&tracker, f->f_code);

move_to_addr(&tracker, f->f_lasti);

int current_line = tracker.line;

assert(current_line >= 0);

int new_lineno;

{

/* Fail if the line falls outside the code block and

int overflow;

long l_new_lineno = PyLong_AsLongAndOverflow(p_new_lineno, &overflow);

if (overflow

#if SIZEOF_LONG > SIZEOF_INT

|| l_new_lineno > INT_MAX

|| l_new_lineno < INT_MIN

) {

PyErr_SetString(PyExc_ValueError,

"lineno out of range");

return -1;

}

new_lineno = (int)l_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;

}

new_lineno = first_line_not_before(&tracker, new_lineno);

if (new_lineno < 0) {

PyErr_Format(PyExc_ValueError,

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

(int)l_new_lineno);

return -1;

}

}

if (tracker.code[f->f_lasti] == YIELD_VALUE || tracker.code[f->f_lasti] == YIELD_FROM) {

PyErr_SetString(PyExc_ValueError,

"can't jump from a 'yield' statement");

return -1;

}

/* Find block stack for current line and target line. */

blockstack current_stack, new_stack;

block_stack_for_line(&tracker, new_lineno, &new_stack);

block_stack_for_line(&tracker, current_line, &current_stack);

/* The trace function is called with a 'return' trace event after the

if (tracker.code[tracker.addr] == DUP_TOP || tracker.code[tracker.addr] == POP_TOP) {

PyErr_SetString(PyExc_ValueError,

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

return -1;

}

/* Validate change of block stack. */

if (new_stack.depth > 0) {

blockitem *current_block_at_new_depth = &(current_stack.stack[new_stack.depth-1]);

if (new_stack.depth > current_stack.depth ||

top_block(&new_stack)->start_line != current_block_at_new_depth->start_line) {

unsigned char target_kind = top_block(&new_stack)->kind;

const char *msg;

if (target_kind == POP_EXCEPT) {

msg = "can't jump into an 'except' block as there's no exception";

}

else if (target_kind == RERAISE) {

msg = "can't jump into a 'finally' block";

}

else {

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

}

PyErr_SetString(PyExc_ValueError, msg);

return -1;

}

}

/* Check for illegal jumps out of finally or except blocks. */

for (int depth = new_stack.depth; depth < current_stack.depth; depth++) {

switch(current_stack.stack[depth].kind) {

case RERAISE:

PyErr_SetString(PyExc_ValueError,

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

return -1;

case POP_EXCEPT:

PyErr_SetString(PyExc_ValueError,

"can't jump out of an 'except' block");

return -1;

}

}

/* Unwind block stack. */

while (current_stack.depth > new_stack.depth) {

unsigned char kind = pop_block(&current_stack);

switch(kind) {

case FOR_ITER:

frame_stack_pop(f);

break;

case SETUP_FINALLY:

case TRY_EXCEPT:

frame_block_unwind(f);

break;

case SETUP_WITH:

case SETUP_ASYNC_WITH:

frame_block_unwind(f);

// Pop the exit function

frame_stack_pop(f);

break;

default:

PyErr_SetString(PyExc_SystemError,

"unexpected block kind");

return -1;

}

}

move_to_addr(&tracker, f->f_lasti);

move_to_nearest_start_of_line(&tracker, new_lineno);

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

f->f_lineno = new_lineno;

f->f_lasti = tracker.addr;

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

f->f_lineno = PyFrame_GetLineNumber(f);

if (v == Py_None)

v = NULL;

Py_XINCREF(v);

Py_XSETREF(f->f_trace, v);

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 PyFrame_MAXFREELIST 200

static void _Py_HOT_FUNCTION

frame_dealloc(PyFrameObject *f)

{

PyObject **p, **valuestack;

PyCodeObject *co;

if (_PyObject_GC_IS_TRACKED(f))

_PyObject_GC_UNTRACK(f);

Py_TRASHCAN_SAFE_BEGIN(f)

/* Kill all local variables */

valuestack = f->f_valuestack;

for (p = f->f_localsplus; p < valuestack; p++)

Py_CLEAR(*p);

/* Free stack */

if (f->f_stacktop != NULL) {

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

Py_XDECREF(*p);

}

Py_XDECREF(f->f_back);

Py_DECREF(f->f_builtins);

Py_DECREF(f->f_globals);

Py_CLEAR(f->f_locals);

Py_CLEAR(f->f_trace);

co = f->f_code;

if (co->co_zombieframe == NULL)

co->co_zombieframe = f;

else if (numfree < PyFrame_MAXFREELIST) {

++numfree;

f->f_back = free_list;

free_list = f;

}

else

PyObject_GC_Del(f);

Py_DECREF(co);

Py_TRASHCAN_SAFE_END(f)

}

static int

frame_traverse(PyFrameObject *f, visitproc visit, void *arg)

{

PyObject **fastlocals, **p;

Py_ssize_t i, slots;

Py_VISIT(f->f_back);

Py_VISIT(f->f_code);

Py_VISIT(f->f_builtins);

Py_VISIT(f->f_globals);

Py_VISIT(f->f_locals);

Py_VISIT(f->f_trace);

/* locals */

slots = f->f_code->co_nlocals + PyTuple_GET_SIZE(f->f_code->co_cellvars) + PyTuple_GET_SIZE(f->f_code->co_freevars);

fastlocals = f->f_localsplus;

for (i = slots; --i >= 0; ++fastlocals)

Py_VISIT(*fastlocals);

/* stack */

if (f->f_stacktop != NULL) {

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

Py_VISIT(*p);

}

return 0;

}

static int

frame_tp_clear(PyFrameObject *f)

{

PyObject **fastlocals, **p, **oldtop;

Py_ssize_t i, slots;

/* Before anything else, make sure that this frame is clearly marked

oldtop = f->f_stacktop;

f->f_stacktop = NULL;

f->f_executing = 0;

Py_CLEAR(f->f_trace);

/* locals */

slots = f->f_code->co_nlocals + PyTuple_GET_SIZE(f->f_code->co_cellvars) + PyTuple_GET_SIZE(f->f_code->co_freevars);

fastlocals = f->f_localsplus;

for (i = slots; --i >= 0; ++fastlocals)

Py_CLEAR(*fastlocals);

/* stack */

if (oldtop != NULL) {

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

Py_CLEAR(*p);

}

return 0;

}

static PyObject *

frame_clear(PyFrameObject *f, PyObject *Py_UNUSED(ignored))

{

if (f->f_executing) {

PyErr_SetString(PyExc_RuntimeError,

"cannot clear an executing frame");

return NULL;

}

if (f->f_gen) {

_PyGen_Finalize(f->f_gen);

assert(f->f_gen == NULL);

}

(void)frame_tp_clear(f);

Py_RETURN_NONE;

}

PyDoc_STRVAR(clear__doc__,

"F.clear(): clear most references held by the frame");

static PyObject *

frame_sizeof(PyFrameObject *f, PyObject *Py_UNUSED(ignored))

{

Py_ssize_t res, extras, ncells, nfrees;

ncells = PyTuple_GET_SIZE(f->f_code->co_cellvars);

nfrees = PyTuple_GET_SIZE(f->f_code->co_freevars);

extras = f->f_code->co_stacksize + f->f_code->co_nlocals +

ncells + nfrees;

/* subtract one as it is already included in PyFrameObject */

res = sizeof(PyFrameObject) + (extras-1) * sizeof(PyObject *);

return PyLong_FromSsize_t(res);

}

PyDoc_STRVAR(sizeof__doc__,

"F.__sizeof__() -> size of F in memory, in bytes");

static PyObject *

frame_repr(PyFrameObject *f)

{

int lineno = PyFrame_GetLineNumber(f);

return PyUnicode_FromFormat(

"<frame at %p, file %R, line %d, code %S>",

f, f->f_code->co_filename, lineno, f->f_code->co_name);

}

static PyMethodDef frame_methods[] = {

{"clear", (PyCFunction)frame_clear, METH_NOARGS,

clear__doc__},

{"__sizeof__", (PyCFunction)frame_sizeof, METH_NOARGS,

sizeof__doc__},

{NULL, NULL} /* sentinel */

};

PyTypeObject PyFrame_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"frame",

sizeof(PyFrameObject),

sizeof(PyObject *),

(destructor)frame_dealloc, /* tp_dealloc */

0, /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

(reprfunc)frame_repr, /* 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_tp_clear, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

frame_methods, /* tp_methods */

frame_memberlist, /* tp_members */

frame_getsetlist, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

};

_Py_IDENTIFIER(__builtins__);

PyFrameObject* _Py_HOT_FUNCTION

_PyFrame_New_NoTrack(PyThreadState *tstate, PyCodeObject *code,

PyObject *globals, PyObject *locals)

{

PyFrameObject *back = tstate->frame;

PyFrameObject *f;

PyObject *builtins;

Py_ssize_t i;

#ifdef Py_DEBUG

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

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

PyErr_BadInternalCall();

return NULL;

}

if (back == NULL || back->f_globals != globals) {

builtins = _PyDict_GetItemIdWithError(globals, &PyId___builtins__);

if (builtins) {

if (PyModule_Check(builtins)) {

builtins = PyModule_GetDict(builtins);

assert(builtins != NULL);

}

}

if (builtins == NULL) {

if (PyErr_Occurred()) {

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

Py_INCREF(builtins);

}

if (code->co_zombieframe != NULL) {

f = code->co_zombieframe;

code->co_zombieframe = NULL;

_Py_NewReference((PyObject *)f);

assert(f->f_code == code);

}

else {

Py_ssize_t extras, ncells, nfrees;

ncells = PyTuple_GET_SIZE(code->co_cellvars);

nfrees = PyTuple_GET_SIZE(code->co_freevars);

extras = code->co_stacksize + code->co_nlocals + ncells +

nfrees;

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 (Py_SIZE(f) < extras) {

PyFrameObject *new_f = PyObject_GC_Resize(PyFrameObject, f, extras);

if (new_f == NULL) {

PyObject_GC_Del(f);

Py_DECREF(builtins);

return NULL;

}

f = new_f;

}

_Py_NewReference((PyObject *)f);

}

f->f_code = code;

extras = code->co_nlocals + ncells + nfrees;

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

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

f->f_localsplus[i] = NULL;

f->f_locals = NULL;

f->f_trace = NULL;

}

f->f_stacktop = f->f_valuestack;

f->f_builtins = builtins;

Py_XINCREF(back);

f->f_back = back;

Py_INCREF(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))

; /* f_locals = NULL; will be set by PyFrame_FastToLocals() */

else if (code->co_flags & CO_NEWLOCALS) {

locals = PyDict_New();

if (locals == NULL) {

Py_DECREF(f);

return NULL;

}

f->f_locals = locals;

}

else {

if (locals == NULL)

locals = globals;

Py_INCREF(locals);

f->f_locals = locals;

}

f->f_lasti = -1;

f->f_lineno = code->co_firstlineno;

f->f_iblock = 0;

f->f_executing = 0;

f->f_gen = NULL;

f->f_trace_opcodes = 0;

f->f_trace_lines = 1;

return f;

}

PyFrame_New(PyThreadState *tstate, PyCodeObject *code,

PyObject *globals, PyObject *locals)

{

PyFrameObject *f = _PyFrame_New_NoTrack(tstate, code, globals, locals);

if (f)

_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("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("block stack underflow");

}

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

return b;

}

static int

map_to_dict(PyObject *map, Py_ssize_t nmap, PyObject *dict, PyObject **values,

int deref)

{

Py_ssize_t j;

assert(PyTuple_Check(map));

assert(PyDict_Check(dict));

assert(PyTuple_Size(map) >= nmap);