2 * New exceptions.c written in Iceland by Richard Jones and Georg Brandl.
4 * Thanks go to Tim Peters and Michael Hudson for debugging.
7 #define PY_SSIZE_T_CLEAN
9 #include "structmember.h"
12 #define EXC_MODULE_NAME "exceptions."
14 /* NOTE: If the exception class hierarchy changes, don't forget to update
15 * Lib/test/exception_hierarchy.txt
18 PyDoc_STRVAR(exceptions_doc
, "Python's standard exception class hierarchy.\n\
20 Exceptions found here are defined both in the exceptions module and the\n\
21 built-in namespace. It is recommended that user-defined exceptions\n\
22 inherit from Exception. See the documentation for the exception\n\
23 inheritance hierarchy.\n\
30 BaseException_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwds
)
32 PyBaseExceptionObject
*self
;
34 self
= (PyBaseExceptionObject
*)type
->tp_alloc(type
, 0);
37 /* the dict is created on the fly in PyObject_GenericSetAttr */
38 self
->message
= self
->dict
= NULL
;
40 self
->args
= PyTuple_New(0);
46 self
->message
= PyString_FromString("");
52 return (PyObject
*)self
;
56 BaseException_init(PyBaseExceptionObject
*self
, PyObject
*args
, PyObject
*kwds
)
58 if (!_PyArg_NoKeywords(Py_TYPE(self
)->tp_name
, kwds
))
61 Py_DECREF(self
->args
);
63 Py_INCREF(self
->args
);
65 if (PyTuple_GET_SIZE(self
->args
) == 1) {
66 Py_CLEAR(self
->message
);
67 self
->message
= PyTuple_GET_ITEM(self
->args
, 0);
68 Py_INCREF(self
->message
);
74 BaseException_clear(PyBaseExceptionObject
*self
)
78 Py_CLEAR(self
->message
);
83 BaseException_dealloc(PyBaseExceptionObject
*self
)
85 _PyObject_GC_UNTRACK(self
);
86 BaseException_clear(self
);
87 Py_TYPE(self
)->tp_free((PyObject
*)self
);
91 BaseException_traverse(PyBaseExceptionObject
*self
, visitproc visit
, void *arg
)
95 Py_VISIT(self
->message
);
100 BaseException_str(PyBaseExceptionObject
*self
)
104 switch (PyTuple_GET_SIZE(self
->args
)) {
106 out
= PyString_FromString("");
109 out
= PyObject_Str(PyTuple_GET_ITEM(self
->args
, 0));
112 out
= PyObject_Str(self
->args
);
119 #ifdef Py_USING_UNICODE
121 BaseException_unicode(PyBaseExceptionObject
*self
)
125 /* issue6108: if __str__ has been overridden in the subclass, unicode()
126 should return the message returned by __str__ as used to happen
127 before this method was implemented. */
128 if (Py_TYPE(self
)->tp_str
!= (reprfunc
)BaseException_str
) {
130 /* Unlike PyObject_Str, tp_str can return unicode (i.e. return the
131 equivalent of unicode(e.__str__()) instead of unicode(str(e))). */
132 str
= Py_TYPE(self
)->tp_str((PyObject
*)self
);
135 out
= PyObject_Unicode(str
);
140 switch (PyTuple_GET_SIZE(self
->args
)) {
142 out
= PyUnicode_FromString("");
145 out
= PyObject_Unicode(PyTuple_GET_ITEM(self
->args
, 0));
148 out
= PyObject_Unicode(self
->args
);
157 BaseException_repr(PyBaseExceptionObject
*self
)
159 PyObject
*repr_suffix
;
164 repr_suffix
= PyObject_Repr(self
->args
);
168 name
= (char *)Py_TYPE(self
)->tp_name
;
169 dot
= strrchr(name
, '.');
170 if (dot
!= NULL
) name
= dot
+1;
172 repr
= PyString_FromString(name
);
174 Py_DECREF(repr_suffix
);
178 PyString_ConcatAndDel(&repr
, repr_suffix
);
182 /* Pickling support */
184 BaseException_reduce(PyBaseExceptionObject
*self
)
186 if (self
->args
&& self
->dict
)
187 return PyTuple_Pack(3, Py_TYPE(self
), self
->args
, self
->dict
);
189 return PyTuple_Pack(2, Py_TYPE(self
), self
->args
);
193 * Needed for backward compatibility, since exceptions used to store
194 * all their attributes in the __dict__. Code is taken from cPickle's
195 * load_build function.
198 BaseException_setstate(PyObject
*self
, PyObject
*state
)
200 PyObject
*d_key
, *d_value
;
203 if (state
!= Py_None
) {
204 if (!PyDict_Check(state
)) {
205 PyErr_SetString(PyExc_TypeError
, "state is not a dictionary");
208 while (PyDict_Next(state
, &i
, &d_key
, &d_value
)) {
209 if (PyObject_SetAttr(self
, d_key
, d_value
) < 0)
217 static PyMethodDef BaseException_methods
[] = {
218 {"__reduce__", (PyCFunction
)BaseException_reduce
, METH_NOARGS
},
219 {"__setstate__", (PyCFunction
)BaseException_setstate
, METH_O
},
220 #ifdef Py_USING_UNICODE
221 {"__unicode__", (PyCFunction
)BaseException_unicode
, METH_NOARGS
},
223 {NULL
, NULL
, 0, NULL
},
229 BaseException_getitem(PyBaseExceptionObject
*self
, Py_ssize_t index
)
231 if (PyErr_WarnPy3k("__getitem__ not supported for exception "
232 "classes in 3.x; use args attribute", 1) < 0)
234 return PySequence_GetItem(self
->args
, index
);
238 BaseException_getslice(PyBaseExceptionObject
*self
,
239 Py_ssize_t start
, Py_ssize_t stop
)
241 if (PyErr_WarnPy3k("__getslice__ not supported for exception "
242 "classes in 3.x; use args attribute", 1) < 0)
244 return PySequence_GetSlice(self
->args
, start
, stop
);
247 static PySequenceMethods BaseException_as_sequence
= {
251 (ssizeargfunc
)BaseException_getitem
, /* sq_item; */
252 (ssizessizeargfunc
)BaseException_getslice
, /* sq_slice; */
253 0, /* sq_ass_item; */
254 0, /* sq_ass_slice; */
255 0, /* sq_contains; */
256 0, /* sq_inplace_concat; */
257 0 /* sq_inplace_repeat; */
261 BaseException_get_dict(PyBaseExceptionObject
*self
)
263 if (self
->dict
== NULL
) {
264 self
->dict
= PyDict_New();
268 Py_INCREF(self
->dict
);
273 BaseException_set_dict(PyBaseExceptionObject
*self
, PyObject
*val
)
276 PyErr_SetString(PyExc_TypeError
, "__dict__ may not be deleted");
279 if (!PyDict_Check(val
)) {
280 PyErr_SetString(PyExc_TypeError
, "__dict__ must be a dictionary");
283 Py_CLEAR(self
->dict
);
290 BaseException_get_args(PyBaseExceptionObject
*self
)
292 if (self
->args
== NULL
) {
296 Py_INCREF(self
->args
);
301 BaseException_set_args(PyBaseExceptionObject
*self
, PyObject
*val
)
305 PyErr_SetString(PyExc_TypeError
, "args may not be deleted");
308 seq
= PySequence_Tuple(val
);
310 Py_CLEAR(self
->args
);
316 BaseException_get_message(PyBaseExceptionObject
*self
)
320 /* if "message" is in self->dict, accessing a user-set message attribute */
322 (msg
= PyDict_GetItemString(self
->dict
, "message"))) {
327 if (self
->message
== NULL
) {
328 PyErr_SetString(PyExc_AttributeError
, "message attribute was deleted");
332 /* accessing the deprecated "builtin" message attribute of Exception */
333 if (PyErr_WarnEx(PyExc_DeprecationWarning
,
334 "BaseException.message has been deprecated as "
335 "of Python 2.6", 1) < 0)
338 Py_INCREF(self
->message
);
339 return self
->message
;
343 BaseException_set_message(PyBaseExceptionObject
*self
, PyObject
*val
)
345 /* if val is NULL, delete the message attribute */
347 if (self
->dict
&& PyDict_GetItemString(self
->dict
, "message")) {
348 if (PyDict_DelItemString(self
->dict
, "message") < 0)
351 Py_XDECREF(self
->message
);
352 self
->message
= NULL
;
356 /* else set it in __dict__, but may need to create the dict first */
357 if (self
->dict
== NULL
) {
358 self
->dict
= PyDict_New();
362 return PyDict_SetItemString(self
->dict
, "message", val
);
365 static PyGetSetDef BaseException_getset
[] = {
366 {"__dict__", (getter
)BaseException_get_dict
, (setter
)BaseException_set_dict
},
367 {"args", (getter
)BaseException_get_args
, (setter
)BaseException_set_args
},
368 {"message", (getter
)BaseException_get_message
,
369 (setter
)BaseException_set_message
},
374 static PyTypeObject _PyExc_BaseException
= {
375 PyObject_HEAD_INIT(NULL
)
377 EXC_MODULE_NAME
"BaseException", /*tp_name*/
378 sizeof(PyBaseExceptionObject
), /*tp_basicsize*/
380 (destructor
)BaseException_dealloc
, /*tp_dealloc*/
385 (reprfunc
)BaseException_repr
, /*tp_repr*/
387 &BaseException_as_sequence
, /*tp_as_sequence*/
391 (reprfunc
)BaseException_str
, /*tp_str*/
392 PyObject_GenericGetAttr
, /*tp_getattro*/
393 PyObject_GenericSetAttr
, /*tp_setattro*/
395 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
| Py_TPFLAGS_HAVE_GC
|
396 Py_TPFLAGS_BASE_EXC_SUBCLASS
, /*tp_flags*/
397 PyDoc_STR("Common base class for all exceptions"), /* tp_doc */
398 (traverseproc
)BaseException_traverse
, /* tp_traverse */
399 (inquiry
)BaseException_clear
, /* tp_clear */
400 0, /* tp_richcompare */
401 0, /* tp_weaklistoffset */
404 BaseException_methods
, /* tp_methods */
406 BaseException_getset
, /* tp_getset */
409 0, /* tp_descr_get */
410 0, /* tp_descr_set */
411 offsetof(PyBaseExceptionObject
, dict
), /* tp_dictoffset */
412 (initproc
)BaseException_init
, /* tp_init */
414 BaseException_new
, /* tp_new */
416 /* the CPython API expects exceptions to be (PyObject *) - both a hold-over
417 from the previous implmentation and also allowing Python objects to be used
419 PyObject
*PyExc_BaseException
= (PyObject
*)&_PyExc_BaseException
;
421 /* note these macros omit the last semicolon so the macro invocation may
422 * include it and not look strange.
424 #define SimpleExtendsException(EXCBASE, EXCNAME, EXCDOC) \
425 static PyTypeObject _PyExc_ ## EXCNAME = { \
426 PyObject_HEAD_INIT(NULL) \
428 EXC_MODULE_NAME # EXCNAME, \
429 sizeof(PyBaseExceptionObject), \
430 0, (destructor)BaseException_dealloc, 0, 0, 0, 0, 0, 0, 0, \
431 0, 0, 0, 0, 0, 0, 0, \
432 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \
433 PyDoc_STR(EXCDOC), (traverseproc)BaseException_traverse, \
434 (inquiry)BaseException_clear, 0, 0, 0, 0, 0, 0, 0, &_ ## EXCBASE, \
435 0, 0, 0, offsetof(PyBaseExceptionObject, dict), \
436 (initproc)BaseException_init, 0, BaseException_new,\
438 PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME
440 #define MiddlingExtendsException(EXCBASE, EXCNAME, EXCSTORE, EXCDOC) \
441 static PyTypeObject _PyExc_ ## EXCNAME = { \
442 PyObject_HEAD_INIT(NULL) \
444 EXC_MODULE_NAME # EXCNAME, \
445 sizeof(Py ## EXCSTORE ## Object), \
446 0, (destructor)EXCSTORE ## _dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
448 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \
449 PyDoc_STR(EXCDOC), (traverseproc)EXCSTORE ## _traverse, \
450 (inquiry)EXCSTORE ## _clear, 0, 0, 0, 0, 0, 0, 0, &_ ## EXCBASE, \
451 0, 0, 0, offsetof(Py ## EXCSTORE ## Object, dict), \
452 (initproc)EXCSTORE ## _init, 0, BaseException_new,\
454 PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME
456 #define ComplexExtendsException(EXCBASE, EXCNAME, EXCSTORE, EXCDEALLOC, EXCMETHODS, EXCMEMBERS, EXCSTR, EXCDOC) \
457 static PyTypeObject _PyExc_ ## EXCNAME = { \
458 PyObject_HEAD_INIT(NULL) \
460 EXC_MODULE_NAME # EXCNAME, \
461 sizeof(Py ## EXCSTORE ## Object), 0, \
462 (destructor)EXCSTORE ## _dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
463 (reprfunc)EXCSTR, 0, 0, 0, \
464 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \
465 PyDoc_STR(EXCDOC), (traverseproc)EXCSTORE ## _traverse, \
466 (inquiry)EXCSTORE ## _clear, 0, 0, 0, 0, EXCMETHODS, \
467 EXCMEMBERS, 0, &_ ## EXCBASE, \
468 0, 0, 0, offsetof(Py ## EXCSTORE ## Object, dict), \
469 (initproc)EXCSTORE ## _init, 0, BaseException_new,\
471 PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME
475 * Exception extends BaseException
477 SimpleExtendsException(PyExc_BaseException
, Exception
,
478 "Common base class for all non-exit exceptions.");
482 * StandardError extends Exception
484 SimpleExtendsException(PyExc_Exception
, StandardError
,
485 "Base class for all standard Python exceptions that do not represent\n"
486 "interpreter exiting.");
490 * TypeError extends StandardError
492 SimpleExtendsException(PyExc_StandardError
, TypeError
,
493 "Inappropriate argument type.");
497 * StopIteration extends Exception
499 SimpleExtendsException(PyExc_Exception
, StopIteration
,
500 "Signal the end from iterator.next().");
504 * GeneratorExit extends BaseException
506 SimpleExtendsException(PyExc_BaseException
, GeneratorExit
,
507 "Request that a generator exit.");
511 * SystemExit extends BaseException
515 SystemExit_init(PySystemExitObject
*self
, PyObject
*args
, PyObject
*kwds
)
517 Py_ssize_t size
= PyTuple_GET_SIZE(args
);
519 if (BaseException_init((PyBaseExceptionObject
*)self
, args
, kwds
) == -1)
524 Py_CLEAR(self
->code
);
526 self
->code
= PyTuple_GET_ITEM(args
, 0);
529 Py_INCREF(self
->code
);
534 SystemExit_clear(PySystemExitObject
*self
)
536 Py_CLEAR(self
->code
);
537 return BaseException_clear((PyBaseExceptionObject
*)self
);
541 SystemExit_dealloc(PySystemExitObject
*self
)
543 _PyObject_GC_UNTRACK(self
);
544 SystemExit_clear(self
);
545 Py_TYPE(self
)->tp_free((PyObject
*)self
);
549 SystemExit_traverse(PySystemExitObject
*self
, visitproc visit
, void *arg
)
551 Py_VISIT(self
->code
);
552 return BaseException_traverse((PyBaseExceptionObject
*)self
, visit
, arg
);
555 static PyMemberDef SystemExit_members
[] = {
556 {"code", T_OBJECT
, offsetof(PySystemExitObject
, code
), 0,
557 PyDoc_STR("exception code")},
558 {NULL
} /* Sentinel */
561 ComplexExtendsException(PyExc_BaseException
, SystemExit
, SystemExit
,
562 SystemExit_dealloc
, 0, SystemExit_members
, 0,
563 "Request to exit from the interpreter.");
566 * KeyboardInterrupt extends BaseException
568 SimpleExtendsException(PyExc_BaseException
, KeyboardInterrupt
,
569 "Program interrupted by user.");
573 * ImportError extends StandardError
575 SimpleExtendsException(PyExc_StandardError
, ImportError
,
576 "Import can't find module, or can't find name in module.");
580 * EnvironmentError extends StandardError
583 /* Where a function has a single filename, such as open() or some
584 * of the os module functions, PyErr_SetFromErrnoWithFilename() is
585 * called, giving a third argument which is the filename. But, so
586 * that old code using in-place unpacking doesn't break, e.g.:
588 * except IOError, (errno, strerror):
590 * we hack args so that it only contains two items. This also
591 * means we need our own __str__() which prints out the filename
592 * when it was supplied.
595 EnvironmentError_init(PyEnvironmentErrorObject
*self
, PyObject
*args
,
598 PyObject
*myerrno
= NULL
, *strerror
= NULL
, *filename
= NULL
;
599 PyObject
*subslice
= NULL
;
601 if (BaseException_init((PyBaseExceptionObject
*)self
, args
, kwds
) == -1)
604 if (PyTuple_GET_SIZE(args
) <= 1 || PyTuple_GET_SIZE(args
) > 3) {
608 if (!PyArg_UnpackTuple(args
, "EnvironmentError", 2, 3,
609 &myerrno
, &strerror
, &filename
)) {
612 Py_CLEAR(self
->myerrno
); /* replacing */
613 self
->myerrno
= myerrno
;
614 Py_INCREF(self
->myerrno
);
616 Py_CLEAR(self
->strerror
); /* replacing */
617 self
->strerror
= strerror
;
618 Py_INCREF(self
->strerror
);
620 /* self->filename will remain Py_None otherwise */
621 if (filename
!= NULL
) {
622 Py_CLEAR(self
->filename
); /* replacing */
623 self
->filename
= filename
;
624 Py_INCREF(self
->filename
);
626 subslice
= PyTuple_GetSlice(args
, 0, 2);
630 Py_DECREF(self
->args
); /* replacing args */
631 self
->args
= subslice
;
637 EnvironmentError_clear(PyEnvironmentErrorObject
*self
)
639 Py_CLEAR(self
->myerrno
);
640 Py_CLEAR(self
->strerror
);
641 Py_CLEAR(self
->filename
);
642 return BaseException_clear((PyBaseExceptionObject
*)self
);
646 EnvironmentError_dealloc(PyEnvironmentErrorObject
*self
)
648 _PyObject_GC_UNTRACK(self
);
649 EnvironmentError_clear(self
);
650 Py_TYPE(self
)->tp_free((PyObject
*)self
);
654 EnvironmentError_traverse(PyEnvironmentErrorObject
*self
, visitproc visit
,
657 Py_VISIT(self
->myerrno
);
658 Py_VISIT(self
->strerror
);
659 Py_VISIT(self
->filename
);
660 return BaseException_traverse((PyBaseExceptionObject
*)self
, visit
, arg
);
664 EnvironmentError_str(PyEnvironmentErrorObject
*self
)
666 PyObject
*rtnval
= NULL
;
668 if (self
->filename
) {
673 fmt
= PyString_FromString("[Errno %s] %s: %s");
677 repr
= PyObject_Repr(self
->filename
);
682 tuple
= PyTuple_New(3);
690 Py_INCREF(self
->myerrno
);
691 PyTuple_SET_ITEM(tuple
, 0, self
->myerrno
);
695 PyTuple_SET_ITEM(tuple
, 0, Py_None
);
697 if (self
->strerror
) {
698 Py_INCREF(self
->strerror
);
699 PyTuple_SET_ITEM(tuple
, 1, self
->strerror
);
703 PyTuple_SET_ITEM(tuple
, 1, Py_None
);
706 PyTuple_SET_ITEM(tuple
, 2, repr
);
708 rtnval
= PyString_Format(fmt
, tuple
);
713 else if (self
->myerrno
&& self
->strerror
) {
717 fmt
= PyString_FromString("[Errno %s] %s");
721 tuple
= PyTuple_New(2);
728 Py_INCREF(self
->myerrno
);
729 PyTuple_SET_ITEM(tuple
, 0, self
->myerrno
);
733 PyTuple_SET_ITEM(tuple
, 0, Py_None
);
735 if (self
->strerror
) {
736 Py_INCREF(self
->strerror
);
737 PyTuple_SET_ITEM(tuple
, 1, self
->strerror
);
741 PyTuple_SET_ITEM(tuple
, 1, Py_None
);
744 rtnval
= PyString_Format(fmt
, tuple
);
750 rtnval
= BaseException_str((PyBaseExceptionObject
*)self
);
755 static PyMemberDef EnvironmentError_members
[] = {
756 {"errno", T_OBJECT
, offsetof(PyEnvironmentErrorObject
, myerrno
), 0,
757 PyDoc_STR("exception errno")},
758 {"strerror", T_OBJECT
, offsetof(PyEnvironmentErrorObject
, strerror
), 0,
759 PyDoc_STR("exception strerror")},
760 {"filename", T_OBJECT
, offsetof(PyEnvironmentErrorObject
, filename
), 0,
761 PyDoc_STR("exception filename")},
762 {NULL
} /* Sentinel */
767 EnvironmentError_reduce(PyEnvironmentErrorObject
*self
)
769 PyObject
*args
= self
->args
;
770 PyObject
*res
= NULL
, *tmp
;
772 /* self->args is only the first two real arguments if there was a
773 * file name given to EnvironmentError. */
774 if (PyTuple_GET_SIZE(args
) == 2 && self
->filename
) {
775 args
= PyTuple_New(3);
776 if (!args
) return NULL
;
778 tmp
= PyTuple_GET_ITEM(self
->args
, 0);
780 PyTuple_SET_ITEM(args
, 0, tmp
);
782 tmp
= PyTuple_GET_ITEM(self
->args
, 1);
784 PyTuple_SET_ITEM(args
, 1, tmp
);
786 Py_INCREF(self
->filename
);
787 PyTuple_SET_ITEM(args
, 2, self
->filename
);
792 res
= PyTuple_Pack(3, Py_TYPE(self
), args
, self
->dict
);
794 res
= PyTuple_Pack(2, Py_TYPE(self
), args
);
800 static PyMethodDef EnvironmentError_methods
[] = {
801 {"__reduce__", (PyCFunction
)EnvironmentError_reduce
, METH_NOARGS
},
805 ComplexExtendsException(PyExc_StandardError
, EnvironmentError
,
806 EnvironmentError
, EnvironmentError_dealloc
,
807 EnvironmentError_methods
, EnvironmentError_members
,
808 EnvironmentError_str
,
809 "Base class for I/O related errors.");
813 * IOError extends EnvironmentError
815 MiddlingExtendsException(PyExc_EnvironmentError
, IOError
,
816 EnvironmentError
, "I/O operation failed.");
820 * OSError extends EnvironmentError
822 MiddlingExtendsException(PyExc_EnvironmentError
, OSError
,
823 EnvironmentError
, "OS system call failed.");
827 * WindowsError extends OSError
833 WindowsError_clear(PyWindowsErrorObject
*self
)
835 Py_CLEAR(self
->myerrno
);
836 Py_CLEAR(self
->strerror
);
837 Py_CLEAR(self
->filename
);
838 Py_CLEAR(self
->winerror
);
839 return BaseException_clear((PyBaseExceptionObject
*)self
);
843 WindowsError_dealloc(PyWindowsErrorObject
*self
)
845 _PyObject_GC_UNTRACK(self
);
846 WindowsError_clear(self
);
847 Py_TYPE(self
)->tp_free((PyObject
*)self
);
851 WindowsError_traverse(PyWindowsErrorObject
*self
, visitproc visit
, void *arg
)
853 Py_VISIT(self
->myerrno
);
854 Py_VISIT(self
->strerror
);
855 Py_VISIT(self
->filename
);
856 Py_VISIT(self
->winerror
);
857 return BaseException_traverse((PyBaseExceptionObject
*)self
, visit
, arg
);
861 WindowsError_init(PyWindowsErrorObject
*self
, PyObject
*args
, PyObject
*kwds
)
863 PyObject
*o_errcode
= NULL
;
867 if (EnvironmentError_init((PyEnvironmentErrorObject
*)self
, args
, kwds
)
871 if (self
->myerrno
== NULL
)
874 /* Set errno to the POSIX errno, and winerror to the Win32
876 errcode
= PyInt_AsLong(self
->myerrno
);
877 if (errcode
== -1 && PyErr_Occurred())
879 posix_errno
= winerror_to_errno(errcode
);
881 Py_CLEAR(self
->winerror
);
882 self
->winerror
= self
->myerrno
;
884 o_errcode
= PyInt_FromLong(posix_errno
);
888 self
->myerrno
= o_errcode
;
895 WindowsError_str(PyWindowsErrorObject
*self
)
897 PyObject
*rtnval
= NULL
;
899 if (self
->filename
) {
904 fmt
= PyString_FromString("[Error %s] %s: %s");
908 repr
= PyObject_Repr(self
->filename
);
913 tuple
= PyTuple_New(3);
920 if (self
->winerror
) {
921 Py_INCREF(self
->winerror
);
922 PyTuple_SET_ITEM(tuple
, 0, self
->winerror
);
926 PyTuple_SET_ITEM(tuple
, 0, Py_None
);
928 if (self
->strerror
) {
929 Py_INCREF(self
->strerror
);
930 PyTuple_SET_ITEM(tuple
, 1, self
->strerror
);
934 PyTuple_SET_ITEM(tuple
, 1, Py_None
);
937 PyTuple_SET_ITEM(tuple
, 2, repr
);
939 rtnval
= PyString_Format(fmt
, tuple
);
944 else if (self
->winerror
&& self
->strerror
) {
948 fmt
= PyString_FromString("[Error %s] %s");
952 tuple
= PyTuple_New(2);
958 if (self
->winerror
) {
959 Py_INCREF(self
->winerror
);
960 PyTuple_SET_ITEM(tuple
, 0, self
->winerror
);
964 PyTuple_SET_ITEM(tuple
, 0, Py_None
);
966 if (self
->strerror
) {
967 Py_INCREF(self
->strerror
);
968 PyTuple_SET_ITEM(tuple
, 1, self
->strerror
);
972 PyTuple_SET_ITEM(tuple
, 1, Py_None
);
975 rtnval
= PyString_Format(fmt
, tuple
);
981 rtnval
= EnvironmentError_str((PyEnvironmentErrorObject
*)self
);
986 static PyMemberDef WindowsError_members
[] = {
987 {"errno", T_OBJECT
, offsetof(PyWindowsErrorObject
, myerrno
), 0,
988 PyDoc_STR("POSIX exception code")},
989 {"strerror", T_OBJECT
, offsetof(PyWindowsErrorObject
, strerror
), 0,
990 PyDoc_STR("exception strerror")},
991 {"filename", T_OBJECT
, offsetof(PyWindowsErrorObject
, filename
), 0,
992 PyDoc_STR("exception filename")},
993 {"winerror", T_OBJECT
, offsetof(PyWindowsErrorObject
, winerror
), 0,
994 PyDoc_STR("Win32 exception code")},
995 {NULL
} /* Sentinel */
998 ComplexExtendsException(PyExc_OSError
, WindowsError
, WindowsError
,
999 WindowsError_dealloc
, 0, WindowsError_members
,
1000 WindowsError_str
, "MS-Windows OS system call failed.");
1002 #endif /* MS_WINDOWS */
1006 * VMSError extends OSError (I think)
1009 MiddlingExtendsException(PyExc_OSError
, VMSError
, EnvironmentError
,
1010 "OpenVMS OS system call failed.");
1015 * EOFError extends StandardError
1017 SimpleExtendsException(PyExc_StandardError
, EOFError
,
1018 "Read beyond end of file.");
1022 * RuntimeError extends StandardError
1024 SimpleExtendsException(PyExc_StandardError
, RuntimeError
,
1025 "Unspecified run-time error.");
1029 * NotImplementedError extends RuntimeError
1031 SimpleExtendsException(PyExc_RuntimeError
, NotImplementedError
,
1032 "Method or function hasn't been implemented yet.");
1035 * NameError extends StandardError
1037 SimpleExtendsException(PyExc_StandardError
, NameError
,
1038 "Name not found globally.");
1041 * UnboundLocalError extends NameError
1043 SimpleExtendsException(PyExc_NameError
, UnboundLocalError
,
1044 "Local name referenced but not bound to a value.");
1047 * AttributeError extends StandardError
1049 SimpleExtendsException(PyExc_StandardError
, AttributeError
,
1050 "Attribute not found.");
1054 * SyntaxError extends StandardError
1058 SyntaxError_init(PySyntaxErrorObject
*self
, PyObject
*args
, PyObject
*kwds
)
1060 PyObject
*info
= NULL
;
1061 Py_ssize_t lenargs
= PyTuple_GET_SIZE(args
);
1063 if (BaseException_init((PyBaseExceptionObject
*)self
, args
, kwds
) == -1)
1067 Py_CLEAR(self
->msg
);
1068 self
->msg
= PyTuple_GET_ITEM(args
, 0);
1069 Py_INCREF(self
->msg
);
1072 info
= PyTuple_GET_ITEM(args
, 1);
1073 info
= PySequence_Tuple(info
);
1074 if (!info
) return -1;
1076 if (PyTuple_GET_SIZE(info
) != 4) {
1077 /* not a very good error message, but it's what Python 2.4 gives */
1078 PyErr_SetString(PyExc_IndexError
, "tuple index out of range");
1083 Py_CLEAR(self
->filename
);
1084 self
->filename
= PyTuple_GET_ITEM(info
, 0);
1085 Py_INCREF(self
->filename
);
1087 Py_CLEAR(self
->lineno
);
1088 self
->lineno
= PyTuple_GET_ITEM(info
, 1);
1089 Py_INCREF(self
->lineno
);
1091 Py_CLEAR(self
->offset
);
1092 self
->offset
= PyTuple_GET_ITEM(info
, 2);
1093 Py_INCREF(self
->offset
);
1095 Py_CLEAR(self
->text
);
1096 self
->text
= PyTuple_GET_ITEM(info
, 3);
1097 Py_INCREF(self
->text
);
1105 SyntaxError_clear(PySyntaxErrorObject
*self
)
1107 Py_CLEAR(self
->msg
);
1108 Py_CLEAR(self
->filename
);
1109 Py_CLEAR(self
->lineno
);
1110 Py_CLEAR(self
->offset
);
1111 Py_CLEAR(self
->text
);
1112 Py_CLEAR(self
->print_file_and_line
);
1113 return BaseException_clear((PyBaseExceptionObject
*)self
);
1117 SyntaxError_dealloc(PySyntaxErrorObject
*self
)
1119 _PyObject_GC_UNTRACK(self
);
1120 SyntaxError_clear(self
);
1121 Py_TYPE(self
)->tp_free((PyObject
*)self
);
1125 SyntaxError_traverse(PySyntaxErrorObject
*self
, visitproc visit
, void *arg
)
1127 Py_VISIT(self
->msg
);
1128 Py_VISIT(self
->filename
);
1129 Py_VISIT(self
->lineno
);
1130 Py_VISIT(self
->offset
);
1131 Py_VISIT(self
->text
);
1132 Py_VISIT(self
->print_file_and_line
);
1133 return BaseException_traverse((PyBaseExceptionObject
*)self
, visit
, arg
);
1136 /* This is called "my_basename" instead of just "basename" to avoid name
1137 conflicts with glibc; basename is already prototyped if _GNU_SOURCE is
1138 defined, and Python does define that. */
1140 my_basename(char *name
)
1143 char *result
= name
;
1147 while (*cp
!= '\0') {
1157 SyntaxError_str(PySyntaxErrorObject
*self
)
1161 int have_filename
= 0;
1162 int have_lineno
= 0;
1163 char *buffer
= NULL
;
1167 str
= PyObject_Str(self
->msg
);
1169 str
= PyObject_Str(Py_None
);
1170 if (!str
) return NULL
;
1171 /* Don't fiddle with non-string return (shouldn't happen anyway) */
1172 if (!PyString_Check(str
)) return str
;
1174 /* XXX -- do all the additional formatting with filename and
1177 have_filename
= (self
->filename
!= NULL
) &&
1178 PyString_Check(self
->filename
);
1179 have_lineno
= (self
->lineno
!= NULL
) && PyInt_Check(self
->lineno
);
1181 if (!have_filename
&& !have_lineno
)
1184 bufsize
= PyString_GET_SIZE(str
) + 64;
1186 bufsize
+= PyString_GET_SIZE(self
->filename
);
1188 buffer
= PyMem_MALLOC(bufsize
);
1192 if (have_filename
&& have_lineno
)
1193 PyOS_snprintf(buffer
, bufsize
, "%s (%s, line %ld)",
1194 PyString_AS_STRING(str
),
1195 my_basename(PyString_AS_STRING(self
->filename
)),
1196 PyInt_AsLong(self
->lineno
));
1197 else if (have_filename
)
1198 PyOS_snprintf(buffer
, bufsize
, "%s (%s)",
1199 PyString_AS_STRING(str
),
1200 my_basename(PyString_AS_STRING(self
->filename
)));
1201 else /* only have_lineno */
1202 PyOS_snprintf(buffer
, bufsize
, "%s (line %ld)",
1203 PyString_AS_STRING(str
),
1204 PyInt_AsLong(self
->lineno
));
1206 result
= PyString_FromString(buffer
);
1216 static PyMemberDef SyntaxError_members
[] = {
1217 {"msg", T_OBJECT
, offsetof(PySyntaxErrorObject
, msg
), 0,
1218 PyDoc_STR("exception msg")},
1219 {"filename", T_OBJECT
, offsetof(PySyntaxErrorObject
, filename
), 0,
1220 PyDoc_STR("exception filename")},
1221 {"lineno", T_OBJECT
, offsetof(PySyntaxErrorObject
, lineno
), 0,
1222 PyDoc_STR("exception lineno")},
1223 {"offset", T_OBJECT
, offsetof(PySyntaxErrorObject
, offset
), 0,
1224 PyDoc_STR("exception offset")},
1225 {"text", T_OBJECT
, offsetof(PySyntaxErrorObject
, text
), 0,
1226 PyDoc_STR("exception text")},
1227 {"print_file_and_line", T_OBJECT
,
1228 offsetof(PySyntaxErrorObject
, print_file_and_line
), 0,
1229 PyDoc_STR("exception print_file_and_line")},
1230 {NULL
} /* Sentinel */
1233 ComplexExtendsException(PyExc_StandardError
, SyntaxError
, SyntaxError
,
1234 SyntaxError_dealloc
, 0, SyntaxError_members
,
1235 SyntaxError_str
, "Invalid syntax.");
1239 * IndentationError extends SyntaxError
1241 MiddlingExtendsException(PyExc_SyntaxError
, IndentationError
, SyntaxError
,
1242 "Improper indentation.");
1246 * TabError extends IndentationError
1248 MiddlingExtendsException(PyExc_IndentationError
, TabError
, SyntaxError
,
1249 "Improper mixture of spaces and tabs.");
1253 * LookupError extends StandardError
1255 SimpleExtendsException(PyExc_StandardError
, LookupError
,
1256 "Base class for lookup errors.");
1260 * IndexError extends LookupError
1262 SimpleExtendsException(PyExc_LookupError
, IndexError
,
1263 "Sequence index out of range.");
1267 * KeyError extends LookupError
1270 KeyError_str(PyBaseExceptionObject
*self
)
1272 /* If args is a tuple of exactly one item, apply repr to args[0].
1273 This is done so that e.g. the exception raised by {}[''] prints
1275 rather than the confusing
1277 alone. The downside is that if KeyError is raised with an explanatory
1278 string, that string will be displayed in quotes. Too bad.
1279 If args is anything else, use the default BaseException__str__().
1281 if (PyTuple_GET_SIZE(self
->args
) == 1) {
1282 return PyObject_Repr(PyTuple_GET_ITEM(self
->args
, 0));
1284 return BaseException_str(self
);
1287 ComplexExtendsException(PyExc_LookupError
, KeyError
, BaseException
,
1288 0, 0, 0, KeyError_str
, "Mapping key not found.");
1292 * ValueError extends StandardError
1294 SimpleExtendsException(PyExc_StandardError
, ValueError
,
1295 "Inappropriate argument value (of correct type).");
1298 * UnicodeError extends ValueError
1301 SimpleExtendsException(PyExc_ValueError
, UnicodeError
,
1302 "Unicode related error.");
1304 #ifdef Py_USING_UNICODE
1306 get_string(PyObject
*attr
, const char *name
)
1309 PyErr_Format(PyExc_TypeError
, "%.200s attribute not set", name
);
1313 if (!PyString_Check(attr
)) {
1314 PyErr_Format(PyExc_TypeError
, "%.200s attribute must be str", name
);
1323 set_string(PyObject
**attr
, const char *value
)
1325 PyObject
*obj
= PyString_FromString(value
);
1335 get_unicode(PyObject
*attr
, const char *name
)
1338 PyErr_Format(PyExc_TypeError
, "%.200s attribute not set", name
);
1342 if (!PyUnicode_Check(attr
)) {
1343 PyErr_Format(PyExc_TypeError
,
1344 "%.200s attribute must be unicode", name
);
1352 PyUnicodeEncodeError_GetEncoding(PyObject
*exc
)
1354 return get_string(((PyUnicodeErrorObject
*)exc
)->encoding
, "encoding");
1358 PyUnicodeDecodeError_GetEncoding(PyObject
*exc
)
1360 return get_string(((PyUnicodeErrorObject
*)exc
)->encoding
, "encoding");
1364 PyUnicodeEncodeError_GetObject(PyObject
*exc
)
1366 return get_unicode(((PyUnicodeErrorObject
*)exc
)->object
, "object");
1370 PyUnicodeDecodeError_GetObject(PyObject
*exc
)
1372 return get_string(((PyUnicodeErrorObject
*)exc
)->object
, "object");
1376 PyUnicodeTranslateError_GetObject(PyObject
*exc
)
1378 return get_unicode(((PyUnicodeErrorObject
*)exc
)->object
, "object");
1382 PyUnicodeEncodeError_GetStart(PyObject
*exc
, Py_ssize_t
*start
)
1385 PyObject
*obj
= get_unicode(((PyUnicodeErrorObject
*)exc
)->object
,
1389 *start
= ((PyUnicodeErrorObject
*)exc
)->start
;
1390 size
= PyUnicode_GET_SIZE(obj
);
1392 *start
= 0; /*XXX check for values <0*/
1401 PyUnicodeDecodeError_GetStart(PyObject
*exc
, Py_ssize_t
*start
)
1404 PyObject
*obj
= get_string(((PyUnicodeErrorObject
*)exc
)->object
,
1408 size
= PyString_GET_SIZE(obj
);
1409 *start
= ((PyUnicodeErrorObject
*)exc
)->start
;
1420 PyUnicodeTranslateError_GetStart(PyObject
*exc
, Py_ssize_t
*start
)
1422 return PyUnicodeEncodeError_GetStart(exc
, start
);
1427 PyUnicodeEncodeError_SetStart(PyObject
*exc
, Py_ssize_t start
)
1429 ((PyUnicodeErrorObject
*)exc
)->start
= start
;
1435 PyUnicodeDecodeError_SetStart(PyObject
*exc
, Py_ssize_t start
)
1437 ((PyUnicodeErrorObject
*)exc
)->start
= start
;
1443 PyUnicodeTranslateError_SetStart(PyObject
*exc
, Py_ssize_t start
)
1445 ((PyUnicodeErrorObject
*)exc
)->start
= start
;
1451 PyUnicodeEncodeError_GetEnd(PyObject
*exc
, Py_ssize_t
*end
)
1454 PyObject
*obj
= get_unicode(((PyUnicodeErrorObject
*)exc
)->object
,
1458 *end
= ((PyUnicodeErrorObject
*)exc
)->end
;
1459 size
= PyUnicode_GET_SIZE(obj
);
1470 PyUnicodeDecodeError_GetEnd(PyObject
*exc
, Py_ssize_t
*end
)
1473 PyObject
*obj
= get_string(((PyUnicodeErrorObject
*)exc
)->object
,
1477 *end
= ((PyUnicodeErrorObject
*)exc
)->end
;
1478 size
= PyString_GET_SIZE(obj
);
1489 PyUnicodeTranslateError_GetEnd(PyObject
*exc
, Py_ssize_t
*start
)
1491 return PyUnicodeEncodeError_GetEnd(exc
, start
);
1496 PyUnicodeEncodeError_SetEnd(PyObject
*exc
, Py_ssize_t end
)
1498 ((PyUnicodeErrorObject
*)exc
)->end
= end
;
1504 PyUnicodeDecodeError_SetEnd(PyObject
*exc
, Py_ssize_t end
)
1506 ((PyUnicodeErrorObject
*)exc
)->end
= end
;
1512 PyUnicodeTranslateError_SetEnd(PyObject
*exc
, Py_ssize_t end
)
1514 ((PyUnicodeErrorObject
*)exc
)->end
= end
;
1519 PyUnicodeEncodeError_GetReason(PyObject
*exc
)
1521 return get_string(((PyUnicodeErrorObject
*)exc
)->reason
, "reason");
1526 PyUnicodeDecodeError_GetReason(PyObject
*exc
)
1528 return get_string(((PyUnicodeErrorObject
*)exc
)->reason
, "reason");
1533 PyUnicodeTranslateError_GetReason(PyObject
*exc
)
1535 return get_string(((PyUnicodeErrorObject
*)exc
)->reason
, "reason");
1540 PyUnicodeEncodeError_SetReason(PyObject
*exc
, const char *reason
)
1542 return set_string(&((PyUnicodeErrorObject
*)exc
)->reason
, reason
);
1547 PyUnicodeDecodeError_SetReason(PyObject
*exc
, const char *reason
)
1549 return set_string(&((PyUnicodeErrorObject
*)exc
)->reason
, reason
);
1554 PyUnicodeTranslateError_SetReason(PyObject
*exc
, const char *reason
)
1556 return set_string(&((PyUnicodeErrorObject
*)exc
)->reason
, reason
);
1561 UnicodeError_init(PyUnicodeErrorObject
*self
, PyObject
*args
, PyObject
*kwds
,
1562 PyTypeObject
*objecttype
)
1564 Py_CLEAR(self
->encoding
);
1565 Py_CLEAR(self
->object
);
1566 Py_CLEAR(self
->reason
);
1568 if (!PyArg_ParseTuple(args
, "O!O!nnO!",
1569 &PyString_Type
, &self
->encoding
,
1570 objecttype
, &self
->object
,
1573 &PyString_Type
, &self
->reason
)) {
1574 self
->encoding
= self
->object
= self
->reason
= NULL
;
1578 Py_INCREF(self
->encoding
);
1579 Py_INCREF(self
->object
);
1580 Py_INCREF(self
->reason
);
1586 UnicodeError_clear(PyUnicodeErrorObject
*self
)
1588 Py_CLEAR(self
->encoding
);
1589 Py_CLEAR(self
->object
);
1590 Py_CLEAR(self
->reason
);
1591 return BaseException_clear((PyBaseExceptionObject
*)self
);
1595 UnicodeError_dealloc(PyUnicodeErrorObject
*self
)
1597 _PyObject_GC_UNTRACK(self
);
1598 UnicodeError_clear(self
);
1599 Py_TYPE(self
)->tp_free((PyObject
*)self
);
1603 UnicodeError_traverse(PyUnicodeErrorObject
*self
, visitproc visit
, void *arg
)
1605 Py_VISIT(self
->encoding
);
1606 Py_VISIT(self
->object
);
1607 Py_VISIT(self
->reason
);
1608 return BaseException_traverse((PyBaseExceptionObject
*)self
, visit
, arg
);
1611 static PyMemberDef UnicodeError_members
[] = {
1612 {"encoding", T_OBJECT
, offsetof(PyUnicodeErrorObject
, encoding
), 0,
1613 PyDoc_STR("exception encoding")},
1614 {"object", T_OBJECT
, offsetof(PyUnicodeErrorObject
, object
), 0,
1615 PyDoc_STR("exception object")},
1616 {"start", T_PYSSIZET
, offsetof(PyUnicodeErrorObject
, start
), 0,
1617 PyDoc_STR("exception start")},
1618 {"end", T_PYSSIZET
, offsetof(PyUnicodeErrorObject
, end
), 0,
1619 PyDoc_STR("exception end")},
1620 {"reason", T_OBJECT
, offsetof(PyUnicodeErrorObject
, reason
), 0,
1621 PyDoc_STR("exception reason")},
1622 {NULL
} /* Sentinel */
1627 * UnicodeEncodeError extends UnicodeError
1631 UnicodeEncodeError_init(PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
1633 if (BaseException_init((PyBaseExceptionObject
*)self
, args
, kwds
) == -1)
1635 return UnicodeError_init((PyUnicodeErrorObject
*)self
, args
,
1636 kwds
, &PyUnicode_Type
);
1640 UnicodeEncodeError_str(PyObject
*self
)
1642 PyUnicodeErrorObject
*uself
= (PyUnicodeErrorObject
*)self
;
1643 PyObject
*result
= NULL
;
1644 PyObject
*reason_str
= NULL
;
1645 PyObject
*encoding_str
= NULL
;
1647 /* Get reason and encoding as strings, which they might not be if
1648 they've been modified after we were contructed. */
1649 reason_str
= PyObject_Str(uself
->reason
);
1650 if (reason_str
== NULL
)
1652 encoding_str
= PyObject_Str(uself
->encoding
);
1653 if (encoding_str
== NULL
)
1656 if (uself
->start
< PyUnicode_GET_SIZE(uself
->object
) && uself
->end
== uself
->start
+1) {
1657 int badchar
= (int)PyUnicode_AS_UNICODE(uself
->object
)[uself
->start
];
1658 char badchar_str
[20];
1659 if (badchar
<= 0xff)
1660 PyOS_snprintf(badchar_str
, sizeof(badchar_str
), "x%02x", badchar
);
1661 else if (badchar
<= 0xffff)
1662 PyOS_snprintf(badchar_str
, sizeof(badchar_str
), "u%04x", badchar
);
1664 PyOS_snprintf(badchar_str
, sizeof(badchar_str
), "U%08x", badchar
);
1665 result
= PyString_FromFormat(
1666 "'%.400s' codec can't encode character u'\\%s' in position %zd: %.400s",
1667 PyString_AS_STRING(encoding_str
),
1670 PyString_AS_STRING(reason_str
));
1673 result
= PyString_FromFormat(
1674 "'%.400s' codec can't encode characters in position %zd-%zd: %.400s",
1675 PyString_AS_STRING(encoding_str
),
1678 PyString_AS_STRING(reason_str
));
1681 Py_XDECREF(reason_str
);
1682 Py_XDECREF(encoding_str
);
1686 static PyTypeObject _PyExc_UnicodeEncodeError
= {
1687 PyObject_HEAD_INIT(NULL
)
1689 EXC_MODULE_NAME
"UnicodeEncodeError",
1690 sizeof(PyUnicodeErrorObject
), 0,
1691 (destructor
)UnicodeError_dealloc
, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1692 (reprfunc
)UnicodeEncodeError_str
, 0, 0, 0,
1693 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
| Py_TPFLAGS_HAVE_GC
,
1694 PyDoc_STR("Unicode encoding error."), (traverseproc
)UnicodeError_traverse
,
1695 (inquiry
)UnicodeError_clear
, 0, 0, 0, 0, 0, UnicodeError_members
,
1696 0, &_PyExc_UnicodeError
, 0, 0, 0, offsetof(PyUnicodeErrorObject
, dict
),
1697 (initproc
)UnicodeEncodeError_init
, 0, BaseException_new
,
1699 PyObject
*PyExc_UnicodeEncodeError
= (PyObject
*)&_PyExc_UnicodeEncodeError
;
1702 PyUnicodeEncodeError_Create(
1703 const char *encoding
, const Py_UNICODE
*object
, Py_ssize_t length
,
1704 Py_ssize_t start
, Py_ssize_t end
, const char *reason
)
1706 return PyObject_CallFunction(PyExc_UnicodeEncodeError
, "su#nns",
1707 encoding
, object
, length
, start
, end
, reason
);
1712 * UnicodeDecodeError extends UnicodeError
1716 UnicodeDecodeError_init(PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
1718 if (BaseException_init((PyBaseExceptionObject
*)self
, args
, kwds
) == -1)
1720 return UnicodeError_init((PyUnicodeErrorObject
*)self
, args
,
1721 kwds
, &PyString_Type
);
1725 UnicodeDecodeError_str(PyObject
*self
)
1727 PyUnicodeErrorObject
*uself
= (PyUnicodeErrorObject
*)self
;
1728 PyObject
*result
= NULL
;
1729 PyObject
*reason_str
= NULL
;
1730 PyObject
*encoding_str
= NULL
;
1732 /* Get reason and encoding as strings, which they might not be if
1733 they've been modified after we were contructed. */
1734 reason_str
= PyObject_Str(uself
->reason
);
1735 if (reason_str
== NULL
)
1737 encoding_str
= PyObject_Str(uself
->encoding
);
1738 if (encoding_str
== NULL
)
1741 if (uself
->start
< PyUnicode_GET_SIZE(uself
->object
) && uself
->end
== uself
->start
+1) {
1742 /* FromFormat does not support %02x, so format that separately */
1744 PyOS_snprintf(byte
, sizeof(byte
), "%02x",
1745 ((int)PyString_AS_STRING(uself
->object
)[uself
->start
])&0xff);
1746 result
= PyString_FromFormat(
1747 "'%.400s' codec can't decode byte 0x%s in position %zd: %.400s",
1748 PyString_AS_STRING(encoding_str
),
1751 PyString_AS_STRING(reason_str
));
1754 result
= PyString_FromFormat(
1755 "'%.400s' codec can't decode bytes in position %zd-%zd: %.400s",
1756 PyString_AS_STRING(encoding_str
),
1759 PyString_AS_STRING(reason_str
));
1762 Py_XDECREF(reason_str
);
1763 Py_XDECREF(encoding_str
);
1767 static PyTypeObject _PyExc_UnicodeDecodeError
= {
1768 PyObject_HEAD_INIT(NULL
)
1770 EXC_MODULE_NAME
"UnicodeDecodeError",
1771 sizeof(PyUnicodeErrorObject
), 0,
1772 (destructor
)UnicodeError_dealloc
, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1773 (reprfunc
)UnicodeDecodeError_str
, 0, 0, 0,
1774 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
| Py_TPFLAGS_HAVE_GC
,
1775 PyDoc_STR("Unicode decoding error."), (traverseproc
)UnicodeError_traverse
,
1776 (inquiry
)UnicodeError_clear
, 0, 0, 0, 0, 0, UnicodeError_members
,
1777 0, &_PyExc_UnicodeError
, 0, 0, 0, offsetof(PyUnicodeErrorObject
, dict
),
1778 (initproc
)UnicodeDecodeError_init
, 0, BaseException_new
,
1780 PyObject
*PyExc_UnicodeDecodeError
= (PyObject
*)&_PyExc_UnicodeDecodeError
;
1783 PyUnicodeDecodeError_Create(
1784 const char *encoding
, const char *object
, Py_ssize_t length
,
1785 Py_ssize_t start
, Py_ssize_t end
, const char *reason
)
1787 return PyObject_CallFunction(PyExc_UnicodeDecodeError
, "ss#nns",
1788 encoding
, object
, length
, start
, end
, reason
);
1793 * UnicodeTranslateError extends UnicodeError
1797 UnicodeTranslateError_init(PyUnicodeErrorObject
*self
, PyObject
*args
,
1800 if (BaseException_init((PyBaseExceptionObject
*)self
, args
, kwds
) == -1)
1803 Py_CLEAR(self
->object
);
1804 Py_CLEAR(self
->reason
);
1806 if (!PyArg_ParseTuple(args
, "O!nnO!",
1807 &PyUnicode_Type
, &self
->object
,
1810 &PyString_Type
, &self
->reason
)) {
1811 self
->object
= self
->reason
= NULL
;
1815 Py_INCREF(self
->object
);
1816 Py_INCREF(self
->reason
);
1823 UnicodeTranslateError_str(PyObject
*self
)
1825 PyUnicodeErrorObject
*uself
= (PyUnicodeErrorObject
*)self
;
1826 PyObject
*result
= NULL
;
1827 PyObject
*reason_str
= NULL
;
1829 /* Get reason as a string, which it might not be if it's been
1830 modified after we were contructed. */
1831 reason_str
= PyObject_Str(uself
->reason
);
1832 if (reason_str
== NULL
)
1835 if (uself
->start
< PyUnicode_GET_SIZE(uself
->object
) && uself
->end
== uself
->start
+1) {
1836 int badchar
= (int)PyUnicode_AS_UNICODE(uself
->object
)[uself
->start
];
1837 char badchar_str
[20];
1838 if (badchar
<= 0xff)
1839 PyOS_snprintf(badchar_str
, sizeof(badchar_str
), "x%02x", badchar
);
1840 else if (badchar
<= 0xffff)
1841 PyOS_snprintf(badchar_str
, sizeof(badchar_str
), "u%04x", badchar
);
1843 PyOS_snprintf(badchar_str
, sizeof(badchar_str
), "U%08x", badchar
);
1844 result
= PyString_FromFormat(
1845 "can't translate character u'\\%s' in position %zd: %.400s",
1848 PyString_AS_STRING(reason_str
));
1850 result
= PyString_FromFormat(
1851 "can't translate characters in position %zd-%zd: %.400s",
1854 PyString_AS_STRING(reason_str
));
1857 Py_XDECREF(reason_str
);
1861 static PyTypeObject _PyExc_UnicodeTranslateError
= {
1862 PyObject_HEAD_INIT(NULL
)
1864 EXC_MODULE_NAME
"UnicodeTranslateError",
1865 sizeof(PyUnicodeErrorObject
), 0,
1866 (destructor
)UnicodeError_dealloc
, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1867 (reprfunc
)UnicodeTranslateError_str
, 0, 0, 0,
1868 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
| Py_TPFLAGS_HAVE_GC
,
1869 PyDoc_STR("Unicode translation error."), (traverseproc
)UnicodeError_traverse
,
1870 (inquiry
)UnicodeError_clear
, 0, 0, 0, 0, 0, UnicodeError_members
,
1871 0, &_PyExc_UnicodeError
, 0, 0, 0, offsetof(PyUnicodeErrorObject
, dict
),
1872 (initproc
)UnicodeTranslateError_init
, 0, BaseException_new
,
1874 PyObject
*PyExc_UnicodeTranslateError
= (PyObject
*)&_PyExc_UnicodeTranslateError
;
1877 PyUnicodeTranslateError_Create(
1878 const Py_UNICODE
*object
, Py_ssize_t length
,
1879 Py_ssize_t start
, Py_ssize_t end
, const char *reason
)
1881 return PyObject_CallFunction(PyExc_UnicodeTranslateError
, "u#nns",
1882 object
, length
, start
, end
, reason
);
1888 * AssertionError extends StandardError
1890 SimpleExtendsException(PyExc_StandardError
, AssertionError
,
1891 "Assertion failed.");
1895 * ArithmeticError extends StandardError
1897 SimpleExtendsException(PyExc_StandardError
, ArithmeticError
,
1898 "Base class for arithmetic errors.");
1902 * FloatingPointError extends ArithmeticError
1904 SimpleExtendsException(PyExc_ArithmeticError
, FloatingPointError
,
1905 "Floating point operation failed.");
1909 * OverflowError extends ArithmeticError
1911 SimpleExtendsException(PyExc_ArithmeticError
, OverflowError
,
1912 "Result too large to be represented.");
1916 * ZeroDivisionError extends ArithmeticError
1918 SimpleExtendsException(PyExc_ArithmeticError
, ZeroDivisionError
,
1919 "Second argument to a division or modulo operation was zero.");
1923 * SystemError extends StandardError
1925 SimpleExtendsException(PyExc_StandardError
, SystemError
,
1926 "Internal error in the Python interpreter.\n"
1928 "Please report this to the Python maintainer, along with the traceback,\n"
1929 "the Python version, and the hardware/OS platform and version.");
1933 * ReferenceError extends StandardError
1935 SimpleExtendsException(PyExc_StandardError
, ReferenceError
,
1936 "Weak ref proxy used after referent went away.");
1940 * MemoryError extends StandardError
1942 SimpleExtendsException(PyExc_StandardError
, MemoryError
, "Out of memory.");
1945 * BufferError extends StandardError
1947 SimpleExtendsException(PyExc_StandardError
, BufferError
, "Buffer error.");
1950 /* Warning category docstrings */
1953 * Warning extends Exception
1955 SimpleExtendsException(PyExc_Exception
, Warning
,
1956 "Base class for warning categories.");
1960 * UserWarning extends Warning
1962 SimpleExtendsException(PyExc_Warning
, UserWarning
,
1963 "Base class for warnings generated by user code.");
1967 * DeprecationWarning extends Warning
1969 SimpleExtendsException(PyExc_Warning
, DeprecationWarning
,
1970 "Base class for warnings about deprecated features.");
1974 * PendingDeprecationWarning extends Warning
1976 SimpleExtendsException(PyExc_Warning
, PendingDeprecationWarning
,
1977 "Base class for warnings about features which will be deprecated\n"
1982 * SyntaxWarning extends Warning
1984 SimpleExtendsException(PyExc_Warning
, SyntaxWarning
,
1985 "Base class for warnings about dubious syntax.");
1989 * RuntimeWarning extends Warning
1991 SimpleExtendsException(PyExc_Warning
, RuntimeWarning
,
1992 "Base class for warnings about dubious runtime behavior.");
1996 * FutureWarning extends Warning
1998 SimpleExtendsException(PyExc_Warning
, FutureWarning
,
1999 "Base class for warnings about constructs that will change semantically\n"
2004 * ImportWarning extends Warning
2006 SimpleExtendsException(PyExc_Warning
, ImportWarning
,
2007 "Base class for warnings about probable mistakes in module imports");
2011 * UnicodeWarning extends Warning
2013 SimpleExtendsException(PyExc_Warning
, UnicodeWarning
,
2014 "Base class for warnings about Unicode related problems, mostly\n"
2015 "related to conversion problems.");
2018 * BytesWarning extends Warning
2020 SimpleExtendsException(PyExc_Warning
, BytesWarning
,
2021 "Base class for warnings about bytes and buffer related problems, mostly\n"
2022 "related to conversion from str or comparing to str.");
2024 /* Pre-computed MemoryError instance. Best to create this as early as
2025 * possible and not wait until a MemoryError is actually raised!
2027 PyObject
*PyExc_MemoryErrorInst
=NULL
;
2029 /* Pre-computed RuntimeError instance for when recursion depth is reached.
2030 Meant to be used when normalizing the exception for exceeding the recursion
2031 depth will cause its own infinite recursion.
2033 PyObject
*PyExc_RecursionErrorInst
= NULL
;
2035 /* module global functions */
2036 static PyMethodDef functions
[] = {
2041 #define PRE_INIT(TYPE) if (PyType_Ready(&_PyExc_ ## TYPE) < 0) \
2042 Py_FatalError("exceptions bootstrapping error.");
2044 #define POST_INIT(TYPE) Py_INCREF(PyExc_ ## TYPE); \
2045 PyModule_AddObject(m, # TYPE, PyExc_ ## TYPE); \
2046 if (PyDict_SetItemString(bdict, # TYPE, PyExc_ ## TYPE)) \
2047 Py_FatalError("Module dictionary insertion problem.");
2053 PyObject
*m
, *bltinmod
, *bdict
;
2055 PRE_INIT(BaseException
)
2057 PRE_INIT(StandardError
)
2059 PRE_INIT(StopIteration
)
2060 PRE_INIT(GeneratorExit
)
2061 PRE_INIT(SystemExit
)
2062 PRE_INIT(KeyboardInterrupt
)
2063 PRE_INIT(ImportError
)
2064 PRE_INIT(EnvironmentError
)
2068 PRE_INIT(WindowsError
)
2074 PRE_INIT(RuntimeError
)
2075 PRE_INIT(NotImplementedError
)
2077 PRE_INIT(UnboundLocalError
)
2078 PRE_INIT(AttributeError
)
2079 PRE_INIT(SyntaxError
)
2080 PRE_INIT(IndentationError
)
2082 PRE_INIT(LookupError
)
2083 PRE_INIT(IndexError
)
2085 PRE_INIT(ValueError
)
2086 PRE_INIT(UnicodeError
)
2087 #ifdef Py_USING_UNICODE
2088 PRE_INIT(UnicodeEncodeError
)
2089 PRE_INIT(UnicodeDecodeError
)
2090 PRE_INIT(UnicodeTranslateError
)
2092 PRE_INIT(AssertionError
)
2093 PRE_INIT(ArithmeticError
)
2094 PRE_INIT(FloatingPointError
)
2095 PRE_INIT(OverflowError
)
2096 PRE_INIT(ZeroDivisionError
)
2097 PRE_INIT(SystemError
)
2098 PRE_INIT(ReferenceError
)
2099 PRE_INIT(MemoryError
)
2100 PRE_INIT(BufferError
)
2102 PRE_INIT(UserWarning
)
2103 PRE_INIT(DeprecationWarning
)
2104 PRE_INIT(PendingDeprecationWarning
)
2105 PRE_INIT(SyntaxWarning
)
2106 PRE_INIT(RuntimeWarning
)
2107 PRE_INIT(FutureWarning
)
2108 PRE_INIT(ImportWarning
)
2109 PRE_INIT(UnicodeWarning
)
2110 PRE_INIT(BytesWarning
)
2112 m
= Py_InitModule4("exceptions", functions
, exceptions_doc
,
2113 (PyObject
*)NULL
, PYTHON_API_VERSION
);
2114 if (m
== NULL
) return;
2116 bltinmod
= PyImport_ImportModule("__builtin__");
2117 if (bltinmod
== NULL
)
2118 Py_FatalError("exceptions bootstrapping error.");
2119 bdict
= PyModule_GetDict(bltinmod
);
2121 Py_FatalError("exceptions bootstrapping error.");
2123 POST_INIT(BaseException
)
2124 POST_INIT(Exception
)
2125 POST_INIT(StandardError
)
2126 POST_INIT(TypeError
)
2127 POST_INIT(StopIteration
)
2128 POST_INIT(GeneratorExit
)
2129 POST_INIT(SystemExit
)
2130 POST_INIT(KeyboardInterrupt
)
2131 POST_INIT(ImportError
)
2132 POST_INIT(EnvironmentError
)
2136 POST_INIT(WindowsError
)
2142 POST_INIT(RuntimeError
)
2143 POST_INIT(NotImplementedError
)
2144 POST_INIT(NameError
)
2145 POST_INIT(UnboundLocalError
)
2146 POST_INIT(AttributeError
)
2147 POST_INIT(SyntaxError
)
2148 POST_INIT(IndentationError
)
2150 POST_INIT(LookupError
)
2151 POST_INIT(IndexError
)
2153 POST_INIT(ValueError
)
2154 POST_INIT(UnicodeError
)
2155 #ifdef Py_USING_UNICODE
2156 POST_INIT(UnicodeEncodeError
)
2157 POST_INIT(UnicodeDecodeError
)
2158 POST_INIT(UnicodeTranslateError
)
2160 POST_INIT(AssertionError
)
2161 POST_INIT(ArithmeticError
)
2162 POST_INIT(FloatingPointError
)
2163 POST_INIT(OverflowError
)
2164 POST_INIT(ZeroDivisionError
)
2165 POST_INIT(SystemError
)
2166 POST_INIT(ReferenceError
)
2167 POST_INIT(MemoryError
)
2168 POST_INIT(BufferError
)
2170 POST_INIT(UserWarning
)
2171 POST_INIT(DeprecationWarning
)
2172 POST_INIT(PendingDeprecationWarning
)
2173 POST_INIT(SyntaxWarning
)
2174 POST_INIT(RuntimeWarning
)
2175 POST_INIT(FutureWarning
)
2176 POST_INIT(ImportWarning
)
2177 POST_INIT(UnicodeWarning
)
2178 POST_INIT(BytesWarning
)
2180 PyExc_MemoryErrorInst
= BaseException_new(&_PyExc_MemoryError
, NULL
, NULL
);
2181 if (!PyExc_MemoryErrorInst
)
2182 Py_FatalError("Cannot pre-allocate MemoryError instance");
2184 PyExc_RecursionErrorInst
= BaseException_new(&_PyExc_RuntimeError
, NULL
, NULL
);
2185 if (!PyExc_RecursionErrorInst
)
2186 Py_FatalError("Cannot pre-allocate RuntimeError instance for "
2187 "recursion errors");
2189 PyBaseExceptionObject
*err_inst
=
2190 (PyBaseExceptionObject
*)PyExc_RecursionErrorInst
;
2191 PyObject
*args_tuple
;
2192 PyObject
*exc_message
;
2193 exc_message
= PyString_FromString("maximum recursion depth exceeded");
2195 Py_FatalError("cannot allocate argument for RuntimeError "
2197 args_tuple
= PyTuple_Pack(1, exc_message
);
2199 Py_FatalError("cannot allocate tuple for RuntimeError "
2201 Py_DECREF(exc_message
);
2202 if (BaseException_init(err_inst
, args_tuple
, NULL
))
2203 Py_FatalError("init of pre-allocated RuntimeError failed");
2204 Py_DECREF(args_tuple
);
2207 Py_DECREF(bltinmod
);
2213 Py_CLEAR(PyExc_MemoryErrorInst
);
2214 Py_CLEAR(PyExc_RecursionErrorInst
);