EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS

[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.10 / Objects / exceptions.c

/*\r
 * New exceptions.c written in Iceland by Richard Jones and Georg Brandl.\r
 *\r
 * Thanks go to Tim Peters and Michael Hudson for debugging.\r
 */\r
\r
#define PY_SSIZE_T_CLEAN\r
#include <Python.h>\r
#include "structmember.h"\r
#include "osdefs.h"\r
\r
#define EXC_MODULE_NAME "exceptions."\r
\r
/* NOTE: If the exception class hierarchy changes, don't forget to update\r
 * Lib/test/exception_hierarchy.txt\r
 */\r
\r
PyDoc_STRVAR(exceptions_doc, "Python's standard exception class hierarchy.\n\\r
\n\\r
Exceptions found here are defined both in the exceptions module and the\n\\r
built-in namespace.  It is recommended that user-defined exceptions\n\\r
inherit from Exception.  See the documentation for the exception\n\\r
inheritance hierarchy.\n\\r
");\r
\r
/*\r
 *    BaseException\r
 */\r
static PyObject *\r
BaseException_new(PyTypeObject *type, PyObject *args, PyObject *kwds)\r
{\r
    PyBaseExceptionObject *self;\r
\r
    self = (PyBaseExceptionObject *)type->tp_alloc(type, 0);\r
    if (!self)\r
        return NULL;\r
    /* the dict is created on the fly in PyObject_GenericSetAttr */\r
    self->message = self->dict = NULL;\r
\r
    self->args = PyTuple_New(0);\r
    if (!self->args) {\r
        Py_DECREF(self);\r
        return NULL;\r
    }\r
\r
    self->message = PyString_FromString("");\r
    if (!self->message) {\r
        Py_DECREF(self);\r
        return NULL;\r
    }\r
\r
    return (PyObject *)self;\r
}\r
\r
static int\r
BaseException_init(PyBaseExceptionObject *self, PyObject *args, PyObject *kwds)\r
{\r
    if (!_PyArg_NoKeywords(Py_TYPE(self)->tp_name, kwds))\r
        return -1;\r
\r
    Py_DECREF(self->args);\r
    self->args = args;\r
    Py_INCREF(self->args);\r
\r
    if (PyTuple_GET_SIZE(self->args) == 1) {\r
        Py_CLEAR(self->message);\r
        self->message = PyTuple_GET_ITEM(self->args, 0);\r
        Py_INCREF(self->message);\r
    }\r
    return 0;\r
}\r
\r
static int\r
BaseException_clear(PyBaseExceptionObject *self)\r
{\r
    Py_CLEAR(self->dict);\r
    Py_CLEAR(self->args);\r
    Py_CLEAR(self->message);\r
    return 0;\r
}\r
\r
static void\r
BaseException_dealloc(PyBaseExceptionObject *self)\r
{\r
    _PyObject_GC_UNTRACK(self);\r
    BaseException_clear(self);\r
    Py_TYPE(self)->tp_free((PyObject *)self);\r
}\r
\r
static int\r
BaseException_traverse(PyBaseExceptionObject *self, visitproc visit, void *arg)\r
{\r
    Py_VISIT(self->dict);\r
    Py_VISIT(self->args);\r
    Py_VISIT(self->message);\r
    return 0;\r
}\r
\r
static PyObject *\r
BaseException_str(PyBaseExceptionObject *self)\r
{\r
    PyObject *out;\r
\r
    switch (PyTuple_GET_SIZE(self->args)) {\r
    case 0:\r
        out = PyString_FromString("");\r
        break;\r
    case 1:\r
        out = PyObject_Str(PyTuple_GET_ITEM(self->args, 0));\r
        break;\r
    default:\r
        out = PyObject_Str(self->args);\r
        break;\r
    }\r
\r
    return out;\r
}\r
\r
#ifdef Py_USING_UNICODE\r
static PyObject *\r
BaseException_unicode(PyBaseExceptionObject *self)\r
{\r
    PyObject *out;\r
\r
    /* issue6108: if __str__ has been overridden in the subclass, unicode()\r
       should return the message returned by __str__ as used to happen\r
       before this method was implemented. */\r
    if (Py_TYPE(self)->tp_str != (reprfunc)BaseException_str) {\r
        PyObject *str;\r
        /* Unlike PyObject_Str, tp_str can return unicode (i.e. return the\r
           equivalent of unicode(e.__str__()) instead of unicode(str(e))). */\r
        str = Py_TYPE(self)->tp_str((PyObject*)self);\r
        if (str == NULL)\r
            return NULL;\r
        out = PyObject_Unicode(str);\r
        Py_DECREF(str);\r
        return out;\r
    }\r
\r
    switch (PyTuple_GET_SIZE(self->args)) {\r
    case 0:\r
        out = PyUnicode_FromString("");\r
        break;\r
    case 1:\r
        out = PyObject_Unicode(PyTuple_GET_ITEM(self->args, 0));\r
        break;\r
    default:\r
        out = PyObject_Unicode(self->args);\r
        break;\r
    }\r
\r
    return out;\r
}\r
#endif\r
\r
static PyObject *\r
BaseException_repr(PyBaseExceptionObject *self)\r
{\r
    PyObject *repr_suffix;\r
    PyObject *repr;\r
    char *name;\r
    char *dot;\r
\r
    repr_suffix = PyObject_Repr(self->args);\r
    if (!repr_suffix)\r
        return NULL;\r
\r
    name = (char *)Py_TYPE(self)->tp_name;\r
    dot = strrchr(name, '.');\r
    if (dot != NULL) name = dot+1;\r
\r
    repr = PyString_FromString(name);\r
    if (!repr) {\r
        Py_DECREF(repr_suffix);\r
        return NULL;\r
    }\r
\r
    PyString_ConcatAndDel(&repr, repr_suffix);\r
    return repr;\r
}\r
\r
/* Pickling support */\r
static PyObject *\r
BaseException_reduce(PyBaseExceptionObject *self)\r
{\r
    if (self->args && self->dict)\r
        return PyTuple_Pack(3, Py_TYPE(self), self->args, self->dict);\r
    else\r
        return PyTuple_Pack(2, Py_TYPE(self), self->args);\r
}\r
\r
/*\r
 * Needed for backward compatibility, since exceptions used to store\r
 * all their attributes in the __dict__. Code is taken from cPickle's\r
 * load_build function.\r
 */\r
static PyObject *\r
BaseException_setstate(PyObject *self, PyObject *state)\r
{\r
    PyObject *d_key, *d_value;\r
    Py_ssize_t i = 0;\r
\r
    if (state != Py_None) {\r
        if (!PyDict_Check(state)) {\r
            PyErr_SetString(PyExc_TypeError, "state is not a dictionary");\r
            return NULL;\r
        }\r
        while (PyDict_Next(state, &i, &d_key, &d_value)) {\r
            if (PyObject_SetAttr(self, d_key, d_value) < 0)\r
                return NULL;\r
        }\r
    }\r
    Py_RETURN_NONE;\r
}\r
\r
\r
static PyMethodDef BaseException_methods[] = {\r
   {"__reduce__", (PyCFunction)BaseException_reduce, METH_NOARGS },\r
   {"__setstate__", (PyCFunction)BaseException_setstate, METH_O },\r
#ifdef Py_USING_UNICODE\r
   {"__unicode__", (PyCFunction)BaseException_unicode, METH_NOARGS },\r
#endif\r
   {NULL, NULL, 0, NULL},\r
};\r
\r
\r
\r
static PyObject *\r
BaseException_getitem(PyBaseExceptionObject *self, Py_ssize_t index)\r
{\r
    if (PyErr_WarnPy3k("__getitem__ not supported for exception "\r
                       "classes in 3.x; use args attribute", 1) < 0)\r
        return NULL;\r
    return PySequence_GetItem(self->args, index);\r
}\r
\r
static PyObject *\r
BaseException_getslice(PyBaseExceptionObject *self,\r
                        Py_ssize_t start, Py_ssize_t stop)\r
{\r
    if (PyErr_WarnPy3k("__getslice__ not supported for exception "\r
                       "classes in 3.x; use args attribute", 1) < 0)\r
        return NULL;\r
    return PySequence_GetSlice(self->args, start, stop);\r
}\r
\r
static PySequenceMethods BaseException_as_sequence = {\r
    0,                      /* sq_length; */\r
    0,                      /* sq_concat; */\r
    0,                      /* sq_repeat; */\r
    (ssizeargfunc)BaseException_getitem,  /* sq_item; */\r
    (ssizessizeargfunc)BaseException_getslice,  /* sq_slice; */\r
    0,                      /* sq_ass_item; */\r
    0,                      /* sq_ass_slice; */\r
    0,                      /* sq_contains; */\r
    0,                      /* sq_inplace_concat; */\r
    0                       /* sq_inplace_repeat; */\r
};\r
\r
static PyObject *\r
BaseException_get_dict(PyBaseExceptionObject *self)\r
{\r
    if (self->dict == NULL) {\r
        self->dict = PyDict_New();\r
        if (!self->dict)\r
            return NULL;\r
    }\r
    Py_INCREF(self->dict);\r
    return self->dict;\r
}\r
\r
static int\r
BaseException_set_dict(PyBaseExceptionObject *self, PyObject *val)\r
{\r
    if (val == NULL) {\r
        PyErr_SetString(PyExc_TypeError, "__dict__ may not be deleted");\r
        return -1;\r
    }\r
    if (!PyDict_Check(val)) {\r
        PyErr_SetString(PyExc_TypeError, "__dict__ must be a dictionary");\r
        return -1;\r
    }\r
    Py_CLEAR(self->dict);\r
    Py_INCREF(val);\r
    self->dict = val;\r
    return 0;\r
}\r
\r
static PyObject *\r
BaseException_get_args(PyBaseExceptionObject *self)\r
{\r
    if (self->args == NULL) {\r
        Py_INCREF(Py_None);\r
        return Py_None;\r
    }\r
    Py_INCREF(self->args);\r
    return self->args;\r
}\r
\r
static int\r
BaseException_set_args(PyBaseExceptionObject *self, PyObject *val)\r
{\r
    PyObject *seq;\r
    if (val == NULL) {\r
        PyErr_SetString(PyExc_TypeError, "args may not be deleted");\r
        return -1;\r
    }\r
    seq = PySequence_Tuple(val);\r
    if (!seq)\r
        return -1;\r
    Py_CLEAR(self->args);\r
    self->args = seq;\r
    return 0;\r
}\r
\r
static PyObject *\r
BaseException_get_message(PyBaseExceptionObject *self)\r
{\r
    PyObject *msg;\r
\r
    /* if "message" is in self->dict, accessing a user-set message attribute */\r
    if (self->dict &&\r
        (msg = PyDict_GetItemString(self->dict, "message"))) {\r
        Py_INCREF(msg);\r
        return msg;\r
    }\r
\r
    if (self->message == NULL) {\r
        PyErr_SetString(PyExc_AttributeError, "message attribute was deleted");\r
        return NULL;\r
    }\r
\r
    /* accessing the deprecated "builtin" message attribute of Exception */\r
    if (PyErr_WarnEx(PyExc_DeprecationWarning,\r
                     "BaseException.message has been deprecated as "\r
                     "of Python 2.6", 1) < 0)\r
        return NULL;\r
\r
    Py_INCREF(self->message);\r
    return self->message;\r
}\r
\r
static int\r
BaseException_set_message(PyBaseExceptionObject *self, PyObject *val)\r
{\r
    /* if val is NULL, delete the message attribute */\r
    if (val == NULL) {\r
        if (self->dict && PyDict_GetItemString(self->dict, "message")) {\r
            if (PyDict_DelItemString(self->dict, "message") < 0)\r
                return -1;\r
        }\r
        Py_CLEAR(self->message);\r
        return 0;\r
    }\r
\r
    /* else set it in __dict__, but may need to create the dict first */\r
    if (self->dict == NULL) {\r
        self->dict = PyDict_New();\r
        if (!self->dict)\r
            return -1;\r
    }\r
    return PyDict_SetItemString(self->dict, "message", val);\r
}\r
\r
static PyGetSetDef BaseException_getset[] = {\r
    {"__dict__", (getter)BaseException_get_dict, (setter)BaseException_set_dict},\r
    {"args", (getter)BaseException_get_args, (setter)BaseException_set_args},\r
    {"message", (getter)BaseException_get_message,\r
            (setter)BaseException_set_message},\r
    {NULL},\r
};\r
\r
\r
static PyTypeObject _PyExc_BaseException = {\r
    PyObject_HEAD_INIT(NULL)\r
    0,                          /*ob_size*/\r
    EXC_MODULE_NAME "BaseException", /*tp_name*/\r
    sizeof(PyBaseExceptionObject), /*tp_basicsize*/\r
    0,                          /*tp_itemsize*/\r
    (destructor)BaseException_dealloc, /*tp_dealloc*/\r
    0,                          /*tp_print*/\r
    0,                          /*tp_getattr*/\r
    0,                          /*tp_setattr*/\r
    0,                          /* tp_compare; */\r
    (reprfunc)BaseException_repr, /*tp_repr*/\r
    0,                          /*tp_as_number*/\r
    &BaseException_as_sequence, /*tp_as_sequence*/\r
    0,                          /*tp_as_mapping*/\r
    0,                          /*tp_hash */\r
    0,                          /*tp_call*/\r
    (reprfunc)BaseException_str,  /*tp_str*/\r
    PyObject_GenericGetAttr,    /*tp_getattro*/\r
    PyObject_GenericSetAttr,    /*tp_setattro*/\r
    0,                          /*tp_as_buffer*/\r
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC |\r
        Py_TPFLAGS_BASE_EXC_SUBCLASS,  /*tp_flags*/\r
    PyDoc_STR("Common base class for all exceptions"), /* tp_doc */\r
    (traverseproc)BaseException_traverse, /* tp_traverse */\r
    (inquiry)BaseException_clear, /* tp_clear */\r
    0,                          /* tp_richcompare */\r
    0,                          /* tp_weaklistoffset */\r
    0,                          /* tp_iter */\r
    0,                          /* tp_iternext */\r
    BaseException_methods,      /* tp_methods */\r
    0,                          /* tp_members */\r
    BaseException_getset,       /* tp_getset */\r
    0,                          /* tp_base */\r
    0,                          /* tp_dict */\r
    0,                          /* tp_descr_get */\r
    0,                          /* tp_descr_set */\r
    offsetof(PyBaseExceptionObject, dict), /* tp_dictoffset */\r
    (initproc)BaseException_init, /* tp_init */\r
    0,                          /* tp_alloc */\r
    BaseException_new,          /* tp_new */\r
};\r
/* the CPython API expects exceptions to be (PyObject *) - both a hold-over\r
from the previous implmentation and also allowing Python objects to be used\r
in the API */\r
PyObject *PyExc_BaseException = (PyObject *)&_PyExc_BaseException;\r
\r
/* note these macros omit the last semicolon so the macro invocation may\r
 * include it and not look strange.\r
 */\r
#define SimpleExtendsException(EXCBASE, EXCNAME, EXCDOC) \\r
static PyTypeObject _PyExc_ ## EXCNAME = { \\r
    PyObject_HEAD_INIT(NULL) \\r
    0, \\r
    EXC_MODULE_NAME # EXCNAME, \\r
    sizeof(PyBaseExceptionObject), \\r
    0, (destructor)BaseException_dealloc, 0, 0, 0, 0, 0, 0, 0, \\r
    0, 0, 0, 0, 0, 0, 0, \\r
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \\r
    PyDoc_STR(EXCDOC), (traverseproc)BaseException_traverse, \\r
    (inquiry)BaseException_clear, 0, 0, 0, 0, 0, 0, 0, &_ ## EXCBASE, \\r
    0, 0, 0, offsetof(PyBaseExceptionObject, dict), \\r
    (initproc)BaseException_init, 0, BaseException_new,\\r
}; \\r
PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME\r
\r
#define MiddlingExtendsException(EXCBASE, EXCNAME, EXCSTORE, EXCDOC) \\r
static PyTypeObject _PyExc_ ## EXCNAME = { \\r
    PyObject_HEAD_INIT(NULL) \\r
    0, \\r
    EXC_MODULE_NAME # EXCNAME, \\r
    sizeof(Py ## EXCSTORE ## Object), \\r
    0, (destructor)EXCSTORE ## _dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, \\r
    0, 0, 0, 0, 0, \\r
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \\r
    PyDoc_STR(EXCDOC), (traverseproc)EXCSTORE ## _traverse, \\r
    (inquiry)EXCSTORE ## _clear, 0, 0, 0, 0, 0, 0, 0, &_ ## EXCBASE, \\r
    0, 0, 0, offsetof(Py ## EXCSTORE ## Object, dict), \\r
    (initproc)EXCSTORE ## _init, 0, BaseException_new,\\r
}; \\r
PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME\r
\r
#define ComplexExtendsException(EXCBASE, EXCNAME, EXCSTORE, EXCDEALLOC, EXCMETHODS, EXCMEMBERS, EXCSTR, EXCDOC) \\r
static PyTypeObject _PyExc_ ## EXCNAME = { \\r
    PyObject_HEAD_INIT(NULL) \\r
    0, \\r
    EXC_MODULE_NAME # EXCNAME, \\r
    sizeof(Py ## EXCSTORE ## Object), 0, \\r
    (destructor)EXCSTORE ## _dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \\r
    (reprfunc)EXCSTR, 0, 0, 0, \\r
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \\r
    PyDoc_STR(EXCDOC), (traverseproc)EXCSTORE ## _traverse, \\r
    (inquiry)EXCSTORE ## _clear, 0, 0, 0, 0, EXCMETHODS, \\r
    EXCMEMBERS, 0, &_ ## EXCBASE, \\r
    0, 0, 0, offsetof(Py ## EXCSTORE ## Object, dict), \\r
    (initproc)EXCSTORE ## _init, 0, BaseException_new,\\r
}; \\r
PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME\r
\r
\r
/*\r
 *    Exception extends BaseException\r
 */\r
SimpleExtendsException(PyExc_BaseException, Exception,\r
                       "Common base class for all non-exit exceptions.");\r
\r
\r
/*\r
 *    StandardError extends Exception\r
 */\r
SimpleExtendsException(PyExc_Exception, StandardError,\r
    "Base class for all standard Python exceptions that do not represent\n"\r
    "interpreter exiting.");\r
\r
\r
/*\r
 *    TypeError extends StandardError\r
 */\r
SimpleExtendsException(PyExc_StandardError, TypeError,\r
                       "Inappropriate argument type.");\r
\r
\r
/*\r
 *    StopIteration extends Exception\r
 */\r
SimpleExtendsException(PyExc_Exception, StopIteration,\r
                       "Signal the end from iterator.next().");\r
\r
\r
/*\r
 *    GeneratorExit extends BaseException\r
 */\r
SimpleExtendsException(PyExc_BaseException, GeneratorExit,\r
                       "Request that a generator exit.");\r
\r
\r
/*\r
 *    SystemExit extends BaseException\r
 */\r
\r
static int\r
SystemExit_init(PySystemExitObject *self, PyObject *args, PyObject *kwds)\r
{\r
    Py_ssize_t size = PyTuple_GET_SIZE(args);\r
\r
    if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)\r
        return -1;\r
\r
    if (size == 0)\r
        return 0;\r
    Py_CLEAR(self->code);\r
    if (size == 1)\r
        self->code = PyTuple_GET_ITEM(args, 0);\r
    else if (size > 1)\r
        self->code = args;\r
    Py_INCREF(self->code);\r
    return 0;\r
}\r
\r
static int\r
SystemExit_clear(PySystemExitObject *self)\r
{\r
    Py_CLEAR(self->code);\r
    return BaseException_clear((PyBaseExceptionObject *)self);\r
}\r
\r
static void\r
SystemExit_dealloc(PySystemExitObject *self)\r
{\r
    _PyObject_GC_UNTRACK(self);\r
    SystemExit_clear(self);\r
    Py_TYPE(self)->tp_free((PyObject *)self);\r
}\r
\r
static int\r
SystemExit_traverse(PySystemExitObject *self, visitproc visit, void *arg)\r
{\r
    Py_VISIT(self->code);\r
    return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);\r
}\r
\r
static PyMemberDef SystemExit_members[] = {\r
    {"code", T_OBJECT, offsetof(PySystemExitObject, code), 0,\r
        PyDoc_STR("exception code")},\r
    {NULL}  /* Sentinel */\r
};\r
\r
ComplexExtendsException(PyExc_BaseException, SystemExit, SystemExit,\r
                        SystemExit_dealloc, 0, SystemExit_members, 0,\r
                        "Request to exit from the interpreter.");\r
\r
/*\r
 *    KeyboardInterrupt extends BaseException\r
 */\r
SimpleExtendsException(PyExc_BaseException, KeyboardInterrupt,\r
                       "Program interrupted by user.");\r
\r
\r
/*\r
 *    ImportError extends StandardError\r
 */\r
SimpleExtendsException(PyExc_StandardError, ImportError,\r
          "Import can't find module, or can't find name in module.");\r
\r
\r
/*\r
 *    EnvironmentError extends StandardError\r
 */\r
\r
/* Where a function has a single filename, such as open() or some\r
 * of the os module functions, PyErr_SetFromErrnoWithFilename() is\r
 * called, giving a third argument which is the filename.  But, so\r
 * that old code using in-place unpacking doesn't break, e.g.:\r
 *\r
 * except IOError, (errno, strerror):\r
 *\r
 * we hack args so that it only contains two items.  This also\r
 * means we need our own __str__() which prints out the filename\r
 * when it was supplied.\r
 */\r
static int\r
EnvironmentError_init(PyEnvironmentErrorObject *self, PyObject *args,\r
    PyObject *kwds)\r
{\r
    PyObject *myerrno = NULL, *strerror = NULL, *filename = NULL;\r
    PyObject *subslice = NULL;\r
\r
    if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)\r
        return -1;\r
\r
    if (PyTuple_GET_SIZE(args) <= 1 || PyTuple_GET_SIZE(args) > 3) {\r
        return 0;\r
    }\r
\r
    if (!PyArg_UnpackTuple(args, "EnvironmentError", 2, 3,\r
                           &myerrno, &strerror, &filename)) {\r
        return -1;\r
    }\r
    Py_CLEAR(self->myerrno);       /* replacing */\r
    self->myerrno = myerrno;\r
    Py_INCREF(self->myerrno);\r
\r
    Py_CLEAR(self->strerror);      /* replacing */\r
    self->strerror = strerror;\r
    Py_INCREF(self->strerror);\r
\r
    /* self->filename will remain Py_None otherwise */\r
    if (filename != NULL) {\r
        Py_CLEAR(self->filename);      /* replacing */\r
        self->filename = filename;\r
        Py_INCREF(self->filename);\r
\r
        subslice = PyTuple_GetSlice(args, 0, 2);\r
        if (!subslice)\r
            return -1;\r
\r
        Py_DECREF(self->args);  /* replacing args */\r
        self->args = subslice;\r
    }\r
    return 0;\r
}\r
\r
static int\r
EnvironmentError_clear(PyEnvironmentErrorObject *self)\r
{\r
    Py_CLEAR(self->myerrno);\r
    Py_CLEAR(self->strerror);\r
    Py_CLEAR(self->filename);\r
    return BaseException_clear((PyBaseExceptionObject *)self);\r
}\r
\r
static void\r
EnvironmentError_dealloc(PyEnvironmentErrorObject *self)\r
{\r
    _PyObject_GC_UNTRACK(self);\r
    EnvironmentError_clear(self);\r
    Py_TYPE(self)->tp_free((PyObject *)self);\r
}\r
\r
static int\r
EnvironmentError_traverse(PyEnvironmentErrorObject *self, visitproc visit,\r
        void *arg)\r
{\r
    Py_VISIT(self->myerrno);\r
    Py_VISIT(self->strerror);\r
    Py_VISIT(self->filename);\r
    return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);\r
}\r
\r
static PyObject *\r
EnvironmentError_str(PyEnvironmentErrorObject *self)\r
{\r
    PyObject *rtnval = NULL;\r
\r
    if (self->filename) {\r
        PyObject *fmt;\r
        PyObject *repr;\r
        PyObject *tuple;\r
\r
        fmt = PyString_FromString("[Errno %s] %s: %s");\r
        if (!fmt)\r
            return NULL;\r
\r
        repr = PyObject_Repr(self->filename);\r
        if (!repr) {\r
            Py_DECREF(fmt);\r
            return NULL;\r
        }\r
        tuple = PyTuple_New(3);\r
        if (!tuple) {\r
            Py_DECREF(repr);\r
            Py_DECREF(fmt);\r
            return NULL;\r
        }\r
\r
        if (self->myerrno) {\r
            Py_INCREF(self->myerrno);\r
            PyTuple_SET_ITEM(tuple, 0, self->myerrno);\r
        }\r
        else {\r
            Py_INCREF(Py_None);\r
            PyTuple_SET_ITEM(tuple, 0, Py_None);\r
        }\r
        if (self->strerror) {\r
            Py_INCREF(self->strerror);\r
            PyTuple_SET_ITEM(tuple, 1, self->strerror);\r
        }\r
        else {\r
            Py_INCREF(Py_None);\r
            PyTuple_SET_ITEM(tuple, 1, Py_None);\r
        }\r
\r
        PyTuple_SET_ITEM(tuple, 2, repr);\r
\r
        rtnval = PyString_Format(fmt, tuple);\r
\r
        Py_DECREF(fmt);\r
        Py_DECREF(tuple);\r
    }\r
    else if (self->myerrno && self->strerror) {\r
        PyObject *fmt;\r
        PyObject *tuple;\r
\r
        fmt = PyString_FromString("[Errno %s] %s");\r
        if (!fmt)\r
            return NULL;\r
\r
        tuple = PyTuple_New(2);\r
        if (!tuple) {\r
            Py_DECREF(fmt);\r
            return NULL;\r
        }\r
\r
        if (self->myerrno) {\r
            Py_INCREF(self->myerrno);\r
            PyTuple_SET_ITEM(tuple, 0, self->myerrno);\r
        }\r
        else {\r
            Py_INCREF(Py_None);\r
            PyTuple_SET_ITEM(tuple, 0, Py_None);\r
        }\r
        if (self->strerror) {\r
            Py_INCREF(self->strerror);\r
            PyTuple_SET_ITEM(tuple, 1, self->strerror);\r
        }\r
        else {\r
            Py_INCREF(Py_None);\r
            PyTuple_SET_ITEM(tuple, 1, Py_None);\r
        }\r
\r
        rtnval = PyString_Format(fmt, tuple);\r
\r
        Py_DECREF(fmt);\r
        Py_DECREF(tuple);\r
    }\r
    else\r
        rtnval = BaseException_str((PyBaseExceptionObject *)self);\r
\r
    return rtnval;\r
}\r
\r
static PyMemberDef EnvironmentError_members[] = {\r
    {"errno", T_OBJECT, offsetof(PyEnvironmentErrorObject, myerrno), 0,\r
        PyDoc_STR("exception errno")},\r
    {"strerror", T_OBJECT, offsetof(PyEnvironmentErrorObject, strerror), 0,\r
        PyDoc_STR("exception strerror")},\r
    {"filename", T_OBJECT, offsetof(PyEnvironmentErrorObject, filename), 0,\r
        PyDoc_STR("exception filename")},\r
    {NULL}  /* Sentinel */\r
};\r
\r
\r
static PyObject *\r
EnvironmentError_reduce(PyEnvironmentErrorObject *self)\r
{\r
    PyObject *args = self->args;\r
    PyObject *res = NULL, *tmp;\r
\r
    /* self->args is only the first two real arguments if there was a\r
     * file name given to EnvironmentError. */\r
    if (PyTuple_GET_SIZE(args) == 2 && self->filename) {\r
        args = PyTuple_New(3);\r
        if (!args)\r
            return NULL;\r
\r
        tmp = PyTuple_GET_ITEM(self->args, 0);\r
        Py_INCREF(tmp);\r
        PyTuple_SET_ITEM(args, 0, tmp);\r
\r
        tmp = PyTuple_GET_ITEM(self->args, 1);\r
        Py_INCREF(tmp);\r
        PyTuple_SET_ITEM(args, 1, tmp);\r
\r
        Py_INCREF(self->filename);\r
        PyTuple_SET_ITEM(args, 2, self->filename);\r
    } else\r
        Py_INCREF(args);\r
\r
    if (self->dict)\r
        res = PyTuple_Pack(3, Py_TYPE(self), args, self->dict);\r
    else\r
        res = PyTuple_Pack(2, Py_TYPE(self), args);\r
    Py_DECREF(args);\r
    return res;\r
}\r
\r
\r
static PyMethodDef EnvironmentError_methods[] = {\r
    {"__reduce__", (PyCFunction)EnvironmentError_reduce, METH_NOARGS},\r
    {NULL}\r
};\r
\r
ComplexExtendsException(PyExc_StandardError, EnvironmentError,\r
                        EnvironmentError, EnvironmentError_dealloc,\r
                        EnvironmentError_methods, EnvironmentError_members,\r
                        EnvironmentError_str,\r
                        "Base class for I/O related errors.");\r
\r
\r
/*\r
 *    IOError extends EnvironmentError\r
 */\r
MiddlingExtendsException(PyExc_EnvironmentError, IOError,\r
                         EnvironmentError, "I/O operation failed.");\r
\r
\r
/*\r
 *    OSError extends EnvironmentError\r
 */\r
MiddlingExtendsException(PyExc_EnvironmentError, OSError,\r
                         EnvironmentError, "OS system call failed.");\r
\r
\r
/*\r
 *    WindowsError extends OSError\r
 */\r
#ifdef MS_WINDOWS\r
#include "errmap.h"\r
\r
static int\r
WindowsError_clear(PyWindowsErrorObject *self)\r
{\r
    Py_CLEAR(self->myerrno);\r
    Py_CLEAR(self->strerror);\r
    Py_CLEAR(self->filename);\r
    Py_CLEAR(self->winerror);\r
    return BaseException_clear((PyBaseExceptionObject *)self);\r
}\r
\r
static void\r
WindowsError_dealloc(PyWindowsErrorObject *self)\r
{\r
    _PyObject_GC_UNTRACK(self);\r
    WindowsError_clear(self);\r
    Py_TYPE(self)->tp_free((PyObject *)self);\r
}\r
\r
static int\r
WindowsError_traverse(PyWindowsErrorObject *self, visitproc visit, void *arg)\r
{\r
    Py_VISIT(self->myerrno);\r
    Py_VISIT(self->strerror);\r
    Py_VISIT(self->filename);\r
    Py_VISIT(self->winerror);\r
    return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);\r
}\r
\r
static int\r
WindowsError_init(PyWindowsErrorObject *self, PyObject *args, PyObject *kwds)\r
{\r
    PyObject *o_errcode = NULL;\r
    long errcode;\r
    long posix_errno;\r
\r
    if (EnvironmentError_init((PyEnvironmentErrorObject *)self, args, kwds)\r
            == -1)\r
        return -1;\r
\r
    if (self->myerrno == NULL)\r
        return 0;\r
\r
    /* Set errno to the POSIX errno, and winerror to the Win32\r
       error code. */\r
    errcode = PyInt_AsLong(self->myerrno);\r
    if (errcode == -1 && PyErr_Occurred())\r
        return -1;\r
    posix_errno = winerror_to_errno(errcode);\r
\r
    Py_CLEAR(self->winerror);\r
    self->winerror = self->myerrno;\r
\r
    o_errcode = PyInt_FromLong(posix_errno);\r
    if (!o_errcode)\r
        return -1;\r
\r
    self->myerrno = o_errcode;\r
\r
    return 0;\r
}\r
\r
\r
static PyObject *\r
WindowsError_str(PyWindowsErrorObject *self)\r
{\r
    PyObject *rtnval = NULL;\r
\r
    if (self->filename) {\r
        PyObject *fmt;\r
        PyObject *repr;\r
        PyObject *tuple;\r
\r
        fmt = PyString_FromString("[Error %s] %s: %s");\r
        if (!fmt)\r
            return NULL;\r
\r
        repr = PyObject_Repr(self->filename);\r
        if (!repr) {\r
            Py_DECREF(fmt);\r
            return NULL;\r
        }\r
        tuple = PyTuple_New(3);\r
        if (!tuple) {\r
            Py_DECREF(repr);\r
            Py_DECREF(fmt);\r
            return NULL;\r
        }\r
\r
        if (self->winerror) {\r
            Py_INCREF(self->winerror);\r
            PyTuple_SET_ITEM(tuple, 0, self->winerror);\r
        }\r
        else {\r
            Py_INCREF(Py_None);\r
            PyTuple_SET_ITEM(tuple, 0, Py_None);\r
        }\r
        if (self->strerror) {\r
            Py_INCREF(self->strerror);\r
            PyTuple_SET_ITEM(tuple, 1, self->strerror);\r
        }\r
        else {\r
            Py_INCREF(Py_None);\r
            PyTuple_SET_ITEM(tuple, 1, Py_None);\r
        }\r
\r
        PyTuple_SET_ITEM(tuple, 2, repr);\r
\r
        rtnval = PyString_Format(fmt, tuple);\r
\r
        Py_DECREF(fmt);\r
        Py_DECREF(tuple);\r
    }\r
    else if (self->winerror && self->strerror) {\r
        PyObject *fmt;\r
        PyObject *tuple;\r
\r
        fmt = PyString_FromString("[Error %s] %s");\r
        if (!fmt)\r
            return NULL;\r
\r
        tuple = PyTuple_New(2);\r
        if (!tuple) {\r
            Py_DECREF(fmt);\r
            return NULL;\r
        }\r
\r
        if (self->winerror) {\r
            Py_INCREF(self->winerror);\r
            PyTuple_SET_ITEM(tuple, 0, self->winerror);\r
        }\r
        else {\r
            Py_INCREF(Py_None);\r
            PyTuple_SET_ITEM(tuple, 0, Py_None);\r
        }\r
        if (self->strerror) {\r
            Py_INCREF(self->strerror);\r
            PyTuple_SET_ITEM(tuple, 1, self->strerror);\r
        }\r
        else {\r
            Py_INCREF(Py_None);\r
            PyTuple_SET_ITEM(tuple, 1, Py_None);\r
        }\r
\r
        rtnval = PyString_Format(fmt, tuple);\r
\r
        Py_DECREF(fmt);\r
        Py_DECREF(tuple);\r
    }\r
    else\r
        rtnval = EnvironmentError_str((PyEnvironmentErrorObject *)self);\r
\r
    return rtnval;\r
}\r
\r
static PyMemberDef WindowsError_members[] = {\r
    {"errno", T_OBJECT, offsetof(PyWindowsErrorObject, myerrno), 0,\r
        PyDoc_STR("POSIX exception code")},\r
    {"strerror", T_OBJECT, offsetof(PyWindowsErrorObject, strerror), 0,\r
        PyDoc_STR("exception strerror")},\r
    {"filename", T_OBJECT, offsetof(PyWindowsErrorObject, filename), 0,\r
        PyDoc_STR("exception filename")},\r
    {"winerror", T_OBJECT, offsetof(PyWindowsErrorObject, winerror), 0,\r
        PyDoc_STR("Win32 exception code")},\r
    {NULL}  /* Sentinel */\r
};\r
\r
ComplexExtendsException(PyExc_OSError, WindowsError, WindowsError,\r
                        WindowsError_dealloc, 0, WindowsError_members,\r
                        WindowsError_str, "MS-Windows OS system call failed.");\r
\r
#endif /* MS_WINDOWS */\r
\r
\r
/*\r
 *    VMSError extends OSError (I think)\r
 */\r
#ifdef __VMS\r
MiddlingExtendsException(PyExc_OSError, VMSError, EnvironmentError,\r
                         "OpenVMS OS system call failed.");\r
#endif\r
\r
\r
/*\r
 *    EOFError extends StandardError\r
 */\r
SimpleExtendsException(PyExc_StandardError, EOFError,\r
                       "Read beyond end of file.");\r
\r
\r
/*\r
 *    RuntimeError extends StandardError\r
 */\r
SimpleExtendsException(PyExc_StandardError, RuntimeError,\r
                       "Unspecified run-time error.");\r
\r
\r
/*\r
 *    NotImplementedError extends RuntimeError\r
 */\r
SimpleExtendsException(PyExc_RuntimeError, NotImplementedError,\r
                       "Method or function hasn't been implemented yet.");\r
\r
/*\r
 *    NameError extends StandardError\r
 */\r
SimpleExtendsException(PyExc_StandardError, NameError,\r
                       "Name not found globally.");\r
\r
/*\r
 *    UnboundLocalError extends NameError\r
 */\r
SimpleExtendsException(PyExc_NameError, UnboundLocalError,\r
                       "Local name referenced but not bound to a value.");\r
\r
/*\r
 *    AttributeError extends StandardError\r
 */\r
SimpleExtendsException(PyExc_StandardError, AttributeError,\r
                       "Attribute not found.");\r
\r
\r
/*\r
 *    SyntaxError extends StandardError\r
 */\r
\r
static int\r
SyntaxError_init(PySyntaxErrorObject *self, PyObject *args, PyObject *kwds)\r
{\r
    PyObject *info = NULL;\r
    Py_ssize_t lenargs = PyTuple_GET_SIZE(args);\r
\r
    if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)\r
        return -1;\r
\r
    if (lenargs >= 1) {\r
        Py_CLEAR(self->msg);\r
        self->msg = PyTuple_GET_ITEM(args, 0);\r
        Py_INCREF(self->msg);\r
    }\r
    if (lenargs == 2) {\r
        info = PyTuple_GET_ITEM(args, 1);\r
        info = PySequence_Tuple(info);\r
        if (!info)\r
            return -1;\r
\r
        if (PyTuple_GET_SIZE(info) != 4) {\r
            /* not a very good error message, but it's what Python 2.4 gives */\r
            PyErr_SetString(PyExc_IndexError, "tuple index out of range");\r
            Py_DECREF(info);\r
            return -1;\r
        }\r
\r
        Py_CLEAR(self->filename);\r
        self->filename = PyTuple_GET_ITEM(info, 0);\r
        Py_INCREF(self->filename);\r
\r
        Py_CLEAR(self->lineno);\r
        self->lineno = PyTuple_GET_ITEM(info, 1);\r
        Py_INCREF(self->lineno);\r
\r
        Py_CLEAR(self->offset);\r
        self->offset = PyTuple_GET_ITEM(info, 2);\r
        Py_INCREF(self->offset);\r
\r
        Py_CLEAR(self->text);\r
        self->text = PyTuple_GET_ITEM(info, 3);\r
        Py_INCREF(self->text);\r
\r
        Py_DECREF(info);\r
    }\r
    return 0;\r
}\r
\r
static int\r
SyntaxError_clear(PySyntaxErrorObject *self)\r
{\r
    Py_CLEAR(self->msg);\r
    Py_CLEAR(self->filename);\r
    Py_CLEAR(self->lineno);\r
    Py_CLEAR(self->offset);\r
    Py_CLEAR(self->text);\r
    Py_CLEAR(self->print_file_and_line);\r
    return BaseException_clear((PyBaseExceptionObject *)self);\r
}\r
\r
static void\r
SyntaxError_dealloc(PySyntaxErrorObject *self)\r
{\r
    _PyObject_GC_UNTRACK(self);\r
    SyntaxError_clear(self);\r
    Py_TYPE(self)->tp_free((PyObject *)self);\r
}\r
\r
static int\r
SyntaxError_traverse(PySyntaxErrorObject *self, visitproc visit, void *arg)\r
{\r
    Py_VISIT(self->msg);\r
    Py_VISIT(self->filename);\r
    Py_VISIT(self->lineno);\r
    Py_VISIT(self->offset);\r
    Py_VISIT(self->text);\r
    Py_VISIT(self->print_file_and_line);\r
    return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);\r
}\r
\r
/* This is called "my_basename" instead of just "basename" to avoid name\r
   conflicts with glibc; basename is already prototyped if _GNU_SOURCE is\r
   defined, and Python does define that. */\r
static char *\r
my_basename(char *name)\r
{\r
    char *cp = name;\r
    char *result = name;\r
\r
    if (name == NULL)\r
        return "???";\r
    while (*cp != '\0') {\r
        if (*cp == SEP)\r
            result = cp + 1;\r
        ++cp;\r
    }\r
    return result;\r
}\r
\r
\r
static PyObject *\r
SyntaxError_str(PySyntaxErrorObject *self)\r
{\r
    PyObject *str;\r
    PyObject *result;\r
    int have_filename = 0;\r
    int have_lineno = 0;\r
    char *buffer = NULL;\r
    Py_ssize_t bufsize;\r
\r
    if (self->msg)\r
        str = PyObject_Str(self->msg);\r
    else\r
        str = PyObject_Str(Py_None);\r
    if (!str)\r
        return NULL;\r
    /* Don't fiddle with non-string return (shouldn't happen anyway) */\r
    if (!PyString_Check(str))\r
        return str;\r
\r
    /* XXX -- do all the additional formatting with filename and\r
       lineno here */\r
\r
    have_filename = (self->filename != NULL) &&\r
        PyString_Check(self->filename);\r
    have_lineno = (self->lineno != NULL) && PyInt_Check(self->lineno);\r
\r
    if (!have_filename && !have_lineno)\r
        return str;\r
\r
    bufsize = PyString_GET_SIZE(str) + 64;\r
    if (have_filename)\r
        bufsize += PyString_GET_SIZE(self->filename);\r
\r
    buffer = PyMem_MALLOC(bufsize);\r
    if (buffer == NULL)\r
        return str;\r
\r
    if (have_filename && have_lineno)\r
        PyOS_snprintf(buffer, bufsize, "%s (%s, line %ld)",\r
            PyString_AS_STRING(str),\r
            my_basename(PyString_AS_STRING(self->filename)),\r
            PyInt_AsLong(self->lineno));\r
    else if (have_filename)\r
        PyOS_snprintf(buffer, bufsize, "%s (%s)",\r
            PyString_AS_STRING(str),\r
            my_basename(PyString_AS_STRING(self->filename)));\r
    else /* only have_lineno */\r
        PyOS_snprintf(buffer, bufsize, "%s (line %ld)",\r
            PyString_AS_STRING(str),\r
            PyInt_AsLong(self->lineno));\r
\r
    result = PyString_FromString(buffer);\r
    PyMem_FREE(buffer);\r
\r
    if (result == NULL)\r
        result = str;\r
    else\r
        Py_DECREF(str);\r
    return result;\r
}\r
\r
static PyMemberDef SyntaxError_members[] = {\r
    {"msg", T_OBJECT, offsetof(PySyntaxErrorObject, msg), 0,\r
        PyDoc_STR("exception msg")},\r
    {"filename", T_OBJECT, offsetof(PySyntaxErrorObject, filename), 0,\r
        PyDoc_STR("exception filename")},\r
    {"lineno", T_OBJECT, offsetof(PySyntaxErrorObject, lineno), 0,\r
        PyDoc_STR("exception lineno")},\r
    {"offset", T_OBJECT, offsetof(PySyntaxErrorObject, offset), 0,\r
        PyDoc_STR("exception offset")},\r
    {"text", T_OBJECT, offsetof(PySyntaxErrorObject, text), 0,\r
        PyDoc_STR("exception text")},\r
    {"print_file_and_line", T_OBJECT,\r
        offsetof(PySyntaxErrorObject, print_file_and_line), 0,\r
        PyDoc_STR("exception print_file_and_line")},\r
    {NULL}  /* Sentinel */\r
};\r
\r
ComplexExtendsException(PyExc_StandardError, SyntaxError, SyntaxError,\r
                        SyntaxError_dealloc, 0, SyntaxError_members,\r
                        SyntaxError_str, "Invalid syntax.");\r
\r
\r
/*\r
 *    IndentationError extends SyntaxError\r
 */\r
MiddlingExtendsException(PyExc_SyntaxError, IndentationError, SyntaxError,\r
                         "Improper indentation.");\r
\r
\r
/*\r
 *    TabError extends IndentationError\r
 */\r
MiddlingExtendsException(PyExc_IndentationError, TabError, SyntaxError,\r
                         "Improper mixture of spaces and tabs.");\r
\r
\r
/*\r
 *    LookupError extends StandardError\r
 */\r
SimpleExtendsException(PyExc_StandardError, LookupError,\r
                       "Base class for lookup errors.");\r
\r
\r
/*\r
 *    IndexError extends LookupError\r
 */\r
SimpleExtendsException(PyExc_LookupError, IndexError,\r
                       "Sequence index out of range.");\r
\r
\r
/*\r
 *    KeyError extends LookupError\r
 */\r
static PyObject *\r
KeyError_str(PyBaseExceptionObject *self)\r
{\r
    /* If args is a tuple of exactly one item, apply repr to args[0].\r
       This is done so that e.g. the exception raised by {}[''] prints\r
         KeyError: ''\r
       rather than the confusing\r
         KeyError\r
       alone.  The downside is that if KeyError is raised with an explanatory\r
       string, that string will be displayed in quotes.  Too bad.\r
       If args is anything else, use the default BaseException__str__().\r
    */\r
    if (PyTuple_GET_SIZE(self->args) == 1) {\r
        return PyObject_Repr(PyTuple_GET_ITEM(self->args, 0));\r
    }\r
    return BaseException_str(self);\r
}\r
\r
ComplexExtendsException(PyExc_LookupError, KeyError, BaseException,\r
                        0, 0, 0, KeyError_str, "Mapping key not found.");\r
\r
\r
/*\r
 *    ValueError extends StandardError\r
 */\r
SimpleExtendsException(PyExc_StandardError, ValueError,\r
                       "Inappropriate argument value (of correct type).");\r
\r
/*\r
 *    UnicodeError extends ValueError\r
 */\r
\r
SimpleExtendsException(PyExc_ValueError, UnicodeError,\r
                       "Unicode related error.");\r
\r
#ifdef Py_USING_UNICODE\r
static PyObject *\r
get_string(PyObject *attr, const char *name)\r
{\r
    if (!attr) {\r
        PyErr_Format(PyExc_TypeError, "%.200s attribute not set", name);\r
        return NULL;\r
    }\r
\r
    if (!PyString_Check(attr)) {\r
        PyErr_Format(PyExc_TypeError, "%.200s attribute must be str", name);\r
        return NULL;\r
    }\r
    Py_INCREF(attr);\r
    return attr;\r
}\r
\r
\r
static int\r
set_string(PyObject **attr, const char *value)\r
{\r
    PyObject *obj = PyString_FromString(value);\r
    if (!obj)\r
        return -1;\r
    Py_CLEAR(*attr);\r
    *attr = obj;\r
    return 0;\r
}\r
\r
\r
static PyObject *\r
get_unicode(PyObject *attr, const char *name)\r
{\r
    if (!attr) {\r
        PyErr_Format(PyExc_TypeError, "%.200s attribute not set", name);\r
        return NULL;\r
    }\r
\r
    if (!PyUnicode_Check(attr)) {\r
        PyErr_Format(PyExc_TypeError,\r
                     "%.200s attribute must be unicode", name);\r
        return NULL;\r
    }\r
    Py_INCREF(attr);\r
    return attr;\r
}\r
\r
PyObject *\r
PyUnicodeEncodeError_GetEncoding(PyObject *exc)\r
{\r
    return get_string(((PyUnicodeErrorObject *)exc)->encoding, "encoding");\r
}\r
\r
PyObject *\r
PyUnicodeDecodeError_GetEncoding(PyObject *exc)\r
{\r
    return get_string(((PyUnicodeErrorObject *)exc)->encoding, "encoding");\r
}\r
\r
PyObject *\r
PyUnicodeEncodeError_GetObject(PyObject *exc)\r
{\r
    return get_unicode(((PyUnicodeErrorObject *)exc)->object, "object");\r
}\r
\r
PyObject *\r
PyUnicodeDecodeError_GetObject(PyObject *exc)\r
{\r
    return get_string(((PyUnicodeErrorObject *)exc)->object, "object");\r
}\r
\r
PyObject *\r
PyUnicodeTranslateError_GetObject(PyObject *exc)\r
{\r
    return get_unicode(((PyUnicodeErrorObject *)exc)->object, "object");\r
}\r
\r
int\r
PyUnicodeEncodeError_GetStart(PyObject *exc, Py_ssize_t *start)\r
{\r
    Py_ssize_t size;\r
    PyObject *obj = get_unicode(((PyUnicodeErrorObject *)exc)->object,\r
                                "object");\r
    if (!obj)\r
        return -1;\r
    *start = ((PyUnicodeErrorObject *)exc)->start;\r
    size = PyUnicode_GET_SIZE(obj);\r
    if (*start<0)\r
        *start = 0; /*XXX check for values <0*/\r
    if (*start>=size)\r
        *start = size-1;\r
    Py_DECREF(obj);\r
    return 0;\r
}\r
\r
\r
int\r
PyUnicodeDecodeError_GetStart(PyObject *exc, Py_ssize_t *start)\r
{\r
    Py_ssize_t size;\r
    PyObject *obj = get_string(((PyUnicodeErrorObject *)exc)->object,\r
                               "object");\r
    if (!obj)\r
        return -1;\r
    size = PyString_GET_SIZE(obj);\r
    *start = ((PyUnicodeErrorObject *)exc)->start;\r
    if (*start<0)\r
        *start = 0;\r
    if (*start>=size)\r
        *start = size-1;\r
    Py_DECREF(obj);\r
    return 0;\r
}\r
\r
\r
int\r
PyUnicodeTranslateError_GetStart(PyObject *exc, Py_ssize_t *start)\r
{\r
    return PyUnicodeEncodeError_GetStart(exc, start);\r
}\r
\r
\r
int\r
PyUnicodeEncodeError_SetStart(PyObject *exc, Py_ssize_t start)\r
{\r
    ((PyUnicodeErrorObject *)exc)->start = start;\r
    return 0;\r
}\r
\r
\r
int\r
PyUnicodeDecodeError_SetStart(PyObject *exc, Py_ssize_t start)\r
{\r
    ((PyUnicodeErrorObject *)exc)->start = start;\r
    return 0;\r
}\r
\r
\r
int\r
PyUnicodeTranslateError_SetStart(PyObject *exc, Py_ssize_t start)\r
{\r
    ((PyUnicodeErrorObject *)exc)->start = start;\r
    return 0;\r
}\r
\r
\r
int\r
PyUnicodeEncodeError_GetEnd(PyObject *exc, Py_ssize_t *end)\r
{\r
    Py_ssize_t size;\r
    PyObject *obj = get_unicode(((PyUnicodeErrorObject *)exc)->object,\r
                                "object");\r
    if (!obj)\r
        return -1;\r
    *end = ((PyUnicodeErrorObject *)exc)->end;\r
    size = PyUnicode_GET_SIZE(obj);\r
    if (*end<1)\r
        *end = 1;\r
    if (*end>size)\r
        *end = size;\r
    Py_DECREF(obj);\r
    return 0;\r
}\r
\r
\r
int\r
PyUnicodeDecodeError_GetEnd(PyObject *exc, Py_ssize_t *end)\r
{\r
    Py_ssize_t size;\r
    PyObject *obj = get_string(((PyUnicodeErrorObject *)exc)->object,\r
                               "object");\r
    if (!obj)\r
        return -1;\r
    *end = ((PyUnicodeErrorObject *)exc)->end;\r
    size = PyString_GET_SIZE(obj);\r
    if (*end<1)\r
        *end = 1;\r
    if (*end>size)\r
        *end = size;\r
    Py_DECREF(obj);\r
    return 0;\r
}\r
\r
\r
int\r
PyUnicodeTranslateError_GetEnd(PyObject *exc, Py_ssize_t *start)\r
{\r
    return PyUnicodeEncodeError_GetEnd(exc, start);\r
}\r
\r
\r
int\r
PyUnicodeEncodeError_SetEnd(PyObject *exc, Py_ssize_t end)\r
{\r
    ((PyUnicodeErrorObject *)exc)->end = end;\r
    return 0;\r
}\r
\r
\r
int\r
PyUnicodeDecodeError_SetEnd(PyObject *exc, Py_ssize_t end)\r
{\r
    ((PyUnicodeErrorObject *)exc)->end = end;\r
    return 0;\r
}\r
\r
\r
int\r
PyUnicodeTranslateError_SetEnd(PyObject *exc, Py_ssize_t end)\r
{\r
    ((PyUnicodeErrorObject *)exc)->end = end;\r
    return 0;\r
}\r
\r
PyObject *\r
PyUnicodeEncodeError_GetReason(PyObject *exc)\r
{\r
    return get_string(((PyUnicodeErrorObject *)exc)->reason, "reason");\r
}\r
\r
\r
PyObject *\r
PyUnicodeDecodeError_GetReason(PyObject *exc)\r
{\r
    return get_string(((PyUnicodeErrorObject *)exc)->reason, "reason");\r
}\r
\r
\r
PyObject *\r
PyUnicodeTranslateError_GetReason(PyObject *exc)\r
{\r
    return get_string(((PyUnicodeErrorObject *)exc)->reason, "reason");\r
}\r
\r
\r
int\r
PyUnicodeEncodeError_SetReason(PyObject *exc, const char *reason)\r
{\r
    return set_string(&((PyUnicodeErrorObject *)exc)->reason, reason);\r
}\r
\r
\r
int\r
PyUnicodeDecodeError_SetReason(PyObject *exc, const char *reason)\r
{\r
    return set_string(&((PyUnicodeErrorObject *)exc)->reason, reason);\r
}\r
\r
\r
int\r
PyUnicodeTranslateError_SetReason(PyObject *exc, const char *reason)\r
{\r
    return set_string(&((PyUnicodeErrorObject *)exc)->reason, reason);\r
}\r
\r
\r
static int\r
UnicodeError_init(PyUnicodeErrorObject *self, PyObject *args, PyObject *kwds,\r
                  PyTypeObject *objecttype)\r
{\r
    Py_CLEAR(self->encoding);\r
    Py_CLEAR(self->object);\r
    Py_CLEAR(self->reason);\r
\r
    if (!PyArg_ParseTuple(args, "O!O!nnO!",\r
        &PyString_Type, &self->encoding,\r
        objecttype, &self->object,\r
        &self->start,\r
        &self->end,\r
        &PyString_Type, &self->reason)) {\r
        self->encoding = self->object = self->reason = NULL;\r
        return -1;\r
    }\r
\r
    Py_INCREF(self->encoding);\r
    Py_INCREF(self->object);\r
    Py_INCREF(self->reason);\r
\r
    return 0;\r
}\r
\r
static int\r
UnicodeError_clear(PyUnicodeErrorObject *self)\r
{\r
    Py_CLEAR(self->encoding);\r
    Py_CLEAR(self->object);\r
    Py_CLEAR(self->reason);\r
    return BaseException_clear((PyBaseExceptionObject *)self);\r
}\r
\r
static void\r
UnicodeError_dealloc(PyUnicodeErrorObject *self)\r
{\r
    _PyObject_GC_UNTRACK(self);\r
    UnicodeError_clear(self);\r
    Py_TYPE(self)->tp_free((PyObject *)self);\r
}\r
\r
static int\r
UnicodeError_traverse(PyUnicodeErrorObject *self, visitproc visit, void *arg)\r
{\r
    Py_VISIT(self->encoding);\r
    Py_VISIT(self->object);\r
    Py_VISIT(self->reason);\r
    return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);\r
}\r
\r
static PyMemberDef UnicodeError_members[] = {\r
    {"encoding", T_OBJECT, offsetof(PyUnicodeErrorObject, encoding), 0,\r
        PyDoc_STR("exception encoding")},\r
    {"object", T_OBJECT, offsetof(PyUnicodeErrorObject, object), 0,\r
        PyDoc_STR("exception object")},\r
    {"start", T_PYSSIZET, offsetof(PyUnicodeErrorObject, start), 0,\r
        PyDoc_STR("exception start")},\r
    {"end", T_PYSSIZET, offsetof(PyUnicodeErrorObject, end), 0,\r
        PyDoc_STR("exception end")},\r
    {"reason", T_OBJECT, offsetof(PyUnicodeErrorObject, reason), 0,\r
        PyDoc_STR("exception reason")},\r
    {NULL}  /* Sentinel */\r
};\r
\r
\r
/*\r
 *    UnicodeEncodeError extends UnicodeError\r
 */\r
\r
static int\r
UnicodeEncodeError_init(PyObject *self, PyObject *args, PyObject *kwds)\r
{\r
    if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)\r
        return -1;\r
    return UnicodeError_init((PyUnicodeErrorObject *)self, args,\r
                             kwds, &PyUnicode_Type);\r
}\r
\r
static PyObject *\r
UnicodeEncodeError_str(PyObject *self)\r
{\r
    PyUnicodeErrorObject *uself = (PyUnicodeErrorObject *)self;\r
    PyObject *result = NULL;\r
    PyObject *reason_str = NULL;\r
    PyObject *encoding_str = NULL;\r
\r
    if (!uself->object)\r
        /* Not properly initialized. */\r
        return PyUnicode_FromString("");\r
\r
    /* Get reason and encoding as strings, which they might not be if\r
       they've been modified after we were contructed. */\r
    reason_str = PyObject_Str(uself->reason);\r
    if (reason_str == NULL)\r
        goto done;\r
    encoding_str = PyObject_Str(uself->encoding);\r
    if (encoding_str == NULL)\r
        goto done;\r
\r
    if (uself->start < PyUnicode_GET_SIZE(uself->object) && uself->end == uself->start+1) {\r
        int badchar = (int)PyUnicode_AS_UNICODE(uself->object)[uself->start];\r
        char badchar_str[20];\r
        if (badchar <= 0xff)\r
            PyOS_snprintf(badchar_str, sizeof(badchar_str), "x%02x", badchar);\r
        else if (badchar <= 0xffff)\r
            PyOS_snprintf(badchar_str, sizeof(badchar_str), "u%04x", badchar);\r
        else\r
            PyOS_snprintf(badchar_str, sizeof(badchar_str), "U%08x", badchar);\r
        result = PyString_FromFormat(\r
            "'%.400s' codec can't encode character u'\\%s' in position %zd: %.400s",\r
            PyString_AS_STRING(encoding_str),\r
            badchar_str,\r
            uself->start,\r
            PyString_AS_STRING(reason_str));\r
    }\r
    else {\r
        result = PyString_FromFormat(\r
            "'%.400s' codec can't encode characters in position %zd-%zd: %.400s",\r
            PyString_AS_STRING(encoding_str),\r
            uself->start,\r
            uself->end-1,\r
            PyString_AS_STRING(reason_str));\r
    }\r
done:\r
    Py_XDECREF(reason_str);\r
    Py_XDECREF(encoding_str);\r
    return result;\r
}\r
\r
static PyTypeObject _PyExc_UnicodeEncodeError = {\r
    PyObject_HEAD_INIT(NULL)\r
    0,\r
    EXC_MODULE_NAME "UnicodeEncodeError",\r
    sizeof(PyUnicodeErrorObject), 0,\r
    (destructor)UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
    (reprfunc)UnicodeEncodeError_str, 0, 0, 0,\r
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,\r
    PyDoc_STR("Unicode encoding error."), (traverseproc)UnicodeError_traverse,\r
    (inquiry)UnicodeError_clear, 0, 0, 0, 0, 0, UnicodeError_members,\r
    0, &_PyExc_UnicodeError, 0, 0, 0, offsetof(PyUnicodeErrorObject, dict),\r
    (initproc)UnicodeEncodeError_init, 0, BaseException_new,\r
};\r
PyObject *PyExc_UnicodeEncodeError = (PyObject *)&_PyExc_UnicodeEncodeError;\r
\r
PyObject *\r
PyUnicodeEncodeError_Create(\r
    const char *encoding, const Py_UNICODE *object, Py_ssize_t length,\r
    Py_ssize_t start, Py_ssize_t end, const char *reason)\r
{\r
    return PyObject_CallFunction(PyExc_UnicodeEncodeError, "su#nns",\r
                                 encoding, object, length, start, end, reason);\r
}\r
\r
\r
/*\r
 *    UnicodeDecodeError extends UnicodeError\r
 */\r
\r
static int\r
UnicodeDecodeError_init(PyObject *self, PyObject *args, PyObject *kwds)\r
{\r
    if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)\r
        return -1;\r
    return UnicodeError_init((PyUnicodeErrorObject *)self, args,\r
                             kwds, &PyString_Type);\r
}\r
\r
static PyObject *\r
UnicodeDecodeError_str(PyObject *self)\r
{\r
    PyUnicodeErrorObject *uself = (PyUnicodeErrorObject *)self;\r
    PyObject *result = NULL;\r
    PyObject *reason_str = NULL;\r
    PyObject *encoding_str = NULL;\r
\r
    if (!uself->object)\r
        /* Not properly initialized. */\r
        return PyUnicode_FromString("");\r
\r
    /* Get reason and encoding as strings, which they might not be if\r
       they've been modified after we were contructed. */\r
    reason_str = PyObject_Str(uself->reason);\r
    if (reason_str == NULL)\r
        goto done;\r
    encoding_str = PyObject_Str(uself->encoding);\r
    if (encoding_str == NULL)\r
        goto done;\r
\r
    if (uself->start < PyUnicode_GET_SIZE(uself->object) && uself->end == uself->start+1) {\r
        /* FromFormat does not support %02x, so format that separately */\r
        char byte[4];\r
        PyOS_snprintf(byte, sizeof(byte), "%02x",\r
                      ((int)PyString_AS_STRING(uself->object)[uself->start])&0xff);\r
        result = PyString_FromFormat(\r
            "'%.400s' codec can't decode byte 0x%s in position %zd: %.400s",\r
            PyString_AS_STRING(encoding_str),\r
            byte,\r
            uself->start,\r
            PyString_AS_STRING(reason_str));\r
    }\r
    else {\r
        result = PyString_FromFormat(\r
            "'%.400s' codec can't decode bytes in position %zd-%zd: %.400s",\r
            PyString_AS_STRING(encoding_str),\r
            uself->start,\r
            uself->end-1,\r
            PyString_AS_STRING(reason_str));\r
    }\r
done:\r
    Py_XDECREF(reason_str);\r
    Py_XDECREF(encoding_str);\r
    return result;\r
}\r
\r
static PyTypeObject _PyExc_UnicodeDecodeError = {\r
    PyObject_HEAD_INIT(NULL)\r
    0,\r
    EXC_MODULE_NAME "UnicodeDecodeError",\r
    sizeof(PyUnicodeErrorObject), 0,\r
    (destructor)UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
    (reprfunc)UnicodeDecodeError_str, 0, 0, 0,\r
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,\r
    PyDoc_STR("Unicode decoding error."), (traverseproc)UnicodeError_traverse,\r
    (inquiry)UnicodeError_clear, 0, 0, 0, 0, 0, UnicodeError_members,\r
    0, &_PyExc_UnicodeError, 0, 0, 0, offsetof(PyUnicodeErrorObject, dict),\r
    (initproc)UnicodeDecodeError_init, 0, BaseException_new,\r
};\r
PyObject *PyExc_UnicodeDecodeError = (PyObject *)&_PyExc_UnicodeDecodeError;\r
\r
PyObject *\r
PyUnicodeDecodeError_Create(\r
    const char *encoding, const char *object, Py_ssize_t length,\r
    Py_ssize_t start, Py_ssize_t end, const char *reason)\r
{\r
    return PyObject_CallFunction(PyExc_UnicodeDecodeError, "ss#nns",\r
                                 encoding, object, length, start, end, reason);\r
}\r
\r
\r
/*\r
 *    UnicodeTranslateError extends UnicodeError\r
 */\r
\r
static int\r
UnicodeTranslateError_init(PyUnicodeErrorObject *self, PyObject *args,\r
                           PyObject *kwds)\r
{\r
    if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)\r
        return -1;\r
\r
    Py_CLEAR(self->object);\r
    Py_CLEAR(self->reason);\r
\r
    if (!PyArg_ParseTuple(args, "O!nnO!",\r
        &PyUnicode_Type, &self->object,\r
        &self->start,\r
        &self->end,\r
        &PyString_Type, &self->reason)) {\r
        self->object = self->reason = NULL;\r
        return -1;\r
    }\r
\r
    Py_INCREF(self->object);\r
    Py_INCREF(self->reason);\r
\r
    return 0;\r
}\r
\r
\r
static PyObject *\r
UnicodeTranslateError_str(PyObject *self)\r
{\r
    PyUnicodeErrorObject *uself = (PyUnicodeErrorObject *)self;\r
    PyObject *result = NULL;\r
    PyObject *reason_str = NULL;\r
\r
    if (!uself->object)\r
        /* Not properly initialized. */\r
        return PyUnicode_FromString("");\r
\r
    /* Get reason as a string, which it might not be if it's been\r
       modified after we were contructed. */\r
    reason_str = PyObject_Str(uself->reason);\r
    if (reason_str == NULL)\r
        goto done;\r
\r
    if (uself->start < PyUnicode_GET_SIZE(uself->object) && uself->end == uself->start+1) {\r
        int badchar = (int)PyUnicode_AS_UNICODE(uself->object)[uself->start];\r
        char badchar_str[20];\r
        if (badchar <= 0xff)\r
            PyOS_snprintf(badchar_str, sizeof(badchar_str), "x%02x", badchar);\r
        else if (badchar <= 0xffff)\r
            PyOS_snprintf(badchar_str, sizeof(badchar_str), "u%04x", badchar);\r
        else\r
            PyOS_snprintf(badchar_str, sizeof(badchar_str), "U%08x", badchar);\r
        result = PyString_FromFormat(\r
            "can't translate character u'\\%s' in position %zd: %.400s",\r
            badchar_str,\r
            uself->start,\r
            PyString_AS_STRING(reason_str));\r
    } else {\r
        result = PyString_FromFormat(\r
            "can't translate characters in position %zd-%zd: %.400s",\r
            uself->start,\r
            uself->end-1,\r
            PyString_AS_STRING(reason_str));\r
    }\r
done:\r
    Py_XDECREF(reason_str);\r
    return result;\r
}\r
\r
static PyTypeObject _PyExc_UnicodeTranslateError = {\r
    PyObject_HEAD_INIT(NULL)\r
    0,\r
    EXC_MODULE_NAME "UnicodeTranslateError",\r
    sizeof(PyUnicodeErrorObject), 0,\r
    (destructor)UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
    (reprfunc)UnicodeTranslateError_str, 0, 0, 0,\r
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,\r
    PyDoc_STR("Unicode translation error."), (traverseproc)UnicodeError_traverse,\r
    (inquiry)UnicodeError_clear, 0, 0, 0, 0, 0, UnicodeError_members,\r
    0, &_PyExc_UnicodeError, 0, 0, 0, offsetof(PyUnicodeErrorObject, dict),\r
    (initproc)UnicodeTranslateError_init, 0, BaseException_new,\r
};\r
PyObject *PyExc_UnicodeTranslateError = (PyObject *)&_PyExc_UnicodeTranslateError;\r
\r
PyObject *\r
PyUnicodeTranslateError_Create(\r
    const Py_UNICODE *object, Py_ssize_t length,\r
    Py_ssize_t start, Py_ssize_t end, const char *reason)\r
{\r
    return PyObject_CallFunction(PyExc_UnicodeTranslateError, "u#nns",\r
                                 object, length, start, end, reason);\r
}\r
#endif\r
\r
\r
/*\r
 *    AssertionError extends StandardError\r
 */\r
SimpleExtendsException(PyExc_StandardError, AssertionError,\r
                       "Assertion failed.");\r
\r
\r
/*\r
 *    ArithmeticError extends StandardError\r
 */\r
SimpleExtendsException(PyExc_StandardError, ArithmeticError,\r
                       "Base class for arithmetic errors.");\r
\r
\r
/*\r
 *    FloatingPointError extends ArithmeticError\r
 */\r
SimpleExtendsException(PyExc_ArithmeticError, FloatingPointError,\r
                       "Floating point operation failed.");\r
\r
\r
/*\r
 *    OverflowError extends ArithmeticError\r
 */\r
SimpleExtendsException(PyExc_ArithmeticError, OverflowError,\r
                       "Result too large to be represented.");\r
\r
\r
/*\r
 *    ZeroDivisionError extends ArithmeticError\r
 */\r
SimpleExtendsException(PyExc_ArithmeticError, ZeroDivisionError,\r
          "Second argument to a division or modulo operation was zero.");\r
\r
\r
/*\r
 *    SystemError extends StandardError\r
 */\r
SimpleExtendsException(PyExc_StandardError, SystemError,\r
    "Internal error in the Python interpreter.\n"\r
    "\n"\r
    "Please report this to the Python maintainer, along with the traceback,\n"\r
    "the Python version, and the hardware/OS platform and version.");\r
\r
\r
/*\r
 *    ReferenceError extends StandardError\r
 */\r
SimpleExtendsException(PyExc_StandardError, ReferenceError,\r
                       "Weak ref proxy used after referent went away.");\r
\r
\r
/*\r
 *    MemoryError extends StandardError\r
 */\r
SimpleExtendsException(PyExc_StandardError, MemoryError, "Out of memory.");\r
\r
/*\r
 *    BufferError extends StandardError\r
 */\r
SimpleExtendsException(PyExc_StandardError, BufferError, "Buffer error.");\r
\r
\r
/* Warning category docstrings */\r
\r
/*\r
 *    Warning extends Exception\r
 */\r
SimpleExtendsException(PyExc_Exception, Warning,\r
                       "Base class for warning categories.");\r
\r
\r
/*\r
 *    UserWarning extends Warning\r
 */\r
SimpleExtendsException(PyExc_Warning, UserWarning,\r
                       "Base class for warnings generated by user code.");\r
\r
\r
/*\r
 *    DeprecationWarning extends Warning\r
 */\r
SimpleExtendsException(PyExc_Warning, DeprecationWarning,\r
                       "Base class for warnings about deprecated features.");\r
\r
\r
/*\r
 *    PendingDeprecationWarning extends Warning\r
 */\r
SimpleExtendsException(PyExc_Warning, PendingDeprecationWarning,\r
    "Base class for warnings about features which will be deprecated\n"\r
    "in the future.");\r
\r
\r
/*\r
 *    SyntaxWarning extends Warning\r
 */\r
SimpleExtendsException(PyExc_Warning, SyntaxWarning,\r
                       "Base class for warnings about dubious syntax.");\r
\r
\r
/*\r
 *    RuntimeWarning extends Warning\r
 */\r
SimpleExtendsException(PyExc_Warning, RuntimeWarning,\r
                 "Base class for warnings about dubious runtime behavior.");\r
\r
\r
/*\r
 *    FutureWarning extends Warning\r
 */\r
SimpleExtendsException(PyExc_Warning, FutureWarning,\r
    "Base class for warnings about constructs that will change semantically\n"\r
    "in the future.");\r
\r
\r
/*\r
 *    ImportWarning extends Warning\r
 */\r
SimpleExtendsException(PyExc_Warning, ImportWarning,\r
          "Base class for warnings about probable mistakes in module imports");\r
\r
\r
/*\r
 *    UnicodeWarning extends Warning\r
 */\r
SimpleExtendsException(PyExc_Warning, UnicodeWarning,\r
    "Base class for warnings about Unicode related problems, mostly\n"\r
    "related to conversion problems.");\r
\r
/*\r
 *    BytesWarning extends Warning\r
 */\r
SimpleExtendsException(PyExc_Warning, BytesWarning,\r
    "Base class for warnings about bytes and buffer related problems, mostly\n"\r
    "related to conversion from str or comparing to str.");\r
\r
/* Pre-computed MemoryError instance.  Best to create this as early as\r
 * possible and not wait until a MemoryError is actually raised!\r
 */\r
PyObject *PyExc_MemoryErrorInst=NULL;\r
\r
/* Pre-computed RuntimeError instance for when recursion depth is reached.\r
   Meant to be used when normalizing the exception for exceeding the recursion\r
   depth will cause its own infinite recursion.\r
*/\r
PyObject *PyExc_RecursionErrorInst = NULL;\r
\r
/* module global functions */\r
static PyMethodDef functions[] = {\r
    /* Sentinel */\r
    {NULL, NULL}\r
};\r
\r
#define PRE_INIT(TYPE) if (PyType_Ready(&_PyExc_ ## TYPE) < 0) \\r
    Py_FatalError("exceptions bootstrapping error.");\r
\r
#define POST_INIT(TYPE) Py_INCREF(PyExc_ ## TYPE); \\r
    PyModule_AddObject(m, # TYPE, PyExc_ ## TYPE); \\r
    if (PyDict_SetItemString(bdict, # TYPE, PyExc_ ## TYPE)) \\r
        Py_FatalError("Module dictionary insertion problem.");\r
\r
\r
PyMODINIT_FUNC\r
_PyExc_Init(void)\r
{\r
    PyObject *m, *bltinmod, *bdict;\r
\r
    PRE_INIT(BaseException)\r
    PRE_INIT(Exception)\r
    PRE_INIT(StandardError)\r
    PRE_INIT(TypeError)\r
    PRE_INIT(StopIteration)\r
    PRE_INIT(GeneratorExit)\r
    PRE_INIT(SystemExit)\r
    PRE_INIT(KeyboardInterrupt)\r
    PRE_INIT(ImportError)\r
    PRE_INIT(EnvironmentError)\r
    PRE_INIT(IOError)\r
    PRE_INIT(OSError)\r
#ifdef MS_WINDOWS\r
    PRE_INIT(WindowsError)\r
#endif\r
#ifdef __VMS\r
    PRE_INIT(VMSError)\r
#endif\r
    PRE_INIT(EOFError)\r
    PRE_INIT(RuntimeError)\r
    PRE_INIT(NotImplementedError)\r
    PRE_INIT(NameError)\r
    PRE_INIT(UnboundLocalError)\r
    PRE_INIT(AttributeError)\r
    PRE_INIT(SyntaxError)\r
    PRE_INIT(IndentationError)\r
    PRE_INIT(TabError)\r
    PRE_INIT(LookupError)\r
    PRE_INIT(IndexError)\r
    PRE_INIT(KeyError)\r
    PRE_INIT(ValueError)\r
    PRE_INIT(UnicodeError)\r
#ifdef Py_USING_UNICODE\r
    PRE_INIT(UnicodeEncodeError)\r
    PRE_INIT(UnicodeDecodeError)\r
    PRE_INIT(UnicodeTranslateError)\r
#endif\r
    PRE_INIT(AssertionError)\r
    PRE_INIT(ArithmeticError)\r
    PRE_INIT(FloatingPointError)\r
    PRE_INIT(OverflowError)\r
    PRE_INIT(ZeroDivisionError)\r
    PRE_INIT(SystemError)\r
    PRE_INIT(ReferenceError)\r
    PRE_INIT(MemoryError)\r
    PRE_INIT(BufferError)\r
    PRE_INIT(Warning)\r
    PRE_INIT(UserWarning)\r
    PRE_INIT(DeprecationWarning)\r
    PRE_INIT(PendingDeprecationWarning)\r
    PRE_INIT(SyntaxWarning)\r
    PRE_INIT(RuntimeWarning)\r
    PRE_INIT(FutureWarning)\r
    PRE_INIT(ImportWarning)\r
    PRE_INIT(UnicodeWarning)\r
    PRE_INIT(BytesWarning)\r
\r
    m = Py_InitModule4("exceptions", functions, exceptions_doc,\r
        (PyObject *)NULL, PYTHON_API_VERSION);\r
    if (m == NULL)\r
        return;\r
\r
    bltinmod = PyImport_ImportModule("__builtin__");\r
    if (bltinmod == NULL)\r
        Py_FatalError("exceptions bootstrapping error.");\r
    bdict = PyModule_GetDict(bltinmod);\r
    if (bdict == NULL)\r
        Py_FatalError("exceptions bootstrapping error.");\r
\r
    POST_INIT(BaseException)\r
    POST_INIT(Exception)\r
    POST_INIT(StandardError)\r
    POST_INIT(TypeError)\r
    POST_INIT(StopIteration)\r
    POST_INIT(GeneratorExit)\r
    POST_INIT(SystemExit)\r
    POST_INIT(KeyboardInterrupt)\r
    POST_INIT(ImportError)\r
    POST_INIT(EnvironmentError)\r
    POST_INIT(IOError)\r
    POST_INIT(OSError)\r
#ifdef MS_WINDOWS\r
    POST_INIT(WindowsError)\r
#endif\r
#ifdef __VMS\r
    POST_INIT(VMSError)\r
#endif\r
    POST_INIT(EOFError)\r
    POST_INIT(RuntimeError)\r
    POST_INIT(NotImplementedError)\r
    POST_INIT(NameError)\r
    POST_INIT(UnboundLocalError)\r
    POST_INIT(AttributeError)\r
    POST_INIT(SyntaxError)\r
    POST_INIT(IndentationError)\r
    POST_INIT(TabError)\r
    POST_INIT(LookupError)\r
    POST_INIT(IndexError)\r
    POST_INIT(KeyError)\r
    POST_INIT(ValueError)\r
    POST_INIT(UnicodeError)\r
#ifdef Py_USING_UNICODE\r
    POST_INIT(UnicodeEncodeError)\r
    POST_INIT(UnicodeDecodeError)\r
    POST_INIT(UnicodeTranslateError)\r
#endif\r
    POST_INIT(AssertionError)\r
    POST_INIT(ArithmeticError)\r
    POST_INIT(FloatingPointError)\r
    POST_INIT(OverflowError)\r
    POST_INIT(ZeroDivisionError)\r
    POST_INIT(SystemError)\r
    POST_INIT(ReferenceError)\r
    POST_INIT(MemoryError)\r
    POST_INIT(BufferError)\r
    POST_INIT(Warning)\r
    POST_INIT(UserWarning)\r
    POST_INIT(DeprecationWarning)\r
    POST_INIT(PendingDeprecationWarning)\r
    POST_INIT(SyntaxWarning)\r
    POST_INIT(RuntimeWarning)\r
    POST_INIT(FutureWarning)\r
    POST_INIT(ImportWarning)\r
    POST_INIT(UnicodeWarning)\r
    POST_INIT(BytesWarning)\r
\r
    PyExc_MemoryErrorInst = BaseException_new(&_PyExc_MemoryError, NULL, NULL);\r
    if (!PyExc_MemoryErrorInst)\r
        Py_FatalError("Cannot pre-allocate MemoryError instance");\r
\r
    PyExc_RecursionErrorInst = BaseException_new(&_PyExc_RuntimeError, NULL, NULL);\r
    if (!PyExc_RecursionErrorInst)\r
        Py_FatalError("Cannot pre-allocate RuntimeError instance for "\r
                        "recursion errors");\r
    else {\r
        PyBaseExceptionObject *err_inst =\r
            (PyBaseExceptionObject *)PyExc_RecursionErrorInst;\r
        PyObject *args_tuple;\r
        PyObject *exc_message;\r
        exc_message = PyString_FromString("maximum recursion depth exceeded");\r
        if (!exc_message)\r
            Py_FatalError("cannot allocate argument for RuntimeError "\r
                            "pre-allocation");\r
        args_tuple = PyTuple_Pack(1, exc_message);\r
        if (!args_tuple)\r
            Py_FatalError("cannot allocate tuple for RuntimeError "\r
                            "pre-allocation");\r
        Py_DECREF(exc_message);\r
        if (BaseException_init(err_inst, args_tuple, NULL))\r
            Py_FatalError("init of pre-allocated RuntimeError failed");\r
        Py_DECREF(args_tuple);\r
    }\r
    Py_DECREF(bltinmod);\r
}\r
\r
void\r
_PyExc_Fini(void)\r
{\r
    Py_CLEAR(PyExc_MemoryErrorInst);\r
    Py_CLEAR(PyExc_RecursionErrorInst);\r
}\r