From 65bf9f265e4052c3eee95cd73f8de66bc92e53bf Mon Sep 17 00:00:00 2001 From: Guido van Rossum Date: Tue, 29 Apr 1997 18:33:38 +0000 Subject: Quickly renamed. --- Python/sysmodule.c | 290 +++++++++++++++++++++++++++-------------------------- Python/traceback.c | 114 ++++++++++----------- 2 files changed, 204 insertions(+), 200 deletions(-) diff --git a/Python/sysmodule.c b/Python/sysmodule.c index 69cb7aa..d15fab1 100644 --- a/Python/sysmodule.c +++ b/Python/sysmodule.c @@ -44,140 +44,137 @@ Data members: - ps1, ps2: optional primary and secondary prompts (strings) */ -#include "allobjects.h" +#include "Python.h" -#include "sysmodule.h" -#include "import.h" -#include "modsupport.h" #include "osdefs.h" -object *sys_trace, *sys_profile; -int sys_checkinterval = 10; +PyObject *_PySys_TraceFunc, *_PySys_ProfileFunc; +int _PySys_CheckInterval = 10; #if HAVE_UNISTD_H #include #endif -static object *sysdict; +static PyObject *sysdict; #ifdef MS_COREDLL extern void *PyWin_DLLhModule; #endif -object * -sysget(name) +PyObject * +PySys_GetObject(name) char *name; { - return dictlookup(sysdict, name); + return PyDict_GetItemString(sysdict, name); } FILE * -sysgetfile(name, def) +PySys_GetFile(name, def) char *name; FILE *def; { FILE *fp = NULL; - object *v = sysget(name); - if (v != NULL && is_fileobject(v)) - fp = getfilefile(v); + PyObject *v = PySys_GetObject(name); + if (v != NULL && PyFile_Check(v)) + fp = PyFile_AsFile(v); if (fp == NULL) fp = def; return fp; } int -sysset(name, v) +PySys_SetObject(name, v) char *name; - object *v; + PyObject *v; { if (v == NULL) { - if (dictlookup(sysdict, name) == NULL) + if (PyDict_GetItemString(sysdict, name) == NULL) return 0; else - return dictremove(sysdict, name); + return PyDict_DelItemString(sysdict, name); } else - return dictinsert(sysdict, name, v); + return PyDict_SetItemString(sysdict, name, v); } -static object * +static PyObject * sys_exit(self, args) - object *self; - object *args; + PyObject *self; + PyObject *args; { /* Raise SystemExit so callers may catch it or clean up. */ - err_setval(SystemExit, args); + PyErr_SetObject(PyExc_SystemExit, args); return NULL; } -static object * +static PyObject * sys_settrace(self, args) - object *self; - object *args; + PyObject *self; + PyObject *args; { - if (args == None) + if (args == Py_None) args = NULL; else - XINCREF(args); - XDECREF(sys_trace); - sys_trace = args; - INCREF(None); - return None; + Py_XINCREF(args); + Py_XDECREF(_PySys_TraceFunc); + _PySys_TraceFunc = args; + Py_INCREF(Py_None); + return Py_None; } -static object * +static PyObject * sys_setprofile(self, args) - object *self; - object *args; + PyObject *self; + PyObject *args; { - if (args == None) + if (args == Py_None) args = NULL; else - XINCREF(args); - XDECREF(sys_profile); - sys_profile = args; - INCREF(None); - return None; + Py_XINCREF(args); + Py_XDECREF(_PySys_ProfileFunc); + _PySys_ProfileFunc = args; + Py_INCREF(Py_None); + return Py_None; } -static object * +static PyObject * sys_setcheckinterval(self, args) - object *self; - object *args; + PyObject *self; + PyObject *args; { - if (!newgetargs(args, "i", &sys_checkinterval)) + if (!PyArg_ParseTuple(args, "i", &_PySys_CheckInterval)) return NULL; - INCREF(None); - return None; + Py_INCREF(Py_None); + return Py_None; } #ifdef USE_MALLOPT /* Link with -lmalloc (or -lmpc) on an SGI */ #include -static object * +static PyObject * sys_mdebug(self, args) - object *self; - object *args; + PyObject *self; + PyObject *args; { int flag; - if (!getargs(args, "i", &flag)) + if (!PyArg_Parse(args, "i", &flag)) return NULL; mallopt(M_DEBUG, flag); - INCREF(None); - return None; + Py_INCREF(Py_None); + return Py_None; } #endif /* USE_MALLOPT */ -static object * +static PyObject * sys_getrefcount(self, args) - object *self; - object *args; + PyObject *self; + PyObject *args; { - object *arg; - if (!getargs(args, "O", &arg)) + PyObject *arg; + if (!PyArg_Parse(args, "O", &arg)) return NULL; - return newintobject((long) arg->ob_refcnt); + return PyInt_FromLong((long) arg->ob_refcnt); } #ifdef COUNT_ALLOCS @@ -203,7 +200,7 @@ extern PyObject *_Py_GetObjects Py_PROTO((PyObject *, PyObject *)); extern PyObject *_Py_GetDXProfile Py_PROTO((PyObject *, PyObject *)); #endif -static struct methodlist sys_methods[] = { +static PyMethodDef sys_methods[] = { /* Might as well keep this in alphabetic order */ {"exit", sys_exit, 0}, #ifdef COUNT_ALLOCS @@ -225,93 +222,100 @@ static struct methodlist sys_methods[] = { {NULL, NULL} /* sentinel */ }; -static object *sysin, *sysout, *syserr; +static PyObject *sysin, *sysout, *syserr; -static object * +static PyObject * list_builtin_module_names() { - object *list = newlistobject(0); + PyObject *list = PyList_New(0); int i; if (list == NULL) return NULL; for (i = 0; inittab[i].name != NULL; i++) { - object *name = newstringobject(inittab[i].name); + PyObject *name = PyString_FromString(inittab[i].name); if (name == NULL) break; - addlistitem(list, name); - DECREF(name); + PyList_Append(list, name); + Py_DECREF(name); } - if (sortlist(list) != 0) { - DECREF(list); + if (PyList_Sort(list) != 0) { + Py_DECREF(list); list = NULL; } if (list) { - object *v = listtuple(list); - DECREF(list); + PyObject *v = PyList_AsTuple(list); + Py_DECREF(list); list = v; } return list; } void -initsys() +PySys_Init() { - extern long getmaxint PROTO((void)); - extern char *getversion PROTO((void)); - extern char *getcopyright PROTO((void)); - extern char *getplatform PROTO((void)); - extern char *Py_GetPrefix PROTO((void)); - extern char *Py_GetExecPrefix PROTO((void)); - extern int fclose PROTO((FILE *)); - object *m = initmodule("sys", sys_methods); - object *v; - sysdict = getmoduledict(m); - INCREF(sysdict); + extern long PyInt_GetMax Py_PROTO((void)); + extern char *Py_GetVersion Py_PROTO((void)); + extern char *Py_GetCopyright Py_PROTO((void)); + extern char *Py_GetPlatform Py_PROTO((void)); + extern char *Py_GetPrefix Py_PROTO((void)); + extern char *Py_GetExecPrefix Py_PROTO((void)); + extern int fclose Py_PROTO((FILE *)); + PyObject *m = Py_InitModule("sys", sys_methods); + PyObject *v; + sysdict = PyModule_GetDict(m); + Py_INCREF(sysdict); /* NB keep an extra ref to the std files to avoid closing them when the user deletes them */ - sysin = newopenfileobject(stdin, "", "r", fclose); - sysout = newopenfileobject(stdout, "", "w", fclose); - syserr = newopenfileobject(stderr, "", "w", fclose); - if (err_occurred()) - fatal("can't initialize sys.std{in,out,err}"); - dictinsert(sysdict, "stdin", sysin); - dictinsert(sysdict, "stdout", sysout); - dictinsert(sysdict, "stderr", syserr); - dictinsert(sysdict, "version", v = newstringobject(getversion())); - XDECREF(v); - dictinsert(sysdict, "copyright", v = newstringobject(getcopyright())); - XDECREF(v); - dictinsert(sysdict, "platform", v = newstringobject(getplatform())); - XDECREF(v); - dictinsert(sysdict, "prefix", v = newstringobject(Py_GetPrefix())); - XDECREF(v); - dictinsert(sysdict, "exec_prefix", - v = newstringobject(Py_GetExecPrefix())); - XDECREF(v); - dictinsert(sysdict, "maxint", v = newintobject(getmaxint())); - XDECREF(v); - dictinsert(sysdict, "modules", get_modules()); - dictinsert(sysdict, "builtin_module_names", + sysin = PyFile_FromFile(stdin, "", "r", fclose); + sysout = PyFile_FromFile(stdout, "", "w", fclose); + syserr = PyFile_FromFile(stderr, "", "w", fclose); + if (PyErr_Occurred()) + Py_FatalError("can't initialize sys.std{in,out,err}"); + PyDict_SetItemString(sysdict, "stdin", sysin); + PyDict_SetItemString(sysdict, "stdout", sysout); + PyDict_SetItemString(sysdict, "stderr", syserr); + PyDict_SetItemString(sysdict, "version", + v = PyString_FromString(Py_GetVersion())); + Py_XDECREF(v); + PyDict_SetItemString(sysdict, "copyright", + v = PyString_FromString(Py_GetCopyright())); + Py_XDECREF(v); + PyDict_SetItemString(sysdict, "platform", + v = PyString_FromString(Py_GetPlatform())); + Py_XDECREF(v); + PyDict_SetItemString(sysdict, "prefix", + v = PyString_FromString(Py_GetPrefix())); + Py_XDECREF(v); + PyDict_SetItemString(sysdict, "exec_prefix", + v = PyString_FromString(Py_GetExecPrefix())); + Py_XDECREF(v); + PyDict_SetItemString(sysdict, "maxint", + v = PyInt_FromLong(PyInt_GetMax())); + Py_XDECREF(v); + PyDict_SetItemString(sysdict, "modules", PyImport_GetModuleDict()); + PyDict_SetItemString(sysdict, "builtin_module_names", v = list_builtin_module_names()); - XDECREF(v); + Py_XDECREF(v); #ifdef MS_COREDLL - dictinsert(sysdict, "dllhandle", v = newintobject((int)PyWin_DLLhModule)); - XDECREF(v); - dictinsert(sysdict, "winver", v = newstringobject(MS_DLL_ID)); - XDECREF(v); + PyDict_SetItemString(sysdict, "dllhandle", + v = PyInt_FromLong((int)PyWin_DLLhModule)); + Py_XDECREF(v); + PyDict_SetItemString(sysdict, "winver", + v = PyString_FromString(MS_DLL_ID)); + Py_XDECREF(v); #endif - if (err_occurred()) - fatal("can't insert sys.* objects in sys dict"); + if (PyErr_Occurred()) + Py_FatalError("can't insert sys.* objects in sys dict"); } -static object * +static PyObject * makepathobject(path, delim) char *path; int delim; { int i, n; char *p; - object *v, *w; + PyObject *v, *w; n = 1; p = path; @@ -319,19 +323,19 @@ makepathobject(path, delim) n++; p++; } - v = newlistobject(n); + v = PyList_New(n); if (v == NULL) return NULL; for (i = 0; ; i++) { p = strchr(path, delim); if (p == NULL) p = strchr(path, '\0'); /* End of string */ - w = newsizedstringobject(path, (int) (p - path)); + w = PyString_FromStringAndSize(path, (int) (p - path)); if (w == NULL) { - DECREF(v); + Py_DECREF(v); return NULL; } - setlistitem(v, i, w); + PyList_SetItem(v, i, w); if (*p == '\0') break; path = p+1; @@ -340,61 +344,61 @@ makepathobject(path, delim) } void -setpythonpath(path) +PySys_SetPath(path) char *path; { - object *v; + PyObject *v; if ((v = makepathobject(path, DELIM)) == NULL) - fatal("can't create sys.path"); - if (sysset("path", v) != 0) - fatal("can't assign sys.path"); - DECREF(v); + Py_FatalError("can't create sys.path"); + if (PySys_SetObject("path", v) != 0) + Py_FatalError("can't assign sys.path"); + Py_DECREF(v); } -static object * +static PyObject * makeargvobject(argc, argv) int argc; char **argv; { - object *av; + PyObject *av; if (argc <= 0 || argv == NULL) { /* Ensure at least one (empty) argument is seen */ static char *empty_argv[1] = {""}; argv = empty_argv; argc = 1; } - av = newlistobject(argc); + av = PyList_New(argc); if (av != NULL) { int i; for (i = 0; i < argc; i++) { - object *v = newstringobject(argv[i]); + PyObject *v = PyString_FromString(argv[i]); if (v == NULL) { - DECREF(av); + Py_DECREF(av); av = NULL; break; } - setlistitem(av, i, v); + PyList_SetItem(av, i, v); } } return av; } void -setpythonargv(argc, argv) +PySys_SetArgv(argc, argv) int argc; char **argv; { - object *av = makeargvobject(argc, argv); - object *path = sysget("path"); + PyObject *av = makeargvobject(argc, argv); + PyObject *path = PySys_GetObject("path"); if (av == NULL) - fatal("no mem for sys.argv"); - if (sysset("argv", av) != 0) - fatal("can't assign sys.argv"); + Py_FatalError("no mem for sys.argv"); + if (PySys_SetObject("argv", av) != 0) + Py_FatalError("can't assign sys.argv"); if (path != NULL) { char *argv0 = argv[0]; char *p = NULL; int n = 0; - object *a; + PyObject *a; #ifdef HAVE_READLINK char link[MAXPATHLEN+1]; char argv0copy[2*MAXPATHLEN+1]; @@ -448,12 +452,12 @@ setpythonargv(argc, argv) #endif /* Unix */ } #endif /* All others */ - a = newsizedstringobject(argv0, n); + a = PyString_FromStringAndSize(argv0, n); if (a == NULL) - fatal("no mem for sys.path insertion"); - if (inslistitem(path, 0, a) < 0) - fatal("sys.path.insert(0) failed"); - DECREF(a); + Py_FatalError("no mem for sys.path insertion"); + if (PyList_Insert(path, 0, a) < 0) + Py_FatalError("sys.path.insert(0) failed"); + Py_DECREF(a); } - DECREF(av); + Py_DECREF(av); } diff --git a/Python/traceback.c b/Python/traceback.c index f9b840e..9633db1 100644 --- a/Python/traceback.c +++ b/Python/traceback.c @@ -31,19 +31,17 @@ PERFORMANCE OF THIS SOFTWARE. /* Traceback implementation */ -#include "allobjects.h" +#include "Python.h" -#include "sysmodule.h" #include "compile.h" #include "frameobject.h" -#include "traceback.h" #include "structmember.h" #include "osdefs.h" typedef struct _tracebackobject { - OB_HEAD + PyObject_HEAD struct _tracebackobject *tb_next; - frameobject *tb_frame; + PyFrameObject *tb_frame; int tb_lasti; int tb_lineno; } tracebackobject; @@ -58,28 +56,28 @@ static struct memberlist tb_memberlist[] = { {NULL} /* Sentinel */ }; -static object * +static PyObject * tb_getattr(tb, name) tracebackobject *tb; char *name; { - return getmember((char *)tb, tb_memberlist, name); + return PyMember_Get((char *)tb, tb_memberlist, name); } static void tb_dealloc(tb) tracebackobject *tb; { - XDECREF(tb->tb_next); - XDECREF(tb->tb_frame); - DEL(tb); + Py_XDECREF(tb->tb_next); + Py_XDECREF(tb->tb_frame); + PyMem_DEL(tb); } #define Tracebacktype PyTraceBack_Type #define is_tracebackobject PyTraceBack_Check -typeobject Tracebacktype = { - OB_HEAD_INIT(&Typetype) +PyTypeObject Tracebacktype = { + PyObject_HEAD_INIT(&PyType_Type) 0, "traceback", sizeof(tracebackobject), @@ -98,20 +96,20 @@ typeobject Tracebacktype = { static tracebackobject * newtracebackobject(next, frame, lasti, lineno) tracebackobject *next; - frameobject *frame; + PyFrameObject *frame; int lasti, lineno; { tracebackobject *tb; if ((next != NULL && !is_tracebackobject(next)) || - frame == NULL || !is_frameobject(frame)) { - err_badcall(); + frame == NULL || !PyFrame_Check(frame)) { + PyErr_BadInternalCall(); return NULL; } - tb = NEWOBJ(tracebackobject, &Tracebacktype); + tb = PyObject_NEW(tracebackobject, &Tracebacktype); if (tb != NULL) { - XINCREF(next); + Py_XINCREF(next); tb->tb_next = next; - XINCREF(frame); + Py_XINCREF(frame); tb->tb_frame = frame; tb->tb_lasti = lasti; tb->tb_lineno = lineno; @@ -122,44 +120,45 @@ newtracebackobject(next, frame, lasti, lineno) static tracebackobject *tb_current = NULL; int -tb_here(frame) - frameobject *frame; +PyTraceBack_Here(frame) + PyFrameObject *frame; { tracebackobject *tb; - tb = newtracebackobject(tb_current, frame, frame->f_lasti, frame->f_lineno); + tb = newtracebackobject(tb_current, frame, + frame->f_lasti, frame->f_lineno); if (tb == NULL) return -1; - XDECREF(tb_current); + Py_XDECREF(tb_current); tb_current = tb; return 0; } -object * -tb_fetch() +PyObject * +PyTraceBack_Fetch() { - object *v; - v = (object *)tb_current; + PyObject *v; + v = (PyObject *)tb_current; tb_current = NULL; return v; } int -tb_store(v) - object *v; +PyTraceBack_Store(v) + PyObject *v; { if (v != NULL && !is_tracebackobject(v)) { - err_badcall(); + PyErr_BadInternalCall(); return -1; } - XDECREF(tb_current); - XINCREF(v); + Py_XDECREF(tb_current); + Py_XINCREF(v); tb_current = (tracebackobject *)v; return 0; } static void tb_displayline(f, filename, lineno, name) - object *f; + PyObject *f; char *filename; int lineno; char *name; @@ -177,25 +176,25 @@ tb_displayline(f, filename, lineno, name) xfp = fopen(filename, "r"); if (xfp == NULL) { /* Search tail of filename in sys.path before giving up */ - object *path; + PyObject *path; char *tail = strrchr(filename, SEP); if (tail == NULL) tail = filename; else tail++; - path = sysget("path"); - if (path != NULL && is_listobject(path)) { - int npath = getlistsize(path); + path = PySys_GetObject("path"); + if (path != NULL && PyList_Check(path)) { + int npath = PyList_Size(path); int taillen = strlen(tail); char namebuf[MAXPATHLEN+1]; for (i = 0; i < npath; i++) { - object *v = getlistitem(path, i); - if (is_stringobject(v)) { + PyObject *v = PyList_GetItem(path, i); + if (PyString_Check(v)) { int len; - len = getstringsize(v); + len = PyString_Size(v); if (len + 1 + taillen >= MAXPATHLEN) continue; /* Too long */ - strcpy(namebuf, getstringvalue(v)); + strcpy(namebuf, PyString_AsString(v)); if ((int)strlen(namebuf) != len) continue; /* v contains '\0' */ if (len > 0 && namebuf[len-1] != SEP) @@ -211,7 +210,7 @@ tb_displayline(f, filename, lineno, name) } } sprintf(linebuf, FMT, filename, lineno, name); - writestring(linebuf, f); + PyFile_WriteString(linebuf, f); if (xfp == NULL) return; for (i = 0; i < lineno; i++) { @@ -222,10 +221,10 @@ tb_displayline(f, filename, lineno, name) char *p = linebuf; while (*p == ' ' || *p == '\t' || *p == '\014') p++; - writestring(" ", f); - writestring(p, f); + PyFile_WriteString(" ", f); + PyFile_WriteString(p, f); if (strchr(p, '\n') == NULL) - writestring("\n", f); + PyFile_WriteString("\n", f); } fclose(xfp); } @@ -233,7 +232,7 @@ tb_displayline(f, filename, lineno, name) static void tb_printinternal(tb, f, limit) tracebackobject *tb; - object *f; + PyObject *f; int limit; { int depth = 0; @@ -242,14 +241,15 @@ tb_printinternal(tb, f, limit) depth++; tb1 = tb1->tb_next; } - while (tb != NULL && !intrcheck()) { + while (tb != NULL && !PyOS_InterruptOccurred()) { if (depth <= limit) { tb->tb_lineno = PyCode_Addr2Line(tb->tb_frame->f_code, tb->tb_lasti); tb_displayline(f, - getstringvalue(tb->tb_frame->f_code->co_filename), + PyString_AsString( + tb->tb_frame->f_code->co_filename), tb->tb_lineno, - getstringvalue(tb->tb_frame->f_code->co_name)); + PyString_AsString(tb->tb_frame->f_code->co_name)); } depth--; tb = tb->tb_next; @@ -257,25 +257,25 @@ tb_printinternal(tb, f, limit) } int -tb_print(v, f) - object *v; - object *f; +PyTraceBack_Print(v, f) + PyObject *v; + PyObject *f; { - object *limitv; + PyObject *limitv; int limit = 1000; if (v == NULL) return 0; if (!is_tracebackobject(v)) { - err_badcall(); + PyErr_BadInternalCall(); return -1; } - limitv = sysget("tracebacklimit"); - if (limitv && is_intobject(limitv)) { - limit = getintvalue(limitv); + limitv = PySys_GetObject("tracebacklimit"); + if (limitv && PyInt_Check(limitv)) { + limit = PyInt_AsLong(limitv); if (limit <= 0) return 0; } - writestring("Traceback (innermost last):\n", f); + PyFile_WriteString("Traceback (innermost last):\n", f); tb_printinternal((tracebackobject *)v, f, limit); return 0; } -- cgit v0.12