#define PY_SSIZE_T_CLEAN

#include <Python.h>

#include "structmember.h"

#include "osdefs.h"

static PyObject *

BaseException_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

PyBaseExceptionObject *self;

self = (PyBaseExceptionObject *)type->tp_alloc(type, 0);

if (!self)

return NULL;

/* the dict is created on the fly in PyObject_GenericSetAttr */

self->dict = NULL;

self->traceback = self->cause = self->context = NULL;

if (args) {

self->args = args;

Py_INCREF(args);

return (PyObject *)self;

}

self->args = PyTuple_New(0);

if (!self->args) {

Py_DECREF(self);

return NULL;

}

return (PyObject *)self;

}

static int

BaseException_init(PyBaseExceptionObject *self, PyObject *args, PyObject *kwds)

{

PyObject *tmp;

if (!_PyArg_NoKeywords(Py_TYPE(self)->tp_name, kwds))

return -1;

tmp = self->args;

self->args = args;

Py_INCREF(self->args);

Py_XDECREF(tmp);

return 0;

}

static int

BaseException_clear(PyBaseExceptionObject *self)

{

Py_CLEAR(self->dict);

Py_CLEAR(self->args);

Py_CLEAR(self->traceback);

Py_CLEAR(self->cause);

Py_CLEAR(self->context);

return 0;

}

static void

BaseException_dealloc(PyBaseExceptionObject *self)

{

_PyObject_GC_UNTRACK(self);

BaseException_clear(self);

Py_TYPE(self)->tp_free((PyObject *)self);

}

static int

BaseException_traverse(PyBaseExceptionObject *self, visitproc visit, void *arg)

{

Py_VISIT(self->dict);

Py_VISIT(self->args);

Py_VISIT(self->traceback);

Py_VISIT(self->cause);

Py_VISIT(self->context);

return 0;

}

static PyObject *

BaseException_str(PyBaseExceptionObject *self)

{

switch (PyTuple_GET_SIZE(self->args)) {

case 0:

return PyUnicode_FromString("");

case 1:

return PyObject_Str(PyTuple_GET_ITEM(self->args, 0));

default:

return PyObject_Str(self->args);

}

}

static PyObject *

BaseException_repr(PyBaseExceptionObject *self)

{

char *name;

char *dot;

name = (char *)Py_TYPE(self)->tp_name;

dot = strrchr(name, '.');

if (dot != NULL) name = dot+1;

return PyUnicode_FromFormat("%s%R", name, self->args);

}

static PyObject *

BaseException_reduce(PyBaseExceptionObject *self)

{

if (self->args && self->dict)

return PyTuple_Pack(3, Py_TYPE(self), self->args, self->dict);

else

return PyTuple_Pack(2, Py_TYPE(self), self->args);

}

static PyObject *

BaseException_setstate(PyObject *self, PyObject *state)

{

PyObject *d_key, *d_value;

Py_ssize_t i = 0;

if (state != Py_None) {

if (!PyDict_Check(state)) {

PyErr_SetString(PyExc_TypeError, "state is not a dictionary");

return NULL;

}

while (PyDict_Next(state, &i, &d_key, &d_value)) {

if (PyObject_SetAttr(self, d_key, d_value) < 0)

return NULL;

}

}

Py_RETURN_NONE;

}

static PyObject *

BaseException_with_traceback(PyObject *self, PyObject *tb) {

if (PyException_SetTraceback(self, tb))

return NULL;

Py_INCREF(self);

return self;

}

PyDoc_STRVAR(with_traceback_doc,

set self.__traceback__ to tb and return self.");

static PyMethodDef BaseException_methods[] = {

{"__reduce__", (PyCFunction)BaseException_reduce, METH_NOARGS },

{"__setstate__", (PyCFunction)BaseException_setstate, METH_O },

{"with_traceback", (PyCFunction)BaseException_with_traceback, METH_O,

with_traceback_doc},

{NULL, NULL, 0, NULL},

};

static PyObject *

BaseException_get_dict(PyBaseExceptionObject *self)

{

if (self->dict == NULL) {

self->dict = PyDict_New();

if (!self->dict)

return NULL;

}

Py_INCREF(self->dict);

return self->dict;

}

static int

BaseException_set_dict(PyBaseExceptionObject *self, PyObject *val)

{

if (val == NULL) {

PyErr_SetString(PyExc_TypeError, "__dict__ may not be deleted");

return -1;

}

if (!PyDict_Check(val)) {

PyErr_SetString(PyExc_TypeError, "__dict__ must be a dictionary");

return -1;

}

Py_CLEAR(self->dict);

Py_INCREF(val);

self->dict = val;

return 0;

}

static PyObject *

BaseException_get_args(PyBaseExceptionObject *self)

{

if (self->args == NULL) {

Py_INCREF(Py_None);

return Py_None;

}

Py_INCREF(self->args);

return self->args;

}

static int

BaseException_set_args(PyBaseExceptionObject *self, PyObject *val)

{

PyObject *seq;

if (val == NULL) {

PyErr_SetString(PyExc_TypeError, "args may not be deleted");

return -1;

}

seq = PySequence_Tuple(val);

if (!seq)

return -1;

Py_CLEAR(self->args);

self->args = seq;

return 0;

}

static PyObject *

BaseException_get_tb(PyBaseExceptionObject *self)

{

if (self->traceback == NULL) {

Py_INCREF(Py_None);

return Py_None;

}

Py_INCREF(self->traceback);

return self->traceback;

}

static int

BaseException_set_tb(PyBaseExceptionObject *self, PyObject *tb)

{

if (tb == NULL) {

PyErr_SetString(PyExc_TypeError, "__traceback__ may not be deleted");

return -1;

}

else if (!(tb == Py_None || PyTraceBack_Check(tb))) {

PyErr_SetString(PyExc_TypeError,

"__traceback__ must be a traceback or None");

return -1;

}

Py_XINCREF(tb);

Py_XDECREF(self->traceback);

self->traceback = tb;

return 0;

}

static PyObject *

BaseException_get_context(PyObject *self) {

PyObject *res = PyException_GetContext(self);

if (res)

return res; /* new reference already returned above */

Py_RETURN_NONE;

}

static int

BaseException_set_context(PyObject *self, PyObject *arg) {

if (arg == NULL) {

PyErr_SetString(PyExc_TypeError, "__context__ may not be deleted");

return -1;

} else if (arg == Py_None) {

arg = NULL;

} else if (!PyExceptionInstance_Check(arg)) {

PyErr_SetString(PyExc_TypeError, "exception context must be None "

"or derive from BaseException");

return -1;

} else {

/* PyException_SetContext steals this reference */

Py_INCREF(arg);

}

PyException_SetContext(self, arg);

return 0;

}

static PyObject *

BaseException_get_cause(PyObject *self) {

PyObject *res = PyException_GetCause(self);

if (res)

return res; /* new reference already returned above */

Py_RETURN_NONE;

}

static int

BaseException_set_cause(PyObject *self, PyObject *arg) {

if (arg == NULL) {

PyErr_SetString(PyExc_TypeError, "__cause__ may not be deleted");

return -1;

} else if (arg == Py_None) {

arg = NULL;

} else if (!PyExceptionInstance_Check(arg)) {

PyErr_SetString(PyExc_TypeError, "exception cause must be None "

"or derive from BaseException");

return -1;

} else {

/* PyException_SetCause steals this reference */

Py_INCREF(arg);

}

PyException_SetCause(self, arg);

return 0;

}

static PyGetSetDef BaseException_getset[] = {

{"__dict__", (getter)BaseException_get_dict, (setter)BaseException_set_dict},

{"args", (getter)BaseException_get_args, (setter)BaseException_set_args},

{"__traceback__", (getter)BaseException_get_tb, (setter)BaseException_set_tb},

{"__context__", (getter)BaseException_get_context,

(setter)BaseException_set_context, PyDoc_STR("exception context")},

{"__cause__", (getter)BaseException_get_cause,

(setter)BaseException_set_cause, PyDoc_STR("exception cause")},

{NULL},

};

PyObject *

PyException_GetTraceback(PyObject *self) {

PyBaseExceptionObject *base_self = (PyBaseExceptionObject *)self;

Py_XINCREF(base_self->traceback);

return base_self->traceback;

}

PyException_SetTraceback(PyObject *self, PyObject *tb) {

return BaseException_set_tb((PyBaseExceptionObject *)self, tb);

}

PyObject *

PyException_GetCause(PyObject *self) {

PyObject *cause = ((PyBaseExceptionObject *)self)->cause;

Py_XINCREF(cause);

return cause;

}

PyException_SetCause(PyObject *self, PyObject *cause) {

PyObject *old_cause = ((PyBaseExceptionObject *)self)->cause;

((PyBaseExceptionObject *)self)->cause = cause;

Py_XDECREF(old_cause);

}

PyObject *

PyException_GetContext(PyObject *self) {

PyObject *context = ((PyBaseExceptionObject *)self)->context;

Py_XINCREF(context);

return context;

}

PyException_SetContext(PyObject *self, PyObject *context) {

PyObject *old_context = ((PyBaseExceptionObject *)self)->context;

((PyBaseExceptionObject *)self)->context = context;

Py_XDECREF(old_context);

}

static PyTypeObject _PyExc_BaseException = {

PyVarObject_HEAD_INIT(NULL, 0)

"BaseException", /*tp_name*/

sizeof(PyBaseExceptionObject), /*tp_basicsize*/

0, /*tp_itemsize*/

(destructor)BaseException_dealloc, /*tp_dealloc*/

0, /*tp_print*/

0, /*tp_getattr*/

0, /*tp_setattr*/

0, /* tp_reserved; */

(reprfunc)BaseException_repr, /*tp_repr*/

0, /*tp_as_number*/

0, /*tp_as_sequence*/

0, /*tp_as_mapping*/

0, /*tp_hash */

0, /*tp_call*/

(reprfunc)BaseException_str, /*tp_str*/

PyObject_GenericGetAttr, /*tp_getattro*/

PyObject_GenericSetAttr, /*tp_setattro*/

0, /*tp_as_buffer*/

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC |

Py_TPFLAGS_BASE_EXC_SUBCLASS, /*tp_flags*/

PyDoc_STR("Common base class for all exceptions"), /* tp_doc */

(traverseproc)BaseException_traverse, /* tp_traverse */

(inquiry)BaseException_clear, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

BaseException_methods, /* tp_methods */

0, /* tp_members */

BaseException_getset, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

offsetof(PyBaseExceptionObject, dict), /* tp_dictoffset */

(initproc)BaseException_init, /* tp_init */

0, /* tp_alloc */

BaseException_new, /* tp_new */

};

PyObject *PyExc_BaseException = (PyObject *)&_PyExc_BaseException;

#define SimpleExtendsException(EXCBASE, EXCNAME, EXCDOC) \

static PyTypeObject _PyExc_ ## EXCNAME = { \

PyVarObject_HEAD_INIT(NULL, 0) \

# EXCNAME, \

sizeof(PyBaseExceptionObject), \

0, (destructor)BaseException_dealloc, 0, 0, 0, 0, 0, 0, 0, \

0, 0, 0, 0, 0, 0, 0, \

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \

PyDoc_STR(EXCDOC), (traverseproc)BaseException_traverse, \

(inquiry)BaseException_clear, 0, 0, 0, 0, 0, 0, 0, &_ ## EXCBASE, \

0, 0, 0, offsetof(PyBaseExceptionObject, dict), \

(initproc)BaseException_init, 0, BaseException_new,\

}; \

PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME

#define MiddlingExtendsException(EXCBASE, EXCNAME, EXCSTORE, EXCDOC) \

static PyTypeObject _PyExc_ ## EXCNAME = { \

PyVarObject_HEAD_INIT(NULL, 0) \

# EXCNAME, \

sizeof(Py ## EXCSTORE ## Object), \

0, (destructor)EXCSTORE ## _dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, \

0, 0, 0, 0, 0, \

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \

PyDoc_STR(EXCDOC), (traverseproc)EXCSTORE ## _traverse, \

(inquiry)EXCSTORE ## _clear, 0, 0, 0, 0, 0, 0, 0, &_ ## EXCBASE, \

0, 0, 0, offsetof(Py ## EXCSTORE ## Object, dict), \

(initproc)EXCSTORE ## _init, 0, BaseException_new,\

}; \

PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME

#define ComplexExtendsException(EXCBASE, EXCNAME, EXCSTORE, EXCDEALLOC, EXCMETHODS, EXCMEMBERS, EXCSTR, EXCDOC) \

static PyTypeObject _PyExc_ ## EXCNAME = { \

PyVarObject_HEAD_INIT(NULL, 0) \

# EXCNAME, \

sizeof(Py ## EXCSTORE ## Object), 0, \

(destructor)EXCSTORE ## _dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \

(reprfunc)EXCSTR, 0, 0, 0, \

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \

PyDoc_STR(EXCDOC), (traverseproc)EXCSTORE ## _traverse, \

(inquiry)EXCSTORE ## _clear, 0, 0, 0, 0, EXCMETHODS, \

EXCMEMBERS, 0, &_ ## EXCBASE, \

0, 0, 0, offsetof(Py ## EXCSTORE ## Object, dict), \

(initproc)EXCSTORE ## _init, 0, BaseException_new,\

}; \

PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME

SimpleExtendsException(PyExc_BaseException, Exception,

"Common base class for all non-exit exceptions.");

SimpleExtendsException(PyExc_Exception, TypeError,

"Inappropriate argument type.");

SimpleExtendsException(PyExc_Exception, StopIteration,

"Signal the end from iterator.__next__().");

SimpleExtendsException(PyExc_BaseException, GeneratorExit,

"Request that a generator exit.");

static int

SystemExit_init(PySystemExitObject *self, PyObject *args, PyObject *kwds)

{

Py_ssize_t size = PyTuple_GET_SIZE(args);

if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)

return -1;

if (size == 0)

return 0;

Py_CLEAR(self->code);

if (size == 1)

self->code = PyTuple_GET_ITEM(args, 0);

else if (size > 1)

self->code = args;

Py_INCREF(self->code);

return 0;

}

static int

SystemExit_clear(PySystemExitObject *self)

{

Py_CLEAR(self->code);

return BaseException_clear((PyBaseExceptionObject *)self);

}

static void

SystemExit_dealloc(PySystemExitObject *self)

{

_PyObject_GC_UNTRACK(self);

SystemExit_clear(self);

Py_TYPE(self)->tp_free((PyObject *)self);

}

static int

SystemExit_traverse(PySystemExitObject *self, visitproc visit, void *arg)

{

Py_VISIT(self->code);

return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);

}

static PyMemberDef SystemExit_members[] = {

{"code", T_OBJECT, offsetof(PySystemExitObject, code), 0,

PyDoc_STR("exception code")},

{NULL} /* Sentinel */

};

ComplexExtendsException(PyExc_BaseException, SystemExit, SystemExit,

SystemExit_dealloc, 0, SystemExit_members, 0,

"Request to exit from the interpreter.");

SimpleExtendsException(PyExc_BaseException, KeyboardInterrupt,

"Program interrupted by user.");

SimpleExtendsException(PyExc_Exception, ImportError,

"Import can't find module, or can't find name in module.");

static int

EnvironmentError_init(PyEnvironmentErrorObject *self, PyObject *args,

PyObject *kwds)

{

PyObject *myerrno = NULL, *strerror = NULL, *filename = NULL;

PyObject *subslice = NULL;

if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)

return -1;

if (PyTuple_GET_SIZE(args) <= 1 || PyTuple_GET_SIZE(args) > 3) {

return 0;

}

if (!PyArg_UnpackTuple(args, "EnvironmentError", 2, 3,

&myerrno, &strerror, &filename)) {

return -1;

}

Py_CLEAR(self->myerrno); /* replacing */

self->myerrno = myerrno;

Py_INCREF(self->myerrno);

Py_CLEAR(self->strerror); /* replacing */

self->strerror = strerror;

Py_INCREF(self->strerror);

/* self->filename will remain Py_None otherwise */

if (filename != NULL) {

Py_CLEAR(self->filename); /* replacing */

self->filename = filename;

Py_INCREF(self->filename);

subslice = PyTuple_GetSlice(args, 0, 2);

if (!subslice)

return -1;

Py_DECREF(self->args); /* replacing args */

self->args = subslice;

}

return 0;

}

static int

EnvironmentError_clear(PyEnvironmentErrorObject *self)

{

Py_CLEAR(self->myerrno);

Py_CLEAR(self->strerror);

Py_CLEAR(self->filename);

return BaseException_clear((PyBaseExceptionObject *)self);

}

static void

EnvironmentError_dealloc(PyEnvironmentErrorObject *self)

{

_PyObject_GC_UNTRACK(self);

EnvironmentError_clear(self);

Py_TYPE(self)->tp_free((PyObject *)self);

}

static int

EnvironmentError_traverse(PyEnvironmentErrorObject *self, visitproc visit,

void *arg)

{

Py_VISIT(self->myerrno);

Py_VISIT(self->strerror);

Py_VISIT(self->filename);

return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);

}

static PyObject *

EnvironmentError_str(PyEnvironmentErrorObject *self)

{

if (self->filename)

return PyUnicode_FromFormat("[Errno %S] %S: %R",

self->myerrno ? self->myerrno: Py_None,

self->strerror ? self->strerror: Py_None,

self->filename);

else if (self->myerrno && self->strerror)

return PyUnicode_FromFormat("[Errno %S] %S",

self->myerrno ? self->myerrno: Py_None,

self->strerror ? self->strerror: Py_None);

else

return BaseException_str((PyBaseExceptionObject *)self);

}

static PyMemberDef EnvironmentError_members[] = {

{"errno", T_OBJECT, offsetof(PyEnvironmentErrorObject, myerrno), 0,

PyDoc_STR("exception errno")},

{"strerror", T_OBJECT, offsetof(PyEnvironmentErrorObject, strerror), 0,

PyDoc_STR("exception strerror")},

{"filename", T_OBJECT, offsetof(PyEnvironmentErrorObject, filename), 0,

PyDoc_STR("exception filename")},

{NULL} /* Sentinel */

};

static PyObject *

EnvironmentError_reduce(PyEnvironmentErrorObject *self)

{

PyObject *args = self->args;

PyObject *res = NULL, *tmp;

/* self->args is only the first two real arguments if there was a

if (PyTuple_GET_SIZE(args) == 2 && self->filename) {

args = PyTuple_New(3);

if (!args)

return NULL;

tmp = PyTuple_GET_ITEM(self->args, 0);

Py_INCREF(tmp);

PyTuple_SET_ITEM(args, 0, tmp);

tmp = PyTuple_GET_ITEM(self->args, 1);

Py_INCREF(tmp);

PyTuple_SET_ITEM(args, 1, tmp);

Py_INCREF(self->filename);

PyTuple_SET_ITEM(args, 2, self->filename);

} else

Py_INCREF(args);

if (self->dict)

res = PyTuple_Pack(3, Py_TYPE(self), args, self->dict);

else

res = PyTuple_Pack(2, Py_TYPE(self), args);

Py_DECREF(args);

return res;

}

static PyMethodDef EnvironmentError_methods[] = {

{"__reduce__", (PyCFunction)EnvironmentError_reduce, METH_NOARGS},

{NULL}

};

ComplexExtendsException(PyExc_Exception, EnvironmentError,

EnvironmentError, EnvironmentError_dealloc,

EnvironmentError_methods, EnvironmentError_members,

EnvironmentError_str,

"Base class for I/O related errors.");

MiddlingExtendsException(PyExc_EnvironmentError, IOError,

EnvironmentError, "I/O operation failed.");

MiddlingExtendsException(PyExc_EnvironmentError, OSError,

EnvironmentError, "OS system call failed.");

#ifdef MS_WINDOWS

#include "errmap.h"

static int

WindowsError_clear(PyWindowsErrorObject *self)

{

Py_CLEAR(self->myerrno);

Py_CLEAR(self->strerror);

Py_CLEAR(self->filename);

Py_CLEAR(self->winerror);

return BaseException_clear((PyBaseExceptionObject *)self);

}

static void

WindowsError_dealloc(PyWindowsErrorObject *self)

{

_PyObject_GC_UNTRACK(self);

WindowsError_clear(self);

Py_TYPE(self)->tp_free((PyObject *)self);

}

static int

WindowsError_traverse(PyWindowsErrorObject *self, visitproc visit, void *arg)

{

Py_VISIT(self->myerrno);

Py_VISIT(self->strerror);

Py_VISIT(self->filename);

Py_VISIT(self->winerror);

return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);

}

static int

WindowsError_init(PyWindowsErrorObject *self, PyObject *args, PyObject *kwds)

{

PyObject *o_errcode = NULL;

long errcode;

long posix_errno;

if (EnvironmentError_init((PyEnvironmentErrorObject *)self, args, kwds)

== -1)

return -1;

if (self->myerrno == NULL)

return 0;

/* Set errno to the POSIX errno, and winerror to the Win32

errcode = PyLong_AsLong(self->myerrno);

if (errcode == -1 && PyErr_Occurred())

return -1;

posix_errno = winerror_to_errno(errcode);

Py_CLEAR(self->winerror);

self->winerror = self->myerrno;

o_errcode = PyLong_FromLong(posix_errno);

if (!o_errcode)

return -1;

self->myerrno = o_errcode;

return 0;

}

static PyObject *

WindowsError_str(PyWindowsErrorObject *self)

{

if (self->filename)

return PyUnicode_FromFormat("[Error %S] %S: %R",

self->winerror ? self->winerror: Py_None,

self->strerror ? self->strerror: Py_None,

self->filename);

else if (self->winerror && self->strerror)

return PyUnicode_FromFormat("[Error %S] %S",

self->winerror ? self->winerror: Py_None,

self->strerror ? self->strerror: Py_None);

else

return EnvironmentError_str((PyEnvironmentErrorObject *)self);

}

static PyMemberDef WindowsError_members[] = {

{"errno", T_OBJECT, offsetof(PyWindowsErrorObject, myerrno), 0,

PyDoc_STR("POSIX exception code")},

{"strerror", T_OBJECT, offsetof(PyWindowsErrorObject, strerror), 0,

PyDoc_STR("exception strerror")},

{"filename", T_OBJECT, offsetof(PyWindowsErrorObject, filename), 0,

PyDoc_STR("exception filename")},

{"winerror", T_OBJECT, offsetof(PyWindowsErrorObject, winerror), 0,

PyDoc_STR("Win32 exception code")},

{NULL} /* Sentinel */

};

ComplexExtendsException(PyExc_OSError, WindowsError, WindowsError,

WindowsError_dealloc, 0, WindowsError_members,

WindowsError_str, "MS-Windows OS system call failed.");

#endif /* MS_WINDOWS */

#ifdef __VMS

MiddlingExtendsException(PyExc_OSError, VMSError, EnvironmentError,

"OpenVMS OS system call failed.");

SimpleExtendsException(PyExc_Exception, EOFError,

"Read beyond end of file.");

SimpleExtendsException(PyExc_Exception, RuntimeError,

"Unspecified run-time error.");

SimpleExtendsException(PyExc_RuntimeError, NotImplementedError,

"Method or function hasn't been implemented yet.");

SimpleExtendsException(PyExc_Exception, NameError,

"Name not found globally.");

SimpleExtendsException(PyExc_NameError, UnboundLocalError,

"Local name referenced but not bound to a value.");

SimpleExtendsException(PyExc_Exception, AttributeError,

"Attribute not found.");

static int

SyntaxError_init(PySyntaxErrorObject *self, PyObject *args, PyObject *kwds)

{

PyObject *info = NULL;

Py_ssize_t lenargs = PyTuple_GET_SIZE(args);

if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)

return -1;

if (lenargs >= 1) {

Py_CLEAR(self->msg);

self->msg = PyTuple_GET_ITEM(args, 0);

Py_INCREF(self->msg);

}

if (lenargs == 2) {

info = PyTuple_GET_ITEM(args, 1);

info = PySequence_Tuple(info);

if (!info)

return -1;

if (PyTuple_GET_SIZE(info) != 4) {

/* not a very good error message, but it's what Python 2.4 gives */

PyErr_SetString(PyExc_IndexError, "tuple index out of range");

Py_DECREF(info);

return -1;

}

Py_CLEAR(self->filename);

self->filename = PyTuple_GET_ITEM(info, 0);

Py_INCREF(self->filename);

Py_CLEAR(self->lineno);

self->lineno = PyTuple_GET_ITEM(info, 1);

Py_INCREF(self->lineno);

Py_CLEAR(self->offset);

self->offset = PyTuple_GET_ITEM(info, 2);

Py_INCREF(self->offset);

Py_CLEAR(self->text);

self->text = PyTuple_GET_ITEM(info, 3);

Py_INCREF(self->text);

Py_DECREF(info);

}

return 0;

}

static int

SyntaxError_clear(PySyntaxErrorObject *self)

{

Py_CLEAR(self->msg);

Py_CLEAR(self->filename);

Py_CLEAR(self->lineno);

Py_CLEAR(self->offset);

Py_CLEAR(self->text);

Py_CLEAR(self->print_file_and_line);

return BaseException_clear((PyBaseExceptionObject *)self);

}

static void

SyntaxError_dealloc(PySyntaxErrorObject *self)

{

_PyObject_GC_UNTRACK(self);

SyntaxError_clear(self);

Py_TYPE(self)->tp_free((PyObject *)self);

}

static int

SyntaxError_traverse(PySyntaxErrorObject *self, visitproc visit, void *arg)

{

Py_VISIT(self->msg);

Py_VISIT(self->filename);

Py_VISIT(self->lineno);

Py_VISIT(self->offset);

Py_VISIT(self->text);

Py_VISIT(self->print_file_and_line);

return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);

}

static PyObject*

my_basename(PyObject *name)

{

Py_UNICODE *unicode;

Py_ssize_t i, size, offset;

unicode = PyUnicode_AS_UNICODE(name);

size = PyUnicode_GET_SIZE(name);

offset = 0;

for(i=0; i < size; i++) {

if (unicode[i] == SEP)

offset = i + 1;

}

if (offset != 0) {

return PyUnicode_FromUnicode(

PyUnicode_AS_UNICODE(name) + offset,

size - offset);

} else {

Py_INCREF(name);

return name;

}

}

static PyObject *