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 #ifdef HAVE_FCNTL_H
  12 #include <fcntl.h>
  13 #endif
  14
  15 #define OFF(x) offsetof(PyTracebackObject, x)
  16
  17 /* Method from Parser/tokenizer.c */
  18 extern char * PyTokenizer_FindEncoding(int);
  19
  20 static PyObject *
  21 tb_dir(PyTracebackObject *self)
  22 {
  23     return Py_BuildValue("[ssss]", "tb_frame", "tb_next",
  24                                    "tb_lasti", "tb_lineno");
  25 }
  26
  27 static PyMethodDef tb_methods[] = {
  28    {"__dir__", (PyCFunction)tb_dir, METH_NOARGS},
  29    {NULL, NULL, 0, NULL},
  30 };
  31
  32 static PyMemberDef tb_memberlist[] = {
  33     {"tb_next",         T_OBJECT,       OFF(tb_next),   READONLY},
  34     {"tb_frame",        T_OBJECT,       OFF(tb_frame),  READONLY},
  35     {"tb_lasti",        T_INT,          OFF(tb_lasti),  READONLY},
  36     {"tb_lineno",       T_INT,          OFF(tb_lineno), READONLY},
  37     {NULL}      /* Sentinel */
  38 };
  39
  40 static void
  41 tb_dealloc(PyTracebackObject *tb)
  42 {
  43     PyObject_GC_UnTrack(tb);
  44     Py_TRASHCAN_SAFE_BEGIN(tb)
  45     Py_XDECREF(tb->tb_next);
  46     Py_XDECREF(tb->tb_frame);
  47     PyObject_GC_Del(tb);
  48     Py_TRASHCAN_SAFE_END(tb)
  49 }
  50
  51 static int
  52 tb_traverse(PyTracebackObject *tb, visitproc visit, void *arg)
  53 {
  54     Py_VISIT(tb->tb_next);
  55     Py_VISIT(tb->tb_frame);
  56     return 0;
  57 }
  58
  59 static void
  60 tb_clear(PyTracebackObject *tb)
  61 {
  62     Py_CLEAR(tb->tb_next);
  63     Py_CLEAR(tb->tb_frame);
  64 }
  65
  66 PyTypeObject PyTraceBack_Type = {
  67     PyVarObject_HEAD_INIT(&PyType_Type, 0)
  68     "traceback",
  69     sizeof(PyTracebackObject),
  70     0,
  71     (destructor)tb_dealloc, /*tp_dealloc*/
  72     0,                  /*tp_print*/
  73     0,    /*tp_getattr*/
  74     0,                  /*tp_setattr*/
  75     0,                  /*tp_reserved*/
  76     0,                  /*tp_repr*/
  77     0,                  /*tp_as_number*/
  78     0,                  /*tp_as_sequence*/
  79     0,                  /*tp_as_mapping*/
  80     0,                  /* tp_hash */
  81     0,                  /* tp_call */
  82     0,                  /* tp_str */
  83     PyObject_GenericGetAttr,                    /* tp_getattro */
  84     0,                  /* tp_setattro */
  85     0,                                          /* tp_as_buffer */
  86     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
  87     0,                                          /* tp_doc */
  88     (traverseproc)tb_traverse,                  /* tp_traverse */
  89     (inquiry)tb_clear,                          /* tp_clear */
  90     0,                                          /* tp_richcompare */
  91     0,                                          /* tp_weaklistoffset */
  92     0,                                          /* tp_iter */
  93     0,                                          /* tp_iternext */
  94     tb_methods,         /* tp_methods */
  95     tb_memberlist,      /* tp_members */
  96     0,                                          /* tp_getset */
  97     0,                                          /* tp_base */
  98     0,                                          /* tp_dict */
  99 };
 100
 101 static PyTracebackObject *
 102 newtracebackobject(PyTracebackObject *next, PyFrameObject *frame)
 103 {
 104     PyTracebackObject *tb;
 105     if ((next != NULL && !PyTraceBack_Check(next)) ||
 106                     frame == NULL || !PyFrame_Check(frame)) {
 107         PyErr_BadInternalCall();
 108         return NULL;
 109     }
 110     tb = PyObject_GC_New(PyTracebackObject, &PyTraceBack_Type);
 111     if (tb != NULL) {
 112         Py_XINCREF(next);
 113         tb->tb_next = next;
 114         Py_XINCREF(frame);
 115         tb->tb_frame = frame;
 116         tb->tb_lasti = frame->f_lasti;
 117         tb->tb_lineno = PyCode_Addr2Line(frame->f_code,
 118                                          frame->f_lasti);
 119         PyObject_GC_Track(tb);
 120     }
 121     return tb;
 122 }
 123
 124 int
 125 PyTraceBack_Here(PyFrameObject *frame)
 126 {
 127     PyThreadState *tstate = PyThreadState_GET();
 128     PyTracebackObject *oldtb = (PyTracebackObject *) tstate->curexc_traceback;
 129     PyTracebackObject *tb = newtracebackobject(oldtb, frame);
 130     if (tb == NULL)
 131         return -1;
 132     tstate->curexc_traceback = (PyObject *)tb;
 133     Py_XDECREF(oldtb);
 134     return 0;
 135 }
 136
 137 static PyObject *
 138 _Py_FindSourceFile(PyObject *filename, char* namebuf, size_t namelen, PyObject *io)
 139 {
 140     Py_ssize_t i;
 141     PyObject *binary;
 142     PyObject *v;
 143     Py_ssize_t npath;
 144     size_t taillen;
 145     PyObject *syspath;
 146     PyObject *path;
 147     const char* tail;
 148     PyObject *filebytes;
 149     const char* filepath;
 150     Py_ssize_t len;
 151     PyObject* result;
 152
 153     filebytes = PyUnicode_AsEncodedObject(filename,
 154         Py_FileSystemDefaultEncoding, "surrogateescape");
 155     if (filebytes == NULL) {
 156         PyErr_Clear();
 157         return NULL;
 158     }
 159     filepath = PyBytes_AS_STRING(filebytes);
 160
 161     /* Search tail of filename in sys.path before giving up */
 162     tail = strrchr(filepath, SEP);
 163     if (tail == NULL)
 164         tail = filepath;
 165     else
 166         tail++;
 167     taillen = strlen(tail);
 168
 169     syspath = PySys_GetObject("path");
 170     if (syspath == NULL || !PyList_Check(syspath))
 171         goto error;
 172     npath = PyList_Size(syspath);
 173
 174     for (i = 0; i < npath; i++) {
 175         v = PyList_GetItem(syspath, i);
 176         if (v == NULL) {
 177             PyErr_Clear();
 178             break;
 179         }
 180         if (!PyUnicode_Check(v))
 181             continue;
 182
 183         path = PyUnicode_AsEncodedObject(v, Py_FileSystemDefaultEncoding,
 184                                          "surrogateescape");
 185         if (path == NULL) {
 186             PyErr_Clear();
 187             continue;
 188         }
 189         len = PyBytes_GET_SIZE(path);
 190         if (len + 1 + (Py_ssize_t)taillen >= (Py_ssize_t)namelen - 1) {
 191             Py_DECREF(path);
 192             continue; /* Too long */
 193         }
 194         strcpy(namebuf, PyBytes_AS_STRING(path));
 195         Py_DECREF(path);
 196         if (strlen(namebuf) != len)
 197             continue; /* v contains '\0' */
 198         if (len > 0 && namebuf[len-1] != SEP)
 199             namebuf[len++] = SEP;
 200         strcpy(namebuf+len, tail);
 201
 202         binary = PyObject_CallMethod(io, "open", "ss", namebuf, "rb");
 203         if (binary != NULL) {
 204             result = binary;
 205             goto finally;
 206         }
 207         PyErr_Clear();
 208     }
 209     goto error;
 210
 211 error:
 212     result = NULL;
 213 finally:
 214     Py_DECREF(filebytes);
 215     return result;
 216 }
 217
 218 int
 219 _Py_DisplaySourceLine(PyObject *f, PyObject *filename, int lineno, int indent)
 220 {
 221     int err = 0;
 222     int fd;
 223     int i;
 224     char *found_encoding;
 225     char *encoding;
 226     PyObject *io;
 227     PyObject *binary;
 228     PyObject *fob = NULL;
 229     PyObject *lineobj = NULL;
 230     PyObject *res;
 231     char buf[MAXPATHLEN+1];
 232     Py_UNICODE *u, *p;
 233     Py_ssize_t len;
 234
 235     /* open the file */
 236     if (filename == NULL)
 237         return 0;
 238
 239     io = PyImport_ImportModuleNoBlock("io");
 240     if (io == NULL)
 241         return -1;
 242     binary = PyObject_CallMethod(io, "open", "Os", filename, "rb");
 243
 244     if (binary == NULL) {
 245         binary = _Py_FindSourceFile(filename, buf, sizeof(buf), io);
 246         if (binary == NULL) {
 247             Py_DECREF(io);
 248             return 0;
 249         }
 250     }
 251
 252     /* use the right encoding to decode the file as unicode */
 253     fd = PyObject_AsFileDescriptor(binary);
 254     found_encoding = PyTokenizer_FindEncoding(fd);
 255     encoding = (found_encoding != NULL) ? found_encoding : "utf-8";
 256     lseek(fd, 0, 0); /* Reset position */
 257     fob = PyObject_CallMethod(io, "TextIOWrapper", "Os", binary, encoding);
 258     Py_DECREF(io);
 259     Py_DECREF(binary);
 260     PyMem_FREE(found_encoding);
 261
 262     if (fob == NULL) {
 263         PyErr_Clear();
 264         return 0;
 265     }
 266
 267     /* get the line number lineno */
 268     for (i = 0; i < lineno; i++) {
 269         Py_XDECREF(lineobj);
 270         lineobj = PyFile_GetLine(fob, -1);
 271         if (!lineobj) {
 272             err = -1;
 273             break;
 274         }
 275     }
 276     res = PyObject_CallMethod(fob, "close", "");
 277     if (res)
 278         Py_DECREF(res);
 279     else
 280         PyErr_Clear();
 281     Py_DECREF(fob);
 282     if (!lineobj || !PyUnicode_Check(lineobj)) {
 283         Py_XDECREF(lineobj);
 284         return err;
 285     }
 286
 287     /* remove the indentation of the line */
 288     u = PyUnicode_AS_UNICODE(lineobj);
 289     len = PyUnicode_GET_SIZE(lineobj);
 290     for (p=u; *p == ' ' || *p == '\t' || *p == '\014'; p++)
 291         len--;
 292     if (u != p) {
 293         PyObject *truncated;
 294         truncated = PyUnicode_FromUnicode(p, len);
 295         if (truncated) {
 296             Py_DECREF(lineobj);
 297             lineobj = truncated;
 298         } else {
 299             PyErr_Clear();
 300         }
 301     }
 302
 303     /* Write some spaces before the line */
 304     strcpy(buf, "          ");
 305     assert (strlen(buf) == 10);
 306     while (indent > 0) {
 307         if(indent < 10)
 308             buf[indent] = '\0';
 309         err = PyFile_WriteString(buf, f);
 310         if (err != 0)
 311             break;
 312         indent -= 10;
 313     }
 314
 315     /* finally display the line */
 316     if (err == 0)
 317         err = PyFile_WriteObject(lineobj, f, Py_PRINT_RAW);
 318     Py_DECREF(lineobj);
 319     if  (err == 0)
 320         err = PyFile_WriteString("\n", f);
 321     return err;
 322 }
 323
 324 static int
 325 tb_displayline(PyObject *f, PyObject *filename, int lineno, PyObject *name)
 326 {
 327     int err;
 328     PyObject *line;
 329
 330     if (filename == NULL || name == NULL)
 331         return -1;
 332     line = PyUnicode_FromFormat("  File \"%U\", line %d, in %U\n",
 333                                 filename, lineno, name);
 334     if (line == NULL)
 335         return -1;
 336     err = PyFile_WriteObject(line, f, Py_PRINT_RAW);
 337     Py_DECREF(line);
 338     if (err != 0)
 339         return err;
 340     return _Py_DisplaySourceLine(f, filename, lineno, 4);
 341 }
 342
 343 static int
 344 tb_printinternal(PyTracebackObject *tb, PyObject *f, long limit)
 345 {
 346     int err = 0;
 347     long depth = 0;
 348     PyTracebackObject *tb1 = tb;
 349     while (tb1 != NULL) {
 350         depth++;
 351         tb1 = tb1->tb_next;
 352     }
 353     while (tb != NULL && err == 0) {
 354         if (depth <= limit) {
 355             err = tb_displayline(f,
 356                                  tb->tb_frame->f_code->co_filename,
 357                                  tb->tb_lineno,
 358                                  tb->tb_frame->f_code->co_name);
 359         }
 360         depth--;
 361         tb = tb->tb_next;
 362         if (err == 0)
 363             err = PyErr_CheckSignals();
 364     }
 365     return err;
 366 }
 367
 368 #define PyTraceBack_LIMIT 1000
 369
 370 int
 371 PyTraceBack_Print(PyObject *v, PyObject *f)
 372 {
 373     int err;
 374     PyObject *limitv;
 375     long limit = PyTraceBack_LIMIT;
 376
 377     if (v == NULL)
 378         return 0;
 379     if (!PyTraceBack_Check(v)) {
 380         PyErr_BadInternalCall();
 381         return -1;
 382     }
 383     limitv = PySys_GetObject("tracebacklimit");
 384     if (limitv) {
 385         PyObject *exc_type, *exc_value, *exc_tb;
 386
 387         PyErr_Fetch(&exc_type, &exc_value, &exc_tb);
 388         limit = PyLong_AsLong(limitv);
 389         if (limit == -1 && PyErr_Occurred()) {
 390             if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
 391                 limit = PyTraceBack_LIMIT;
 392             }
 393             else {
 394                 Py_XDECREF(exc_type);
 395                 Py_XDECREF(exc_value);
 396                 Py_XDECREF(exc_tb);
 397                 return 0;
 398             }
 399         }
 400         else if (limit <= 0) {
 401             limit = PyTraceBack_LIMIT;
 402         }
 403         PyErr_Restore(exc_type, exc_value, exc_tb);
 404     }
 405     err = PyFile_WriteString("Traceback (most recent call last):\n", f);
 406     if (!err)
 407         err = tb_printinternal((PyTracebackObject *)v, f, limit);
 408     return err;
 409 }