diff options
Diffstat (limited to 'sys/src/cmd/python/Objects/exceptions.c')
| -rw-r--r-- | sys/src/cmd/python/Objects/exceptions.c | 2147 |
1 files changed, 0 insertions, 2147 deletions
diff --git a/sys/src/cmd/python/Objects/exceptions.c b/sys/src/cmd/python/Objects/exceptions.c deleted file mode 100644 index 0cd819c5a..000000000 --- a/sys/src/cmd/python/Objects/exceptions.c +++ /dev/null @@ -1,2147 +0,0 @@ -/* - * 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 MAKE_IT_NONE(x) (x) = Py_None; Py_INCREF(Py_None); -#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); - /* 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(self->ob_type->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); - self->ob_type->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; -} - -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 *)self->ob_type->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, self->ob_type, self->args, self->dict); - else - return PyTuple_Pack(2, self->ob_type, 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 }, - {NULL, NULL, 0, NULL}, -}; - - - -static PyObject * -BaseException_getitem(PyBaseExceptionObject *self, Py_ssize_t index) -{ - return PySequence_GetItem(self->args, index); -} - -static PyObject * -BaseException_getslice(PyBaseExceptionObject *self, - Py_ssize_t start, Py_ssize_t stop) -{ - 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 PyMemberDef BaseException_members[] = { - {"message", T_OBJECT, offsetof(PyBaseExceptionObject, message), 0, - PyDoc_STR("exception message")}, - {NULL} /* Sentinel */ -}; - - -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 PyGetSetDef BaseException_getset[] = { - {"__dict__", (getter)BaseException_get_dict, (setter)BaseException_set_dict}, - {"args", (getter)BaseException_get_args, (setter)BaseException_set_args}, - {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, /*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 */ - BaseException_members, /* 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 Exception - */ -SimpleExtendsException(PyExc_Exception, 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); - self->ob_type->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[] = { - {"message", T_OBJECT, offsetof(PySystemExitObject, message), 0, - PyDoc_STR("exception message")}, - {"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); - self->ob_type->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[] = { - {"message", T_OBJECT, offsetof(PyEnvironmentErrorObject, message), 0, - PyDoc_STR("exception message")}, - {"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, self->ob_type, args, self->dict); - else - res = PyTuple_Pack(2, self->ob_type, 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); - self->ob_type->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[] = { - {"message", T_OBJECT, offsetof(PyWindowsErrorObject, message), 0, - PyDoc_STR("exception message")}, - {"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); - self->ob_type->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[] = { - {"message", T_OBJECT, offsetof(PySyntaxErrorObject, message), 0, - PyDoc_STR("exception message")}, - {"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 int -get_int(PyObject *attr, Py_ssize_t *value, const char *name) -{ - if (!attr) { - PyErr_Format(PyExc_TypeError, "%.200s attribute not set", name); - return -1; - } - - if (PyInt_Check(attr)) { - *value = PyInt_AS_LONG(attr); - } else if (PyLong_Check(attr)) { - *value = _PyLong_AsSsize_t(attr); - if (*value == -1 && PyErr_Occurred()) - return -1; - } else { - PyErr_Format(PyExc_TypeError, "%.200s attribute must be int", name); - return -1; - } - return 0; -} - -static int -set_ssize_t(PyObject **attr, Py_ssize_t value) -{ - PyObject *obj = PyInt_FromSsize_t(value); - if (!obj) - return -1; - Py_CLEAR(*attr); - *attr = obj; - return 0; -} - -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) -{ - if (!get_int(((PyUnicodeErrorObject *)exc)->start, start, "start")) { - Py_ssize_t size; - PyObject *obj = get_unicode(((PyUnicodeErrorObject *)exc)->object, - "object"); - if (!obj) return -1; - 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; - } - return -1; -} - - -int -PyUnicodeDecodeError_GetStart(PyObject *exc, Py_ssize_t *start) -{ - if (!get_int(((PyUnicodeErrorObject *)exc)->start, start, "start")) { - Py_ssize_t size; - PyObject *obj = get_string(((PyUnicodeErrorObject *)exc)->object, - "object"); - if (!obj) return -1; - size = PyString_GET_SIZE(obj); - if (*start<0) - *start = 0; - if (*start>=size) - *start = size-1; - Py_DECREF(obj); - return 0; - } - return -1; -} - - -int -PyUnicodeTranslateError_GetStart(PyObject *exc, Py_ssize_t *start) -{ - return PyUnicodeEncodeError_GetStart(exc, start); -} - - -int -PyUnicodeEncodeError_SetStart(PyObject *exc, Py_ssize_t start) -{ - return set_ssize_t(&((PyUnicodeErrorObject *)exc)->start, start); -} - - -int -PyUnicodeDecodeError_SetStart(PyObject *exc, Py_ssize_t start) -{ - return set_ssize_t(&((PyUnicodeErrorObject *)exc)->start, start); -} - - -int -PyUnicodeTranslateError_SetStart(PyObject *exc, Py_ssize_t start) -{ - return set_ssize_t(&((PyUnicodeErrorObject *)exc)->start, start); -} - - -int -PyUnicodeEncodeError_GetEnd(PyObject *exc, Py_ssize_t *end) -{ - if (!get_int(((PyUnicodeErrorObject *)exc)->end, end, "end")) { - Py_ssize_t size; - PyObject *obj = get_unicode(((PyUnicodeErrorObject *)exc)->object, - "object"); - if (!obj) return -1; - size = PyUnicode_GET_SIZE(obj); - if (*end<1) - *end = 1; - if (*end>size) - *end = size; - Py_DECREF(obj); - return 0; - } - return -1; -} - - -int -PyUnicodeDecodeError_GetEnd(PyObject *exc, Py_ssize_t *end) -{ - if (!get_int(((PyUnicodeErrorObject *)exc)->end, end, "end")) { - Py_ssize_t size; - PyObject *obj = get_string(((PyUnicodeErrorObject *)exc)->object, - "object"); - if (!obj) return -1; - size = PyString_GET_SIZE(obj); - if (*end<1) - *end = 1; - if (*end>size) - *end = size; - Py_DECREF(obj); - return 0; - } - return -1; -} - - -int -PyUnicodeTranslateError_GetEnd(PyObject *exc, Py_ssize_t *start) -{ - return PyUnicodeEncodeError_GetEnd(exc, start); -} - - -int -PyUnicodeEncodeError_SetEnd(PyObject *exc, Py_ssize_t end) -{ - return set_ssize_t(&((PyUnicodeErrorObject *)exc)->end, end); -} - - -int -PyUnicodeDecodeError_SetEnd(PyObject *exc, Py_ssize_t end) -{ - return set_ssize_t(&((PyUnicodeErrorObject *)exc)->end, end); -} - - -int -PyUnicodeTranslateError_SetEnd(PyObject *exc, Py_ssize_t end) -{ - return set_ssize_t(&((PyUnicodeErrorObject *)exc)->end, end); -} - -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->start); - Py_CLEAR(self->end); - Py_CLEAR(self->reason); - - if (!PyArg_ParseTuple(args, "O!O!O!O!O!", - &PyString_Type, &self->encoding, - objecttype, &self->object, - &PyInt_Type, &self->start, - &PyInt_Type, &self->end, - &PyString_Type, &self->reason)) { - self->encoding = self->object = self->start = self->end = - self->reason = NULL; - return -1; - } - - Py_INCREF(self->encoding); - Py_INCREF(self->object); - Py_INCREF(self->start); - Py_INCREF(self->end); - Py_INCREF(self->reason); - - return 0; -} - -static int -UnicodeError_clear(PyUnicodeErrorObject *self) -{ - Py_CLEAR(self->encoding); - Py_CLEAR(self->object); - Py_CLEAR(self->start); - Py_CLEAR(self->end); - Py_CLEAR(self->reason); - return BaseException_clear((PyBaseExceptionObject *)self); -} - -static void -UnicodeError_dealloc(PyUnicodeErrorObject *self) -{ - _PyObject_GC_UNTRACK(self); - UnicodeError_clear(self); - self->ob_type->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->start); - Py_VISIT(self->end); - Py_VISIT(self->reason); - return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg); -} - -static PyMemberDef UnicodeError_members[] = { - {"message", T_OBJECT, offsetof(PyUnicodeErrorObject, message), 0, - PyDoc_STR("exception message")}, - {"encoding", T_OBJECT, offsetof(PyUnicodeErrorObject, encoding), 0, - PyDoc_STR("exception encoding")}, - {"object", T_OBJECT, offsetof(PyUnicodeErrorObject, object), 0, - PyDoc_STR("exception object")}, - {"start", T_OBJECT, offsetof(PyUnicodeErrorObject, start), 0, - PyDoc_STR("exception start")}, - {"end", T_OBJECT, 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) -{ - Py_ssize_t start; - Py_ssize_t end; - - if (PyUnicodeEncodeError_GetStart(self, &start)) - return NULL; - - if (PyUnicodeEncodeError_GetEnd(self, &end)) - return NULL; - - if (end==start+1) { - int badchar = (int)PyUnicode_AS_UNICODE(((PyUnicodeErrorObject *)self)->object)[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); - return PyString_FromFormat( - "'%.400s' codec can't encode character u'\\%s' in position %zd: %.400s", - PyString_AS_STRING(((PyUnicodeErrorObject *)self)->encoding), - badchar_str, - start, - PyString_AS_STRING(((PyUnicodeErrorObject *)self)->reason) - ); - } - return PyString_FromFormat( - "'%.400s' codec can't encode characters in position %zd-%zd: %.400s", - PyString_AS_STRING(((PyUnicodeErrorObject *)self)->encoding), - start, - (end-1), - PyString_AS_STRING(((PyUnicodeErrorObject *)self)->reason) - ); -} - -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) -{ - Py_ssize_t start = 0; - Py_ssize_t end = 0; - - if (PyUnicodeDecodeError_GetStart(self, &start)) - return NULL; - - if (PyUnicodeDecodeError_GetEnd(self, &end)) - return NULL; - - if (end==start+1) { - /* FromFormat does not support %02x, so format that separately */ - char byte[4]; - PyOS_snprintf(byte, sizeof(byte), "%02x", - ((int)PyString_AS_STRING(((PyUnicodeErrorObject *)self)->object)[start])&0xff); - return PyString_FromFormat( - "'%.400s' codec can't decode byte 0x%s in position %zd: %.400s", - PyString_AS_STRING(((PyUnicodeErrorObject *)self)->encoding), - byte, - start, - PyString_AS_STRING(((PyUnicodeErrorObject *)self)->reason) - ); - } - return PyString_FromFormat( - "'%.400s' codec can't decode bytes in position %zd-%zd: %.400s", - PyString_AS_STRING(((PyUnicodeErrorObject *)self)->encoding), - start, - (end-1), - PyString_AS_STRING(((PyUnicodeErrorObject *)self)->reason) - ); -} - -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) -{ - assert(length < INT_MAX); - assert(start < INT_MAX); - assert(end < INT_MAX); - 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->start); - Py_CLEAR(self->end); - Py_CLEAR(self->reason); - - if (!PyArg_ParseTuple(args, "O!O!O!O!", - &PyUnicode_Type, &self->object, - &PyInt_Type, &self->start, - &PyInt_Type, &self->end, - &PyString_Type, &self->reason)) { - self->object = self->start = self->end = self->reason = NULL; - return -1; - } - - Py_INCREF(self->object); - Py_INCREF(self->start); - Py_INCREF(self->end); - Py_INCREF(self->reason); - - return 0; -} - - -static PyObject * -UnicodeTranslateError_str(PyObject *self) -{ - Py_ssize_t start; - Py_ssize_t end; - - if (PyUnicodeTranslateError_GetStart(self, &start)) - return NULL; - - if (PyUnicodeTranslateError_GetEnd(self, &end)) - return NULL; - - if (end==start+1) { - int badchar = (int)PyUnicode_AS_UNICODE(((PyUnicodeErrorObject *)self)->object)[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); - return PyString_FromFormat( - "can't translate character u'\\%s' in position %zd: %.400s", - badchar_str, - start, - PyString_AS_STRING(((PyUnicodeErrorObject *)self)->reason) - ); - } - return PyString_FromFormat( - "can't translate characters in position %zd-%zd: %.400s", - start, - (end-1), - PyString_AS_STRING(((PyUnicodeErrorObject *)self)->reason) - ); -} - -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."); - - -/* 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."); - - -/* 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; - -/* 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."); - -#if defined _MSC_VER && _MSC_VER >= 1400 && defined(__STDC_SECURE_LIB__) -/* crt variable checking in VisualStudio .NET 2005 */ -#include <crtdbg.h> - -static int prevCrtReportMode; -static _invalid_parameter_handler prevCrtHandler; - -/* Invalid parameter handler. Sets a ValueError exception */ -static void -InvalidParameterHandler( - const wchar_t * expression, - const wchar_t * function, - const wchar_t * file, - unsigned int line, - uintptr_t pReserved) -{ - /* Do nothing, allow execution to continue. Usually this - * means that the CRT will set errno to EINVAL - */ -} -#endif - - -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(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) - - 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(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) - - PyExc_MemoryErrorInst = BaseException_new(&_PyExc_MemoryError, NULL, NULL); - if (!PyExc_MemoryErrorInst) - Py_FatalError("Cannot pre-allocate MemoryError instance\n"); - - Py_DECREF(bltinmod); - -#if defined _MSC_VER && _MSC_VER >= 1400 && defined(__STDC_SECURE_LIB__) - /* Set CRT argument error handler */ - prevCrtHandler = _set_invalid_parameter_handler(InvalidParameterHandler); - /* turn off assertions in debug mode */ - prevCrtReportMode = _CrtSetReportMode(_CRT_ASSERT, 0); -#endif -} - -void -_PyExc_Fini(void) -{ - Py_XDECREF(PyExc_MemoryErrorInst); - PyExc_MemoryErrorInst = NULL; -#if defined _MSC_VER && _MSC_VER >= 1400 && defined(__STDC_SECURE_LIB__) - /* reset CRT error handling */ - _set_invalid_parameter_handler(prevCrtHandler); - _CrtSetReportMode(_CRT_ASSERT, prevCrtReportMode); -#endif -} |