| |
| /* 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; |
| if (err != 0) { |
| fclose(xfp); |
| 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; |
| } |