mirror of
https://github.com/Sneed-Group/Poodletooth-iLand
synced 2024-12-25 12:42:41 -06:00
283 lines
8.5 KiB
C
283 lines
8.5 KiB
C
|
|
/* Traceback implementation */
|
|
|
|
#include "Python.h"
|
|
|
|
#include "code.h"
|
|
#include "frameobject.h"
|
|
#include "structmember.h"
|
|
#include "osdefs.h"
|
|
#include "traceback.h"
|
|
|
|
#define OFF(x) offsetof(PyTracebackObject, x)
|
|
|
|
static PyMemberDef tb_memberlist[] = {
|
|
{"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 */
|
|
};
|
|
|
|
static void
|
|
tb_dealloc(PyTracebackObject *tb)
|
|
{
|
|
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)
|
|
}
|
|
|
|
static int
|
|
tb_traverse(PyTracebackObject *tb, visitproc visit, void *arg)
|
|
{
|
|
Py_VISIT(tb->tb_next);
|
|
Py_VISIT(tb->tb_frame);
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
tb_clear(PyTracebackObject *tb)
|
|
{
|
|
Py_CLEAR(tb->tb_next);
|
|
Py_CLEAR(tb->tb_frame);
|
|
}
|
|
|
|
PyTypeObject PyTraceBack_Type = {
|
|
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_compare*/
|
|
0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
0, /* tp_hash */
|
|
0, /* tp_call */
|
|
0, /* tp_str */
|
|
0, /* 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 */
|
|
0, /* tp_methods */
|
|
tb_memberlist, /* tp_members */
|
|
0, /* tp_getset */
|
|
0, /* tp_base */
|
|
0, /* tp_dict */
|
|
};
|
|
|
|
static PyTracebackObject *
|
|
newtracebackobject(PyTracebackObject *next, PyFrameObject *frame)
|
|
{
|
|
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;
|
|
}
|
|
|
|
int
|
|
PyTraceBack_Here(PyFrameObject *frame)
|
|
{
|
|
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;
|
|
}
|
|
|
|
int
|
|
_Py_DisplaySourceLine(PyObject *f, const char *filename, int lineno, int indent)
|
|
{
|
|
int err = 0;
|
|
FILE *xfp = NULL;
|
|
char linebuf[2000];
|
|
int i;
|
|
char namebuf[MAXPATHLEN+1];
|
|
|
|
if (filename == NULL)
|
|
return -1;
|
|
/* This is needed by Emacs' compile command */
|
|
#define FMT " File \"%.500s\", line %d, in %.500s\n"
|
|
xfp = fopen(filename, "r" PY_STDIOTEXTMODE);
|
|
if (xfp == NULL) {
|
|
/* Search tail of filename in sys.path before giving up */
|
|
PyObject *path;
|
|
const char *tail = strrchr(filename, SEP);
|
|
if (tail == NULL)
|
|
tail = filename;
|
|
else
|
|
tail++;
|
|
path = PySys_GetObject("path");
|
|
if (path != NULL && PyList_Check(path)) {
|
|
Py_ssize_t _npath = PyList_Size(path);
|
|
int npath = Py_SAFE_DOWNCAST(_npath, Py_ssize_t, int);
|
|
size_t taillen = strlen(tail);
|
|
for (i = 0; i < npath; i++) {
|
|
PyObject *v = PyList_GetItem(path, i);
|
|
if (v == NULL) {
|
|
PyErr_Clear();
|
|
break;
|
|
}
|
|
if (PyString_Check(v)) {
|
|
size_t len;
|
|
len = PyString_GET_SIZE(v);
|
|
if (len + 1 + taillen >= MAXPATHLEN)
|
|
continue; /* Too long */
|
|
strcpy(namebuf, PyString_AsString(v));
|
|
if (strlen(namebuf) != len)
|
|
continue; /* v contains '\0' */
|
|
if (len > 0 && namebuf[len-1] != SEP)
|
|
namebuf[len++] = SEP;
|
|
strcpy(namebuf+len, tail);
|
|
xfp = fopen(namebuf, "r" PY_STDIOTEXTMODE);
|
|
if (xfp != NULL) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (xfp == NULL)
|
|
return err;
|
|
if (err != 0) {
|
|
fclose(xfp);
|
|
return err;
|
|
}
|
|
|
|
for (i = 0; i < lineno; i++) {
|
|
char* pLastChar = &linebuf[sizeof(linebuf)-2];
|
|
do {
|
|
*pLastChar = '\0';
|
|
if (Py_UniversalNewlineFgets(linebuf, sizeof linebuf, xfp, NULL) == NULL)
|
|
break;
|
|
/* fgets read *something*; if it didn't get as
|
|
far as pLastChar, it must have found a newline
|
|
or hit the end of the file; if pLastChar is \n,
|
|
it obviously found a newline; else we haven't
|
|
yet seen a newline, so must continue */
|
|
} while (*pLastChar != '\0' && *pLastChar != '\n');
|
|
}
|
|
if (i == lineno) {
|
|
char buf[11];
|
|
char *p = linebuf;
|
|
while (*p == ' ' || *p == '\t' || *p == '\014')
|
|
p++;
|
|
|
|
/* Write some spaces before the line */
|
|
strcpy(buf, " ");
|
|
assert (strlen(buf) == 10);
|
|
while (indent > 0) {
|
|
if(indent < 10)
|
|
buf[indent] = '\0';
|
|
err = PyFile_WriteString(buf, f);
|
|
if (err != 0)
|
|
break;
|
|
indent -= 10;
|
|
}
|
|
|
|
if (err == 0)
|
|
err = PyFile_WriteString(p, f);
|
|
if (err == 0 && strchr(p, '\n') == NULL)
|
|
err = PyFile_WriteString("\n", f);
|
|
}
|
|
fclose(xfp);
|
|
return err;
|
|
}
|
|
|
|
static int
|
|
tb_displayline(PyObject *f, const char *filename, int lineno, const char *name)
|
|
{
|
|
int err = 0;
|
|
char linebuf[2000];
|
|
|
|
if (filename == NULL || name == NULL)
|
|
return -1;
|
|
/* This is needed by Emacs' compile command */
|
|
#define FMT " File \"%.500s\", line %d, in %.500s\n"
|
|
PyOS_snprintf(linebuf, sizeof(linebuf), FMT, filename, lineno, name);
|
|
err = PyFile_WriteString(linebuf, f);
|
|
if (err != 0)
|
|
return err;
|
|
return _Py_DisplaySourceLine(f, filename, lineno, 4);
|
|
}
|
|
|
|
static int
|
|
tb_printinternal(PyTracebackObject *tb, PyObject *f, long limit)
|
|
{
|
|
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,
|
|
PyString_AsString(
|
|
tb->tb_frame->f_code->co_filename),
|
|
tb->tb_lineno,
|
|
PyString_AsString(tb->tb_frame->f_code->co_name));
|
|
}
|
|
depth--;
|
|
tb = tb->tb_next;
|
|
if (err == 0)
|
|
err = PyErr_CheckSignals();
|
|
}
|
|
return err;
|
|
}
|
|
|
|
int
|
|
PyTraceBack_Print(PyObject *v, PyObject *f)
|
|
{
|
|
int err;
|
|
PyObject *limitv;
|
|
long limit = 1000;
|
|
if (v == NULL)
|
|
return 0;
|
|
if (!PyTraceBack_Check(v)) {
|
|
PyErr_BadInternalCall();
|
|
return -1;
|
|
}
|
|
limitv = PySys_GetObject("tracebacklimit");
|
|
if (limitv && PyInt_Check(limitv)) {
|
|
limit = PyInt_AsLong(limitv);
|
|
if (limit <= 0)
|
|
return 0;
|
|
}
|
|
err = PyFile_WriteString("Traceback (most recent call last):\n", f);
|
|
if (!err)
|
|
err = tb_printinternal((PyTracebackObject *)v, f, limit);
|
|
return err;
|
|
}
|