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