Py_CLEAR(*fastlocals); 	/* stack */	if (oldtop != NULL) {		for (p = f->f_valuestack; p < oldtop; p++)			Py_CLEAR(*p);	}}  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;	Py_ssize_t i; #ifdef Py_DEBUG	if (code == NULL || globals == NULL || !PyDict_Check(globals) ||	    (locals != NULL && !PyMapping_Check(locals))) {		PyErr_BadInternalCall();		return NULL;	}#endif	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			   Give them 'None', at least. */			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.		   Save a lookup and a call. */		builtins = back->f_builtins;		assert(builtins != NULL && PyDict_Check(builtins));		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 (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_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_exc_type = f->f_exc_value = f->f_exc_traceback = 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_tstate = tstate; 	f->f_lasti = -1;	f->f_lineno = code->co_firstlineno;	f->f_iblock = 0; 	_PyObject_GC_TRACK(f);	return f;} /* Block management */ voidPyFrame_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;} /* Convert between "fast" version of locals and dictionary version */ static voidmap_to_dict(PyObject *map, Py_ssize_t nmap, PyObject *dict, PyObject **values,	    Py_ssize_t deref){	Py_ssize_t 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 voiddict_to_map(PyObject *map, Py_ssize_t nmap, PyObject *dict, PyObject **values,	    Py_ssize_t deref, int clear){	Py_ssize_t 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);	}} voidPyFrame_FastToLocals(PyFrameObject *f){	/* Merge fast locals into f->f_locals */	PyObject *locals, *map;	PyObject **fast;	PyObject *error_type, *error_value, *error_traceback;	PyCodeObject *co;	Py_ssize_t j;        int ncells, nfreevars;	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;		}	}	co = f->f_code;	map = co->co_varnames;	if (!PyTuple_Check(map))		return;	PyErr_Fetch(&error_type, &error_value, &error_traceback);	fast = f->f_localsplus;	j = PyTuple_GET_SIZE(map);	if (j > co->co_nlocals)		j = co->co_nlocals;	if (co->co_nlocals)		map_to_dict(map, j, locals, fast, 0);	ncells = PyTuple_GET_SIZE(co->co_cellvars);	nfreevars = PyTuple_GET_SIZE(co->co_freevars);	if (ncells || nfreevars) {		map_to_dict(co->co_cellvars, ncells,			    locals, fast + co->co_nlocals, 1);		map_to_dict(co->co_freevars, nfreevars,			    locals, fast + co->co_nlocals + ncells, 1);	}	PyErr_Restore(error_type, error_value, error_traceback);} voidPyFrame_LocalsToFast(PyFrameObject *f, int clear){	/* Merge f->f_locals into fast locals */	PyObject *locals, *map;	PyObject **fast;	PyObject *error_type, *error_value, *error_traceback;	PyCodeObject *co;	Py_ssize_t j;	int ncells, nfreevars;	if (f == NULL)		return;	locals = f->f_locals;	co = f->f_code;	map = co->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_GET_SIZE(map);	if (j > co->co_nlocals)		j = co->co_nlocals;	if (co->co_nlocals)	    dict_to_map(co->co_varnames, j, locals, fast, 0, clear);	ncells = PyTuple_GET_SIZE(co->co_cellvars);	nfreevars = PyTuple_GET_SIZE(co->co_freevars);	if (ncells || nfreevars) {		dict_to_map(co->co_cellvars, ncells,			    locals, fast + co->co_nlocals, 1, clear);		dict_to_map(co->co_freevars, nfreevars,			    locals, fast + co->co_nlocals + ncells, 1,  			    clear);	}	PyErr_Restore(error_type, error_value, error_traceback);} /* Clear out the free list */ voidPyFrame_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;}

Lines 501–849 of 849. Previous lines