From 1875247549d8260002dca279c8d7b3c59f0a68cf Mon Sep 17 00:00:00 2001 From: Guido van Rossum Date: Tue, 29 Apr 1997 14:49:28 +0000 Subject: [PATCH] Quickly renamed. --- Objects/frameobject.c | 201 +++++++++++++++++++++--------------------- 1 file changed, 101 insertions(+), 100 deletions(-) diff --git a/Objects/frameobject.c b/Objects/frameobject.c index 1936138cbf2..b5af7b6ed6f 100644 --- a/Objects/frameobject.c +++ b/Objects/frameobject.c @@ -31,15 +31,14 @@ PERFORMANCE OF THIS SOFTWARE. /* Frame object implementation */ -#include "allobjects.h" +#include "Python.h" #include "compile.h" #include "frameobject.h" #include "opcode.h" #include "structmember.h" -#include "bltinmodule.h" -#define OFF(x) offsetof(frameobject, x) +#define OFF(x) offsetof(PyFrameObject, x) static struct memberlist frame_memberlist[] = { {"f_back", T_OBJECT, OFF(f_back), RO}, @@ -54,23 +53,23 @@ static struct memberlist frame_memberlist[] = { {NULL} /* Sentinel */ }; -static object * +static PyObject * frame_getattr(f, name) - frameobject *f; + PyFrameObject *f; char *name; { if (strcmp(name, "f_locals") == 0) - fast_2_locals(f); - return getmember((char *)f, frame_memberlist, name); + PyFrame_FastToLocals(f); + return PyMember_Get((char *)f, frame_memberlist, name); } static int frame_setattr(f, name, value) - frameobject *f; + PyFrameObject *f; char *name; - object *value; + PyObject *value; { - return setmember((char *)f, frame_memberlist, name, value); + return PyMember_Set((char *)f, frame_memberlist, name, value); } /* Stack frames are allocated and deallocated at a considerable rate. @@ -92,11 +91,11 @@ frame_setattr(f, name, value) unless the program contains run-away recursion. I hope. */ -static frameobject *free_list = NULL; +static PyFrameObject *free_list = NULL; static void frame_dealloc(f) - frameobject *f; + PyFrameObject *f; { int i; PyObject **fastlocals; @@ -104,24 +103,24 @@ frame_dealloc(f) /* Kill all local variables */ fastlocals = f->f_localsplus; for (i = f->f_nlocals; --i >= 0; ++fastlocals) { - XDECREF(*fastlocals); + Py_XDECREF(*fastlocals); } - XDECREF(f->f_back); - XDECREF(f->f_code); - XDECREF(f->f_builtins); - XDECREF(f->f_globals); - XDECREF(f->f_locals); - XDECREF(f->f_trace); + 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); f->f_back = free_list; free_list = f; } -typeobject Frametype = { - OB_HEAD_INIT(&Typetype) +PyTypeObject PyFrame_Type = { + PyObject_HEAD_INIT(&PyType_Type) 0, "frame", - sizeof(frameobject), + sizeof(PyFrameObject), 0, (destructor)frame_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ @@ -134,16 +133,16 @@ typeobject Frametype = { 0, /*tp_as_mapping*/ }; -frameobject * -newframeobject(back, code, globals, locals) - frameobject *back; - codeobject *code; - object *globals; - object *locals; +PyFrameObject * +PyFrame_New(back, code, globals, locals) + PyFrameObject *back; + PyCodeObject *code; + PyObject *globals; + PyObject *locals; { - static object *builtin_object; - frameobject *f; - object *builtins; + static PyObject *builtin_object; + PyFrameObject *f; + PyObject *builtins; int extras = code->co_stacksize + code->co_nlocals; if (builtin_object == NULL) { @@ -151,57 +150,59 @@ newframeobject(back, code, globals, locals) if (builtin_object == NULL) return NULL; } - if ((back != NULL && !is_frameobject(back)) || - code == NULL || !is_codeobject(code) || - globals == NULL || !is_dictobject(globals) || - (locals != NULL && !is_dictobject(locals))) { - err_badcall(); + if ((back != NULL && !PyFrame_Check(back)) || + code == NULL || !PyCode_Check(code) || + globals == NULL || !PyDict_Check(globals) || + (locals != NULL && !PyDict_Check(locals))) { + PyErr_BadInternalCall(); return NULL; } - builtins = mappinglookup(globals, builtin_object); - if (builtins != NULL && is_moduleobject(builtins)) - builtins = getmoduledict(builtins); - if (builtins == NULL || !is_mappingobject(builtins)) { - err_setstr(TypeError, "bad __builtins__ dictionary"); + builtins = PyDict_GetItem(globals, builtin_object); + if (builtins != NULL && PyModule_Check(builtins)) + builtins = PyModule_GetDict(builtins); + if (builtins == NULL || !PyDict_Check(builtins)) { + PyErr_SetString(PyExc_TypeError, + "bad __builtins__ dictionary"); return NULL; } if (free_list == NULL) { - f = (frameobject *) - malloc(sizeof(frameobject) + extras*sizeof(object *)); + f = (PyFrameObject *) + malloc(sizeof(PyFrameObject) + + extras*sizeof(PyObject *)); if (f == NULL) - return (PyFrameObject *)err_nomem(); - f->ob_type = &Frametype; - NEWREF(f); + return (PyFrameObject *)PyErr_NoMemory(); + f->ob_type = &PyFrame_Type; + _Py_NewReference(f); } else { f = free_list; free_list = free_list->f_back; if (f->f_nlocals + f->f_stacksize < extras) { - f = realloc(f, sizeof(frameobject) + - extras*sizeof(object *)); + f = realloc(f, sizeof(PyFrameObject) + + extras*sizeof(PyObject *)); if (f == NULL) - return (PyFrameObject *)err_nomem(); + return (PyFrameObject *)PyErr_NoMemory(); } else extras = f->f_nlocals + f->f_stacksize; - f->ob_type = &Frametype; - NEWREF(f); + f->ob_type = &PyFrame_Type; + _Py_NewReference(f); } - XINCREF(back); + Py_XINCREF(back); f->f_back = back; - INCREF(code); + Py_INCREF(code); f->f_code = code; - XINCREF(builtins); + Py_XINCREF(builtins); f->f_builtins = builtins; - INCREF(globals); + Py_INCREF(globals); f->f_globals = globals; if (code->co_flags & CO_NEWLOCALS) { if (code->co_flags & CO_OPTIMIZED) locals = NULL; /* Let fast_2_locals handle it */ else { - locals = newdictobject(); + locals = PyDict_New(); if (locals == NULL) { - DECREF(f); + Py_DECREF(f); return NULL; } } @@ -209,14 +210,14 @@ newframeobject(back, code, globals, locals) else { if (locals == NULL) locals = globals; - INCREF(locals); + Py_INCREF(locals); } f->f_locals = locals; f->f_trace = NULL; f->f_lasti = 0; f->f_lineno = code->co_firstlineno; - f->f_restricted = (builtins != getbuiltindict()); + f->f_restricted = (builtins != PyBuiltin_GetDict()); f->f_iblock = 0; f->f_nlocals = code->co_nlocals; f->f_stacksize = extras - code->co_nlocals; @@ -232,28 +233,28 @@ newframeobject(back, code, globals, locals) /* Block management */ void -setup_block(f, type, handler, level) - frameobject *f; +PyFrame_BlockSetup(f, type, handler, level) + PyFrameObject *f; int type; int handler; int level; { - block *b; + PyTryBlock *b; if (f->f_iblock >= CO_MAXBLOCKS) - fatal("XXX block stack overflow"); + 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; } -block * -pop_block(f) - frameobject *f; +PyTryBlock * +PyFrame_BlockPop(f) + PyFrameObject *f; { - block *b; + PyTryBlock *b; if (f->f_iblock <= 0) - fatal("XXX block stack underflow"); + Py_FatalError("XXX block stack underflow"); b = &f->f_blockstack[--f->f_iblock]; return b; } @@ -261,59 +262,59 @@ pop_block(f) /* Convert between "fast" version of locals and dictionary version */ void -fast_2_locals(f) - frameobject *f; +PyFrame_FastToLocals(f) + PyFrameObject *f; { /* Merge fast locals into f->f_locals */ - object *locals, *map; - object **fast; - object *error_type, *error_value, *error_traceback; + 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 = newdictobject(); + locals = f->f_locals = PyDict_New(); if (locals == NULL) { - err_clear(); /* Can't report it :-( */ + PyErr_Clear(); /* Can't report it :-( */ return; } } if (f->f_nlocals == 0) return; map = f->f_code->co_varnames; - if (!is_dictobject(locals) || !is_tupleobject(map)) + if (!PyDict_Check(locals) || !PyTuple_Check(map)) return; - err_fetch(&error_type, &error_value, &error_traceback); + PyErr_Fetch(&error_type, &error_value, &error_traceback); fast = f->f_localsplus; - j = gettuplesize(map); + j = PyTuple_Size(map); if (j > f->f_nlocals) j = f->f_nlocals; for (; --j >= 0; ) { - object *key = gettupleitem(map, j); - object *value = fast[j]; + PyObject *key = PyTuple_GetItem(map, j); + PyObject *value = fast[j]; if (value == NULL) { - err_clear(); - if (dict2remove(locals, key) != 0) - err_clear(); + PyErr_Clear(); + if (PyDict_DelItem(locals, key) != 0) + PyErr_Clear(); } else { - if (dict2insert(locals, key, value) != 0) - err_clear(); + if (PyDict_SetItem(locals, key, value) != 0) + PyErr_Clear(); } } - err_restore(error_type, error_value, error_traceback); + PyErr_Restore(error_type, error_value, error_traceback); } void -locals_2_fast(f, clear) - frameobject *f; +PyFrame_LocalsToFast(f, clear) + PyFrameObject *f; int clear; { /* Merge f->f_locals into fast locals */ - object *locals, *map; - object **fast; - object *error_type, *error_value, *error_traceback; + PyObject *locals, *map; + PyObject **fast; + PyObject *error_type, *error_value, *error_traceback; int j; if (f == NULL) return; @@ -321,24 +322,24 @@ locals_2_fast(f, clear) map = f->f_code->co_varnames; if (locals == NULL || f->f_code->co_nlocals == 0) return; - if (!is_dictobject(locals) || !is_tupleobject(map)) + if (!PyDict_Check(locals) || !PyTuple_Check(map)) return; - err_fetch(&error_type, &error_value, &error_traceback); + PyErr_Fetch(&error_type, &error_value, &error_traceback); fast = f->f_localsplus; - j = gettuplesize(map); + j = PyTuple_Size(map); if (j > f->f_nlocals) j = f->f_nlocals; for (; --j >= 0; ) { - object *key = gettupleitem(map, j); - object *value = dict2lookup(locals, key); + PyObject *key = PyTuple_GetItem(map, j); + PyObject *value = PyDict_GetItem(locals, key); if (value == NULL) - err_clear(); + PyErr_Clear(); else - INCREF(value); + Py_INCREF(value); if (value != NULL || clear) { - XDECREF(fast[j]); + Py_XDECREF(fast[j]); fast[j] = value; } } - err_restore(error_type, error_value, error_traceback); + PyErr_Restore(error_type, error_value, error_traceback); }