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 int
 138 _Py_FindSourceFile(const char* filename, char* namebuf, size_t namelen, int open_flags)
 139 {
 140         int i;
 141         int fd = -1;
 142         PyObject *v;
 143         Py_ssize_t _npath;
 144         int npath;
 145         size_t taillen;
 146         PyObject *syspath;
 147         const char* path;
 148         const char* tail;
 149         Py_ssize_t len;
 150
 151         /* Search tail of filename in sys.path before giving up */
 152         tail = strrchr(filename, SEP);
 153         if (tail == NULL)
 154                 tail = filename;
 155         else
 156                 tail++;
 157         taillen = strlen(tail);
 158
 159         syspath = PySys_GetObject("path");
 160         if (syspath == NULL || !PyList_Check(syspath))
 161                 return -1;
 162         _npath = PyList_Size(syspath);
 163         npath = Py_SAFE_DOWNCAST(_npath, Py_ssize_t, int);
 164
 165         for (i = 0; i < npath; i++) {
 166                 v = PyList_GetItem(syspath, i);
 167                 if (v == NULL) {
 168                         PyErr_Clear();
 169                         break;
 170                 }
 171                 if (!PyUnicode_Check(v))
 172                         continue;
 173                 path = _PyUnicode_AsStringAndSize(v, &len);
 174                 if (len + 1 + (Py_ssize_t)taillen >= (Py_ssize_t)namelen - 1)
 175                         continue; /* Too long */
 176                 strcpy(namebuf, path);
 177                 if (strlen(namebuf) != len)
 178                         continue; /* v contains '\0' */
 179                 if (len > 0 && namebuf[len-1] != SEP)
 180                         namebuf[len++] = SEP;
 181                 strcpy(namebuf+len, tail);
 182                 Py_BEGIN_ALLOW_THREADS
 183                 fd = open(namebuf, open_flags);
 184                 Py_END_ALLOW_THREADS
 185                 if (0 <= fd) {
 186                         return fd;
 187                 }
 188         }
 189         return -1;
 190 }
 191
 192 int
 193 _Py_DisplaySourceLine(PyObject *f, const char *filename, int lineno, int indent)
 194 {
 195         int err = 0;
 196         int fd;
 197         int i;
 198         char *found_encoding;
 199         char *encoding;
 200         PyObject *fob = NULL;
 201         PyObject *lineobj = NULL;
 202 #ifdef O_BINARY
 203         const int open_flags = O_RDONLY | O_BINARY;   /* necessary for Windows */
 204 #else
 205         const int open_flags = O_RDONLY;
 206 #endif
 207         char buf[MAXPATHLEN+1];
 208         Py_UNICODE *u, *p;
 209         Py_ssize_t len;
 210
 211         /* open the file */
 212         if (filename == NULL)
 213                 return 0;
 214         Py_BEGIN_ALLOW_THREADS
 215         fd = open(filename, open_flags);
 216         Py_END_ALLOW_THREADS
 217         if (fd < 0) {
 218                 fd = _Py_FindSourceFile(filename, buf, sizeof(buf), open_flags);
 219                 if (fd < 0)
 220                         return 0;
 221                 filename = buf;
 222         }
 223
 224         /* use the right encoding to decode the file as unicode */
 225         found_encoding = PyTokenizer_FindEncoding(fd);
 226         encoding = (found_encoding != NULL) ? found_encoding :
 227                 (char*)PyUnicode_GetDefaultEncoding();
 228         lseek(fd, 0, 0); /* Reset position */
 229         fob = PyFile_FromFd(fd, (char*)filename, "r", -1, (char*)encoding,
 230                 NULL, NULL, 1);
 231         PyMem_FREE(found_encoding);
 232         if (fob == NULL) {
 233                 PyErr_Clear();
 234                 close(fd);
 235                 return 0;
 236         }
 237
 238         /* get the line number lineno */
 239         for (i = 0; i < lineno; i++) {
 240                 Py_XDECREF(lineobj);
 241                 lineobj = PyFile_GetLine(fob, -1);
 242                 if (!lineobj) {
 243                         err = -1;
 244                         break;
 245                 }
 246         }
 247         Py_DECREF(fob);
 248         if (!lineobj || !PyUnicode_Check(lineobj)) {
 249                 Py_XDECREF(lineobj);
 250                 return err;
 251         }
 252
 253         /* remove the indentation of the line */
 254         u = PyUnicode_AS_UNICODE(lineobj);
 255         len = PyUnicode_GET_SIZE(lineobj);
 256         for (p=u; *p == ' ' || *p == '\t' || *p == '\014'; p++)
 257                 len--;
 258         if (u != p) {
 259                 PyObject *truncated;
 260                 truncated = PyUnicode_FromUnicode(p, len);
 261                 if (truncated) {
 262                         Py_DECREF(lineobj);
 263                         lineobj = truncated;
 264                 } else {
 265                         PyErr_Clear();
 266                 }
 267         }
 268
 269         /* Write some spaces before the line */
 270         strcpy(buf, "          ");
 271         assert (strlen(buf) == 10);
 272         while (indent > 0) {
 273                 if(indent < 10)
 274                         buf[indent] = '\0';
 275                 err = PyFile_WriteString(buf, f);
 276                 if (err != 0)
 277                         break;
 278                 indent -= 10;
 279         }
 280
 281         /* finally display the line */
 282         if (err == 0)
 283                 err = PyFile_WriteObject(lineobj, f, Py_PRINT_RAW);
 284         Py_DECREF(lineobj);
 285         if  (err == 0)
 286                 err = PyFile_WriteString("\n", f);
 287         return err;
 288 }
 289
 290 static int
 291 tb_displayline(PyObject *f, const char *filename, int lineno, const char *name)
 292 {
 293         int err = 0;
 294         char linebuf[2000];
 295
 296         if (filename == NULL || name == NULL)
 297                 return -1;
 298         /* This is needed by Emacs' compile command */
 299 #define FMT "  File \"%.500s\", line %d, in %.500s\n"
 300         PyOS_snprintf(linebuf, sizeof(linebuf), FMT, filename, lineno, name);
 301         err = PyFile_WriteString(linebuf, f);
 302         if (err != 0)
 303                 return err;
 304         return _Py_DisplaySourceLine(f, filename, lineno, 4);
 305 }
 306
 307 static int
 308 tb_printinternal(PyTracebackObject *tb, PyObject *f, long limit)
 309 {
 310         int err = 0;
 311         long depth = 0;
 312         PyTracebackObject *tb1 = tb;
 313         while (tb1 != NULL) {
 314                 depth++;
 315                 tb1 = tb1->tb_next;
 316         }
 317         while (tb != NULL && err == 0) {
 318                 if (depth <= limit) {
 319                         err = tb_displayline(f,
 320                             _PyUnicode_AsString(
 321                                     tb->tb_frame->f_code->co_filename),
 322                             tb->tb_lineno,
 323                             _PyUnicode_AsString(tb->tb_frame->f_code->co_name));
 324                 }
 325                 depth--;
 326                 tb = tb->tb_next;
 327                 if (err == 0)
 328                         err = PyErr_CheckSignals();
 329         }
 330         return err;
 331 }
 332
 333 #define PyTraceBack_LIMIT 1000
 334
 335 int
 336 PyTraceBack_Print(PyObject *v, PyObject *f)
 337 {
 338         int err;
 339         PyObject *limitv;
 340         long limit = PyTraceBack_LIMIT;
 341
 342         if (v == NULL)
 343                 return 0;
 344         if (!PyTraceBack_Check(v)) {
 345                 PyErr_BadInternalCall();
 346                 return -1;
 347         }
 348         limitv = PySys_GetObject("tracebacklimit");
 349         if (limitv) {
 350                 PyObject *exc_type, *exc_value, *exc_tb;
 351
 352                 PyErr_Fetch(&exc_type, &exc_value, &exc_tb);
 353                 limit = PyLong_AsLong(limitv);
 354                 if (limit == -1 && PyErr_Occurred()) {
 355                         if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
 356                                 limit = PyTraceBack_LIMIT;
 357                         }
 358                         else {
 359                                 Py_XDECREF(exc_type);
 360                                 Py_XDECREF(exc_value);
 361                                 Py_XDECREF(exc_tb);
 362                                 return 0;
 363                         }
 364                 }
 365                 else if (limit <= 0) {
 366                         limit = PyTraceBack_LIMIT;
 367                 }
 368                 PyErr_Restore(exc_type, exc_value, exc_tb);
 369         }
 370         err = PyFile_WriteString("Traceback (most recent call last):\n", f);
 371         if (!err)
 372                 err = tb_printinternal((PyTracebackObject *)v, f, limit);
 373         return err;
 374 }