Python/traceback.c

   1
   2 /* Traceback implementation */
   3
   4 #include "Python.h"
   5
   6 #include "code.h"
   7 #include "frameobject.h"
   8 #include "structmember.h"
   9 #include "osdefs.h"
  10 #include "traceback.h"
  11
  12 #define OFF(x) offsetof(PyTracebackObject, x)
  13
  14 static PyMemberDef tb_memberlist[] = {
  15         {"tb_next",     T_OBJECT,       OFF(tb_next), READONLY},
  16         {"tb_frame",    T_OBJECT,       OFF(tb_frame), READONLY},
  17         {"tb_lasti",    T_INT,          OFF(tb_lasti), READONLY},
  18         {"tb_lineno",   T_INT,          OFF(tb_lineno), READONLY},
  19         {NULL}  /* Sentinel */
  20 };
  21
  22 static void
  23 tb_dealloc(PyTracebackObject *tb)
  24 {
  25         PyObject_GC_UnTrack(tb);
  26         Py_TRASHCAN_SAFE_BEGIN(tb)
  27         Py_XDECREF(tb->tb_next);
  28         Py_XDECREF(tb->tb_frame);
  29         PyObject_GC_Del(tb);
  30         Py_TRASHCAN_SAFE_END(tb)
  31 }
  32
  33 static int
  34 tb_traverse(PyTracebackObject *tb, visitproc visit, void *arg)
  35 {
  36         Py_VISIT(tb->tb_next);
  37         Py_VISIT(tb->tb_frame);
  38         return 0;
  39 }
  40
  41 static void
  42 tb_clear(PyTracebackObject *tb)
  43 {
  44         Py_CLEAR(tb->tb_next);
  45         Py_CLEAR(tb->tb_frame);
  46 }
  47
  48 PyTypeObject PyTraceBack_Type = {
  49         PyVarObject_HEAD_INIT(&PyType_Type, 0)
  50         "traceback",
  51         sizeof(PyTracebackObject),
  52         0,
  53         (destructor)tb_dealloc, /*tp_dealloc*/
  54         0,              /*tp_print*/
  55         0,              /*tp_getattr*/
  56         0,              /*tp_setattr*/
  57         0,              /*tp_compare*/
  58         0,              /*tp_repr*/
  59         0,              /*tp_as_number*/
  60         0,              /*tp_as_sequence*/
  61         0,              /*tp_as_mapping*/
  62         0,              /* tp_hash */
  63         0,              /* tp_call */
  64         0,              /* tp_str */
  65         0,              /* tp_getattro */
  66         0,              /* tp_setattro */
  67         0,                                      /* tp_as_buffer */
  68         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
  69         0,                                      /* tp_doc */
  70         (traverseproc)tb_traverse,              /* tp_traverse */
  71         (inquiry)tb_clear,                      /* tp_clear */
  72         0,                                      /* tp_richcompare */
  73         0,                                      /* tp_weaklistoffset */
  74         0,                                      /* tp_iter */
  75         0,                                      /* tp_iternext */
  76         0,                                      /* tp_methods */
  77         tb_memberlist,                          /* tp_members */
  78         0,                                      /* tp_getset */
  79         0,                                      /* tp_base */
  80         0,                                      /* tp_dict */
  81 };
  82
  83 static PyTracebackObject *
  84 newtracebackobject(PyTracebackObject *next, PyFrameObject *frame)
  85 {
  86         PyTracebackObject *tb;
  87         if ((next != NULL && !PyTraceBack_Check(next)) ||
  88                         frame == NULL || !PyFrame_Check(frame)) {
  89                 PyErr_BadInternalCall();
  90                 return NULL;
  91         }
  92         tb = PyObject_GC_New(PyTracebackObject, &PyTraceBack_Type);
  93         if (tb != NULL) {
  94                 Py_XINCREF(next);
  95                 tb->tb_next = next;
  96                 Py_XINCREF(frame);
  97                 tb->tb_frame = frame;
  98                 tb->tb_lasti = frame->f_lasti;
  99                 tb->tb_lineno = PyFrame_GetLineNumber(frame);
 100                 PyObject_GC_Track(tb);
 101         }
 102         return tb;
 103 }
 104
 105 int
 106 PyTraceBack_Here(PyFrameObject *frame)
 107 {
 108         PyThreadState *tstate = PyThreadState_GET();
 109         PyTracebackObject *oldtb = (PyTracebackObject *) tstate->curexc_traceback;
 110         PyTracebackObject *tb = newtracebackobject(oldtb, frame);
 111         if (tb == NULL)
 112                 return -1;
 113         tstate->curexc_traceback = (PyObject *)tb;
 114         Py_XDECREF(oldtb);
 115         return 0;
 116 }
 117
 118 int
 119 _Py_DisplaySourceLine(PyObject *f, const char *filename, int lineno, int indent)
 120 {
 121         int err = 0;
 122         FILE *xfp = NULL;
 123         char linebuf[2000];
 124         int i;
 125         char namebuf[MAXPATHLEN+1];
 126
 127         if (filename == NULL)
 128                 return -1;
 129         /* This is needed by Emacs' compile command */
 130 #define FMT "  File \"%.500s\", line %d, in %.500s\n"
 131         xfp = fopen(filename, "r" PY_STDIOTEXTMODE);
 132         if (xfp == NULL) {
 133                 /* Search tail of filename in sys.path before giving up */
 134                 PyObject *path;
 135                 const char *tail = strrchr(filename, SEP);
 136                 if (tail == NULL)
 137                         tail = filename;
 138                 else
 139                         tail++;
 140                 path = PySys_GetObject("path");
 141                 if (path != NULL && PyList_Check(path)) {
 142                         Py_ssize_t _npath = PyList_Size(path);
 143                         int npath = Py_SAFE_DOWNCAST(_npath, Py_ssize_t, int);
 144                         size_t taillen = strlen(tail);
 145                         for (i = 0; i < npath; i++) {
 146                                 PyObject *v = PyList_GetItem(path, i);
 147                                 if (v == NULL) {
 148                                         PyErr_Clear();
 149                                         break;
 150                                 }
 151                                 if (PyString_Check(v)) {
 152                                         size_t len;
 153                                         len = PyString_GET_SIZE(v);
 154                                         if (len + 1 + taillen >= MAXPATHLEN)
 155                                                 continue; /* Too long */
 156                                         strcpy(namebuf, PyString_AsString(v));
 157                                         if (strlen(namebuf) != len)
 158                                                 continue; /* v contains '\0' */
 159                                         if (len > 0 && namebuf[len-1] != SEP)
 160                                                 namebuf[len++] = SEP;
 161                                         strcpy(namebuf+len, tail);
 162                                         xfp = fopen(namebuf, "r" PY_STDIOTEXTMODE);
 163                                         if (xfp != NULL) {
 164                                                 filename = namebuf;
 165                                                 break;
 166                                         }
 167                                 }
 168                         }
 169                 }
 170         }
 171
 172         if (xfp == NULL)
 173             return err;
 174         if (err != 0) {
 175             fclose(xfp);
 176             return err;
 177         }
 178
 179         for (i = 0; i < lineno; i++) {
 180                 char* pLastChar = &linebuf[sizeof(linebuf)-2];
 181                 do {
 182                         *pLastChar = '\0';
 183                         if (Py_UniversalNewlineFgets(linebuf, sizeof linebuf, xfp, NULL) == NULL)
 184                                 break;
 185                         /* fgets read *something*; if it didn't get as
 186                            far as pLastChar, it must have found a newline
 187                            or hit the end of the file;  if pLastChar is \n,
 188                            it obviously found a newline; else we haven't
 189                            yet seen a newline, so must continue */
 190                 } while (*pLastChar != '\0' && *pLastChar != '\n');
 191         }
 192         if (i == lineno) {
 193                 char buf[11];
 194                 char *p = linebuf;
 195                 while (*p == ' ' || *p == '\t' || *p == '\014')
 196                         p++;
 197
 198                 /* Write some spaces before the line */
 199                 strcpy(buf, "          ");
 200                 assert (strlen(buf) == 10);
 201                 while (indent > 0) {
 202                         if(indent < 10)
 203                                 buf[indent] = '\0';
 204                         err = PyFile_WriteString(buf, f);
 205                         if (err != 0)
 206                                 break;
 207                         indent -= 10;
 208                 }
 209
 210                 if (err == 0)
 211                         err = PyFile_WriteString(p, f);
 212                 if (err == 0 && strchr(p, '\n') == NULL)
 213                         err = PyFile_WriteString("\n", f);
 214         }
 215         fclose(xfp);
 216         return err;
 217 }
 218
 219 static int
 220 tb_displayline(PyObject *f, const char *filename, int lineno, const char *name)
 221 {
 222         int err = 0;
 223         char linebuf[2000];
 224
 225         if (filename == NULL || name == NULL)
 226                 return -1;
 227         /* This is needed by Emacs' compile command */
 228 #define FMT "  File \"%.500s\", line %d, in %.500s\n"
 229         PyOS_snprintf(linebuf, sizeof(linebuf), FMT, filename, lineno, name);
 230         err = PyFile_WriteString(linebuf, f);
 231         if (err != 0)
 232                 return err;
 233         return _Py_DisplaySourceLine(f, filename, lineno, 4);
 234 }
 235
 236 static int
 237 tb_printinternal(PyTracebackObject *tb, PyObject *f, long limit)
 238 {
 239         int err = 0;
 240         long depth = 0;
 241         PyTracebackObject *tb1 = tb;
 242         while (tb1 != NULL) {
 243                 depth++;
 244                 tb1 = tb1->tb_next;
 245         }
 246         while (tb != NULL && err == 0) {
 247                 if (depth <= limit) {
 248                         err = tb_displayline(f,
 249                             PyString_AsString(
 250                                     tb->tb_frame->f_code->co_filename),
 251                             tb->tb_lineno,
 252                             PyString_AsString(tb->tb_frame->f_code->co_name));
 253                 }
 254                 depth--;
 255                 tb = tb->tb_next;
 256                 if (err == 0)
 257                         err = PyErr_CheckSignals();
 258         }
 259         return err;
 260 }
 261
 262 int
 263 PyTraceBack_Print(PyObject *v, PyObject *f)
 264 {
 265         int err;
 266         PyObject *limitv;
 267         long limit = 1000;
 268         if (v == NULL)
 269                 return 0;
 270         if (!PyTraceBack_Check(v)) {
 271                 PyErr_BadInternalCall();
 272                 return -1;
 273         }
 274         limitv = PySys_GetObject("tracebacklimit");
 275         if (limitv && PyInt_Check(limitv)) {
 276                 limit = PyInt_AsLong(limitv);
 277                 if (limit <= 0)
 278                         return 0;
 279         }
 280         err = PyFile_WriteString("Traceback (most recent call last):\n", f);
 281         if (!err)
 282                 err = tb_printinternal((PyTracebackObject *)v, f, limit);
 283         return err;
 284 }