| /* Traceback implementation */ | |
| #include "Python.h" | |
| #include "code.h" | |
| #include "frameobject.h" | |
| #include "structmember.h" | |
| #include "osdefs.h" | |
| #include "traceback.h" | |
| #define OFF(x) offsetof(PyTracebackObject, x) | |
| static PyMemberDef tb_memberlist[] = { | |
| {"tb_next", T_OBJECT, OFF(tb_next), READONLY}, | |
| {"tb_frame", T_OBJECT, OFF(tb_frame), READONLY}, | |
| {"tb_lasti", T_INT, OFF(tb_lasti), READONLY}, | |
| {"tb_lineno", T_INT, OFF(tb_lineno), READONLY}, | |
| {NULL} /* Sentinel */ | |
| }; | |
| static void | |
| tb_dealloc(PyTracebackObject *tb) | |
| { | |
| PyObject_GC_UnTrack(tb); | |
| Py_TRASHCAN_SAFE_BEGIN(tb) | |
| Py_XDECREF(tb->tb_next); | |
| Py_XDECREF(tb->tb_frame); | |
| PyObject_GC_Del(tb); | |
| Py_TRASHCAN_SAFE_END(tb) | |
| } | |
| static int | |
| tb_traverse(PyTracebackObject *tb, visitproc visit, void *arg) | |
| { | |
| Py_VISIT(tb->tb_next); | |
| Py_VISIT(tb->tb_frame); | |
| return 0; | |
| } | |
| static void | |
| tb_clear(PyTracebackObject *tb) | |
| { | |
| Py_CLEAR(tb->tb_next); | |
| Py_CLEAR(tb->tb_frame); | |
| } | |
| PyTypeObject PyTraceBack_Type = { | |
| PyVarObject_HEAD_INIT(&PyType_Type, 0) | |
| "traceback", | |
| sizeof(PyTracebackObject), | |
| 0, | |
| (destructor)tb_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 */ | |
| 0, /* tp_getattro */ | |
| 0, /* tp_setattro */ | |
| 0, /* tp_as_buffer */ | |
| Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */ | |
| 0, /* tp_doc */ | |
| (traverseproc)tb_traverse, /* tp_traverse */ | |
| (inquiry)tb_clear, /* tp_clear */ | |
| 0, /* tp_richcompare */ | |
| 0, /* tp_weaklistoffset */ | |
| 0, /* tp_iter */ | |
| 0, /* tp_iternext */ | |
| 0, /* tp_methods */ | |
| tb_memberlist, /* tp_members */ | |
| 0, /* tp_getset */ | |
| 0, /* tp_base */ | |
| 0, /* tp_dict */ | |
| }; | |
| static PyTracebackObject * | |
| newtracebackobject(PyTracebackObject *next, PyFrameObject *frame) | |
| { | |
| PyTracebackObject *tb; | |
| if ((next != NULL && !PyTraceBack_Check(next)) || | |
| frame == NULL || !PyFrame_Check(frame)) { | |
| PyErr_BadInternalCall(); | |
| return NULL; | |
| } | |
| tb = PyObject_GC_New(PyTracebackObject, &PyTraceBack_Type); | |
| if (tb != NULL) { | |
| Py_XINCREF(next); | |
| tb->tb_next = next; | |
| Py_XINCREF(frame); | |
| tb->tb_frame = frame; | |
| tb->tb_lasti = frame->f_lasti; | |
| tb->tb_lineno = PyFrame_GetLineNumber(frame); | |
| PyObject_GC_Track(tb); | |
| } | |
| return tb; | |
| } | |
| int | |
| PyTraceBack_Here(PyFrameObject *frame) | |
| { | |
| PyThreadState *tstate = PyThreadState_GET(); | |
| PyTracebackObject *oldtb = (PyTracebackObject *) tstate->curexc_traceback; | |
| PyTracebackObject *tb = newtracebackobject(oldtb, frame); | |
| if (tb == NULL) | |
| return -1; | |
| tstate->curexc_traceback = (PyObject *)tb; | |
| Py_XDECREF(oldtb); | |
| return 0; | |
| } | |
| int | |
| _Py_DisplaySourceLine(PyObject *f, const char *filename, int lineno, int indent) | |
| { | |
| int err = 0; | |
| FILE *xfp = NULL; | |
| char linebuf[2000]; | |
| int i; | |
| char namebuf[MAXPATHLEN+1]; | |
| if (filename == NULL) | |
| return -1; | |
| /* This is needed by Emacs' compile command */ | |
| #define FMT " File \"%.500s\", line %d, in %.500s\n" | |
| xfp = fopen(filename, "r" PY_STDIOTEXTMODE); | |
| if (xfp == NULL) { | |
| /* Search tail of filename in sys.path before giving up */ | |
| PyObject *path; | |
| const char *tail = strrchr(filename, SEP); | |
| if (tail == NULL) | |
| tail = filename; | |
| else | |
| tail++; | |
| path = PySys_GetObject("path"); | |
| if (path != NULL && PyList_Check(path)) { | |
| Py_ssize_t _npath = PyList_Size(path); | |
| int npath = Py_SAFE_DOWNCAST(_npath, Py_ssize_t, int); | |
| size_t taillen = strlen(tail); | |
| for (i = 0; i < npath; i++) { | |
| PyObject *v = PyList_GetItem(path, i); | |
| if (v == NULL) { | |
| PyErr_Clear(); | |
| break; | |
| } | |
| if (PyString_Check(v)) { | |
| size_t len; | |
| len = PyString_GET_SIZE(v); | |
| if (len + 1 + taillen >= MAXPATHLEN) | |
| continue; /* Too long */ | |
| strcpy(namebuf, PyString_AsString(v)); | |
| if (strlen(namebuf) != len) | |
| continue; /* v contains '\0' */ | |
| if (len > 0 && namebuf[len-1] != SEP) | |
| namebuf[len++] = SEP; | |
| strcpy(namebuf+len, tail); | |
| xfp = fopen(namebuf, "r" PY_STDIOTEXTMODE); | |
| if (xfp != NULL) { | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| if (xfp == NULL) | |
| return err; | |
| for (i = 0; i < lineno; i++) { | |
| char* pLastChar = &linebuf[sizeof(linebuf)-2]; | |
| do { | |
| *pLastChar = '\0'; | |
| if (Py_UniversalNewlineFgets(linebuf, sizeof linebuf, xfp, NULL) == NULL) | |
| break; | |
| /* fgets read *something*; if it didn't get as | |
| far as pLastChar, it must have found a newline | |
| or hit the end of the file; if pLastChar is \n, | |
| it obviously found a newline; else we haven't | |
| yet seen a newline, so must continue */ | |
| } while (*pLastChar != '\0' && *pLastChar != '\n'); | |
| } | |
| if (i == lineno) { | |
| char buf[11]; | |
| char *p = linebuf; | |
| while (*p == ' ' || *p == '\t' || *p == '\014') | |
| p++; | |
| /* Write some spaces before the line */ | |
| strcpy(buf, " "); | |
| assert (strlen(buf) == 10); | |
| while (indent > 0) { | |
| if(indent < 10) | |
| buf[indent] = '\0'; | |
| err = PyFile_WriteString(buf, f); | |
| if (err != 0) | |
| break; | |
| indent -= 10; | |
| } | |
| if (err == 0) | |
| err = PyFile_WriteString(p, f); | |
| if (err == 0 && strchr(p, '\n') == NULL) | |
| err = PyFile_WriteString("\n", f); | |
| } | |
| fclose(xfp); | |
| return err; | |
| } | |
| static int | |
| tb_displayline(PyObject *f, const char *filename, int lineno, const char *name) | |
| { | |
| int err = 0; | |
| char linebuf[2000]; | |
| if (filename == NULL || name == NULL) | |
| return -1; | |
| /* This is needed by Emacs' compile command */ | |
| #define FMT " File \"%.500s\", line %d, in %.500s\n" | |
| PyOS_snprintf(linebuf, sizeof(linebuf), FMT, filename, lineno, name); | |
| err = PyFile_WriteString(linebuf, f); | |
| if (err != 0) | |
| return err; | |
| return _Py_DisplaySourceLine(f, filename, lineno, 4); | |
| } | |
| static int | |
| tb_printinternal(PyTracebackObject *tb, PyObject *f, long limit) | |
| { | |
| int err = 0; | |
| long depth = 0; | |
| PyTracebackObject *tb1 = tb; | |
| while (tb1 != NULL) { | |
| depth++; | |
| tb1 = tb1->tb_next; | |
| } | |
| while (tb != NULL && err == 0) { | |
| if (depth <= limit) { | |
| err = tb_displayline(f, | |
| PyString_AsString( | |
| tb->tb_frame->f_code->co_filename), | |
| tb->tb_lineno, | |
| PyString_AsString(tb->tb_frame->f_code->co_name)); | |
| } | |
| depth--; | |
| tb = tb->tb_next; | |
| if (err == 0) | |
| err = PyErr_CheckSignals(); | |
| } | |
| return err; | |
| } | |
| int | |
| PyTraceBack_Print(PyObject *v, PyObject *f) | |
| { | |
| int err; | |
| PyObject *limitv; | |
| long limit = 1000; | |
| if (v == NULL) | |
| return 0; | |
| if (!PyTraceBack_Check(v)) { | |
| PyErr_BadInternalCall(); | |
| return -1; | |
| } | |
| limitv = PySys_GetObject("tracebacklimit"); | |
| if (limitv && PyInt_Check(limitv)) { | |
| limit = PyInt_AsLong(limitv); | |
| if (limit <= 0) | |
| return 0; | |
| } | |
| err = PyFile_WriteString("Traceback (most recent call last):\n", f); | |
| if (!err) | |
| err = tb_printinternal((PyTracebackObject *)v, f, limit); | |
| return err; | |
| } |