traceback.c 17.2 KB
Newer Older
1

Guido van Rossum's avatar
Guido van Rossum committed
2 3
/* Traceback implementation */

Guido van Rossum's avatar
Guido van Rossum committed
4
#include "Python.h"
Guido van Rossum's avatar
Guido van Rossum committed
5

Jeremy Hylton's avatar
Jeremy Hylton committed
6
#include "code.h"
Guido van Rossum's avatar
Guido van Rossum committed
7 8
#include "frameobject.h"
#include "structmember.h"
9
#include "osdefs.h"
10 11 12
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
Guido van Rossum's avatar
Guido van Rossum committed
13

14
#define OFF(x) offsetof(PyTracebackObject, x)
Guido van Rossum's avatar
Guido van Rossum committed
15

16
#define PUTS(fd, str) write(fd, str, strlen(str))
17
#define MAX_STRING_LENGTH 500
18 19 20
#define MAX_FRAME_DEPTH 100
#define MAX_NTHREADS 100

21 22
/* Function from Parser/tokenizer.c */
extern char * PyTokenizer_FindEncodingFilename(int, PyObject *);
23

24 25 26 27 28 29 30 31 32 33 34 35
static PyObject *
tb_dir(PyTracebackObject *self)
{
    return Py_BuildValue("[ssss]", "tb_frame", "tb_next",
                                   "tb_lasti", "tb_lineno");
}

static PyMethodDef tb_methods[] = {
   {"__dir__", (PyCFunction)tb_dir, METH_NOARGS},
   {NULL, NULL, 0, NULL},
};

36
static PyMemberDef tb_memberlist[] = {
37 38 39 40 41
    {"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 */
Guido van Rossum's avatar
Guido van Rossum committed
42 43 44
};

static void
45
tb_dealloc(PyTracebackObject *tb)
Guido van Rossum's avatar
Guido van Rossum committed
46
{
47 48 49 50 51 52
    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)
Guido van Rossum's avatar
Guido van Rossum committed
53 54
}

55
static int
56
tb_traverse(PyTracebackObject *tb, visitproc visit, void *arg)
57
{
58 59 60
    Py_VISIT(tb->tb_next);
    Py_VISIT(tb->tb_frame);
    return 0;
61 62 63
}

static void
64
tb_clear(PyTracebackObject *tb)
65
{
66 67
    Py_CLEAR(tb->tb_next);
    Py_CLEAR(tb->tb_frame);
68 69
}

70
PyTypeObject PyTraceBack_Type = {
71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102
    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_reserved*/
    0,                  /*tp_repr*/
    0,                  /*tp_as_number*/
    0,                  /*tp_as_sequence*/
    0,                  /*tp_as_mapping*/
    0,                  /* tp_hash */
    0,                  /* tp_call */
    0,                  /* tp_str */
    PyObject_GenericGetAttr,                    /* 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 */
    tb_methods,         /* tp_methods */
    tb_memberlist,      /* tp_members */
    0,                                          /* tp_getset */
    0,                                          /* tp_base */
    0,                                          /* tp_dict */
Guido van Rossum's avatar
Guido van Rossum committed
103 104
};

105 106
static PyTracebackObject *
newtracebackobject(PyTracebackObject *next, PyFrameObject *frame)
Guido van Rossum's avatar
Guido van Rossum committed
107
{
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124
    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;
Guido van Rossum's avatar
Guido van Rossum committed
125 126 127
}

int
128
PyTraceBack_Here(PyFrameObject *frame)
Guido van Rossum's avatar
Guido van Rossum committed
129
{
130 131 132 133 134 135 136 137
    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;
Guido van Rossum's avatar
Guido van Rossum committed
138 139
}

140 141
static PyObject *
_Py_FindSourceFile(PyObject *filename, char* namebuf, size_t namelen, PyObject *io)
142
{
143 144
    Py_ssize_t i;
    PyObject *binary;
145
    PyObject *v;
146
    Py_ssize_t npath;
147 148
    size_t taillen;
    PyObject *syspath;
149
    PyObject *path;
150
    const char* tail;
151
    PyObject *filebytes;
152
    const char* filepath;
153
    Py_ssize_t len;
154
    PyObject* result;
155
    _Py_IDENTIFIER(open);
156

157 158
    filebytes = PyUnicode_EncodeFSDefault(filename);
    if (filebytes == NULL) {
159 160 161
        PyErr_Clear();
        return NULL;
    }
162
    filepath = PyBytes_AS_STRING(filebytes);
163

164
    /* Search tail of filename in sys.path before giving up */
165
    tail = strrchr(filepath, SEP);
166
    if (tail == NULL)
167
        tail = filepath;
168 169 170 171 172 173
    else
        tail++;
    taillen = strlen(tail);

    syspath = PySys_GetObject("path");
    if (syspath == NULL || !PyList_Check(syspath))
174
        goto error;
175
    npath = PyList_Size(syspath);
176 177 178 179 180 181 182 183 184

    for (i = 0; i < npath; i++) {
        v = PyList_GetItem(syspath, i);
        if (v == NULL) {
            PyErr_Clear();
            break;
        }
        if (!PyUnicode_Check(v))
            continue;
185
        path = PyUnicode_EncodeFSDefault(v);
186 187 188 189
        if (path == NULL) {
            PyErr_Clear();
            continue;
        }
190 191 192
        len = PyBytes_GET_SIZE(path);
        if (len + 1 + (Py_ssize_t)taillen >= (Py_ssize_t)namelen - 1) {
            Py_DECREF(path);
193
            continue; /* Too long */
194 195 196
        }
        strcpy(namebuf, PyBytes_AS_STRING(path));
        Py_DECREF(path);
197 198 199 200 201
        if (strlen(namebuf) != len)
            continue; /* v contains '\0' */
        if (len > 0 && namebuf[len-1] != SEP)
            namebuf[len++] = SEP;
        strcpy(namebuf+len, tail);
202

203
        binary = _PyObject_CallMethodId(io, &PyId_open, "ss", namebuf, "rb");
204 205 206 207
        if (binary != NULL) {
            result = binary;
            goto finally;
        }
208
        PyErr_Clear();
209
    }
210 211 212 213 214 215 216
    goto error;

error:
    result = NULL;
finally:
    Py_DECREF(filebytes);
    return result;
217 218
}

Christian Heimes's avatar
Christian Heimes committed
219
int
220
_Py_DisplaySourceLine(PyObject *f, PyObject *filename, int lineno, int indent)
Guido van Rossum's avatar
Guido van Rossum committed
221
{
222 223 224 225 226
    int err = 0;
    int fd;
    int i;
    char *found_encoding;
    char *encoding;
227 228
    PyObject *io;
    PyObject *binary;
229 230
    PyObject *fob = NULL;
    PyObject *lineobj = NULL;
231
    PyObject *res;
232
    char buf[MAXPATHLEN+1];
Martin v. Löwis's avatar
Martin v. Löwis committed
233 234
    int kind;
    void *data;
235 236 237
    _Py_IDENTIFIER(close);
    _Py_IDENTIFIER(open);
    _Py_IDENTIFIER(TextIOWrapper);
238 239 240 241

    /* open the file */
    if (filename == NULL)
        return 0;
242 243 244 245

    io = PyImport_ImportModuleNoBlock("io");
    if (io == NULL)
        return -1;
246
    binary = _PyObject_CallMethodId(io, &PyId_open, "Os", filename, "rb");
247 248 249 250 251

    if (binary == NULL) {
        binary = _Py_FindSourceFile(filename, buf, sizeof(buf), io);
        if (binary == NULL) {
            Py_DECREF(io);
252
            return 0;
253
        }
254 255 256
    }

    /* use the right encoding to decode the file as unicode */
257
    fd = PyObject_AsFileDescriptor(binary);
258 259 260
    if (fd < 0) {
        Py_DECREF(io);
        Py_DECREF(binary);
261
        return 0;
262
    }
263
    found_encoding = PyTokenizer_FindEncodingFilename(fd, filename);
264
    encoding = (found_encoding != NULL) ? found_encoding : "utf-8";
265 266 267 268 269
    /* Reset position */
    if (lseek(fd, 0, SEEK_SET) == (off_t)-1) {
        Py_DECREF(io);
        Py_DECREF(binary);
        PyMem_FREE(found_encoding);
270
        return 0;
271
    }
272
    fob = _PyObject_CallMethodId(io, &PyId_TextIOWrapper, "Os", binary, encoding);
273 274
    Py_DECREF(io);
    Py_DECREF(binary);
275
    PyMem_FREE(found_encoding);
276

277 278 279 280 281 282 283 284 285 286 287 288 289 290
    if (fob == NULL) {
        PyErr_Clear();
        return 0;
    }

    /* get the line number lineno */
    for (i = 0; i < lineno; i++) {
        Py_XDECREF(lineobj);
        lineobj = PyFile_GetLine(fob, -1);
        if (!lineobj) {
            err = -1;
            break;
        }
    }
291
    res = _PyObject_CallMethodId(fob, &PyId_close, "");
292 293 294 295
    if (res)
        Py_DECREF(res);
    else
        PyErr_Clear();
296 297 298 299 300 301 302
    Py_DECREF(fob);
    if (!lineobj || !PyUnicode_Check(lineobj)) {
        Py_XDECREF(lineobj);
        return err;
    }

    /* remove the indentation of the line */
Martin v. Löwis's avatar
Martin v. Löwis committed
303 304 305 306 307 308 309 310
    kind = PyUnicode_KIND(lineobj);
    data = PyUnicode_DATA(lineobj);
    for (i=0; i < PyUnicode_GET_LENGTH(lineobj); i++) {
        Py_UCS4 ch = PyUnicode_READ(kind, data, i);
        if (ch != ' ' && ch != '\t' && ch != '\014')
            break;
    }
    if (i) {
311
        PyObject *truncated;
Martin v. Löwis's avatar
Martin v. Löwis committed
312
        truncated = PyUnicode_Substring(lineobj, i, PyUnicode_GET_LENGTH(lineobj));
313 314 315 316 317 318 319 320 321 322 323 324
        if (truncated) {
            Py_DECREF(lineobj);
            lineobj = truncated;
        } else {
            PyErr_Clear();
        }
    }

    /* Write some spaces before the line */
    strcpy(buf, "          ");
    assert (strlen(buf) == 10);
    while (indent > 0) {
Benjamin Peterson's avatar
Benjamin Peterson committed
325
        if (indent < 10)
326 327 328 329 330 331 332 333 334 335 336 337 338 339
            buf[indent] = '\0';
        err = PyFile_WriteString(buf, f);
        if (err != 0)
            break;
        indent -= 10;
    }

    /* finally display the line */
    if (err == 0)
        err = PyFile_WriteObject(lineobj, f, Py_PRINT_RAW);
    Py_DECREF(lineobj);
    if  (err == 0)
        err = PyFile_WriteString("\n", f);
    return err;
Guido van Rossum's avatar
Guido van Rossum committed
340 341
}

342
static int
343
tb_displayline(PyObject *f, PyObject *filename, int lineno, PyObject *name)
Christian Heimes's avatar
Christian Heimes committed
344
{
345 346
    int err;
    PyObject *line;
Christian Heimes's avatar
Christian Heimes committed
347

348 349
    if (filename == NULL || name == NULL)
        return -1;
350 351 352 353 354 355
    line = PyUnicode_FromFormat("  File \"%U\", line %d, in %U\n",
                                filename, lineno, name);
    if (line == NULL)
        return -1;
    err = PyFile_WriteObject(line, f, Py_PRINT_RAW);
    Py_DECREF(line);
356 357
    if (err != 0)
        return err;
358 359 360 361
    /* ignore errors since we can't report them, can we? */
    if (_Py_DisplaySourceLine(f, filename, lineno, 4))
        PyErr_Clear();
    return err;
Christian Heimes's avatar
Christian Heimes committed
362 363 364 365
}

static int
tb_printinternal(PyTracebackObject *tb, PyObject *f, long limit)
Guido van Rossum's avatar
Guido van Rossum committed
366
{
367 368 369 370 371 372 373 374 375 376
    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,
377 378 379
                                 tb->tb_frame->f_code->co_filename,
                                 tb->tb_lineno,
                                 tb->tb_frame->f_code->co_name);
380 381 382 383 384 385 386
        }
        depth--;
        tb = tb->tb_next;
        if (err == 0)
            err = PyErr_CheckSignals();
    }
    return err;
Guido van Rossum's avatar
Guido van Rossum committed
387 388
}

389 390
#define PyTraceBack_LIMIT 1000

Guido van Rossum's avatar
Guido van Rossum committed
391
int
392
PyTraceBack_Print(PyObject *v, PyObject *f)
Guido van Rossum's avatar
Guido van Rossum committed
393
{
394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429
    int err;
    PyObject *limitv;
    long limit = PyTraceBack_LIMIT;

    if (v == NULL)
        return 0;
    if (!PyTraceBack_Check(v)) {
        PyErr_BadInternalCall();
        return -1;
    }
    limitv = PySys_GetObject("tracebacklimit");
    if (limitv) {
        PyObject *exc_type, *exc_value, *exc_tb;

        PyErr_Fetch(&exc_type, &exc_value, &exc_tb);
        limit = PyLong_AsLong(limitv);
        if (limit == -1 && PyErr_Occurred()) {
            if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
                limit = PyTraceBack_LIMIT;
            }
            else {
                Py_XDECREF(exc_type);
                Py_XDECREF(exc_value);
                Py_XDECREF(exc_tb);
                return 0;
            }
        }
        else if (limit <= 0) {
            limit = PyTraceBack_LIMIT;
        }
        PyErr_Restore(exc_type, exc_value, exc_tb);
    }
    err = PyFile_WriteString("Traceback (most recent call last):\n", f);
    if (!err)
        err = tb_printinternal((PyTracebackObject *)v, f, limit);
    return err;
Guido van Rossum's avatar
Guido van Rossum committed
430
}
431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483

/* Reverse a string. For example, "abcd" becomes "dcba".

   This function is signal safe. */

static void
reverse_string(char *text, const size_t len)
{
    char tmp;
    size_t i, j;
    if (len == 0)
        return;
    for (i=0, j=len-1; i < j; i++, j--) {
        tmp = text[i];
        text[i] = text[j];
        text[j] = tmp;
    }
}

/* Format an integer in range [0; 999999] to decimal,
   and write it into the file fd.

   This function is signal safe. */

static void
dump_decimal(int fd, int value)
{
    char buffer[7];
    int len;
    if (value < 0 || 999999 < value)
        return;
    len = 0;
    do {
        buffer[len] = '0' + (value % 10);
        value /= 10;
        len++;
    } while (value);
    reverse_string(buffer, len);
    write(fd, buffer, len);
}

/* Format an integer in range [0; 0xffffffff] to hexdecimal of 'width' digits,
   and write it into the file fd.

   This function is signal safe. */

static void
dump_hexadecimal(int width, unsigned long value, int fd)
{
    int len;
    char buffer[sizeof(unsigned long) * 2 + 1];
    len = 0;
    do {
484
        buffer[len] = Py_hexdigits[value & 15];
485 486 487 488 489 490 491 492 493 494 495 496 497 498
        value >>= 4;
        len++;
    } while (len < width || value);
    reverse_string(buffer, len);
    write(fd, buffer, len);
}

/* Write an unicode object into the file fd using ascii+backslashreplace.

   This function is signal safe. */

static void
dump_ascii(int fd, PyObject *text)
{
Martin v. Löwis's avatar
Martin v. Löwis committed
499
    PyASCIIObject *ascii = (PyASCIIObject *)text;
500 501
    Py_ssize_t i, size;
    int truncated;
Martin v. Löwis's avatar
Martin v. Löwis committed
502
    int kind;
503 504
    void *data = NULL;
    wchar_t *wstr = NULL;
Martin v. Löwis's avatar
Martin v. Löwis committed
505 506 507 508 509 510 511 512 513 514
    Py_UCS4 ch;

    size = ascii->length;
    kind = ascii->state.kind;
    if (ascii->state.compact) {
        if (ascii->state.ascii)
            data = ((PyASCIIObject*)text) + 1;
        else
            data = ((PyCompactUnicodeObject*)text) + 1;
    }
515
    else if (kind != PyUnicode_WCHAR_KIND) {
Martin v. Löwis's avatar
Martin v. Löwis committed
516 517 518 519
        data = ((PyUnicodeObject *)text)->data.any;
        if (data == NULL)
            return;
    }
520 521 522 523 524 525
    else {
        wstr = ((PyASCIIObject *)text)->wstr;
        if (wstr == NULL)
            return;
        size = ((PyCompactUnicodeObject *)text)->wstr_length;
    }
526 527 528 529 530 531 532 533

    if (MAX_STRING_LENGTH < size) {
        size = MAX_STRING_LENGTH;
        truncated = 1;
    }
    else
        truncated = 0;

Martin v. Löwis's avatar
Martin v. Löwis committed
534
    for (i=0; i < size; i++) {
535 536 537 538
        if (kind != PyUnicode_WCHAR_KIND)
            ch = PyUnicode_READ(kind, data, i);
        else
            ch = wstr[i];
Martin v. Löwis's avatar
Martin v. Löwis committed
539 540
        if (ch < 128) {
            char c = (char)ch;
541 542
            write(fd, &c, 1);
        }
543
        else if (ch < 0xff) {
544
            PUTS(fd, "\\x");
Martin v. Löwis's avatar
Martin v. Löwis committed
545
            dump_hexadecimal(2, ch, fd);
546
        }
547
        else if (ch < 0xffff) {
548
            PUTS(fd, "\\u");
Martin v. Löwis's avatar
Martin v. Löwis committed
549
            dump_hexadecimal(4, ch, fd);
550 551 552
        }
        else {
            PUTS(fd, "\\U");
Martin v. Löwis's avatar
Martin v. Löwis committed
553
            dump_hexadecimal(8, ch, fd);
554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582
        }
    }
    if (truncated)
        PUTS(fd, "...");
}

/* Write a frame into the file fd: "File "xxx", line xxx in xxx".

   This function is signal safe. */

static void
dump_frame(int fd, PyFrameObject *frame)
{
    PyCodeObject *code;
    int lineno;

    code = frame->f_code;
    PUTS(fd, "  File ");
    if (code != NULL && code->co_filename != NULL
        && PyUnicode_Check(code->co_filename))
    {
        write(fd, "\"", 1);
        dump_ascii(fd, code->co_filename);
        write(fd, "\"", 1);
    } else {
        PUTS(fd, "???");
    }

    /* PyFrame_GetLineNumber() was introduced in Python 2.7.0 and 3.2.0 */
Martin v. Löwis's avatar
Martin v. Löwis committed
583
    lineno = PyCode_Addr2Line(code, frame->f_lasti);
584 585 586 587 588 589 590 591 592 593 594 595 596
    PUTS(fd, ", line ");
    dump_decimal(fd, lineno);
    PUTS(fd, " in ");

    if (code != NULL && code->co_name != NULL
        && PyUnicode_Check(code->co_name))
        dump_ascii(fd, code->co_name);
    else
        PUTS(fd, "???");

    write(fd, "\n", 1);
}

597
static void
598 599 600 601 602
dump_traceback(int fd, PyThreadState *tstate, int write_header)
{
    PyFrameObject *frame;
    unsigned int depth;

603 604 605
    if (write_header)
        PUTS(fd, "Traceback (most recent call first):\n");

606 607
    frame = _PyThreadState_GetFrame(tstate);
    if (frame == NULL)
608
        return;
609 610 611 612 613 614 615 616 617 618 619 620 621 622 623

    depth = 0;
    while (frame != NULL) {
        if (MAX_FRAME_DEPTH <= depth) {
            PUTS(fd, "  ...\n");
            break;
        }
        if (!PyFrame_Check(frame))
            break;
        dump_frame(fd, frame);
        frame = frame->f_back;
        depth++;
    }
}

624
void
625 626
_Py_DumpTraceback(int fd, PyThreadState *tstate)
{
627
    dump_traceback(fd, tstate, 1);
628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677
}

/* Write the thread identifier into the file 'fd': "Current thread 0xHHHH:\" if
   is_current is true, "Thread 0xHHHH:\n" otherwise.

   This function is signal safe. */

static void
write_thread_id(int fd, PyThreadState *tstate, int is_current)
{
    if (is_current)
        PUTS(fd, "Current thread 0x");
    else
        PUTS(fd, "Thread 0x");
    dump_hexadecimal(sizeof(long)*2, (unsigned long)tstate->thread_id, fd);
    PUTS(fd, ":\n");
}

const char*
_Py_DumpTracebackThreads(int fd, PyInterpreterState *interp,
                         PyThreadState *current_thread)
{
    PyThreadState *tstate;
    unsigned int nthreads;

    /* Get the current interpreter from the current thread */
    tstate = PyInterpreterState_ThreadHead(interp);
    if (tstate == NULL)
        return "unable to get the thread head state";

    /* Dump the traceback of each thread */
    tstate = PyInterpreterState_ThreadHead(interp);
    nthreads = 0;
    do
    {
        if (nthreads != 0)
            write(fd, "\n", 1);
        if (nthreads >= MAX_NTHREADS) {
            PUTS(fd, "...\n");
            break;
        }
        write_thread_id(fd, tstate, tstate == current_thread);
        dump_traceback(fd, tstate, 0);
        tstate = PyThreadState_Next(tstate);
        nthreads++;
    } while (tstate != NULL);

    return NULL;
}