blob: 7d1fc2e8acc99bdcea3ef1dad280847ac9a8d009 [file] [log] [blame]
Guido van Rossumf70e43a1991-02-19 12:39:46 +00001
Guido van Rossum3f5da241990-12-20 15:06:42 +00002/* Traceback implementation */
3
Guido van Rossum65bf9f21997-04-29 18:33:38 +00004#include "Python.h"
Guido van Rossum3f5da241990-12-20 15:06:42 +00005
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00006#include "code.h"
Guido van Rossum3f5da241990-12-20 15:06:42 +00007#include "frameobject.h"
Guido van Rossum3f5da241990-12-20 15:06:42 +00008#include "structmember.h"
Guido van Rossum7169dbb1992-02-26 15:17:59 +00009#include "osdefs.h"
Amaury Forgeot d'Arccf8016a2008-10-09 23:37:48 +000010#ifdef HAVE_FCNTL_H
11#include <fcntl.h>
12#endif
Guido van Rossum3f5da241990-12-20 15:06:42 +000013
Nicholas Bastina7604bf2004-03-21 18:37:23 +000014#define OFF(x) offsetof(PyTracebackObject, x)
Guido van Rossum3f5da241990-12-20 15:06:42 +000015
Victor Stinner84bb1cf2013-05-17 00:12:04 +020016#define PUTS(fd, str) write(fd, str, (int)strlen(str))
Victor Stinner54f939b2012-07-30 13:08:58 +020017#define MAX_STRING_LENGTH 500
Victor Stinner024e37a2011-03-31 01:31:06 +020018#define MAX_FRAME_DEPTH 100
19#define MAX_NTHREADS 100
20
Victor Stinnerfe7c5b52011-04-05 01:48:03 +020021/* Function from Parser/tokenizer.c */
22extern char * PyTokenizer_FindEncodingFilename(int, PyObject *);
Amaury Forgeot d'Arccf8016a2008-10-09 23:37:48 +000023
Victor Stinnerbd303c12013-11-07 23:07:29 +010024_Py_IDENTIFIER(TextIOWrapper);
25_Py_IDENTIFIER(close);
26_Py_IDENTIFIER(open);
27_Py_IDENTIFIER(path);
28
Collin Winter3eed7652007-08-14 17:53:54 +000029static PyObject *
30tb_dir(PyTracebackObject *self)
31{
32 return Py_BuildValue("[ssss]", "tb_frame", "tb_next",
33 "tb_lasti", "tb_lineno");
34}
35
36static PyMethodDef tb_methods[] = {
37 {"__dir__", (PyCFunction)tb_dir, METH_NOARGS},
38 {NULL, NULL, 0, NULL},
39};
40
Neal Norwitz8dfc4a92007-08-11 06:39:53 +000041static PyMemberDef tb_memberlist[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000042 {"tb_next", T_OBJECT, OFF(tb_next), READONLY},
43 {"tb_frame", T_OBJECT, OFF(tb_frame), READONLY},
44 {"tb_lasti", T_INT, OFF(tb_lasti), READONLY},
45 {"tb_lineno", T_INT, OFF(tb_lineno), READONLY},
46 {NULL} /* Sentinel */
Guido van Rossum3f5da241990-12-20 15:06:42 +000047};
48
Guido van Rossum3f5da241990-12-20 15:06:42 +000049static void
Nicholas Bastina7604bf2004-03-21 18:37:23 +000050tb_dealloc(PyTracebackObject *tb)
Guido van Rossum3f5da241990-12-20 15:06:42 +000051{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000052 PyObject_GC_UnTrack(tb);
53 Py_TRASHCAN_SAFE_BEGIN(tb)
54 Py_XDECREF(tb->tb_next);
55 Py_XDECREF(tb->tb_frame);
56 PyObject_GC_Del(tb);
57 Py_TRASHCAN_SAFE_END(tb)
Guido van Rossum3f5da241990-12-20 15:06:42 +000058}
59
Jeremy Hyltonfd14d8e2001-10-22 22:17:41 +000060static int
Nicholas Bastina7604bf2004-03-21 18:37:23 +000061tb_traverse(PyTracebackObject *tb, visitproc visit, void *arg)
Jeremy Hyltonfd14d8e2001-10-22 22:17:41 +000062{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000063 Py_VISIT(tb->tb_next);
64 Py_VISIT(tb->tb_frame);
65 return 0;
Jeremy Hyltonfd14d8e2001-10-22 22:17:41 +000066}
67
68static void
Nicholas Bastina7604bf2004-03-21 18:37:23 +000069tb_clear(PyTracebackObject *tb)
Jeremy Hyltonfd14d8e2001-10-22 22:17:41 +000070{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000071 Py_CLEAR(tb->tb_next);
72 Py_CLEAR(tb->tb_frame);
Jeremy Hyltonfd14d8e2001-10-22 22:17:41 +000073}
74
Tim Petersd7c36522001-10-22 19:34:09 +000075PyTypeObject PyTraceBack_Type = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000076 PyVarObject_HEAD_INIT(&PyType_Type, 0)
77 "traceback",
78 sizeof(PyTracebackObject),
79 0,
80 (destructor)tb_dealloc, /*tp_dealloc*/
81 0, /*tp_print*/
82 0, /*tp_getattr*/
83 0, /*tp_setattr*/
84 0, /*tp_reserved*/
85 0, /*tp_repr*/
86 0, /*tp_as_number*/
87 0, /*tp_as_sequence*/
88 0, /*tp_as_mapping*/
89 0, /* tp_hash */
90 0, /* tp_call */
91 0, /* tp_str */
92 PyObject_GenericGetAttr, /* tp_getattro */
93 0, /* tp_setattro */
94 0, /* tp_as_buffer */
95 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
96 0, /* tp_doc */
97 (traverseproc)tb_traverse, /* tp_traverse */
98 (inquiry)tb_clear, /* tp_clear */
99 0, /* tp_richcompare */
100 0, /* tp_weaklistoffset */
101 0, /* tp_iter */
102 0, /* tp_iternext */
103 tb_methods, /* tp_methods */
104 tb_memberlist, /* tp_members */
105 0, /* tp_getset */
106 0, /* tp_base */
107 0, /* tp_dict */
Guido van Rossum3f5da241990-12-20 15:06:42 +0000108};
109
Nicholas Bastina7604bf2004-03-21 18:37:23 +0000110static PyTracebackObject *
111newtracebackobject(PyTracebackObject *next, PyFrameObject *frame)
Guido van Rossum3f5da241990-12-20 15:06:42 +0000112{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000113 PyTracebackObject *tb;
114 if ((next != NULL && !PyTraceBack_Check(next)) ||
115 frame == NULL || !PyFrame_Check(frame)) {
116 PyErr_BadInternalCall();
117 return NULL;
118 }
119 tb = PyObject_GC_New(PyTracebackObject, &PyTraceBack_Type);
120 if (tb != NULL) {
121 Py_XINCREF(next);
122 tb->tb_next = next;
123 Py_XINCREF(frame);
124 tb->tb_frame = frame;
125 tb->tb_lasti = frame->f_lasti;
126 tb->tb_lineno = PyFrame_GetLineNumber(frame);
127 PyObject_GC_Track(tb);
128 }
129 return tb;
Guido van Rossum3f5da241990-12-20 15:06:42 +0000130}
131
Guido van Rossum3f5da241990-12-20 15:06:42 +0000132int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000133PyTraceBack_Here(PyFrameObject *frame)
Guido van Rossum3f5da241990-12-20 15:06:42 +0000134{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000135 PyThreadState *tstate = PyThreadState_GET();
136 PyTracebackObject *oldtb = (PyTracebackObject *) tstate->curexc_traceback;
137 PyTracebackObject *tb = newtracebackobject(oldtb, frame);
138 if (tb == NULL)
139 return -1;
140 tstate->curexc_traceback = (PyObject *)tb;
141 Py_XDECREF(oldtb);
142 return 0;
Guido van Rossum3f5da241990-12-20 15:06:42 +0000143}
144
Antoine Pitrou0ddbf472014-10-08 20:00:09 +0200145/* Insert a frame into the traceback for (funcname, filename, lineno). */
Serhiy Storchaka73c95f12015-06-21 15:59:46 +0300146void _PyTraceback_Add(const char *funcname, const char *filename, int lineno)
Antoine Pitrou0ddbf472014-10-08 20:00:09 +0200147{
148 PyObject *globals = NULL;
149 PyCodeObject *code = NULL;
150 PyFrameObject *frame = NULL;
151 PyObject *exception, *value, *tb;
152
153 /* Save and clear the current exception. Python functions must not be
154 called with an exception set. Calling Python functions happens when
155 the codec of the filesystem encoding is implemented in pure Python. */
156 PyErr_Fetch(&exception, &value, &tb);
157
158 globals = PyDict_New();
159 if (!globals)
160 goto done;
161 code = PyCode_NewEmpty(filename, funcname, lineno);
162 if (!code)
163 goto done;
164 frame = PyFrame_New(PyThreadState_Get(), code, globals, NULL);
165 if (!frame)
166 goto done;
167 frame->f_lineno = lineno;
168
169 PyErr_Restore(exception, value, tb);
170 PyTraceBack_Here(frame);
171
172done:
173 Py_XDECREF(globals);
174 Py_XDECREF(code);
175 Py_XDECREF(frame);
176}
177
Victor Stinner0fe25a42010-06-17 23:08:50 +0000178static PyObject *
179_Py_FindSourceFile(PyObject *filename, char* namebuf, size_t namelen, PyObject *io)
Amaury Forgeot d'Arccf8016a2008-10-09 23:37:48 +0000180{
Victor Stinner0fe25a42010-06-17 23:08:50 +0000181 Py_ssize_t i;
182 PyObject *binary;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000183 PyObject *v;
Victor Stinner0fe25a42010-06-17 23:08:50 +0000184 Py_ssize_t npath;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000185 size_t taillen;
186 PyObject *syspath;
Victor Stinner4c7c8c32010-10-16 13:14:10 +0000187 PyObject *path;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000188 const char* tail;
Victor Stinner4c7c8c32010-10-16 13:14:10 +0000189 PyObject *filebytes;
Victor Stinner0fe25a42010-06-17 23:08:50 +0000190 const char* filepath;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000191 Py_ssize_t len;
Victor Stinner4c7c8c32010-10-16 13:14:10 +0000192 PyObject* result;
Amaury Forgeot d'Arccf8016a2008-10-09 23:37:48 +0000193
Victor Stinner4c7c8c32010-10-16 13:14:10 +0000194 filebytes = PyUnicode_EncodeFSDefault(filename);
195 if (filebytes == NULL) {
Victor Stinner0fe25a42010-06-17 23:08:50 +0000196 PyErr_Clear();
197 return NULL;
198 }
Victor Stinner4c7c8c32010-10-16 13:14:10 +0000199 filepath = PyBytes_AS_STRING(filebytes);
Victor Stinner0fe25a42010-06-17 23:08:50 +0000200
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000201 /* Search tail of filename in sys.path before giving up */
Victor Stinner0fe25a42010-06-17 23:08:50 +0000202 tail = strrchr(filepath, SEP);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000203 if (tail == NULL)
Victor Stinner0fe25a42010-06-17 23:08:50 +0000204 tail = filepath;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000205 else
206 tail++;
207 taillen = strlen(tail);
Amaury Forgeot d'Arccf8016a2008-10-09 23:37:48 +0000208
Victor Stinnerbd303c12013-11-07 23:07:29 +0100209 syspath = _PySys_GetObjectId(&PyId_path);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000210 if (syspath == NULL || !PyList_Check(syspath))
Victor Stinner4c7c8c32010-10-16 13:14:10 +0000211 goto error;
Victor Stinner0fe25a42010-06-17 23:08:50 +0000212 npath = PyList_Size(syspath);
Amaury Forgeot d'Arccf8016a2008-10-09 23:37:48 +0000213
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000214 for (i = 0; i < npath; i++) {
215 v = PyList_GetItem(syspath, i);
216 if (v == NULL) {
217 PyErr_Clear();
218 break;
219 }
220 if (!PyUnicode_Check(v))
221 continue;
Victor Stinner4c7c8c32010-10-16 13:14:10 +0000222 path = PyUnicode_EncodeFSDefault(v);
Victor Stinner0fe25a42010-06-17 23:08:50 +0000223 if (path == NULL) {
224 PyErr_Clear();
225 continue;
226 }
Victor Stinner4c7c8c32010-10-16 13:14:10 +0000227 len = PyBytes_GET_SIZE(path);
228 if (len + 1 + (Py_ssize_t)taillen >= (Py_ssize_t)namelen - 1) {
229 Py_DECREF(path);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000230 continue; /* Too long */
Victor Stinner4c7c8c32010-10-16 13:14:10 +0000231 }
232 strcpy(namebuf, PyBytes_AS_STRING(path));
233 Py_DECREF(path);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000234 if (strlen(namebuf) != len)
235 continue; /* v contains '\0' */
236 if (len > 0 && namebuf[len-1] != SEP)
237 namebuf[len++] = SEP;
238 strcpy(namebuf+len, tail);
Victor Stinner0fe25a42010-06-17 23:08:50 +0000239
Martin v. Löwisafe55bb2011-10-09 10:38:36 +0200240 binary = _PyObject_CallMethodId(io, &PyId_open, "ss", namebuf, "rb");
Victor Stinner4c7c8c32010-10-16 13:14:10 +0000241 if (binary != NULL) {
242 result = binary;
243 goto finally;
244 }
Victor Stinner0fe25a42010-06-17 23:08:50 +0000245 PyErr_Clear();
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000246 }
Victor Stinner4c7c8c32010-10-16 13:14:10 +0000247 goto error;
248
249error:
250 result = NULL;
251finally:
252 Py_DECREF(filebytes);
253 return result;
Amaury Forgeot d'Arccf8016a2008-10-09 23:37:48 +0000254}
255
Christian Heimes33fe8092008-04-13 13:53:33 +0000256int
Victor Stinner0fe25a42010-06-17 23:08:50 +0000257_Py_DisplaySourceLine(PyObject *f, PyObject *filename, int lineno, int indent)
Guido van Rossum3f5da241990-12-20 15:06:42 +0000258{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000259 int err = 0;
260 int fd;
261 int i;
262 char *found_encoding;
263 char *encoding;
Victor Stinner0fe25a42010-06-17 23:08:50 +0000264 PyObject *io;
265 PyObject *binary;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000266 PyObject *fob = NULL;
267 PyObject *lineobj = NULL;
Antoine Pitroub86680e2010-10-14 21:15:17 +0000268 PyObject *res;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000269 char buf[MAXPATHLEN+1];
Martin v. Löwisd63a3b82011-09-28 07:41:54 +0200270 int kind;
271 void *data;
Christian Heimes679db4a2008-01-18 09:56:22 +0000272
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000273 /* open the file */
274 if (filename == NULL)
275 return 0;
Victor Stinner0fe25a42010-06-17 23:08:50 +0000276
277 io = PyImport_ImportModuleNoBlock("io");
278 if (io == NULL)
279 return -1;
Martin v. Löwisafe55bb2011-10-09 10:38:36 +0200280 binary = _PyObject_CallMethodId(io, &PyId_open, "Os", filename, "rb");
Victor Stinner0fe25a42010-06-17 23:08:50 +0000281
282 if (binary == NULL) {
Victor Stinnerceceaa02013-07-16 00:32:14 +0200283 PyErr_Clear();
284
Victor Stinner0fe25a42010-06-17 23:08:50 +0000285 binary = _Py_FindSourceFile(filename, buf, sizeof(buf), io);
286 if (binary == NULL) {
287 Py_DECREF(io);
Victor Stinnerceceaa02013-07-16 00:32:14 +0200288 return -1;
Victor Stinner0fe25a42010-06-17 23:08:50 +0000289 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000290 }
Christian Heimes33fe8092008-04-13 13:53:33 +0000291
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000292 /* use the right encoding to decode the file as unicode */
Victor Stinner0fe25a42010-06-17 23:08:50 +0000293 fd = PyObject_AsFileDescriptor(binary);
Christian Heimes8c077bc2013-07-21 01:53:10 +0200294 if (fd < 0) {
295 Py_DECREF(io);
296 Py_DECREF(binary);
Benjamin Peterson04b01dc2013-07-21 13:26:13 -0700297 return 0;
Christian Heimes8c077bc2013-07-21 01:53:10 +0200298 }
Victor Stinnerfe7c5b52011-04-05 01:48:03 +0200299 found_encoding = PyTokenizer_FindEncodingFilename(fd, filename);
Victor Stinner5272fa92013-12-19 13:39:32 +0100300 if (found_encoding == NULL)
301 PyErr_Clear();
Victor Stinner0fe25a42010-06-17 23:08:50 +0000302 encoding = (found_encoding != NULL) ? found_encoding : "utf-8";
Christian Heimes1f347292013-07-21 02:12:35 +0200303 /* Reset position */
304 if (lseek(fd, 0, SEEK_SET) == (off_t)-1) {
305 Py_DECREF(io);
306 Py_DECREF(binary);
307 PyMem_FREE(found_encoding);
Benjamin Peterson04b01dc2013-07-21 13:26:13 -0700308 return 0;
Christian Heimes1f347292013-07-21 02:12:35 +0200309 }
Martin v. Löwisafe55bb2011-10-09 10:38:36 +0200310 fob = _PyObject_CallMethodId(io, &PyId_TextIOWrapper, "Os", binary, encoding);
Victor Stinner0fe25a42010-06-17 23:08:50 +0000311 Py_DECREF(io);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000312 PyMem_FREE(found_encoding);
Victor Stinner0fe25a42010-06-17 23:08:50 +0000313
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000314 if (fob == NULL) {
315 PyErr_Clear();
Victor Stinner81f241a2015-03-25 02:25:25 +0100316
317 res = _PyObject_CallMethodId(binary, &PyId_close, "");
318 Py_DECREF(binary);
319 if (res)
320 Py_DECREF(res);
321 else
322 PyErr_Clear();
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000323 return 0;
324 }
Victor Stinner81f241a2015-03-25 02:25:25 +0100325 Py_DECREF(binary);
Christian Heimes33fe8092008-04-13 13:53:33 +0000326
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000327 /* get the line number lineno */
328 for (i = 0; i < lineno; i++) {
329 Py_XDECREF(lineobj);
330 lineobj = PyFile_GetLine(fob, -1);
331 if (!lineobj) {
Victor Stinner5e78f4d2014-10-30 10:17:27 +0100332 PyErr_Clear();
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000333 err = -1;
334 break;
335 }
336 }
Martin v. Löwisafe55bb2011-10-09 10:38:36 +0200337 res = _PyObject_CallMethodId(fob, &PyId_close, "");
Antoine Pitroub86680e2010-10-14 21:15:17 +0000338 if (res)
339 Py_DECREF(res);
340 else
341 PyErr_Clear();
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000342 Py_DECREF(fob);
343 if (!lineobj || !PyUnicode_Check(lineobj)) {
344 Py_XDECREF(lineobj);
345 return err;
346 }
Amaury Forgeot d'Arccf8016a2008-10-09 23:37:48 +0000347
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000348 /* remove the indentation of the line */
Martin v. Löwisd63a3b82011-09-28 07:41:54 +0200349 kind = PyUnicode_KIND(lineobj);
350 data = PyUnicode_DATA(lineobj);
351 for (i=0; i < PyUnicode_GET_LENGTH(lineobj); i++) {
352 Py_UCS4 ch = PyUnicode_READ(kind, data, i);
353 if (ch != ' ' && ch != '\t' && ch != '\014')
354 break;
355 }
356 if (i) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000357 PyObject *truncated;
Martin v. Löwisd63a3b82011-09-28 07:41:54 +0200358 truncated = PyUnicode_Substring(lineobj, i, PyUnicode_GET_LENGTH(lineobj));
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000359 if (truncated) {
360 Py_DECREF(lineobj);
361 lineobj = truncated;
362 } else {
363 PyErr_Clear();
364 }
365 }
Amaury Forgeot d'Arccf8016a2008-10-09 23:37:48 +0000366
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000367 /* Write some spaces before the line */
368 strcpy(buf, " ");
369 assert (strlen(buf) == 10);
370 while (indent > 0) {
Benjamin Peterson0f9b7d32013-07-21 13:29:37 -0700371 if (indent < 10)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000372 buf[indent] = '\0';
373 err = PyFile_WriteString(buf, f);
374 if (err != 0)
375 break;
376 indent -= 10;
377 }
Amaury Forgeot d'Arccf8016a2008-10-09 23:37:48 +0000378
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000379 /* finally display the line */
380 if (err == 0)
381 err = PyFile_WriteObject(lineobj, f, Py_PRINT_RAW);
382 Py_DECREF(lineobj);
383 if (err == 0)
384 err = PyFile_WriteString("\n", f);
385 return err;
Guido van Rossum3f5da241990-12-20 15:06:42 +0000386}
387
Guido van Rossum7e8d26d1997-05-22 22:35:47 +0000388static int
Victor Stinner0fe25a42010-06-17 23:08:50 +0000389tb_displayline(PyObject *f, PyObject *filename, int lineno, PyObject *name)
Guido van Rossum3f5da241990-12-20 15:06:42 +0000390{
Victor Stinner0fe25a42010-06-17 23:08:50 +0000391 int err;
392 PyObject *line;
Christian Heimes33fe8092008-04-13 13:53:33 +0000393
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000394 if (filename == NULL || name == NULL)
395 return -1;
Victor Stinner0fe25a42010-06-17 23:08:50 +0000396 line = PyUnicode_FromFormat(" File \"%U\", line %d, in %U\n",
397 filename, lineno, name);
398 if (line == NULL)
399 return -1;
400 err = PyFile_WriteObject(line, f, Py_PRINT_RAW);
401 Py_DECREF(line);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000402 if (err != 0)
403 return err;
Kristján Valur Jónssonc5963d32012-07-19 21:02:03 +0000404 /* ignore errors since we can't report them, can we? */
405 if (_Py_DisplaySourceLine(f, filename, lineno, 4))
406 PyErr_Clear();
407 return err;
Christian Heimes33fe8092008-04-13 13:53:33 +0000408}
409
410static int
411tb_printinternal(PyTracebackObject *tb, PyObject *f, long limit)
412{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000413 int err = 0;
414 long depth = 0;
415 PyTracebackObject *tb1 = tb;
416 while (tb1 != NULL) {
417 depth++;
418 tb1 = tb1->tb_next;
419 }
420 while (tb != NULL && err == 0) {
421 if (depth <= limit) {
422 err = tb_displayline(f,
Victor Stinner0fe25a42010-06-17 23:08:50 +0000423 tb->tb_frame->f_code->co_filename,
424 tb->tb_lineno,
425 tb->tb_frame->f_code->co_name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000426 }
427 depth--;
428 tb = tb->tb_next;
429 if (err == 0)
430 err = PyErr_CheckSignals();
431 }
432 return err;
Guido van Rossum3f5da241990-12-20 15:06:42 +0000433}
434
Christian Heimes0fbab7f2007-12-04 21:55:18 +0000435#define PyTraceBack_LIMIT 1000
436
Guido van Rossum3f5da241990-12-20 15:06:42 +0000437int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000438PyTraceBack_Print(PyObject *v, PyObject *f)
Guido van Rossum3f5da241990-12-20 15:06:42 +0000439{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000440 int err;
441 PyObject *limitv;
442 long limit = PyTraceBack_LIMIT;
Christian Heimes0fbab7f2007-12-04 21:55:18 +0000443
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000444 if (v == NULL)
445 return 0;
446 if (!PyTraceBack_Check(v)) {
447 PyErr_BadInternalCall();
448 return -1;
449 }
450 limitv = PySys_GetObject("tracebacklimit");
451 if (limitv) {
452 PyObject *exc_type, *exc_value, *exc_tb;
Christian Heimes0fbab7f2007-12-04 21:55:18 +0000453
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000454 PyErr_Fetch(&exc_type, &exc_value, &exc_tb);
455 limit = PyLong_AsLong(limitv);
456 if (limit == -1 && PyErr_Occurred()) {
457 if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
458 limit = PyTraceBack_LIMIT;
459 }
460 else {
461 Py_XDECREF(exc_type);
462 Py_XDECREF(exc_value);
463 Py_XDECREF(exc_tb);
464 return 0;
465 }
466 }
467 else if (limit <= 0) {
468 limit = PyTraceBack_LIMIT;
469 }
470 PyErr_Restore(exc_type, exc_value, exc_tb);
471 }
472 err = PyFile_WriteString("Traceback (most recent call last):\n", f);
473 if (!err)
474 err = tb_printinternal((PyTracebackObject *)v, f, limit);
475 return err;
Guido van Rossum3f5da241990-12-20 15:06:42 +0000476}
Victor Stinner024e37a2011-03-31 01:31:06 +0200477
478/* Reverse a string. For example, "abcd" becomes "dcba".
479
480 This function is signal safe. */
481
482static void
483reverse_string(char *text, const size_t len)
484{
485 char tmp;
486 size_t i, j;
487 if (len == 0)
488 return;
489 for (i=0, j=len-1; i < j; i++, j--) {
490 tmp = text[i];
491 text[i] = text[j];
492 text[j] = tmp;
493 }
494}
495
496/* Format an integer in range [0; 999999] to decimal,
497 and write it into the file fd.
498
499 This function is signal safe. */
500
501static void
502dump_decimal(int fd, int value)
503{
504 char buffer[7];
505 int len;
506 if (value < 0 || 999999 < value)
507 return;
508 len = 0;
509 do {
510 buffer[len] = '0' + (value % 10);
511 value /= 10;
512 len++;
513 } while (value);
514 reverse_string(buffer, len);
515 write(fd, buffer, len);
516}
517
Guido van Rossum7be5d7d2013-10-20 18:21:02 -0700518/* Format an integer in range [0; 0xffffffff] to hexadecimal of 'width' digits,
Victor Stinner024e37a2011-03-31 01:31:06 +0200519 and write it into the file fd.
520
521 This function is signal safe. */
522
523static void
Guido van Rossum7be5d7d2013-10-20 18:21:02 -0700524dump_hexadecimal(int fd, unsigned long value, int width)
Victor Stinner024e37a2011-03-31 01:31:06 +0200525{
Victor Stinner024e37a2011-03-31 01:31:06 +0200526 int len;
527 char buffer[sizeof(unsigned long) * 2 + 1];
528 len = 0;
529 do {
Victor Stinnerf5cff562011-10-14 02:13:11 +0200530 buffer[len] = Py_hexdigits[value & 15];
Victor Stinner024e37a2011-03-31 01:31:06 +0200531 value >>= 4;
532 len++;
533 } while (len < width || value);
534 reverse_string(buffer, len);
535 write(fd, buffer, len);
536}
537
538/* Write an unicode object into the file fd using ascii+backslashreplace.
539
540 This function is signal safe. */
541
542static void
543dump_ascii(int fd, PyObject *text)
544{
Martin v. Löwisd63a3b82011-09-28 07:41:54 +0200545 PyASCIIObject *ascii = (PyASCIIObject *)text;
Victor Stinner024e37a2011-03-31 01:31:06 +0200546 Py_ssize_t i, size;
547 int truncated;
Martin v. Löwisd63a3b82011-09-28 07:41:54 +0200548 int kind;
Victor Stinnera336de72011-10-05 22:44:12 +0200549 void *data = NULL;
550 wchar_t *wstr = NULL;
Martin v. Löwisd63a3b82011-09-28 07:41:54 +0200551 Py_UCS4 ch;
Victor Stinner024e37a2011-03-31 01:31:06 +0200552
Martin v. Löwisd63a3b82011-09-28 07:41:54 +0200553 size = ascii->length;
554 kind = ascii->state.kind;
555 if (ascii->state.compact) {
556 if (ascii->state.ascii)
557 data = ((PyASCIIObject*)text) + 1;
558 else
559 data = ((PyCompactUnicodeObject*)text) + 1;
560 }
Victor Stinnera336de72011-10-05 22:44:12 +0200561 else if (kind != PyUnicode_WCHAR_KIND) {
Martin v. Löwisd63a3b82011-09-28 07:41:54 +0200562 data = ((PyUnicodeObject *)text)->data.any;
563 if (data == NULL)
564 return;
565 }
Victor Stinnera336de72011-10-05 22:44:12 +0200566 else {
567 wstr = ((PyASCIIObject *)text)->wstr;
568 if (wstr == NULL)
569 return;
570 size = ((PyCompactUnicodeObject *)text)->wstr_length;
571 }
Victor Stinner024e37a2011-03-31 01:31:06 +0200572
573 if (MAX_STRING_LENGTH < size) {
574 size = MAX_STRING_LENGTH;
575 truncated = 1;
576 }
577 else
578 truncated = 0;
579
Martin v. Löwisd63a3b82011-09-28 07:41:54 +0200580 for (i=0; i < size; i++) {
Victor Stinnera336de72011-10-05 22:44:12 +0200581 if (kind != PyUnicode_WCHAR_KIND)
582 ch = PyUnicode_READ(kind, data, i);
583 else
584 ch = wstr[i];
Martin v. Löwisd63a3b82011-09-28 07:41:54 +0200585 if (ch < 128) {
586 char c = (char)ch;
Victor Stinner024e37a2011-03-31 01:31:06 +0200587 write(fd, &c, 1);
588 }
Victor Stinner63ab8752011-11-22 03:31:20 +0100589 else if (ch < 0xff) {
Victor Stinner024e37a2011-03-31 01:31:06 +0200590 PUTS(fd, "\\x");
Guido van Rossum7be5d7d2013-10-20 18:21:02 -0700591 dump_hexadecimal(fd, ch, 2);
Victor Stinner024e37a2011-03-31 01:31:06 +0200592 }
Victor Stinner63ab8752011-11-22 03:31:20 +0100593 else if (ch < 0xffff) {
Victor Stinner024e37a2011-03-31 01:31:06 +0200594 PUTS(fd, "\\u");
Guido van Rossum7be5d7d2013-10-20 18:21:02 -0700595 dump_hexadecimal(fd, ch, 4);
Victor Stinner024e37a2011-03-31 01:31:06 +0200596 }
597 else {
598 PUTS(fd, "\\U");
Guido van Rossum7be5d7d2013-10-20 18:21:02 -0700599 dump_hexadecimal(fd, ch, 8);
Victor Stinner024e37a2011-03-31 01:31:06 +0200600 }
601 }
602 if (truncated)
603 PUTS(fd, "...");
604}
605
606/* Write a frame into the file fd: "File "xxx", line xxx in xxx".
607
608 This function is signal safe. */
609
610static void
611dump_frame(int fd, PyFrameObject *frame)
612{
613 PyCodeObject *code;
614 int lineno;
615
616 code = frame->f_code;
617 PUTS(fd, " File ");
618 if (code != NULL && code->co_filename != NULL
619 && PyUnicode_Check(code->co_filename))
620 {
621 write(fd, "\"", 1);
622 dump_ascii(fd, code->co_filename);
623 write(fd, "\"", 1);
624 } else {
625 PUTS(fd, "???");
626 }
627
628 /* PyFrame_GetLineNumber() was introduced in Python 2.7.0 and 3.2.0 */
Martin v. Löwisd63a3b82011-09-28 07:41:54 +0200629 lineno = PyCode_Addr2Line(code, frame->f_lasti);
Victor Stinner024e37a2011-03-31 01:31:06 +0200630 PUTS(fd, ", line ");
631 dump_decimal(fd, lineno);
632 PUTS(fd, " in ");
633
634 if (code != NULL && code->co_name != NULL
635 && PyUnicode_Check(code->co_name))
636 dump_ascii(fd, code->co_name);
637 else
638 PUTS(fd, "???");
639
640 write(fd, "\n", 1);
641}
642
Victor Stinnerfcb88c42011-04-01 15:34:01 +0200643static void
Victor Stinner024e37a2011-03-31 01:31:06 +0200644dump_traceback(int fd, PyThreadState *tstate, int write_header)
645{
646 PyFrameObject *frame;
647 unsigned int depth;
648
Victor Stinner024e37a2011-03-31 01:31:06 +0200649 if (write_header)
Guido van Rossum7be5d7d2013-10-20 18:21:02 -0700650 PUTS(fd, "Stack (most recent call first):\n");
Victor Stinnerfcb88c42011-04-01 15:34:01 +0200651
652 frame = _PyThreadState_GetFrame(tstate);
653 if (frame == NULL)
654 return;
655
Victor Stinner024e37a2011-03-31 01:31:06 +0200656 depth = 0;
657 while (frame != NULL) {
658 if (MAX_FRAME_DEPTH <= depth) {
659 PUTS(fd, " ...\n");
660 break;
661 }
662 if (!PyFrame_Check(frame))
663 break;
664 dump_frame(fd, frame);
665 frame = frame->f_back;
666 depth++;
667 }
Victor Stinner024e37a2011-03-31 01:31:06 +0200668}
669
Victor Stinnerfcb88c42011-04-01 15:34:01 +0200670void
Victor Stinner024e37a2011-03-31 01:31:06 +0200671_Py_DumpTraceback(int fd, PyThreadState *tstate)
672{
Victor Stinnerfcb88c42011-04-01 15:34:01 +0200673 dump_traceback(fd, tstate, 1);
Victor Stinner024e37a2011-03-31 01:31:06 +0200674}
675
676/* Write the thread identifier into the file 'fd': "Current thread 0xHHHH:\" if
677 is_current is true, "Thread 0xHHHH:\n" otherwise.
678
679 This function is signal safe. */
680
681static void
682write_thread_id(int fd, PyThreadState *tstate, int is_current)
683{
684 if (is_current)
685 PUTS(fd, "Current thread 0x");
686 else
687 PUTS(fd, "Thread 0x");
Guido van Rossum7be5d7d2013-10-20 18:21:02 -0700688 dump_hexadecimal(fd, (unsigned long)tstate->thread_id, sizeof(long)*2);
689 PUTS(fd, " (most recent call first):\n");
Victor Stinner024e37a2011-03-31 01:31:06 +0200690}
691
692const char*
693_Py_DumpTracebackThreads(int fd, PyInterpreterState *interp,
694 PyThreadState *current_thread)
695{
696 PyThreadState *tstate;
697 unsigned int nthreads;
698
699 /* Get the current interpreter from the current thread */
700 tstate = PyInterpreterState_ThreadHead(interp);
701 if (tstate == NULL)
702 return "unable to get the thread head state";
703
704 /* Dump the traceback of each thread */
705 tstate = PyInterpreterState_ThreadHead(interp);
706 nthreads = 0;
707 do
708 {
709 if (nthreads != 0)
710 write(fd, "\n", 1);
711 if (nthreads >= MAX_NTHREADS) {
712 PUTS(fd, "...\n");
713 break;
714 }
715 write_thread_id(fd, tstate, tstate == current_thread);
716 dump_traceback(fd, tstate, 0);
717 tstate = PyThreadState_Next(tstate);
718 nthreads++;
719 } while (tstate != NULL);
720
721 return NULL;
722}
723