cpython: 4243df51fe43 Objects/exceptions.c (original) (raw)

Backed out changeset f23fa1f7b68fSorry, I didn't want to push this change before the review :-( I was pushing a change into the 2.7 branch.

line wrap: on

line source

/*

• 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" /* Compatibility aliases */ PyObject *PyExc_EnvironmentError = NULL; PyObject *PyExc_IOError = NULL; #ifdef MS_WINDOWS PyObject PyExc_WindowsError = NULL; #endif / The dict map from errno codes to OSError subclasses */ static PyObject errnomap = NULL; / NOTE: If the exception class hierarchy changes, don't forget to update

• Lib/test/exception_hierarchy.txt */

/*

• 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->dict = NULL; self->traceback = self->cause = self->context = NULL; self->suppress_context = 0; if (args) { self->args = args; Py_INCREF(args); return (PyObject *)self; } self->args = PyTuple_New(0); if (!self->args) { Py_DECREF(self); return NULL; } return (PyObject *)self; } static int BaseException_init(PyBaseExceptionObject *self, PyObject *args, PyObject *kwds) { if (!_PyArg_NoKeywords(Py_TYPE(self)->tp_name, kwds)) return -1; Py_INCREF(args); Py_XSETREF(self->args, args); return 0; } static int BaseException_clear(PyBaseExceptionObject *self) { Py_CLEAR(self->dict); Py_CLEAR(self->args); Py_CLEAR(self->traceback); Py_CLEAR(self->cause); Py_CLEAR(self->context); return 0; } static void BaseException_dealloc(PyBaseExceptionObject *self) { _PyObject_GC_UNTRACK(self); BaseException_clear(self); Py_TYPE(self)->tp_free((PyObject *)self); } static int BaseException_traverse(PyBaseExceptionObject *self, visitproc visit, void *arg) { Py_VISIT(self->dict); Py_VISIT(self->args); Py_VISIT(self->traceback); Py_VISIT(self->cause); Py_VISIT(self->context); return 0; } static PyObject * BaseException_str(PyBaseExceptionObject *self) { switch (PyTuple_GET_SIZE(self->args)) { case 0: return PyUnicode_FromString(""); case 1: return PyObject_Str(PyTuple_GET_ITEM(self->args, 0)); default: return PyObject_Str(self->args); } } static PyObject * BaseException_repr(PyBaseExceptionObject *self) { const char *name; const char *dot; name = Py_TYPE(self)->tp_name; dot = (const char ) strrchr(name, '.'); if (dot != NULL) name = dot+1; return PyUnicode_FromFormat("%s%R", name, self->args); } / 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 PyObject * BaseException_with_traceback(PyObject *self, PyObject *tb) { if (PyException_SetTraceback(self, tb)) return NULL; Py_INCREF(self); return self; } PyDoc_STRVAR(with_traceback_doc, "Exception.with_traceback(tb) --\n[](#l171) set self.traceback to tb and return self."); static PyMethodDef BaseException_methods[] = { {"reduce", (PyCFunction)BaseException_reduce, METH_NOARGS }, {"setstate", (PyCFunction)BaseException_setstate, METH_O }, {"with_traceback", (PyCFunction)BaseException_with_traceback, METH_O, with_traceback_doc}, {NULL, NULL, 0, NULL}, }; static PyObject * BaseException_get_args(PyBaseExceptionObject *self) { if (self->args == NULL) { Py_RETURN_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_XSETREF(self->args, seq); return 0; } static PyObject * BaseException_get_tb(PyBaseExceptionObject *self) { if (self->traceback == NULL) { Py_RETURN_NONE; } Py_INCREF(self->traceback); return self->traceback; } static int BaseException_set_tb(PyBaseExceptionObject *self, PyObject *tb) { if (tb == NULL) { PyErr_SetString(PyExc_TypeError, "traceback may not be deleted"); return -1; } else if (!(tb == Py_None || PyTraceBack_Check(tb))) { PyErr_SetString(PyExc_TypeError, "traceback must be a traceback or None"); return -1; } Py_INCREF(tb); Py_XSETREF(self->traceback, tb); return 0; } static PyObject * BaseException_get_context(PyObject *self) { PyObject res = PyException_GetContext(self); if (res) return res; / new reference already returned above */ Py_RETURN_NONE; } static int BaseException_set_context(PyObject *self, PyObject arg) { if (arg == NULL) { PyErr_SetString(PyExc_TypeError, "context may not be deleted"); return -1; } else if (arg == Py_None) { arg = NULL; } else if (!PyExceptionInstance_Check(arg)) { PyErr_SetString(PyExc_TypeError, "exception context must be None " "or derive from BaseException"); return -1; } else { / PyException_SetContext steals this reference */ Py_INCREF(arg); } PyException_SetContext(self, arg); return 0; } static PyObject * BaseException_get_cause(PyObject *self) { PyObject res = PyException_GetCause(self); if (res) return res; / new reference already returned above */ Py_RETURN_NONE; } static int BaseException_set_cause(PyObject *self, PyObject arg) { if (arg == NULL) { PyErr_SetString(PyExc_TypeError, "cause may not be deleted"); return -1; } else if (arg == Py_None) { arg = NULL; } else if (!PyExceptionInstance_Check(arg)) { PyErr_SetString(PyExc_TypeError, "exception cause must be None " "or derive from BaseException"); return -1; } else { / PyException_SetCause steals this reference */ Py_INCREF(arg); } PyException_SetCause(self, arg); return 0; } static PyGetSetDef BaseException_getset[] = { {"dict", PyObject_GenericGetDict, PyObject_GenericSetDict}, {"args", (getter)BaseException_get_args, (setter)BaseException_set_args}, {"traceback", (getter)BaseException_get_tb, (setter)BaseException_set_tb}, {"context", (getter)BaseException_get_context, (setter)BaseException_set_context, PyDoc_STR("exception context")}, {"cause", (getter)BaseException_get_cause, (setter)BaseException_set_cause, PyDoc_STR("exception cause")}, {NULL}, }; PyObject * PyException_GetTraceback(PyObject *self) { PyBaseExceptionObject *base_self = (PyBaseExceptionObject *)self; Py_XINCREF(base_self->traceback); return base_self->traceback; } int PyException_SetTraceback(PyObject *self, PyObject *tb) { return BaseException_set_tb((PyBaseExceptionObject *)self, tb); } PyObject * PyException_GetCause(PyObject *self) { PyObject *cause = ((PyBaseExceptionObject )self)->cause; Py_XINCREF(cause); return cause; } / Steals a reference to cause */ void PyException_SetCause(PyObject *self, PyObject *cause) { ((PyBaseExceptionObject *)self)->suppress_context = 1; Py_XSETREF(((PyBaseExceptionObject *)self)->cause, cause); } PyObject * PyException_GetContext(PyObject *self) { PyObject *context = ((PyBaseExceptionObject )self)->context; Py_XINCREF(context); return context; } / Steals a reference to context */ void PyException_SetContext(PyObject *self, PyObject *context) { Py_XSETREF(((PyBaseExceptionObject )self)->context, context); } static struct PyMemberDef BaseException_members[] = { {"suppress_context", T_BOOL, offsetof(PyBaseExceptionObject, suppress_context)}, {NULL} }; static PyTypeObject _PyExc_BaseException = { PyVarObject_HEAD_INIT(NULL, 0) "BaseException", /tp_name/ sizeof(PyBaseExceptionObject), /tp_basicsize/ 0, /tp_itemsize/ (destructor)BaseException_dealloc, /tp_dealloc/ 0, /tp_print/ 0, /tp_getattr/ 0, /tp_setattr/ 0, / tp_reserved; */ (reprfunc)BaseException_repr, /tp_repr/ 0, /tp_as_number/ 0, /tp_as_sequence/ 0, /tp_as_mapping/ 0, /*tp_hash / 0, /tp_call/ (reprfunc)BaseException_str, /tp_str/ PyObject_GenericGetAttr, /tp_getattro/ PyObject_GenericSetAttr, /tp_setattro/ 0, /tp_as_buffer/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASE_EXC_SUBCLASS, /tp_flags/ PyDoc_STR("Common base class for all exceptions"), / tp_doc / (traverseproc)BaseException_traverse, / tp_traverse / (inquiry)BaseException_clear, / tp_clear / 0, / tp_richcompare / 0, / tp_weaklistoffset / 0, / tp_iter / 0, / tp_iternext / BaseException_methods, / tp_methods / 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) [](#l402) static PyTypeObject PyExc ## EXCNAME = { [](#l403) PyVarObject_HEAD_INIT(NULL, 0) [](#l404) # EXCNAME, [](#l405) sizeof(PyBaseExceptionObject), [](#l406) 0, (destructor)BaseException_dealloc, 0, 0, 0, 0, 0, 0, 0, [](#l407) 0, 0, 0, 0, 0, 0, 0, [](#l408) Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, [](#l409) PyDoc_STR(EXCDOC), (traverseproc)BaseException_traverse, [](#l410) (inquiry)BaseException_clear, 0, 0, 0, 0, 0, 0, 0, &_ ## EXCBASE, [](#l411) 0, 0, 0, offsetof(PyBaseExceptionObject, dict), [](#l412) (initproc)BaseException_init, 0, BaseException_new,[](#l413) }; [](#l414) PyObject *PyExc_ ## EXCNAME = (PyObject *)&PyExc ## EXCNAME #define MiddlingExtendsException(EXCBASE, EXCNAME, EXCSTORE, EXCDOC) [](#l417) static PyTypeObject PyExc ## EXCNAME = { [](#l418) PyVarObject_HEAD_INIT(NULL, 0) [](#l419) # EXCNAME, [](#l420) sizeof(Py ## EXCSTORE ## Object), [](#l421) 0, (destructor)EXCSTORE ## _dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, [](#l422) 0, 0, 0, 0, 0, [](#l423) Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, [](#l424) PyDoc_STR(EXCDOC), (traverseproc)EXCSTORE ## _traverse, [](#l425) (inquiry)EXCSTORE ## clear, 0, 0, 0, 0, 0, 0, 0, & ## EXCBASE, [](#l426) 0, 0, 0, offsetof(Py ## EXCSTORE ## Object, dict), [](#l427) (initproc)EXCSTORE ## init, 0, 0, [](#l428) }; [](#l429) PyObject *PyExc ## EXCNAME = (PyObject *)&PyExc ## EXCNAME #define ComplexExtendsException(EXCBASE, EXCNAME, EXCSTORE, EXCNEW, [](#l432) EXCMETHODS, EXCMEMBERS, EXCGETSET, [](#l433) EXCSTR, EXCDOC) [](#l434) static PyTypeObject PyExc ## EXCNAME = { [](#l435) PyVarObject_HEAD_INIT(NULL, 0) [](#l436) # EXCNAME, [](#l437) sizeof(Py ## EXCSTORE ## Object), 0, [](#l438) (destructor)EXCSTORE ## _dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, [](#l439) (reprfunc)EXCSTR, 0, 0, 0, [](#l440) Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, [](#l441) PyDoc_STR(EXCDOC), (traverseproc)EXCSTORE ## _traverse, [](#l442) (inquiry)EXCSTORE ## clear, 0, 0, 0, 0, EXCMETHODS, [](#l443) EXCMEMBERS, EXCGETSET, & ## EXCBASE, [](#l444) 0, 0, 0, offsetof(Py ## EXCSTORE ## Object, dict), [](#l445) (initproc)EXCSTORE ## init, 0, EXCNEW,[](#l446) }; [](#l447) PyObject *PyExc ## EXCNAME = (PyObject )&PyExc ## EXCNAME /

• Exception extends BaseException

/ SimpleExtendsException(PyExc_BaseException, Exception, "Common base class for all non-exit exceptions."); /

• TypeError extends Exception

/ SimpleExtendsException(PyExc_Exception, TypeError, "Inappropriate argument type."); /

• StopAsyncIteration extends Exception

/ SimpleExtendsException(PyExc_Exception, StopAsyncIteration, "Signal the end from iterator.anext()."); /

• StopIteration extends Exception

/ static PyMemberDef StopIteration_members[] = { {"value", T_OBJECT, offsetof(PyStopIterationObject, value), 0, PyDoc_STR("generator return value")}, {NULL} / Sentinel */ }; static int StopIteration_init(PyStopIterationObject *self, PyObject *args, PyObject *kwds) { Py_ssize_t size = PyTuple_GET_SIZE(args); PyObject *value; if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1) return -1; Py_CLEAR(self->value); if (size > 0) value = PyTuple_GET_ITEM(args, 0); else value = Py_None; Py_INCREF(value); self->value = value; return 0; } static int StopIteration_clear(PyStopIterationObject *self) { Py_CLEAR(self->value); return BaseException_clear((PyBaseExceptionObject *)self); } static void StopIteration_dealloc(PyStopIterationObject *self) { _PyObject_GC_UNTRACK(self); StopIteration_clear(self); Py_TYPE(self)->tp_free((PyObject *)self); } static int StopIteration_traverse(PyStopIterationObject *self, visitproc visit, void *arg) { Py_VISIT(self->value); return BaseException_traverse((PyBaseExceptionObject )self, visit, arg); } ComplexExtendsException( PyExc_Exception, / base / StopIteration, / name / StopIteration, / prefix for *_init, etc / 0, / new / 0, / methods / StopIteration_members, / members / 0, / getset / 0, / str / "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; if (size == 1) { Py_INCREF(PyTuple_GET_ITEM(args, 0)); Py_XSETREF(self->code, PyTuple_GET_ITEM(args, 0)); } else { / size > 1 */ Py_INCREF(args); Py_XSETREF(self->code, args); } 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, 0, 0, SystemExit_members, 0, 0, "Request to exit from the interpreter."); /

• KeyboardInterrupt extends BaseException

/ SimpleExtendsException(PyExc_BaseException, KeyboardInterrupt, "Program interrupted by user."); /

• ImportError extends Exception

*/ static int ImportError_init(PyImportErrorObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = {"name", "path", 0}; PyObject *empty_tuple; PyObject *msg = NULL; PyObject *name = NULL; PyObject *path = NULL; if (BaseException_init((PyBaseExceptionObject *)self, args, NULL) == -1) return -1; empty_tuple = PyTuple_New(0); if (!empty_tuple) return -1; if (!PyArg_ParseTupleAndKeywords(empty_tuple, kwds, "|$OO:ImportError", kwlist, &name, &path)) { Py_DECREF(empty_tuple); return -1; } Py_DECREF(empty_tuple); Py_XINCREF(name); Py_XSETREF(self->name, name); Py_XINCREF(path); Py_XSETREF(self->path, path); if (PyTuple_GET_SIZE(args) == 1) { msg = PyTuple_GET_ITEM(args, 0); Py_INCREF(msg); } Py_XSETREF(self->msg, msg); return 0; } static int ImportError_clear(PyImportErrorObject *self) { Py_CLEAR(self->msg); Py_CLEAR(self->name); Py_CLEAR(self->path); return BaseException_clear((PyBaseExceptionObject *)self); } static void ImportError_dealloc(PyImportErrorObject *self) { _PyObject_GC_UNTRACK(self); ImportError_clear(self); Py_TYPE(self)->tp_free((PyObject *)self); } static int ImportError_traverse(PyImportErrorObject *self, visitproc visit, void *arg) { Py_VISIT(self->msg); Py_VISIT(self->name); Py_VISIT(self->path); return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg); } static PyObject * ImportError_str(PyImportErrorObject *self) { if (self->msg && PyUnicode_CheckExact(self->msg)) { Py_INCREF(self->msg); return self->msg; } else { return BaseException_str((PyBaseExceptionObject )self); } } static PyMemberDef ImportError_members[] = { {"msg", T_OBJECT, offsetof(PyImportErrorObject, msg), 0, PyDoc_STR("exception message")}, {"name", T_OBJECT, offsetof(PyImportErrorObject, name), 0, PyDoc_STR("module name")}, {"path", T_OBJECT, offsetof(PyImportErrorObject, path), 0, PyDoc_STR("module path")}, {NULL} / Sentinel / }; static PyMethodDef ImportError_methods[] = { {NULL} }; ComplexExtendsException(PyExc_Exception, ImportError, ImportError, 0 / new /, ImportError_methods, ImportError_members, 0 / getset /, ImportError_str, "Import can't find module, or can't find name in " "module."); /

• ModuleNotFoundError extends ImportError

/ MiddlingExtendsException(PyExc_ImportError, ModuleNotFoundError, ImportError, "Module not found."); /

• OSError extends Exception

/ #ifdef MS_WINDOWS #include "errmap.h" #endif / 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 OSError, (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. *
• (If a function has two filenames, such as rename(), symlink(),
• or copy(), PyErr_SetFromErrnoWithFilenameObjects() is called,
• which allows passing in a second filename.) */

/* This function doesn't cleanup on error, the caller should */ static int oserror_parse_args(PyObject **p_args, PyObject **myerrno, PyObject **strerror, PyObject **filename, PyObject **filename2 #ifdef MS_WINDOWS , PyObject **winerror #endif ) { Py_ssize_t nargs; PyObject *args = p_args; #ifndef MS_WINDOWS / * ignored on non-Windows platforms, * but parsed so OSError has a consistent signature */ PyObject *_winerror = NULL; PyObject *winerror = &_winerror; #endif / MS_WINDOWS */ nargs = PyTuple_GET_SIZE(args); if (nargs >= 2 && nargs <= 5) { if (!PyArg_UnpackTuple(args, "OSError", 2, 5, myerrno, strerror, filename, winerror, filename2)) return -1; #ifdef MS_WINDOWS if (*winerror && PyLong_Check(*winerror)) { long errcode, winerrcode; PyObject *newargs; Py_ssize_t i; winerrcode = PyLong_AsLong(*winerror); if (winerrcode == -1 && PyErr_Occurred()) return -1; /* Set errno to the corresponding POSIX errno (overriding first argument). Windows Socket error codes (>= 10000) have the same value as their POSIX counterparts. */ if (winerrcode < 10000) errcode = winerror_to_errno(winerrcode); else errcode = winerrcode; *myerrno = PyLong_FromLong(errcode); if (!*myerrno) return -1; newargs = PyTuple_New(nargs); if (!newargs) return -1; PyTuple_SET_ITEM(newargs, 0, *myerrno); for (i = 1; i < nargs; i++) { PyObject *val = PyTuple_GET_ITEM(args, i); Py_INCREF(val); PyTuple_SET_ITEM(newargs, i, val); } Py_DECREF(args); args = *p_args = newargs; } #endif /* MS_WINDOWS */ } return 0; } static int oserror_init(PyOSErrorObject *self, PyObject **p_args, PyObject *myerrno, PyObject *strerror, PyObject *filename, PyObject *filename2 #ifdef MS_WINDOWS , PyObject *winerror #endif ) { PyObject *args = *p_args; Py_ssize_t nargs = PyTuple_GET_SIZE(args); /* self->filename will remain Py_None otherwise */ if (filename && filename != Py_None) { if (Py_TYPE(self) == (PyTypeObject ) PyExc_BlockingIOError && PyNumber_Check(filename)) { / BlockingIOError's 3rd argument can be the number of * characters written. / self->written = PyNumber_AsSsize_t(filename, PyExc_ValueError); if (self->written == -1 && PyErr_Occurred()) return -1; } else { Py_INCREF(filename); self->filename = filename; if (filename2 && filename2 != Py_None) { Py_INCREF(filename2); self->filename2 = filename2; } if (nargs >= 2 && nargs <= 5) { /* filename, filename2, and winerror are removed from the args tuple (for compatibility purposes, see test_exceptions.py) */ PyObject *subslice = PyTuple_GetSlice(args, 0, 2); if (!subslice) return -1; Py_DECREF(args); /* replacing args */ *p_args = args = subslice; } } } Py_XINCREF(myerrno); self->myerrno = myerrno; Py_XINCREF(strerror); self->strerror = strerror; #ifdef MS_WINDOWS Py_XINCREF(winerror); self->winerror = winerror; #endif / Steals the reference to args */ Py_XSETREF(self->args, args); *p_args = args = NULL; return 0; } static PyObject * OSError_new(PyTypeObject *type, PyObject *args, PyObject *kwds); static int OSError_init(PyOSErrorObject *self, PyObject *args, PyObject *kwds); static int oserror_use_init(PyTypeObject type) { / When init is defined in an OSError subclass, we want any extraneous argument to new to be ignored. The only reasonable solution, given new takes a variable number of arguments, is to defer arg parsing and initialization to init. But when new is overridden as well, it should call our new with the right arguments. (see http://bugs.python.org/issue12555#msg148829 ) */ if (type->tp_init != (initproc) OSError_init && type->tp_new == (newfunc) OSError_new) { assert((PyObject *) type != PyExc_OSError); return 1; } return 0; } static PyObject * OSError_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { PyOSErrorObject *self = NULL; PyObject *myerrno = NULL, *strerror = NULL; PyObject *filename = NULL, *filename2 = NULL; #ifdef MS_WINDOWS PyObject *winerror = NULL; #endif Py_INCREF(args); if (!oserror_use_init(type)) { if (!_PyArg_NoKeywords(type->tp_name, kwds)) goto error; if (oserror_parse_args(&args, &myerrno, &strerror, &filename, &filename2 #ifdef MS_WINDOWS , &winerror #endif )) goto error; if (myerrno && PyLong_Check(myerrno) && errnomap && (PyObject *) type == PyExc_OSError) { PyObject *newtype; newtype = PyDict_GetItem(errnomap, myerrno); if (newtype) { assert(PyType_Check(newtype)); type = (PyTypeObject *) newtype; } else if (PyErr_Occurred()) goto error; } } self = (PyOSErrorObject *) type->tp_alloc(type, 0); if (!self) goto error; self->dict = NULL; self->traceback = self->cause = self->context = NULL; self->written = -1; if (!oserror_use_init(type)) { if (oserror_init(self, &args, myerrno, strerror, filename, filename2 #ifdef MS_WINDOWS , winerror #endif )) goto error; } else { self->args = PyTuple_New(0); if (self->args == NULL) goto error; } Py_XDECREF(args); return (PyObject *) self; error: Py_XDECREF(args); Py_XDECREF(self); return NULL; } static int OSError_init(PyOSErrorObject *self, PyObject *args, PyObject *kwds) { PyObject *myerrno = NULL, *strerror = NULL; PyObject *filename = NULL, *filename2 = NULL; #ifdef MS_WINDOWS PyObject winerror = NULL; #endif if (!oserror_use_init(Py_TYPE(self))) / Everything already done in OSError_new */ return 0; if (!_PyArg_NoKeywords(Py_TYPE(self)->tp_name, kwds)) return -1; Py_INCREF(args); if (oserror_parse_args(&args, &myerrno, &strerror, &filename, &filename2 #ifdef MS_WINDOWS , &winerror #endif )) goto error; if (oserror_init(self, &args, myerrno, strerror, filename, filename2 #ifdef MS_WINDOWS , winerror #endif )) goto error; return 0; error: Py_DECREF(args); return -1; } static int OSError_clear(PyOSErrorObject *self) { Py_CLEAR(self->myerrno); Py_CLEAR(self->strerror); Py_CLEAR(self->filename); Py_CLEAR(self->filename2); #ifdef MS_WINDOWS Py_CLEAR(self->winerror); #endif return BaseException_clear((PyBaseExceptionObject *)self); } static void OSError_dealloc(PyOSErrorObject *self) { _PyObject_GC_UNTRACK(self); OSError_clear(self); Py_TYPE(self)->tp_free((PyObject *)self); } static int OSError_traverse(PyOSErrorObject *self, visitproc visit, void *arg) { Py_VISIT(self->myerrno); Py_VISIT(self->strerror); Py_VISIT(self->filename); Py_VISIT(self->filename2); #ifdef MS_WINDOWS Py_VISIT(self->winerror); #endif return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg); } static PyObject * OSError_str(PyOSErrorObject self) { #define OR_NONE(x) ((x)?(x):Py_None) #ifdef MS_WINDOWS / If available, winerror has the priority over myerrno */ if (self->winerror && self->filename) { if (self->filename2) { return PyUnicode_FromFormat("[WinError %S] %S: %R -> %R", OR_NONE(self->winerror), OR_NONE(self->strerror), self->filename, self->filename2); } else { return PyUnicode_FromFormat("[WinError %S] %S: %R", OR_NONE(self->winerror), OR_NONE(self->strerror), self->filename); } } if (self->winerror && self->strerror) return PyUnicode_FromFormat("[WinError %S] %S", self->winerror ? self->winerror: Py_None, self->strerror ? self->strerror: Py_None); #endif if (self->filename) { if (self->filename2) { return PyUnicode_FromFormat("[Errno %S] %S: %R -> %R", OR_NONE(self->myerrno), OR_NONE(self->strerror), self->filename, self->filename2); } else { return PyUnicode_FromFormat("[Errno %S] %S: %R", OR_NONE(self->myerrno), OR_NONE(self->strerror), self->filename); } } if (self->myerrno && self->strerror) return PyUnicode_FromFormat("[Errno %S] %S", self->myerrno, self->strerror); return BaseException_str((PyBaseExceptionObject *)self); } static PyObject * OSError_reduce(PyOSErrorObject *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 OSError. / if (PyTuple_GET_SIZE(args) == 2 && self->filename) { Py_ssize_t size = self->filename2 ? 5 : 3; args = PyTuple_New(size); 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); if (self->filename2) { / * This tuple is essentially used as OSError(*args). * So, to recreate filename2, we need to pass in * winerror as well. / Py_INCREF(Py_None); PyTuple_SET_ITEM(args, 3, Py_None); / filename2 */ Py_INCREF(self->filename2); PyTuple_SET_ITEM(args, 4, self->filename2); } } 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 PyObject * OSError_written_get(PyOSErrorObject *self, void *context) { if (self->written == -1) { PyErr_SetString(PyExc_AttributeError, "characters_written"); return NULL; } return PyLong_FromSsize_t(self->written); } static int OSError_written_set(PyOSErrorObject *self, PyObject *arg, void context) { Py_ssize_t n; n = PyNumber_AsSsize_t(arg, PyExc_ValueError); if (n == -1 && PyErr_Occurred()) return -1; self->written = n; return 0; } static PyMemberDef OSError_members[] = { {"errno", T_OBJECT, offsetof(PyOSErrorObject, myerrno), 0, PyDoc_STR("POSIX exception code")}, {"strerror", T_OBJECT, offsetof(PyOSErrorObject, strerror), 0, PyDoc_STR("exception strerror")}, {"filename", T_OBJECT, offsetof(PyOSErrorObject, filename), 0, PyDoc_STR("exception filename")}, {"filename2", T_OBJECT, offsetof(PyOSErrorObject, filename2), 0, PyDoc_STR("second exception filename")}, #ifdef MS_WINDOWS {"winerror", T_OBJECT, offsetof(PyOSErrorObject, winerror), 0, PyDoc_STR("Win32 exception code")}, #endif {NULL} / Sentinel / }; static PyMethodDef OSError_methods[] = { {"reduce", (PyCFunction)OSError_reduce, METH_NOARGS}, {NULL} }; static PyGetSetDef OSError_getset[] = { {"characters_written", (getter) OSError_written_get, (setter) OSError_written_set, NULL}, {NULL} }; ComplexExtendsException(PyExc_Exception, OSError, OSError, OSError_new, OSError_methods, OSError_members, OSError_getset, OSError_str, "Base class for I/O related errors."); /

• Various OSError subclasses

/ MiddlingExtendsException(PyExc_OSError, BlockingIOError, OSError, "I/O operation would block."); MiddlingExtendsException(PyExc_OSError, ConnectionError, OSError, "Connection error."); MiddlingExtendsException(PyExc_OSError, ChildProcessError, OSError, "Child process error."); MiddlingExtendsException(PyExc_ConnectionError, BrokenPipeError, OSError, "Broken pipe."); MiddlingExtendsException(PyExc_ConnectionError, ConnectionAbortedError, OSError, "Connection aborted."); MiddlingExtendsException(PyExc_ConnectionError, ConnectionRefusedError, OSError, "Connection refused."); MiddlingExtendsException(PyExc_ConnectionError, ConnectionResetError, OSError, "Connection reset."); MiddlingExtendsException(PyExc_OSError, FileExistsError, OSError, "File already exists."); MiddlingExtendsException(PyExc_OSError, FileNotFoundError, OSError, "File not found."); MiddlingExtendsException(PyExc_OSError, IsADirectoryError, OSError, "Operation doesn't work on directories."); MiddlingExtendsException(PyExc_OSError, NotADirectoryError, OSError, "Operation only works on directories."); MiddlingExtendsException(PyExc_OSError, InterruptedError, OSError, "Interrupted by signal."); MiddlingExtendsException(PyExc_OSError, PermissionError, OSError, "Not enough permissions."); MiddlingExtendsException(PyExc_OSError, ProcessLookupError, OSError, "Process not found."); MiddlingExtendsException(PyExc_OSError, TimeoutError, OSError, "Timeout expired."); /

• EOFError extends Exception

/ SimpleExtendsException(PyExc_Exception, EOFError, "Read beyond end of file."); /

• RuntimeError extends Exception

/ SimpleExtendsException(PyExc_Exception, RuntimeError, "Unspecified run-time error."); /

• RecursionError extends RuntimeError

/ SimpleExtendsException(PyExc_RuntimeError, RecursionError, "Recursion limit exceeded."); /

• NotImplementedError extends RuntimeError

/ SimpleExtendsException(PyExc_RuntimeError, NotImplementedError, "Method or function hasn't been implemented yet."); /

• NameError extends Exception

/ SimpleExtendsException(PyExc_Exception, NameError, "Name not found globally."); /

• UnboundLocalError extends NameError

/ SimpleExtendsException(PyExc_NameError, UnboundLocalError, "Local name referenced but not bound to a value."); /

• AttributeError extends Exception

/ SimpleExtendsException(PyExc_Exception, AttributeError, "Attribute not found."); /

• SyntaxError extends Exception

/ / Helper function to customize error message for some syntax errors */ static int _report_missing_parentheses(PySyntaxErrorObject *self); 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_INCREF(PyTuple_GET_ITEM(args, 0)); Py_XSETREF(self->msg, PyTuple_GET_ITEM(args, 0)); } 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_INCREF(PyTuple_GET_ITEM(info, 0)); Py_XSETREF(self->filename, PyTuple_GET_ITEM(info, 0)); Py_INCREF(PyTuple_GET_ITEM(info, 1)); Py_XSETREF(self->lineno, PyTuple_GET_ITEM(info, 1)); Py_INCREF(PyTuple_GET_ITEM(info, 2)); Py_XSETREF(self->offset, PyTuple_GET_ITEM(info, 2)); Py_INCREF(PyTuple_GET_ITEM(info, 3)); Py_XSETREF(self->text, PyTuple_GET_ITEM(info, 3)); Py_DECREF(info); / Issue #21669: Custom error for 'print' & 'exec' as statements */ if (self->text && PyUnicode_Check(self->text)) { if (_report_missing_parentheses(self) < 0) { return -1; } } } 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 PyObject my_basename(PyObject *name) { Py_ssize_t i, size, offset; int kind; void data; if (PyUnicode_READY(name)) return NULL; kind = PyUnicode_KIND(name); data = PyUnicode_DATA(name); size = PyUnicode_GET_LENGTH(name); offset = 0; for(i=0; i < size; i++) { if (PyUnicode_READ(kind, data, i) == SEP) offset = i + 1; } if (offset != 0) return PyUnicode_Substring(name, offset, size); else { Py_INCREF(name); return name; } } static PyObject * SyntaxError_str(PySyntaxErrorObject *self) { int have_lineno = 0; PyObject *filename; PyObject *result; /* Below, we always ignore overflow errors, just printing -1. Still, we cannot allow an OverflowError to be raised, so we need to call PyLong_AsLongAndOverflow. */ int overflow; /* XXX -- do all the additional formatting with filename and lineno here */ if (self->filename && PyUnicode_Check(self->filename)) { filename = my_basename(self->filename); if (filename == NULL) return NULL; } else { filename = NULL; } have_lineno = (self->lineno != NULL) && PyLong_CheckExact(self->lineno); if (!filename && !have_lineno) return PyObject_Str(self->msg ? self->msg : Py_None); if (filename && have_lineno) result = PyUnicode_FromFormat("%S (%U, line %ld)", self->msg ? self->msg : Py_None, filename, PyLong_AsLongAndOverflow(self->lineno, &overflow)); else if (filename) result = PyUnicode_FromFormat("%S (%U)", self->msg ? self->msg : Py_None, filename); else / only have_lineno / result = PyUnicode_FromFormat("%S (line %ld)", self->msg ? self->msg : Py_None, PyLong_AsLongAndOverflow(self->lineno, &overflow)); Py_XDECREF(filename); 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_Exception, SyntaxError, SyntaxError, 0, 0, SyntaxError_members, 0, 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 Exception

/ SimpleExtendsException(PyExc_Exception, 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, 0, KeyError_str, "Mapping key not found."); /

• ValueError extends Exception

/ SimpleExtendsException(PyExc_Exception, ValueError, "Inappropriate argument value (of correct type)."); /

• UnicodeError extends ValueError

*/ SimpleExtendsException(PyExc_ValueError, UnicodeError, "Unicode related error."); static PyObject * get_string(PyObject *attr, const char *name) { if (!attr) { PyErr_Format(PyExc_TypeError, "%.200s attribute not set", name); return NULL; } if (!PyBytes_Check(attr)) { PyErr_Format(PyExc_TypeError, "%.200s attribute must be bytes", name); return NULL; } Py_INCREF(attr); return attr; } 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; } static int set_unicodefromstring(PyObject **attr, const char *value) { PyObject *obj = PyUnicode_FromString(value); if (!obj) return -1; Py_XSETREF(*attr, obj); return 0; } PyObject * PyUnicodeEncodeError_GetEncoding(PyObject *exc) { return get_unicode(((PyUnicodeErrorObject *)exc)->encoding, "encoding"); } PyObject * PyUnicodeDecodeError_GetEncoding(PyObject *exc) { return get_unicode(((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_LENGTH(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 = PyBytes_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_LENGTH(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; size = PyBytes_GET_SIZE(obj); *end = ((PyUnicodeErrorObject *)exc)->end; 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_unicode(((PyUnicodeErrorObject *)exc)->reason, "reason"); } PyObject * PyUnicodeDecodeError_GetReason(PyObject *exc) { return get_unicode(((PyUnicodeErrorObject *)exc)->reason, "reason"); } PyObject * PyUnicodeTranslateError_GetReason(PyObject *exc) { return get_unicode(((PyUnicodeErrorObject *)exc)->reason, "reason"); } int PyUnicodeEncodeError_SetReason(PyObject *exc, const char *reason) { return set_unicodefromstring(&((PyUnicodeErrorObject *)exc)->reason, reason); } int PyUnicodeDecodeError_SetReason(PyObject *exc, const char *reason) { return set_unicodefromstring(&((PyUnicodeErrorObject *)exc)->reason, reason); } int PyUnicodeTranslateError_SetReason(PyObject *exc, const char *reason) { return set_unicodefromstring(&((PyUnicodeErrorObject *)exc)->reason, reason); } 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) { PyUnicodeErrorObject *err; if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1) return -1; err = (PyUnicodeErrorObject *)self; Py_CLEAR(err->encoding); Py_CLEAR(err->object); Py_CLEAR(err->reason); if (!PyArg_ParseTuple(args, "UUnnU", &err->encoding, &err->object, &err->start, &err->end, &err->reason)) { err->encoding = err->object = err->reason = NULL; return -1; } Py_INCREF(err->encoding); Py_INCREF(err->object); Py_INCREF(err->reason); return 0; } 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 constructed. */ 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_LENGTH(uself->object) && uself->end == uself->start+1) { Py_UCS4 badchar = PyUnicode_ReadChar(uself->object, uself->start); const char *fmt; if (badchar <= 0xff) fmt = "'%U' codec can't encode character '\x%02x' in position %zd: %U"; else if (badchar <= 0xffff) fmt = "'%U' codec can't encode character '\u%04x' in position %zd: %U"; else fmt = "'%U' codec can't encode character '\U%08x' in position %zd: %U"; result = PyUnicode_FromFormat( fmt, encoding_str, (int)badchar, uself->start, reason_str); } else { result = PyUnicode_FromFormat( "'%U' codec can't encode characters in position %zd-%zd: %U", encoding_str, uself->start, uself->end-1, reason_str); } done: Py_XDECREF(reason_str); Py_XDECREF(encoding_str); return result; } static PyTypeObject _PyExc_UnicodeEncodeError = { PyVarObject_HEAD_INIT(NULL, 0) "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) { PyUnicodeErrorObject *ude; if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1) return -1; ude = (PyUnicodeErrorObject *)self; Py_CLEAR(ude->encoding); Py_CLEAR(ude->object); Py_CLEAR(ude->reason); if (!PyArg_ParseTuple(args, "UOnnU", &ude->encoding, &ude->object, &ude->start, &ude->end, &ude->reason)) { ude->encoding = ude->object = ude->reason = NULL; return -1; } Py_INCREF(ude->encoding); Py_INCREF(ude->object); Py_INCREF(ude->reason); if (!PyBytes_Check(ude->object)) { Py_buffer view; if (PyObject_GetBuffer(ude->object, &view, PyBUF_SIMPLE) != 0) goto error; Py_XSETREF(ude->object, PyBytes_FromStringAndSize(view.buf, view.len)); PyBuffer_Release(&view); if (!ude->object) goto error; } return 0; error: Py_CLEAR(ude->encoding); Py_CLEAR(ude->object); Py_CLEAR(ude->reason); return -1; } 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 constructed. */ 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 < PyBytes_GET_SIZE(uself->object) && uself->end == uself->start+1) { int byte = (int)(PyBytes_AS_STRING(((PyUnicodeErrorObject *)self)->object)[uself->start]&0xff); result = PyUnicode_FromFormat( "'%U' codec can't decode byte 0x%02x in position %zd: %U", encoding_str, byte, uself->start, reason_str); } else { result = PyUnicode_FromFormat( "'%U' codec can't decode bytes in position %zd-%zd: %U", encoding_str, uself->start, uself->end-1, reason_str ); } done: Py_XDECREF(reason_str); Py_XDECREF(encoding_str); return result; } static PyTypeObject _PyExc_UnicodeDecodeError = { PyVarObject_HEAD_INIT(NULL, 0) "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, "sy#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, "UnnU", &self->object, &self->start, &self->end, &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 constructed. */ reason_str = PyObject_Str(uself->reason); if (reason_str == NULL) goto done; if (uself->start < PyUnicode_GET_LENGTH(uself->object) && uself->end == uself->start+1) { Py_UCS4 badchar = PyUnicode_ReadChar(uself->object, uself->start); const char *fmt; if (badchar <= 0xff) fmt = "can't translate character '\x%02x' in position %zd: %U"; else if (badchar <= 0xffff) fmt = "can't translate character '\u%04x' in position %zd: %U"; else fmt = "can't translate character '\U%08x' in position %zd: %U"; result = PyUnicode_FromFormat( fmt, (int)badchar, uself->start, reason_str ); } else { result = PyUnicode_FromFormat( "can't translate characters in position %zd-%zd: %U", uself->start, uself->end-1, reason_str ); } done: Py_XDECREF(reason_str); return result; } static PyTypeObject _PyExc_UnicodeTranslateError = { PyVarObject_HEAD_INIT(NULL, 0) "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; / Deprecated. */ 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); } PyObject * _PyUnicodeTranslateError_Create( PyObject *object, Py_ssize_t start, Py_ssize_t end, const char reason) { return PyObject_CallFunction(PyExc_UnicodeTranslateError, "Onns", object, start, end, reason); } /

• AssertionError extends Exception

/ SimpleExtendsException(PyExc_Exception, AssertionError, "Assertion failed."); /

• ArithmeticError extends Exception

/ SimpleExtendsException(PyExc_Exception, 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 Exception

/ SimpleExtendsException(PyExc_Exception, 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 Exception

/ SimpleExtendsException(PyExc_Exception, ReferenceError, "Weak ref proxy used after referent went away."); /

• MemoryError extends Exception

*/ #define MEMERRORS_SAVE 16 static PyBaseExceptionObject *memerrors_freelist = NULL; static int memerrors_numfree = 0; static PyObject * MemoryError_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { PyBaseExceptionObject *self; if (type != (PyTypeObject ) PyExc_MemoryError) return BaseException_new(type, args, kwds); if (memerrors_freelist == NULL) return BaseException_new(type, args, kwds); / Fetch object from freelist and revive it / self = memerrors_freelist; self->args = PyTuple_New(0); / This shouldn't happen since the empty tuple is persistent */ if (self->args == NULL) return NULL; memerrors_freelist = (PyBaseExceptionObject *) self->dict; memerrors_numfree--; self->dict = NULL; _Py_NewReference((PyObject *)self); _PyObject_GC_TRACK(self); return (PyObject *)self; } static void MemoryError_dealloc(PyBaseExceptionObject *self) { _PyObject_GC_UNTRACK(self); BaseException_clear(self); if (memerrors_numfree >= MEMERRORS_SAVE) Py_TYPE(self)->tp_free((PyObject *)self); else { self->dict = (PyObject ) memerrors_freelist; memerrors_freelist = self; memerrors_numfree++; } } static void preallocate_memerrors(void) { / We create enough MemoryErrors and then decref them, which will fill up the freelist. */ int i; PyObject *errors[MEMERRORS_SAVE]; for (i = 0; i < MEMERRORS_SAVE; i++) { errors[i] = MemoryError_new((PyTypeObject *) PyExc_MemoryError, NULL, NULL); if (!errors[i]) Py_FatalError("Could not preallocate MemoryError object"); } for (i = 0; i < MEMERRORS_SAVE; i++) { Py_DECREF(errors[i]); } } static void free_preallocated_memerrors(void) { while (memerrors_freelist != NULL) { PyObject *self = (PyObject *) memerrors_freelist; memerrors_freelist = (PyBaseExceptionObject *) memerrors_freelist->dict; Py_TYPE(self)->tp_free((PyObject *)self); } } static PyTypeObject _PyExc_MemoryError = { PyVarObject_HEAD_INIT(NULL, 0) "MemoryError", sizeof(PyBaseExceptionObject), 0, (destructor)MemoryError_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("Out of memory."), (traverseproc)BaseException_traverse, (inquiry)BaseException_clear, 0, 0, 0, 0, 0, 0, 0, &_PyExc_Exception, 0, 0, 0, offsetof(PyBaseExceptionObject, dict), (initproc)BaseException_init, 0, MemoryError_new }; PyObject *PyExc_MemoryError = (PyObject ) &_PyExc_MemoryError; /

• BufferError extends Exception

/ SimpleExtendsException(PyExc_Exception, 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."); /

• ResourceWarning extends Warning

/ SimpleExtendsException(PyExc_Warning, ResourceWarning, "Base class for warnings about resource usage."); / Pre-computed RecursionError 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; #define PRE_INIT(TYPE) [](#l2369) if (!(PyExc ## TYPE.tp_flags & Py_TPFLAGS_READY)) { [](#l2370) if (PyType_Ready(&PyExc ## TYPE) < 0) [](#l2371) Py_FatalError("exceptions bootstrapping error."); [](#l2372) Py_INCREF(PyExc_ ## TYPE); [](#l2373) } #define POST_INIT(TYPE) [](#l2376) if (PyDict_SetItemString(bdict, # TYPE, PyExc_ ## TYPE)) [](#l2377) Py_FatalError("Module dictionary insertion problem."); #define INIT_ALIAS(NAME, TYPE) Py_INCREF(PyExc_ ## TYPE); [](#l2380) Py_XDECREF(PyExc_ ## NAME); [](#l2381) PyExc_ ## NAME = PyExc_ ## TYPE; [](#l2382) if (PyDict_SetItemString(bdict, # NAME, PyExc_ ## NAME)) [](#l2383) Py_FatalError("Module dictionary insertion problem."); #define ADD_ERRNO(TYPE, CODE) { [](#l2386) PyObject *_code = PyLong_FromLong(CODE); [](#l2387) assert(_PyObject_RealIsSubclass(PyExc_ ## TYPE, PyExc_OSError)); [](#l2388) if (!_code || PyDict_SetItem(errnomap, _code, PyExc_ ## TYPE)) [](#l2389) Py_FatalError("errmap insertion problem."); [](#l2390) Py_DECREF(_code); [](#l2391) } #ifdef MS_WINDOWS #include <winsock2.h> / The following constants were added to errno.h in VS2010 but have preferred WSA equivalents. / #undef EADDRINUSE #undef EADDRNOTAVAIL #undef EAFNOSUPPORT #undef EALREADY #undef ECONNABORTED #undef ECONNREFUSED #undef ECONNRESET #undef EDESTADDRREQ #undef EHOSTUNREACH #undef EINPROGRESS #undef EISCONN #undef ELOOP #undef EMSGSIZE #undef ENETDOWN #undef ENETRESET #undef ENETUNREACH #undef ENOBUFS #undef ENOPROTOOPT #undef ENOTCONN #undef ENOTSOCK #undef EOPNOTSUPP #undef EPROTONOSUPPORT #undef EPROTOTYPE #undef ETIMEDOUT #undef EWOULDBLOCK #if defined(WSAEALREADY) && !defined(EALREADY) #define EALREADY WSAEALREADY #endif #if defined(WSAECONNABORTED) && !defined(ECONNABORTED) #define ECONNABORTED WSAECONNABORTED #endif #if defined(WSAECONNREFUSED) && !defined(ECONNREFUSED) #define ECONNREFUSED WSAECONNREFUSED #endif #if defined(WSAECONNRESET) && !defined(ECONNRESET) #define ECONNRESET WSAECONNRESET #endif #if defined(WSAEINPROGRESS) && !defined(EINPROGRESS) #define EINPROGRESS WSAEINPROGRESS #endif #if defined(WSAESHUTDOWN) && !defined(ESHUTDOWN) #define ESHUTDOWN WSAESHUTDOWN #endif #if defined(WSAETIMEDOUT) && !defined(ETIMEDOUT) #define ETIMEDOUT WSAETIMEDOUT #endif #if defined(WSAEWOULDBLOCK) && !defined(EWOULDBLOCK) #define EWOULDBLOCK WSAEWOULDBLOCK #endif #endif / MS_WINDOWS */ void _PyExc_Init(PyObject *bltinmod) { PyObject bdict; PRE_INIT(BaseException) PRE_INIT(Exception) PRE_INIT(TypeError) PRE_INIT(StopAsyncIteration) PRE_INIT(StopIteration) PRE_INIT(GeneratorExit) PRE_INIT(SystemExit) PRE_INIT(KeyboardInterrupt) PRE_INIT(ImportError) PRE_INIT(ModuleNotFoundError) PRE_INIT(OSError) PRE_INIT(EOFError) PRE_INIT(RuntimeError) PRE_INIT(RecursionError) 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) PRE_INIT(UnicodeEncodeError) PRE_INIT(UnicodeDecodeError) PRE_INIT(UnicodeTranslateError) PRE_INIT(AssertionError) PRE_INIT(ArithmeticError) PRE_INIT(FloatingPointError) PRE_INIT(OverflowError) PRE_INIT(ZeroDivisionError) PRE_INIT(SystemError) PRE_INIT(ReferenceError) PRE_INIT(BufferError) 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) PRE_INIT(ResourceWarning) / OSError subclasses / PRE_INIT(ConnectionError); PRE_INIT(BlockingIOError); PRE_INIT(BrokenPipeError); PRE_INIT(ChildProcessError); PRE_INIT(ConnectionAbortedError); PRE_INIT(ConnectionRefusedError); PRE_INIT(ConnectionResetError); PRE_INIT(FileExistsError); PRE_INIT(FileNotFoundError); PRE_INIT(IsADirectoryError); PRE_INIT(NotADirectoryError); PRE_INIT(InterruptedError); PRE_INIT(PermissionError); PRE_INIT(ProcessLookupError); PRE_INIT(TimeoutError); bdict = PyModule_GetDict(bltinmod); if (bdict == NULL) Py_FatalError("exceptions bootstrapping error."); POST_INIT(BaseException) POST_INIT(Exception) POST_INIT(TypeError) POST_INIT(StopAsyncIteration) POST_INIT(StopIteration) POST_INIT(GeneratorExit) POST_INIT(SystemExit) POST_INIT(KeyboardInterrupt) POST_INIT(ImportError) POST_INIT(ModuleNotFoundError) POST_INIT(OSError) INIT_ALIAS(EnvironmentError, OSError) INIT_ALIAS(IOError, OSError) #ifdef MS_WINDOWS INIT_ALIAS(WindowsError, OSError) #endif POST_INIT(EOFError) POST_INIT(RuntimeError) POST_INIT(RecursionError) 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) POST_INIT(UnicodeEncodeError) POST_INIT(UnicodeDecodeError) POST_INIT(UnicodeTranslateError) POST_INIT(AssertionError) POST_INIT(ArithmeticError) POST_INIT(FloatingPointError) POST_INIT(OverflowError) POST_INIT(ZeroDivisionError) POST_INIT(SystemError) POST_INIT(ReferenceError) POST_INIT(BufferError) 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) POST_INIT(ResourceWarning) if (!errnomap) { errnomap = PyDict_New(); if (!errnomap) Py_FatalError("Cannot allocate map from errnos to OSError subclasses"); } / OSError subclasses */ POST_INIT(ConnectionError); POST_INIT(BlockingIOError); ADD_ERRNO(BlockingIOError, EAGAIN); ADD_ERRNO(BlockingIOError, EALREADY); ADD_ERRNO(BlockingIOError, EINPROGRESS); ADD_ERRNO(BlockingIOError, EWOULDBLOCK); POST_INIT(BrokenPipeError); ADD_ERRNO(BrokenPipeError, EPIPE); #ifdef ESHUTDOWN ADD_ERRNO(BrokenPipeError, ESHUTDOWN); #endif POST_INIT(ChildProcessError); ADD_ERRNO(ChildProcessError, ECHILD); POST_INIT(ConnectionAbortedError); ADD_ERRNO(ConnectionAbortedError, ECONNABORTED); POST_INIT(ConnectionRefusedError); ADD_ERRNO(ConnectionRefusedError, ECONNREFUSED); POST_INIT(ConnectionResetError); ADD_ERRNO(ConnectionResetError, ECONNRESET); POST_INIT(FileExistsError); ADD_ERRNO(FileExistsError, EEXIST); POST_INIT(FileNotFoundError); ADD_ERRNO(FileNotFoundError, ENOENT); POST_INIT(IsADirectoryError); ADD_ERRNO(IsADirectoryError, EISDIR); POST_INIT(NotADirectoryError); ADD_ERRNO(NotADirectoryError, ENOTDIR); POST_INIT(InterruptedError); ADD_ERRNO(InterruptedError, EINTR); POST_INIT(PermissionError); ADD_ERRNO(PermissionError, EACCES); ADD_ERRNO(PermissionError, EPERM); POST_INIT(ProcessLookupError); ADD_ERRNO(ProcessLookupError, ESRCH); POST_INIT(TimeoutError); ADD_ERRNO(TimeoutError, ETIMEDOUT); preallocate_memerrors(); if (!PyExc_RecursionErrorInst) { PyExc_RecursionErrorInst = BaseException_new(&_PyExc_RecursionError, NULL, NULL); if (!PyExc_RecursionErrorInst) Py_FatalError("Cannot pre-allocate RecursionError instance for " "recursion errors"); else { PyBaseExceptionObject *err_inst = (PyBaseExceptionObject *)PyExc_RecursionErrorInst; PyObject *args_tuple; PyObject exc_message; exc_message = PyUnicode_FromString("maximum recursion depth exceeded"); if (!exc_message) Py_FatalError("cannot allocate argument for RecursionError " "pre-allocation"); args_tuple = PyTuple_Pack(1, exc_message); if (!args_tuple) Py_FatalError("cannot allocate tuple for RecursionError " "pre-allocation"); Py_DECREF(exc_message); if (BaseException_init(err_inst, args_tuple, NULL)) Py_FatalError("init of pre-allocated RecursionError failed"); Py_DECREF(args_tuple); } } } void _PyExc_Fini(void) { Py_CLEAR(PyExc_RecursionErrorInst); free_preallocated_memerrors(); Py_CLEAR(errnomap); } / Helper to do the equivalent of "raise X from Y" in C, but always using

• the current exception rather than passing one in. *
• We currently limit this to only exceptions that use the BaseException
• tp_init and tp_new methods, since we can be reasonably sure we can wrap
• those correctly without losing data and without losing backwards
• compatibility. *
• We also aim to rule out all exceptions that might be storing additional
• state, whether by having a size difference relative to BaseException,
• additional arguments passed in during construction or by having a
• non-empty instance dict. *
• We need to be very careful with what we wrap, since changing types to
• a broader exception type would be backwards incompatible for
• existing codecs, and with different init or new method implementations
• may either not support instantiation with PyErr_Format or lose
• information when instantiated that way. *
• XXX (ncoghlan): This could be made more comprehensive by exploiting the
• fact that exceptions are expected to support pickling. If more builtin
• exceptions (e.g. AttributeError) start to be converted to rich
• exceptions with additional attributes, that's probably a better approach
• to pursue over adding special cases for particular stateful subclasses. *
• Returns a borrowed reference to the new exception (if any), NULL if the
• existing exception was left in place. */ PyObject * _PyErr_TrySetFromCause(const char format, ...) { PyObject msg_prefix; PyObject *exc, *val, *tb; PyTypeObject *caught_type; PyObject **dictptr; PyObject *instance_args; Py_ssize_t num_args, caught_type_size, base_exc_size; PyObject *new_exc, *new_val, *new_tb; va_list vargs; int same_basic_size; PyErr_Fetch(&exc, &val, &tb); caught_type = (PyTypeObject )exc; / Ensure type info indicates no extra state is stored at the C level
  • and that the type can be reinstantiated using PyErr_Format */ caught_type_size = caught_type->tp_basicsize; base_exc_size = _PyExc_BaseException.tp_basicsize; same_basic_size = ( caught_type_size == base_exc_size || (PyType_SUPPORTS_WEAKREFS(caught_type) && (caught_type_size == base_exc_size + (Py_ssize_t)sizeof(PyObject )) ) ); if (caught_type->tp_init != (initproc)BaseException_init || caught_type->tp_new != BaseException_new || !same_basic_size || caught_type->tp_itemsize != _PyExc_BaseException.tp_itemsize) { / We can't be sure we can wrap this safely, since it may contain
    • more state than just the exception type. Accordingly, we just
    • leave it alone. / PyErr_Restore(exc, val, tb); return NULL; } / Check the args are empty or contain a single string */ PyErr_NormalizeException(&exc, &val, &tb); instance_args = ((PyBaseExceptionObject )val)->args; num_args = PyTuple_GET_SIZE(instance_args); if (num_args > 1 || (num_args == 1 && !PyUnicode_CheckExact(PyTuple_GET_ITEM(instance_args, 0)))) { / More than 1 arg, or the one arg we do have isn't a string / PyErr_Restore(exc, val, tb); return NULL; } / Ensure the instance dict is also empty */ dictptr = _PyObject_GetDictPtr(val); if (dictptr != NULL && *dictptr != NULL && PyObject_Length(dictptr) > 0) { / While we could potentially copy a non-empty instance dictionary
    • to the replacement exception, for now we take the more
    • conservative path of leaving exceptions with attributes set
    • alone. / PyErr_Restore(exc, val, tb); return NULL; } / For exceptions that we can wrap safely, we chain the original
  • exception to a new one of the exact same type with an
  • error message that mentions the additional details and the
  • original exception. *
  • It would be nice to wrap OSError and various other exception
  • types as well, but that's quite a bit trickier due to the extra
  • state potentially stored on OSError instances. / / Ensure the traceback is set correctly on the existing exception */ if (tb != NULL) { PyException_SetTraceback(val, tb); Py_DECREF(tb); }

#ifdef HAVE_STDARG_PROTOTYPES va_start(vargs, format); #else va_start(vargs); #endif msg_prefix = PyUnicode_FromFormatV(format, vargs); va_end(vargs); if (msg_prefix == NULL) { Py_DECREF(exc); Py_DECREF(val); return NULL; } PyErr_Format(exc, "%U (%s: %S)", msg_prefix, Py_TYPE(val)->tp_name, val); Py_DECREF(exc); Py_DECREF(msg_prefix); PyErr_Fetch(&new_exc, &new_val, &new_tb); PyErr_NormalizeException(&new_exc, &new_val, &new_tb); PyException_SetCause(new_val, val); PyErr_Restore(new_exc, new_val, new_tb); return new_val; } /* To help with migration from Python 2, SyntaxError.init applies some

• heuristics to try to report a more meaningful exception when print and
• exec are used like statements. *
• The heuristics are currently expected to detect the following cases:
• • top level statement
• • statement in a nested suite
• • trailing section of a one line complex statement *
• They're currently known not to trigger:
• • after a semi-colon *
• The error message can be a bit odd in cases where the "arguments" are
• completely illegal syntactically, but that isn't worth the hassle of
• fixing. *
• We also can't do anything about cases that are legal Python 3 syntax
• but mean something entirely different from what they did in Python 2
• (omitting the arguments entirely, printing items preceded by a unary plus
• or minus, using the stream redirection syntax). */

static int _check_for_legacy_statements(PySyntaxErrorObject self, Py_ssize_t start) { / Return values: * -1: an error occurred * 0: nothing happened * 1: the check triggered & the error message was changed */ static PyObject *print_prefix = NULL; static PyObject *exec_prefix = NULL; Py_ssize_t text_len = PyUnicode_GET_LENGTH(self->text); int kind = PyUnicode_KIND(self->text); void data = PyUnicode_DATA(self->text); / Ignore leading whitespace / while (start < text_len) { Py_UCS4 ch = PyUnicode_READ(kind, data, start); if (!Py_UNICODE_ISSPACE(ch)) break; start++; } /* Checking against an empty or whitespace-only part of the string */ if (start == text_len) { return 0; } /* Check for legacy print statements */ if (print_prefix == NULL) { print_prefix = PyUnicode_InternFromString("print "); if (print_prefix == NULL) { return -1; } } if (PyUnicode_Tailmatch(self->text, print_prefix, start, text_len, -1)) { Py_XSETREF(self->msg, PyUnicode_FromString("Missing parentheses in call to 'print'")); return 1; } / Check for legacy exec statements / if (exec_prefix == NULL) { exec_prefix = PyUnicode_InternFromString("exec "); if (exec_prefix == NULL) { return -1; } } if (PyUnicode_Tailmatch(self->text, exec_prefix, start, text_len, -1)) { Py_XSETREF(self->msg, PyUnicode_FromString("Missing parentheses in call to 'exec'")); return 1; } / Fall back to the default error message */ return 0; } static int _report_missing_parentheses(PySyntaxErrorObject self) { Py_UCS4 left_paren = 40; Py_ssize_t left_paren_index; Py_ssize_t text_len = PyUnicode_GET_LENGTH(self->text); int legacy_check_result = 0; / Skip entirely if there is an opening parenthesis / left_paren_index = PyUnicode_FindChar(self->text, left_paren, 0, text_len, 1); if (left_paren_index < -1) { return -1; } if (left_paren_index != -1) { /* Use default error message for any line with an opening paren */ return 0; } /* Handle the simple statement case */ legacy_check_result = _check_for_legacy_statements(self, 0); if (legacy_check_result < 0) { return -1; } if (legacy_check_result == 0) { /* Handle the one-line complex statement case */ Py_UCS4 colon = 58; Py_ssize_t colon_index; colon_index = PyUnicode_FindChar(self->text, colon, 0, text_len, 1); if (colon_index < -1) { return -1; } if (colon_index >= 0 && colon_index < text_len) { / Check again, starting from just after the colon */ if (_check_for_legacy_statements(self, colon_index+1) < 0) { return -1; } } } return 0; }