blob: a11283e34091ccf2ad7f0ba94932468fb9d4bf29 [file] [log] [blame]
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001/*
2 * New exceptions.c written in Iceland by Richard Jones and Georg Brandl.
3 *
4 * Thanks go to Tim Peters and Michael Hudson for debugging.
5 */
6
Thomas Wouters477c8d52006-05-27 19:21:47 +00007#define PY_SSIZE_T_CLEAN
8#include <Python.h>
9#include "structmember.h"
10#include "osdefs.h"
11
Thomas Wouters477c8d52006-05-27 19:21:47 +000012
Antoine Pitrou6b4883d2011-10-12 02:54:14 +020013/* Compatibility aliases */
14PyObject *PyExc_EnvironmentError = NULL;
15PyObject *PyExc_IOError = NULL;
16#ifdef MS_WINDOWS
17PyObject *PyExc_WindowsError = NULL;
18#endif
19#ifdef __VMS
20PyObject *PyExc_VMSError = NULL;
21#endif
22
23/* The dict map from errno codes to OSError subclasses */
24static PyObject *errnomap = NULL;
25
26
Thomas Wouters477c8d52006-05-27 19:21:47 +000027/* NOTE: If the exception class hierarchy changes, don't forget to update
28 * Lib/test/exception_hierarchy.txt
29 */
30
Thomas Wouters477c8d52006-05-27 19:21:47 +000031/*
32 * BaseException
33 */
34static PyObject *
35BaseException_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
36{
37 PyBaseExceptionObject *self;
38
39 self = (PyBaseExceptionObject *)type->tp_alloc(type, 0);
Guido van Rossumd8faa362007-04-27 19:54:29 +000040 if (!self)
41 return NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +000042 /* the dict is created on the fly in PyObject_GenericSetAttr */
Guido van Rossumebe3e162007-05-17 18:20:34 +000043 self->dict = NULL;
Collin Winter1966f1c2007-09-01 20:26:44 +000044 self->traceback = self->cause = self->context = NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +000045
46 self->args = PyTuple_New(0);
47 if (!self->args) {
48 Py_DECREF(self);
49 return NULL;
50 }
51
Thomas Wouters477c8d52006-05-27 19:21:47 +000052 return (PyObject *)self;
53}
54
55static int
56BaseException_init(PyBaseExceptionObject *self, PyObject *args, PyObject *kwds)
57{
Christian Heimes90aa7642007-12-19 02:45:37 +000058 if (!_PyArg_NoKeywords(Py_TYPE(self)->tp_name, kwds))
Thomas Wouters4d70c3d2006-06-08 14:42:34 +000059 return -1;
60
Antoine Pitroue0e27352011-12-15 14:31:28 +010061 Py_XDECREF(self->args);
Thomas Wouters477c8d52006-05-27 19:21:47 +000062 self->args = args;
63 Py_INCREF(self->args);
64
Thomas Wouters477c8d52006-05-27 19:21:47 +000065 return 0;
66}
67
Thomas Wouters4d70c3d2006-06-08 14:42:34 +000068static int
Thomas Wouters477c8d52006-05-27 19:21:47 +000069BaseException_clear(PyBaseExceptionObject *self)
70{
71 Py_CLEAR(self->dict);
72 Py_CLEAR(self->args);
Collin Winter828f04a2007-08-31 00:04:24 +000073 Py_CLEAR(self->traceback);
Collin Winter1966f1c2007-09-01 20:26:44 +000074 Py_CLEAR(self->cause);
75 Py_CLEAR(self->context);
Thomas Wouters477c8d52006-05-27 19:21:47 +000076 return 0;
77}
78
79static void
80BaseException_dealloc(PyBaseExceptionObject *self)
81{
Thomas Wouters89f507f2006-12-13 04:49:30 +000082 _PyObject_GC_UNTRACK(self);
Thomas Wouters477c8d52006-05-27 19:21:47 +000083 BaseException_clear(self);
Christian Heimes90aa7642007-12-19 02:45:37 +000084 Py_TYPE(self)->tp_free((PyObject *)self);
Thomas Wouters477c8d52006-05-27 19:21:47 +000085}
86
Thomas Wouters4d70c3d2006-06-08 14:42:34 +000087static int
Thomas Wouters477c8d52006-05-27 19:21:47 +000088BaseException_traverse(PyBaseExceptionObject *self, visitproc visit, void *arg)
89{
Thomas Wouters4d70c3d2006-06-08 14:42:34 +000090 Py_VISIT(self->dict);
Thomas Wouters477c8d52006-05-27 19:21:47 +000091 Py_VISIT(self->args);
Collin Winter828f04a2007-08-31 00:04:24 +000092 Py_VISIT(self->traceback);
Collin Winter1966f1c2007-09-01 20:26:44 +000093 Py_VISIT(self->cause);
94 Py_VISIT(self->context);
Thomas Wouters477c8d52006-05-27 19:21:47 +000095 return 0;
96}
97
98static PyObject *
99BaseException_str(PyBaseExceptionObject *self)
100{
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000101 switch (PyTuple_GET_SIZE(self->args)) {
Thomas Wouters477c8d52006-05-27 19:21:47 +0000102 case 0:
Walter Dörwaldf5bec7c2007-05-26 15:03:32 +0000103 return PyUnicode_FromString("");
Thomas Wouters477c8d52006-05-27 19:21:47 +0000104 case 1:
Thomas Heller519a0422007-11-15 20:48:54 +0000105 return PyObject_Str(PyTuple_GET_ITEM(self->args, 0));
Thomas Wouters477c8d52006-05-27 19:21:47 +0000106 default:
Thomas Heller519a0422007-11-15 20:48:54 +0000107 return PyObject_Str(self->args);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000108 }
Thomas Wouters477c8d52006-05-27 19:21:47 +0000109}
110
111static PyObject *
112BaseException_repr(PyBaseExceptionObject *self)
113{
Thomas Wouters477c8d52006-05-27 19:21:47 +0000114 char *name;
115 char *dot;
116
Christian Heimes90aa7642007-12-19 02:45:37 +0000117 name = (char *)Py_TYPE(self)->tp_name;
Thomas Wouters477c8d52006-05-27 19:21:47 +0000118 dot = strrchr(name, '.');
119 if (dot != NULL) name = dot+1;
120
Walter Dörwald7569dfe2007-05-19 21:49:49 +0000121 return PyUnicode_FromFormat("%s%R", name, self->args);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000122}
123
124/* Pickling support */
125static PyObject *
126BaseException_reduce(PyBaseExceptionObject *self)
127{
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000128 if (self->args && self->dict)
Christian Heimes90aa7642007-12-19 02:45:37 +0000129 return PyTuple_Pack(3, Py_TYPE(self), self->args, self->dict);
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000130 else
Christian Heimes90aa7642007-12-19 02:45:37 +0000131 return PyTuple_Pack(2, Py_TYPE(self), self->args);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000132}
133
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000134/*
135 * Needed for backward compatibility, since exceptions used to store
136 * all their attributes in the __dict__. Code is taken from cPickle's
137 * load_build function.
138 */
139static PyObject *
140BaseException_setstate(PyObject *self, PyObject *state)
141{
142 PyObject *d_key, *d_value;
143 Py_ssize_t i = 0;
144
145 if (state != Py_None) {
146 if (!PyDict_Check(state)) {
147 PyErr_SetString(PyExc_TypeError, "state is not a dictionary");
148 return NULL;
149 }
150 while (PyDict_Next(state, &i, &d_key, &d_value)) {
151 if (PyObject_SetAttr(self, d_key, d_value) < 0)
152 return NULL;
153 }
154 }
155 Py_RETURN_NONE;
156}
Thomas Wouters477c8d52006-05-27 19:21:47 +0000157
Collin Winter828f04a2007-08-31 00:04:24 +0000158static PyObject *
159BaseException_with_traceback(PyObject *self, PyObject *tb) {
160 if (PyException_SetTraceback(self, tb))
161 return NULL;
162
163 Py_INCREF(self);
164 return self;
165}
166
Georg Brandl76941002008-05-05 21:38:47 +0000167PyDoc_STRVAR(with_traceback_doc,
168"Exception.with_traceback(tb) --\n\
169 set self.__traceback__ to tb and return self.");
170
Thomas Wouters477c8d52006-05-27 19:21:47 +0000171
172static PyMethodDef BaseException_methods[] = {
173 {"__reduce__", (PyCFunction)BaseException_reduce, METH_NOARGS },
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000174 {"__setstate__", (PyCFunction)BaseException_setstate, METH_O },
Georg Brandl76941002008-05-05 21:38:47 +0000175 {"with_traceback", (PyCFunction)BaseException_with_traceback, METH_O,
176 with_traceback_doc},
Thomas Wouters477c8d52006-05-27 19:21:47 +0000177 {NULL, NULL, 0, NULL},
178};
179
Thomas Wouters477c8d52006-05-27 19:21:47 +0000180static PyObject *
181BaseException_get_args(PyBaseExceptionObject *self)
182{
183 if (self->args == NULL) {
184 Py_INCREF(Py_None);
185 return Py_None;
186 }
187 Py_INCREF(self->args);
188 return self->args;
189}
190
191static int
192BaseException_set_args(PyBaseExceptionObject *self, PyObject *val)
193{
194 PyObject *seq;
195 if (val == NULL) {
196 PyErr_SetString(PyExc_TypeError, "args may not be deleted");
197 return -1;
198 }
199 seq = PySequence_Tuple(val);
Benjamin Peterson90b13582012-02-03 19:22:31 -0500200 if (!seq)
201 return -1;
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000202 Py_CLEAR(self->args);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000203 self->args = seq;
204 return 0;
205}
206
Collin Winter828f04a2007-08-31 00:04:24 +0000207static PyObject *
208BaseException_get_tb(PyBaseExceptionObject *self)
209{
210 if (self->traceback == NULL) {
211 Py_INCREF(Py_None);
212 return Py_None;
213 }
214 Py_INCREF(self->traceback);
215 return self->traceback;
216}
217
218static int
219BaseException_set_tb(PyBaseExceptionObject *self, PyObject *tb)
220{
221 if (tb == NULL) {
222 PyErr_SetString(PyExc_TypeError, "__traceback__ may not be deleted");
223 return -1;
224 }
225 else if (!(tb == Py_None || PyTraceBack_Check(tb))) {
226 PyErr_SetString(PyExc_TypeError,
227 "__traceback__ must be a traceback or None");
228 return -1;
229 }
230
231 Py_XINCREF(tb);
232 Py_XDECREF(self->traceback);
233 self->traceback = tb;
234 return 0;
235}
236
Georg Brandlab6f2f62009-03-31 04:16:10 +0000237static PyObject *
238BaseException_get_context(PyObject *self) {
239 PyObject *res = PyException_GetContext(self);
Benjamin Peterson90b13582012-02-03 19:22:31 -0500240 if (res)
241 return res; /* new reference already returned above */
Georg Brandlab6f2f62009-03-31 04:16:10 +0000242 Py_RETURN_NONE;
243}
244
245static int
246BaseException_set_context(PyObject *self, PyObject *arg) {
247 if (arg == NULL) {
248 PyErr_SetString(PyExc_TypeError, "__context__ may not be deleted");
249 return -1;
250 } else if (arg == Py_None) {
251 arg = NULL;
252 } else if (!PyExceptionInstance_Check(arg)) {
253 PyErr_SetString(PyExc_TypeError, "exception context must be None "
254 "or derive from BaseException");
255 return -1;
256 } else {
257 /* PyException_SetContext steals this reference */
258 Py_INCREF(arg);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000259 }
Georg Brandlab6f2f62009-03-31 04:16:10 +0000260 PyException_SetContext(self, arg);
261 return 0;
262}
263
264static PyObject *
265BaseException_get_cause(PyObject *self) {
266 PyObject *res = PyException_GetCause(self);
Benjamin Peterson90b13582012-02-03 19:22:31 -0500267 if (res)
268 return res; /* new reference already returned above */
Nick Coghlanab7bf212012-02-26 17:49:52 +1000269 Py_INCREF(Py_Ellipsis);
270 return Py_Ellipsis;
271}
272
273int
274_PyException_SetCauseChecked(PyObject *self, PyObject *arg) {
275 if (arg == Py_Ellipsis) {
276 arg = NULL;
277 } else if (arg != Py_None && !PyExceptionInstance_Check(arg)) {
278 PyErr_SetString(PyExc_TypeError, "exception cause must be None, "
279 "Ellipsis or derive from BaseException");
280 return -1;
281 } else {
282 /* PyException_SetCause steals a reference */
283 Py_INCREF(arg);
284 }
285 PyException_SetCause(self, arg);
286 return 0;
Georg Brandlab6f2f62009-03-31 04:16:10 +0000287}
288
289static int
290BaseException_set_cause(PyObject *self, PyObject *arg) {
291 if (arg == NULL) {
292 PyErr_SetString(PyExc_TypeError, "__cause__ may not be deleted");
293 return -1;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000294 }
Nick Coghlanab7bf212012-02-26 17:49:52 +1000295 return _PyException_SetCauseChecked(self, arg);
Georg Brandlab6f2f62009-03-31 04:16:10 +0000296}
297
Guido van Rossum360e4b82007-05-14 22:51:27 +0000298
Thomas Wouters477c8d52006-05-27 19:21:47 +0000299static PyGetSetDef BaseException_getset[] = {
Benjamin Peterson23d7f122012-02-19 20:02:57 -0500300 {"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict},
Thomas Wouters477c8d52006-05-27 19:21:47 +0000301 {"args", (getter)BaseException_get_args, (setter)BaseException_set_args},
Collin Winter828f04a2007-08-31 00:04:24 +0000302 {"__traceback__", (getter)BaseException_get_tb, (setter)BaseException_set_tb},
Georg Brandlab6f2f62009-03-31 04:16:10 +0000303 {"__context__", (getter)BaseException_get_context,
304 (setter)BaseException_set_context, PyDoc_STR("exception context")},
305 {"__cause__", (getter)BaseException_get_cause,
306 (setter)BaseException_set_cause, PyDoc_STR("exception cause")},
Thomas Wouters477c8d52006-05-27 19:21:47 +0000307 {NULL},
308};
309
310
Collin Winter828f04a2007-08-31 00:04:24 +0000311PyObject *
312PyException_GetTraceback(PyObject *self) {
313 PyBaseExceptionObject *base_self = (PyBaseExceptionObject *)self;
314 Py_XINCREF(base_self->traceback);
315 return base_self->traceback;
316}
317
318
319int
320PyException_SetTraceback(PyObject *self, PyObject *tb) {
321 return BaseException_set_tb((PyBaseExceptionObject *)self, tb);
322}
323
324PyObject *
325PyException_GetCause(PyObject *self) {
326 PyObject *cause = ((PyBaseExceptionObject *)self)->cause;
327 Py_XINCREF(cause);
328 return cause;
329}
330
331/* Steals a reference to cause */
332void
333PyException_SetCause(PyObject *self, PyObject *cause) {
334 PyObject *old_cause = ((PyBaseExceptionObject *)self)->cause;
335 ((PyBaseExceptionObject *)self)->cause = cause;
336 Py_XDECREF(old_cause);
337}
338
339PyObject *
340PyException_GetContext(PyObject *self) {
341 PyObject *context = ((PyBaseExceptionObject *)self)->context;
342 Py_XINCREF(context);
343 return context;
344}
345
346/* Steals a reference to context */
347void
348PyException_SetContext(PyObject *self, PyObject *context) {
349 PyObject *old_context = ((PyBaseExceptionObject *)self)->context;
350 ((PyBaseExceptionObject *)self)->context = context;
351 Py_XDECREF(old_context);
352}
353
354
Thomas Wouters477c8d52006-05-27 19:21:47 +0000355static PyTypeObject _PyExc_BaseException = {
Martin v. Löwis9f2e3462007-07-21 17:22:18 +0000356 PyVarObject_HEAD_INIT(NULL, 0)
Neal Norwitz2633c692007-02-26 22:22:47 +0000357 "BaseException", /*tp_name*/
Thomas Wouters477c8d52006-05-27 19:21:47 +0000358 sizeof(PyBaseExceptionObject), /*tp_basicsize*/
359 0, /*tp_itemsize*/
360 (destructor)BaseException_dealloc, /*tp_dealloc*/
361 0, /*tp_print*/
362 0, /*tp_getattr*/
363 0, /*tp_setattr*/
Mark Dickinsone94c6792009-02-02 20:36:42 +0000364 0, /* tp_reserved; */
Thomas Wouters477c8d52006-05-27 19:21:47 +0000365 (reprfunc)BaseException_repr, /*tp_repr*/
366 0, /*tp_as_number*/
Brett Cannonba7bf492007-02-27 00:15:55 +0000367 0, /*tp_as_sequence*/
Thomas Wouters477c8d52006-05-27 19:21:47 +0000368 0, /*tp_as_mapping*/
369 0, /*tp_hash */
370 0, /*tp_call*/
371 (reprfunc)BaseException_str, /*tp_str*/
372 PyObject_GenericGetAttr, /*tp_getattro*/
373 PyObject_GenericSetAttr, /*tp_setattro*/
374 0, /*tp_as_buffer*/
Thomas Wouters27d517b2007-02-25 20:39:11 +0000375 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC |
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000376 Py_TPFLAGS_BASE_EXC_SUBCLASS, /*tp_flags*/
Thomas Wouters477c8d52006-05-27 19:21:47 +0000377 PyDoc_STR("Common base class for all exceptions"), /* tp_doc */
378 (traverseproc)BaseException_traverse, /* tp_traverse */
379 (inquiry)BaseException_clear, /* tp_clear */
380 0, /* tp_richcompare */
381 0, /* tp_weaklistoffset */
382 0, /* tp_iter */
383 0, /* tp_iternext */
384 BaseException_methods, /* tp_methods */
Georg Brandlab6f2f62009-03-31 04:16:10 +0000385 0, /* tp_members */
Thomas Wouters477c8d52006-05-27 19:21:47 +0000386 BaseException_getset, /* tp_getset */
387 0, /* tp_base */
388 0, /* tp_dict */
389 0, /* tp_descr_get */
390 0, /* tp_descr_set */
391 offsetof(PyBaseExceptionObject, dict), /* tp_dictoffset */
392 (initproc)BaseException_init, /* tp_init */
393 0, /* tp_alloc */
394 BaseException_new, /* tp_new */
395};
396/* the CPython API expects exceptions to be (PyObject *) - both a hold-over
397from the previous implmentation and also allowing Python objects to be used
398in the API */
399PyObject *PyExc_BaseException = (PyObject *)&_PyExc_BaseException;
400
401/* note these macros omit the last semicolon so the macro invocation may
402 * include it and not look strange.
403 */
404#define SimpleExtendsException(EXCBASE, EXCNAME, EXCDOC) \
405static PyTypeObject _PyExc_ ## EXCNAME = { \
Martin v. Löwis9f2e3462007-07-21 17:22:18 +0000406 PyVarObject_HEAD_INIT(NULL, 0) \
Neal Norwitz2633c692007-02-26 22:22:47 +0000407 # EXCNAME, \
Thomas Wouters477c8d52006-05-27 19:21:47 +0000408 sizeof(PyBaseExceptionObject), \
409 0, (destructor)BaseException_dealloc, 0, 0, 0, 0, 0, 0, 0, \
410 0, 0, 0, 0, 0, 0, 0, \
411 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \
412 PyDoc_STR(EXCDOC), (traverseproc)BaseException_traverse, \
413 (inquiry)BaseException_clear, 0, 0, 0, 0, 0, 0, 0, &_ ## EXCBASE, \
414 0, 0, 0, offsetof(PyBaseExceptionObject, dict), \
415 (initproc)BaseException_init, 0, BaseException_new,\
416}; \
417PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME
418
419#define MiddlingExtendsException(EXCBASE, EXCNAME, EXCSTORE, EXCDOC) \
420static PyTypeObject _PyExc_ ## EXCNAME = { \
Martin v. Löwis9f2e3462007-07-21 17:22:18 +0000421 PyVarObject_HEAD_INIT(NULL, 0) \
Neal Norwitz2633c692007-02-26 22:22:47 +0000422 # EXCNAME, \
Thomas Wouters477c8d52006-05-27 19:21:47 +0000423 sizeof(Py ## EXCSTORE ## Object), \
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000424 0, (destructor)EXCSTORE ## _dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
Thomas Wouters477c8d52006-05-27 19:21:47 +0000425 0, 0, 0, 0, 0, \
426 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000427 PyDoc_STR(EXCDOC), (traverseproc)EXCSTORE ## _traverse, \
428 (inquiry)EXCSTORE ## _clear, 0, 0, 0, 0, 0, 0, 0, &_ ## EXCBASE, \
Thomas Wouters477c8d52006-05-27 19:21:47 +0000429 0, 0, 0, offsetof(Py ## EXCSTORE ## Object, dict), \
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200430 (initproc)EXCSTORE ## _init, 0, 0, \
Thomas Wouters477c8d52006-05-27 19:21:47 +0000431}; \
432PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME
433
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200434#define ComplexExtendsException(EXCBASE, EXCNAME, EXCSTORE, EXCNEW, \
435 EXCMETHODS, EXCMEMBERS, EXCGETSET, \
436 EXCSTR, EXCDOC) \
Thomas Wouters477c8d52006-05-27 19:21:47 +0000437static PyTypeObject _PyExc_ ## EXCNAME = { \
Martin v. Löwis9f2e3462007-07-21 17:22:18 +0000438 PyVarObject_HEAD_INIT(NULL, 0) \
Neal Norwitz2633c692007-02-26 22:22:47 +0000439 # EXCNAME, \
Thomas Wouters477c8d52006-05-27 19:21:47 +0000440 sizeof(Py ## EXCSTORE ## Object), 0, \
441 (destructor)EXCSTORE ## _dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
442 (reprfunc)EXCSTR, 0, 0, 0, \
443 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \
444 PyDoc_STR(EXCDOC), (traverseproc)EXCSTORE ## _traverse, \
445 (inquiry)EXCSTORE ## _clear, 0, 0, 0, 0, EXCMETHODS, \
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200446 EXCMEMBERS, EXCGETSET, &_ ## EXCBASE, \
Thomas Wouters477c8d52006-05-27 19:21:47 +0000447 0, 0, 0, offsetof(Py ## EXCSTORE ## Object, dict), \
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200448 (initproc)EXCSTORE ## _init, 0, EXCNEW,\
Thomas Wouters477c8d52006-05-27 19:21:47 +0000449}; \
450PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME
451
452
453/*
454 * Exception extends BaseException
455 */
456SimpleExtendsException(PyExc_BaseException, Exception,
457 "Common base class for all non-exit exceptions.");
458
459
460/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +0000461 * TypeError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +0000462 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +0000463SimpleExtendsException(PyExc_Exception, TypeError,
Thomas Wouters477c8d52006-05-27 19:21:47 +0000464 "Inappropriate argument type.");
465
466
467/*
468 * StopIteration extends Exception
469 */
Nick Coghlan1f7ce622012-01-13 21:43:40 +1000470
471static PyMemberDef StopIteration_members[] = {
472 {"value", T_OBJECT, offsetof(PyStopIterationObject, value), 0,
473 PyDoc_STR("generator return value")},
474 {NULL} /* Sentinel */
475};
476
477static int
478StopIteration_init(PyStopIterationObject *self, PyObject *args, PyObject *kwds)
479{
480 Py_ssize_t size = PyTuple_GET_SIZE(args);
481 PyObject *value;
482
483 if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
484 return -1;
485 Py_CLEAR(self->value);
486 if (size > 0)
487 value = PyTuple_GET_ITEM(args, 0);
488 else
489 value = Py_None;
490 Py_INCREF(value);
491 self->value = value;
492 return 0;
493}
494
495static int
496StopIteration_clear(PyStopIterationObject *self)
497{
498 Py_CLEAR(self->value);
499 return BaseException_clear((PyBaseExceptionObject *)self);
500}
501
502static void
503StopIteration_dealloc(PyStopIterationObject *self)
504{
505 _PyObject_GC_UNTRACK(self);
506 StopIteration_clear(self);
507 Py_TYPE(self)->tp_free((PyObject *)self);
508}
509
510static int
511StopIteration_traverse(PyStopIterationObject *self, visitproc visit, void *arg)
512{
513 Py_VISIT(self->value);
514 return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
515}
516
517PyObject *
518PyStopIteration_Create(PyObject *value)
519{
520 return PyObject_CallFunctionObjArgs(PyExc_StopIteration, value, NULL);
521}
522
523ComplexExtendsException(
524 PyExc_Exception, /* base */
525 StopIteration, /* name */
526 StopIteration, /* prefix for *_init, etc */
527 0, /* new */
528 0, /* methods */
529 StopIteration_members, /* members */
530 0, /* getset */
531 0, /* str */
532 "Signal the end from iterator.__next__()."
533);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000534
535
536/*
Christian Heimescbf3b5c2007-12-03 21:02:03 +0000537 * GeneratorExit extends BaseException
Thomas Wouters477c8d52006-05-27 19:21:47 +0000538 */
Christian Heimescbf3b5c2007-12-03 21:02:03 +0000539SimpleExtendsException(PyExc_BaseException, GeneratorExit,
Thomas Wouters477c8d52006-05-27 19:21:47 +0000540 "Request that a generator exit.");
541
542
543/*
544 * SystemExit extends BaseException
545 */
Thomas Wouters477c8d52006-05-27 19:21:47 +0000546
547static int
548SystemExit_init(PySystemExitObject *self, PyObject *args, PyObject *kwds)
549{
550 Py_ssize_t size = PyTuple_GET_SIZE(args);
551
552 if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
553 return -1;
554
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000555 if (size == 0)
556 return 0;
557 Py_CLEAR(self->code);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000558 if (size == 1)
559 self->code = PyTuple_GET_ITEM(args, 0);
Victor Stinner92236e52011-05-26 14:25:54 +0200560 else /* size > 1 */
Thomas Wouters477c8d52006-05-27 19:21:47 +0000561 self->code = args;
562 Py_INCREF(self->code);
563 return 0;
564}
565
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000566static int
Thomas Wouters477c8d52006-05-27 19:21:47 +0000567SystemExit_clear(PySystemExitObject *self)
568{
569 Py_CLEAR(self->code);
570 return BaseException_clear((PyBaseExceptionObject *)self);
571}
572
573static void
574SystemExit_dealloc(PySystemExitObject *self)
575{
Thomas Wouters89f507f2006-12-13 04:49:30 +0000576 _PyObject_GC_UNTRACK(self);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000577 SystemExit_clear(self);
Christian Heimes90aa7642007-12-19 02:45:37 +0000578 Py_TYPE(self)->tp_free((PyObject *)self);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000579}
580
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000581static int
Thomas Wouters477c8d52006-05-27 19:21:47 +0000582SystemExit_traverse(PySystemExitObject *self, visitproc visit, void *arg)
583{
584 Py_VISIT(self->code);
585 return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
586}
587
588static PyMemberDef SystemExit_members[] = {
Thomas Wouters477c8d52006-05-27 19:21:47 +0000589 {"code", T_OBJECT, offsetof(PySystemExitObject, code), 0,
590 PyDoc_STR("exception code")},
591 {NULL} /* Sentinel */
592};
593
594ComplexExtendsException(PyExc_BaseException, SystemExit, SystemExit,
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200595 0, 0, SystemExit_members, 0, 0,
Thomas Wouters477c8d52006-05-27 19:21:47 +0000596 "Request to exit from the interpreter.");
597
598/*
599 * KeyboardInterrupt extends BaseException
600 */
601SimpleExtendsException(PyExc_BaseException, KeyboardInterrupt,
602 "Program interrupted by user.");
603
604
605/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +0000606 * ImportError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +0000607 */
Thomas Wouters477c8d52006-05-27 19:21:47 +0000608
Brett Cannon79ec55e2012-04-12 20:24:54 -0400609static int
610ImportError_init(PyImportErrorObject *self, PyObject *args, PyObject *kwds)
611{
612 PyObject *msg = NULL;
613 PyObject *name = NULL;
614 PyObject *path = NULL;
615
616/* Macro replacement doesn't allow ## to start the first line of a macro,
617 so we move the assignment and NULL check into the if-statement. */
618#define GET_KWD(kwd) { \
619 kwd = PyDict_GetItemString(kwds, #kwd); \
620 if (kwd) { \
621 Py_CLEAR(self->kwd); \
622 self->kwd = kwd; \
623 Py_INCREF(self->kwd);\
624 if (PyDict_DelItemString(kwds, #kwd)) \
625 return -1; \
626 } \
627 }
628
629 if (kwds) {
630 GET_KWD(name);
631 GET_KWD(path);
632 }
633
634 if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
635 return -1;
636 if (PyTuple_GET_SIZE(args) != 1)
637 return 0;
638 if (!PyArg_UnpackTuple(args, "ImportError", 1, 1, &msg))
639 return -1;
640
641 Py_CLEAR(self->msg); /* replacing */
642 self->msg = msg;
643 Py_INCREF(self->msg);
644
645 return 0;
646}
647
648static int
649ImportError_clear(PyImportErrorObject *self)
650{
651 Py_CLEAR(self->msg);
652 Py_CLEAR(self->name);
653 Py_CLEAR(self->path);
654 return BaseException_clear((PyBaseExceptionObject *)self);
655}
656
657static void
658ImportError_dealloc(PyImportErrorObject *self)
659{
660 _PyObject_GC_UNTRACK(self);
661 ImportError_clear(self);
662 Py_TYPE(self)->tp_free((PyObject *)self);
663}
664
665static int
666ImportError_traverse(PyImportErrorObject *self, visitproc visit, void *arg)
667{
668 Py_VISIT(self->msg);
669 Py_VISIT(self->name);
670 Py_VISIT(self->path);
671 return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
672}
673
674static PyObject *
675ImportError_str(PyImportErrorObject *self)
676{
677 if (self->msg) {
678 Py_INCREF(self->msg);
679 return self->msg;
680 }
681 else {
682 return BaseException_str((PyBaseExceptionObject *)self);
683 }
684}
685
686static PyMemberDef ImportError_members[] = {
687 {"msg", T_OBJECT, offsetof(PyImportErrorObject, msg), 0,
688 PyDoc_STR("exception message")},
689 {"name", T_OBJECT, offsetof(PyImportErrorObject, name), 0,
690 PyDoc_STR("module name")},
691 {"path", T_OBJECT, offsetof(PyImportErrorObject, path), 0,
692 PyDoc_STR("module path")},
693 {NULL} /* Sentinel */
694};
695
696static PyMethodDef ImportError_methods[] = {
697 {NULL}
698};
699
700ComplexExtendsException(PyExc_Exception, ImportError,
701 ImportError, 0 /* new */,
702 ImportError_methods, ImportError_members,
703 0 /* getset */, ImportError_str,
704 "Import can't find module, or can't find name in "
705 "module.");
Thomas Wouters477c8d52006-05-27 19:21:47 +0000706
707/*
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200708 * OSError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +0000709 */
710
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200711#ifdef MS_WINDOWS
712#include "errmap.h"
713#endif
714
Thomas Wouters477c8d52006-05-27 19:21:47 +0000715/* Where a function has a single filename, such as open() or some
716 * of the os module functions, PyErr_SetFromErrnoWithFilename() is
717 * called, giving a third argument which is the filename. But, so
718 * that old code using in-place unpacking doesn't break, e.g.:
719 *
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200720 * except OSError, (errno, strerror):
Thomas Wouters477c8d52006-05-27 19:21:47 +0000721 *
722 * we hack args so that it only contains two items. This also
723 * means we need our own __str__() which prints out the filename
724 * when it was supplied.
725 */
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200726
Antoine Pitroue0e27352011-12-15 14:31:28 +0100727/* This function doesn't cleanup on error, the caller should */
728static int
729oserror_parse_args(PyObject **p_args,
730 PyObject **myerrno, PyObject **strerror,
731 PyObject **filename
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200732#ifdef MS_WINDOWS
Antoine Pitroue0e27352011-12-15 14:31:28 +0100733 , PyObject **winerror
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200734#endif
Antoine Pitroue0e27352011-12-15 14:31:28 +0100735 )
736{
737 Py_ssize_t nargs;
738 PyObject *args = *p_args;
Thomas Wouters477c8d52006-05-27 19:21:47 +0000739
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200740 nargs = PyTuple_GET_SIZE(args);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000741
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200742#ifdef MS_WINDOWS
743 if (nargs >= 2 && nargs <= 4) {
744 if (!PyArg_UnpackTuple(args, "OSError", 2, 4,
Antoine Pitroue0e27352011-12-15 14:31:28 +0100745 myerrno, strerror, filename, winerror))
746 return -1;
747 if (*winerror && PyLong_Check(*winerror)) {
748 long errcode, winerrcode;
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200749 PyObject *newargs;
750 Py_ssize_t i;
751
Antoine Pitroue0e27352011-12-15 14:31:28 +0100752 winerrcode = PyLong_AsLong(*winerror);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200753 if (winerrcode == -1 && PyErr_Occurred())
Antoine Pitroue0e27352011-12-15 14:31:28 +0100754 return -1;
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200755 /* Set errno to the corresponding POSIX errno (overriding
756 first argument). Windows Socket error codes (>= 10000)
757 have the same value as their POSIX counterparts.
758 */
759 if (winerrcode < 10000)
760 errcode = winerror_to_errno(winerrcode);
761 else
762 errcode = winerrcode;
Antoine Pitroue0e27352011-12-15 14:31:28 +0100763 *myerrno = PyLong_FromLong(errcode);
764 if (!*myerrno)
765 return -1;
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200766 newargs = PyTuple_New(nargs);
767 if (!newargs)
Antoine Pitroue0e27352011-12-15 14:31:28 +0100768 return -1;
769 PyTuple_SET_ITEM(newargs, 0, *myerrno);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200770 for (i = 1; i < nargs; i++) {
771 PyObject *val = PyTuple_GET_ITEM(args, i);
772 Py_INCREF(val);
773 PyTuple_SET_ITEM(newargs, i, val);
774 }
775 Py_DECREF(args);
Antoine Pitroue0e27352011-12-15 14:31:28 +0100776 args = *p_args = newargs;
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200777 }
778 }
779#else
780 if (nargs >= 2 && nargs <= 3) {
781 if (!PyArg_UnpackTuple(args, "OSError", 2, 3,
Antoine Pitroue0e27352011-12-15 14:31:28 +0100782 myerrno, strerror, filename))
783 return -1;
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200784 }
785#endif
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000786
Antoine Pitroue0e27352011-12-15 14:31:28 +0100787 return 0;
788}
Thomas Wouters477c8d52006-05-27 19:21:47 +0000789
Antoine Pitroue0e27352011-12-15 14:31:28 +0100790static int
791oserror_init(PyOSErrorObject *self, PyObject **p_args,
792 PyObject *myerrno, PyObject *strerror,
793 PyObject *filename
794#ifdef MS_WINDOWS
795 , PyObject *winerror
796#endif
797 )
798{
799 PyObject *args = *p_args;
800 Py_ssize_t nargs = PyTuple_GET_SIZE(args);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000801
802 /* self->filename will remain Py_None otherwise */
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200803 if (filename && filename != Py_None) {
Antoine Pitroue0e27352011-12-15 14:31:28 +0100804 if (Py_TYPE(self) == (PyTypeObject *) PyExc_BlockingIOError &&
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200805 PyNumber_Check(filename)) {
806 /* BlockingIOError's 3rd argument can be the number of
807 * characters written.
808 */
809 self->written = PyNumber_AsSsize_t(filename, PyExc_ValueError);
810 if (self->written == -1 && PyErr_Occurred())
Antoine Pitroue0e27352011-12-15 14:31:28 +0100811 return -1;
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200812 }
813 else {
814 Py_INCREF(filename);
815 self->filename = filename;
Thomas Wouters477c8d52006-05-27 19:21:47 +0000816
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200817 if (nargs >= 2 && nargs <= 3) {
818 /* filename is removed from the args tuple (for compatibility
819 purposes, see test_exceptions.py) */
Antoine Pitroue0e27352011-12-15 14:31:28 +0100820 PyObject *subslice = PyTuple_GetSlice(args, 0, 2);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200821 if (!subslice)
Antoine Pitroue0e27352011-12-15 14:31:28 +0100822 return -1;
Thomas Wouters477c8d52006-05-27 19:21:47 +0000823
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200824 Py_DECREF(args); /* replacing args */
Antoine Pitroue0e27352011-12-15 14:31:28 +0100825 *p_args = args = subslice;
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200826 }
827 }
Thomas Wouters477c8d52006-05-27 19:21:47 +0000828 }
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200829 Py_XINCREF(myerrno);
830 self->myerrno = myerrno;
831
832 Py_XINCREF(strerror);
833 self->strerror = strerror;
834
835#ifdef MS_WINDOWS
836 Py_XINCREF(winerror);
837 self->winerror = winerror;
838#endif
839
Antoine Pitroue0e27352011-12-15 14:31:28 +0100840 /* Steals the reference to args */
841 self->args = args;
842 args = NULL;
843
844 return 0;
845}
846
847static PyObject *
848OSError_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
849static int
850OSError_init(PyOSErrorObject *self, PyObject *args, PyObject *kwds);
851
852static int
853oserror_use_init(PyTypeObject *type)
854{
855 /* When __init__ is defined in a OSError subclass, we want any
856 extraneous argument to __new__ to be ignored. The only reasonable
857 solution, given __new__ takes a variable number of arguments,
858 is to defer arg parsing and initialization to __init__.
859
860 But when __new__ is overriden as well, it should call our __new__
861 with the right arguments.
862
863 (see http://bugs.python.org/issue12555#msg148829 )
864 */
865 if (type->tp_init != (initproc) OSError_init &&
866 type->tp_new == (newfunc) OSError_new) {
867 assert((PyObject *) type != PyExc_OSError);
868 return 1;
869 }
870 return 0;
871}
872
873static PyObject *
874OSError_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
875{
876 PyOSErrorObject *self = NULL;
877 PyObject *myerrno = NULL, *strerror = NULL, *filename = NULL;
878#ifdef MS_WINDOWS
879 PyObject *winerror = NULL;
880#endif
881
882 if (!oserror_use_init(type)) {
883 if (!_PyArg_NoKeywords(type->tp_name, kwds))
884 return NULL;
885
886 Py_INCREF(args);
887 if (oserror_parse_args(&args, &myerrno, &strerror, &filename
888#ifdef MS_WINDOWS
889 , &winerror
890#endif
891 ))
892 goto error;
893
894 if (myerrno && PyLong_Check(myerrno) &&
895 errnomap && (PyObject *) type == PyExc_OSError) {
896 PyObject *newtype;
897 newtype = PyDict_GetItem(errnomap, myerrno);
898 if (newtype) {
899 assert(PyType_Check(newtype));
900 type = (PyTypeObject *) newtype;
901 }
902 else if (PyErr_Occurred())
903 goto error;
904 }
905 }
906
907 self = (PyOSErrorObject *) type->tp_alloc(type, 0);
908 if (!self)
909 goto error;
910
911 self->dict = NULL;
912 self->traceback = self->cause = self->context = NULL;
913 self->written = -1;
914
915 if (!oserror_use_init(type)) {
916 if (oserror_init(self, &args, myerrno, strerror, filename
917#ifdef MS_WINDOWS
918 , winerror
919#endif
920 ))
921 goto error;
922 }
923
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200924 return (PyObject *) self;
925
926error:
927 Py_XDECREF(args);
928 Py_XDECREF(self);
929 return NULL;
930}
931
932static int
Antoine Pitroue0e27352011-12-15 14:31:28 +0100933OSError_init(PyOSErrorObject *self, PyObject *args, PyObject *kwds)
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200934{
Antoine Pitroue0e27352011-12-15 14:31:28 +0100935 PyObject *myerrno = NULL, *strerror = NULL, *filename = NULL;
936#ifdef MS_WINDOWS
937 PyObject *winerror = NULL;
938#endif
939
940 if (!oserror_use_init(Py_TYPE(self)))
941 /* Everything already done in OSError_new */
942 return 0;
943
944 if (!_PyArg_NoKeywords(Py_TYPE(self)->tp_name, kwds))
945 return -1;
946
947 Py_INCREF(args);
948 if (oserror_parse_args(&args, &myerrno, &strerror, &filename
949#ifdef MS_WINDOWS
950 , &winerror
951#endif
952 ))
953 goto error;
954
955 if (oserror_init(self, &args, myerrno, strerror, filename
956#ifdef MS_WINDOWS
957 , winerror
958#endif
959 ))
960 goto error;
961
Thomas Wouters477c8d52006-05-27 19:21:47 +0000962 return 0;
Antoine Pitroue0e27352011-12-15 14:31:28 +0100963
964error:
965 Py_XDECREF(args);
966 return -1;
Thomas Wouters477c8d52006-05-27 19:21:47 +0000967}
968
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000969static int
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200970OSError_clear(PyOSErrorObject *self)
Thomas Wouters477c8d52006-05-27 19:21:47 +0000971{
972 Py_CLEAR(self->myerrno);
973 Py_CLEAR(self->strerror);
974 Py_CLEAR(self->filename);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200975#ifdef MS_WINDOWS
976 Py_CLEAR(self->winerror);
977#endif
Thomas Wouters477c8d52006-05-27 19:21:47 +0000978 return BaseException_clear((PyBaseExceptionObject *)self);
979}
980
981static void
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200982OSError_dealloc(PyOSErrorObject *self)
Thomas Wouters477c8d52006-05-27 19:21:47 +0000983{
Thomas Wouters89f507f2006-12-13 04:49:30 +0000984 _PyObject_GC_UNTRACK(self);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200985 OSError_clear(self);
Christian Heimes90aa7642007-12-19 02:45:37 +0000986 Py_TYPE(self)->tp_free((PyObject *)self);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000987}
988
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000989static int
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200990OSError_traverse(PyOSErrorObject *self, visitproc visit,
Thomas Wouters477c8d52006-05-27 19:21:47 +0000991 void *arg)
992{
993 Py_VISIT(self->myerrno);
994 Py_VISIT(self->strerror);
995 Py_VISIT(self->filename);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200996#ifdef MS_WINDOWS
997 Py_VISIT(self->winerror);
998#endif
Thomas Wouters477c8d52006-05-27 19:21:47 +0000999 return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
1000}
1001
1002static PyObject *
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001003OSError_str(PyOSErrorObject *self)
Thomas Wouters477c8d52006-05-27 19:21:47 +00001004{
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001005#ifdef MS_WINDOWS
1006 /* If available, winerror has the priority over myerrno */
1007 if (self->winerror && self->filename)
1008 return PyUnicode_FromFormat("[Error %S] %S: %R",
1009 self->winerror ? self->winerror: Py_None,
1010 self->strerror ? self->strerror: Py_None,
1011 self->filename);
1012 if (self->winerror && self->strerror)
1013 return PyUnicode_FromFormat("[Error %S] %S",
1014 self->winerror ? self->winerror: Py_None,
1015 self->strerror ? self->strerror: Py_None);
1016#endif
Walter Dörwaldf5bec7c2007-05-26 15:03:32 +00001017 if (self->filename)
1018 return PyUnicode_FromFormat("[Errno %S] %S: %R",
1019 self->myerrno ? self->myerrno: Py_None,
1020 self->strerror ? self->strerror: Py_None,
1021 self->filename);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001022 if (self->myerrno && self->strerror)
Walter Dörwaldf5bec7c2007-05-26 15:03:32 +00001023 return PyUnicode_FromFormat("[Errno %S] %S",
1024 self->myerrno ? self->myerrno: Py_None,
1025 self->strerror ? self->strerror: Py_None);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001026 return BaseException_str((PyBaseExceptionObject *)self);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001027}
1028
Thomas Wouters477c8d52006-05-27 19:21:47 +00001029static PyObject *
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001030OSError_reduce(PyOSErrorObject *self)
Thomas Wouters477c8d52006-05-27 19:21:47 +00001031{
1032 PyObject *args = self->args;
1033 PyObject *res = NULL, *tmp;
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001034
Thomas Wouters477c8d52006-05-27 19:21:47 +00001035 /* self->args is only the first two real arguments if there was a
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001036 * file name given to OSError. */
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001037 if (PyTuple_GET_SIZE(args) == 2 && self->filename) {
Thomas Wouters477c8d52006-05-27 19:21:47 +00001038 args = PyTuple_New(3);
Benjamin Peterson90b13582012-02-03 19:22:31 -05001039 if (!args)
1040 return NULL;
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001041
1042 tmp = PyTuple_GET_ITEM(self->args, 0);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001043 Py_INCREF(tmp);
1044 PyTuple_SET_ITEM(args, 0, tmp);
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001045
1046 tmp = PyTuple_GET_ITEM(self->args, 1);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001047 Py_INCREF(tmp);
1048 PyTuple_SET_ITEM(args, 1, tmp);
1049
1050 Py_INCREF(self->filename);
1051 PyTuple_SET_ITEM(args, 2, self->filename);
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001052 } else
Thomas Wouters477c8d52006-05-27 19:21:47 +00001053 Py_INCREF(args);
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001054
1055 if (self->dict)
Christian Heimes90aa7642007-12-19 02:45:37 +00001056 res = PyTuple_Pack(3, Py_TYPE(self), args, self->dict);
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001057 else
Christian Heimes90aa7642007-12-19 02:45:37 +00001058 res = PyTuple_Pack(2, Py_TYPE(self), args);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001059 Py_DECREF(args);
1060 return res;
1061}
1062
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001063static PyObject *
1064OSError_written_get(PyOSErrorObject *self, void *context)
1065{
1066 if (self->written == -1) {
1067 PyErr_SetString(PyExc_AttributeError, "characters_written");
1068 return NULL;
1069 }
1070 return PyLong_FromSsize_t(self->written);
1071}
Thomas Wouters477c8d52006-05-27 19:21:47 +00001072
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001073static int
1074OSError_written_set(PyOSErrorObject *self, PyObject *arg, void *context)
1075{
1076 Py_ssize_t n;
1077 n = PyNumber_AsSsize_t(arg, PyExc_ValueError);
1078 if (n == -1 && PyErr_Occurred())
1079 return -1;
1080 self->written = n;
1081 return 0;
1082}
1083
1084static PyMemberDef OSError_members[] = {
1085 {"errno", T_OBJECT, offsetof(PyOSErrorObject, myerrno), 0,
1086 PyDoc_STR("POSIX exception code")},
1087 {"strerror", T_OBJECT, offsetof(PyOSErrorObject, strerror), 0,
1088 PyDoc_STR("exception strerror")},
1089 {"filename", T_OBJECT, offsetof(PyOSErrorObject, filename), 0,
1090 PyDoc_STR("exception filename")},
1091#ifdef MS_WINDOWS
1092 {"winerror", T_OBJECT, offsetof(PyOSErrorObject, winerror), 0,
1093 PyDoc_STR("Win32 exception code")},
1094#endif
1095 {NULL} /* Sentinel */
1096};
1097
1098static PyMethodDef OSError_methods[] = {
1099 {"__reduce__", (PyCFunction)OSError_reduce, METH_NOARGS},
Thomas Wouters477c8d52006-05-27 19:21:47 +00001100 {NULL}
1101};
1102
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001103static PyGetSetDef OSError_getset[] = {
1104 {"characters_written", (getter) OSError_written_get,
1105 (setter) OSError_written_set, NULL},
1106 {NULL}
1107};
1108
1109
1110ComplexExtendsException(PyExc_Exception, OSError,
1111 OSError, OSError_new,
1112 OSError_methods, OSError_members, OSError_getset,
1113 OSError_str,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001114 "Base class for I/O related errors.");
1115
1116
1117/*
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001118 * Various OSError subclasses
Thomas Wouters477c8d52006-05-27 19:21:47 +00001119 */
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001120MiddlingExtendsException(PyExc_OSError, BlockingIOError, OSError,
1121 "I/O operation would block.");
1122MiddlingExtendsException(PyExc_OSError, ConnectionError, OSError,
1123 "Connection error.");
1124MiddlingExtendsException(PyExc_OSError, ChildProcessError, OSError,
1125 "Child process error.");
1126MiddlingExtendsException(PyExc_ConnectionError, BrokenPipeError, OSError,
1127 "Broken pipe.");
1128MiddlingExtendsException(PyExc_ConnectionError, ConnectionAbortedError, OSError,
1129 "Connection aborted.");
1130MiddlingExtendsException(PyExc_ConnectionError, ConnectionRefusedError, OSError,
1131 "Connection refused.");
1132MiddlingExtendsException(PyExc_ConnectionError, ConnectionResetError, OSError,
1133 "Connection reset.");
1134MiddlingExtendsException(PyExc_OSError, FileExistsError, OSError,
1135 "File already exists.");
1136MiddlingExtendsException(PyExc_OSError, FileNotFoundError, OSError,
1137 "File not found.");
1138MiddlingExtendsException(PyExc_OSError, IsADirectoryError, OSError,
1139 "Operation doesn't work on directories.");
1140MiddlingExtendsException(PyExc_OSError, NotADirectoryError, OSError,
1141 "Operation only works on directories.");
1142MiddlingExtendsException(PyExc_OSError, InterruptedError, OSError,
1143 "Interrupted by signal.");
1144MiddlingExtendsException(PyExc_OSError, PermissionError, OSError,
1145 "Not enough permissions.");
1146MiddlingExtendsException(PyExc_OSError, ProcessLookupError, OSError,
1147 "Process not found.");
1148MiddlingExtendsException(PyExc_OSError, TimeoutError, OSError,
1149 "Timeout expired.");
Thomas Wouters477c8d52006-05-27 19:21:47 +00001150
1151/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001152 * EOFError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00001153 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001154SimpleExtendsException(PyExc_Exception, EOFError,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001155 "Read beyond end of file.");
1156
1157
1158/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001159 * RuntimeError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00001160 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001161SimpleExtendsException(PyExc_Exception, RuntimeError,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001162 "Unspecified run-time error.");
1163
1164
1165/*
1166 * NotImplementedError extends RuntimeError
1167 */
1168SimpleExtendsException(PyExc_RuntimeError, NotImplementedError,
1169 "Method or function hasn't been implemented yet.");
1170
1171/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001172 * NameError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00001173 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001174SimpleExtendsException(PyExc_Exception, NameError,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001175 "Name not found globally.");
1176
1177/*
1178 * UnboundLocalError extends NameError
1179 */
1180SimpleExtendsException(PyExc_NameError, UnboundLocalError,
1181 "Local name referenced but not bound to a value.");
1182
1183/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001184 * AttributeError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00001185 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001186SimpleExtendsException(PyExc_Exception, AttributeError,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001187 "Attribute not found.");
1188
1189
1190/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001191 * SyntaxError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00001192 */
Thomas Wouters477c8d52006-05-27 19:21:47 +00001193
1194static int
1195SyntaxError_init(PySyntaxErrorObject *self, PyObject *args, PyObject *kwds)
1196{
1197 PyObject *info = NULL;
1198 Py_ssize_t lenargs = PyTuple_GET_SIZE(args);
1199
1200 if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
1201 return -1;
1202
1203 if (lenargs >= 1) {
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001204 Py_CLEAR(self->msg);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001205 self->msg = PyTuple_GET_ITEM(args, 0);
1206 Py_INCREF(self->msg);
1207 }
1208 if (lenargs == 2) {
1209 info = PyTuple_GET_ITEM(args, 1);
1210 info = PySequence_Tuple(info);
Benjamin Peterson90b13582012-02-03 19:22:31 -05001211 if (!info)
1212 return -1;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001213
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001214 if (PyTuple_GET_SIZE(info) != 4) {
1215 /* not a very good error message, but it's what Python 2.4 gives */
1216 PyErr_SetString(PyExc_IndexError, "tuple index out of range");
1217 Py_DECREF(info);
1218 return -1;
1219 }
1220
1221 Py_CLEAR(self->filename);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001222 self->filename = PyTuple_GET_ITEM(info, 0);
1223 Py_INCREF(self->filename);
1224
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001225 Py_CLEAR(self->lineno);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001226 self->lineno = PyTuple_GET_ITEM(info, 1);
1227 Py_INCREF(self->lineno);
1228
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001229 Py_CLEAR(self->offset);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001230 self->offset = PyTuple_GET_ITEM(info, 2);
1231 Py_INCREF(self->offset);
1232
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001233 Py_CLEAR(self->text);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001234 self->text = PyTuple_GET_ITEM(info, 3);
1235 Py_INCREF(self->text);
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001236
1237 Py_DECREF(info);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001238 }
1239 return 0;
1240}
1241
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001242static int
Thomas Wouters477c8d52006-05-27 19:21:47 +00001243SyntaxError_clear(PySyntaxErrorObject *self)
1244{
1245 Py_CLEAR(self->msg);
1246 Py_CLEAR(self->filename);
1247 Py_CLEAR(self->lineno);
1248 Py_CLEAR(self->offset);
1249 Py_CLEAR(self->text);
1250 Py_CLEAR(self->print_file_and_line);
1251 return BaseException_clear((PyBaseExceptionObject *)self);
1252}
1253
1254static void
1255SyntaxError_dealloc(PySyntaxErrorObject *self)
1256{
Thomas Wouters89f507f2006-12-13 04:49:30 +00001257 _PyObject_GC_UNTRACK(self);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001258 SyntaxError_clear(self);
Christian Heimes90aa7642007-12-19 02:45:37 +00001259 Py_TYPE(self)->tp_free((PyObject *)self);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001260}
1261
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001262static int
Thomas Wouters477c8d52006-05-27 19:21:47 +00001263SyntaxError_traverse(PySyntaxErrorObject *self, visitproc visit, void *arg)
1264{
1265 Py_VISIT(self->msg);
1266 Py_VISIT(self->filename);
1267 Py_VISIT(self->lineno);
1268 Py_VISIT(self->offset);
1269 Py_VISIT(self->text);
1270 Py_VISIT(self->print_file_and_line);
1271 return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
1272}
1273
1274/* This is called "my_basename" instead of just "basename" to avoid name
1275 conflicts with glibc; basename is already prototyped if _GNU_SOURCE is
1276 defined, and Python does define that. */
Victor Stinner6237daf2010-04-28 17:26:19 +00001277static PyObject*
1278my_basename(PyObject *name)
Thomas Wouters477c8d52006-05-27 19:21:47 +00001279{
Victor Stinner6237daf2010-04-28 17:26:19 +00001280 Py_ssize_t i, size, offset;
Victor Stinner31392e72011-10-05 20:14:23 +02001281 int kind;
1282 void *data;
1283
1284 if (PyUnicode_READY(name))
1285 return NULL;
1286 kind = PyUnicode_KIND(name);
1287 data = PyUnicode_DATA(name);
Martin v. Löwisd63a3b82011-09-28 07:41:54 +02001288 size = PyUnicode_GET_LENGTH(name);
Victor Stinner6237daf2010-04-28 17:26:19 +00001289 offset = 0;
1290 for(i=0; i < size; i++) {
Martin v. Löwisd63a3b82011-09-28 07:41:54 +02001291 if (PyUnicode_READ(kind, data, i) == SEP)
Victor Stinner6237daf2010-04-28 17:26:19 +00001292 offset = i + 1;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001293 }
Martin v. Löwisd63a3b82011-09-28 07:41:54 +02001294 if (offset != 0)
1295 return PyUnicode_Substring(name, offset, size);
1296 else {
Victor Stinner6237daf2010-04-28 17:26:19 +00001297 Py_INCREF(name);
1298 return name;
1299 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00001300}
1301
1302
1303static PyObject *
1304SyntaxError_str(PySyntaxErrorObject *self)
1305{
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001306 int have_lineno = 0;
Victor Stinner6237daf2010-04-28 17:26:19 +00001307 PyObject *filename;
1308 PyObject *result;
Martin v. Löwisd1a1d1e2007-12-04 22:10:37 +00001309 /* Below, we always ignore overflow errors, just printing -1.
1310 Still, we cannot allow an OverflowError to be raised, so
1311 we need to call PyLong_AsLongAndOverflow. */
1312 int overflow;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001313
1314 /* XXX -- do all the additional formatting with filename and
1315 lineno here */
1316
Neal Norwitzed2b7392007-08-26 04:51:10 +00001317 if (self->filename && PyUnicode_Check(self->filename)) {
Victor Stinner6237daf2010-04-28 17:26:19 +00001318 filename = my_basename(self->filename);
1319 if (filename == NULL)
1320 return NULL;
1321 } else {
1322 filename = NULL;
Martin v. Löwis10a60b32007-07-18 02:28:27 +00001323 }
Martin v. Löwisd1a1d1e2007-12-04 22:10:37 +00001324 have_lineno = (self->lineno != NULL) && PyLong_CheckExact(self->lineno);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001325
Martin v. Löwis10a60b32007-07-18 02:28:27 +00001326 if (!filename && !have_lineno)
Thomas Heller519a0422007-11-15 20:48:54 +00001327 return PyObject_Str(self->msg ? self->msg : Py_None);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001328
Martin v. Löwis10a60b32007-07-18 02:28:27 +00001329 if (filename && have_lineno)
Victor Stinner6237daf2010-04-28 17:26:19 +00001330 result = PyUnicode_FromFormat("%S (%U, line %ld)",
Walter Dörwaldf5bec7c2007-05-26 15:03:32 +00001331 self->msg ? self->msg : Py_None,
Victor Stinner6237daf2010-04-28 17:26:19 +00001332 filename,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001333 PyLong_AsLongAndOverflow(self->lineno, &overflow));
Martin v. Löwis10a60b32007-07-18 02:28:27 +00001334 else if (filename)
Victor Stinner6237daf2010-04-28 17:26:19 +00001335 result = PyUnicode_FromFormat("%S (%U)",
Walter Dörwaldf5bec7c2007-05-26 15:03:32 +00001336 self->msg ? self->msg : Py_None,
Victor Stinner6237daf2010-04-28 17:26:19 +00001337 filename);
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001338 else /* only have_lineno */
Victor Stinner6237daf2010-04-28 17:26:19 +00001339 result = PyUnicode_FromFormat("%S (line %ld)",
Walter Dörwaldf5bec7c2007-05-26 15:03:32 +00001340 self->msg ? self->msg : Py_None,
Martin v. Löwisd1a1d1e2007-12-04 22:10:37 +00001341 PyLong_AsLongAndOverflow(self->lineno, &overflow));
Victor Stinner6237daf2010-04-28 17:26:19 +00001342 Py_XDECREF(filename);
1343 return result;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001344}
1345
1346static PyMemberDef SyntaxError_members[] = {
Thomas Wouters477c8d52006-05-27 19:21:47 +00001347 {"msg", T_OBJECT, offsetof(PySyntaxErrorObject, msg), 0,
1348 PyDoc_STR("exception msg")},
1349 {"filename", T_OBJECT, offsetof(PySyntaxErrorObject, filename), 0,
1350 PyDoc_STR("exception filename")},
1351 {"lineno", T_OBJECT, offsetof(PySyntaxErrorObject, lineno), 0,
1352 PyDoc_STR("exception lineno")},
1353 {"offset", T_OBJECT, offsetof(PySyntaxErrorObject, offset), 0,
1354 PyDoc_STR("exception offset")},
1355 {"text", T_OBJECT, offsetof(PySyntaxErrorObject, text), 0,
1356 PyDoc_STR("exception text")},
1357 {"print_file_and_line", T_OBJECT,
1358 offsetof(PySyntaxErrorObject, print_file_and_line), 0,
1359 PyDoc_STR("exception print_file_and_line")},
1360 {NULL} /* Sentinel */
1361};
1362
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001363ComplexExtendsException(PyExc_Exception, SyntaxError, SyntaxError,
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001364 0, 0, SyntaxError_members, 0,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001365 SyntaxError_str, "Invalid syntax.");
1366
1367
1368/*
1369 * IndentationError extends SyntaxError
1370 */
1371MiddlingExtendsException(PyExc_SyntaxError, IndentationError, SyntaxError,
1372 "Improper indentation.");
1373
1374
1375/*
1376 * TabError extends IndentationError
1377 */
1378MiddlingExtendsException(PyExc_IndentationError, TabError, SyntaxError,
1379 "Improper mixture of spaces and tabs.");
1380
1381
1382/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001383 * LookupError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00001384 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001385SimpleExtendsException(PyExc_Exception, LookupError,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001386 "Base class for lookup errors.");
1387
1388
1389/*
1390 * IndexError extends LookupError
1391 */
1392SimpleExtendsException(PyExc_LookupError, IndexError,
1393 "Sequence index out of range.");
1394
1395
1396/*
1397 * KeyError extends LookupError
1398 */
1399static PyObject *
1400KeyError_str(PyBaseExceptionObject *self)
1401{
1402 /* If args is a tuple of exactly one item, apply repr to args[0].
1403 This is done so that e.g. the exception raised by {}[''] prints
1404 KeyError: ''
1405 rather than the confusing
1406 KeyError
1407 alone. The downside is that if KeyError is raised with an explanatory
1408 string, that string will be displayed in quotes. Too bad.
1409 If args is anything else, use the default BaseException__str__().
1410 */
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001411 if (PyTuple_GET_SIZE(self->args) == 1) {
Walter Dörwaldf5bec7c2007-05-26 15:03:32 +00001412 return PyObject_Repr(PyTuple_GET_ITEM(self->args, 0));
Thomas Wouters477c8d52006-05-27 19:21:47 +00001413 }
1414 return BaseException_str(self);
1415}
1416
1417ComplexExtendsException(PyExc_LookupError, KeyError, BaseException,
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001418 0, 0, 0, 0, KeyError_str, "Mapping key not found.");
Thomas Wouters477c8d52006-05-27 19:21:47 +00001419
1420
1421/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001422 * ValueError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00001423 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001424SimpleExtendsException(PyExc_Exception, ValueError,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001425 "Inappropriate argument value (of correct type).");
1426
1427/*
1428 * UnicodeError extends ValueError
1429 */
1430
1431SimpleExtendsException(PyExc_ValueError, UnicodeError,
1432 "Unicode related error.");
1433
Thomas Wouters477c8d52006-05-27 19:21:47 +00001434static PyObject *
Guido van Rossum98297ee2007-11-06 21:34:58 +00001435get_string(PyObject *attr, const char *name)
Walter Dörwald612344f2007-05-04 19:28:21 +00001436{
1437 if (!attr) {
1438 PyErr_Format(PyExc_TypeError, "%.200s attribute not set", name);
1439 return NULL;
1440 }
1441
Christian Heimes72b710a2008-05-26 13:28:38 +00001442 if (!PyBytes_Check(attr)) {
Walter Dörwald612344f2007-05-04 19:28:21 +00001443 PyErr_Format(PyExc_TypeError, "%.200s attribute must be bytes", name);
1444 return NULL;
1445 }
1446 Py_INCREF(attr);
1447 return attr;
1448}
1449
1450static PyObject *
Thomas Wouters477c8d52006-05-27 19:21:47 +00001451get_unicode(PyObject *attr, const char *name)
1452{
1453 if (!attr) {
1454 PyErr_Format(PyExc_TypeError, "%.200s attribute not set", name);
1455 return NULL;
1456 }
1457
1458 if (!PyUnicode_Check(attr)) {
1459 PyErr_Format(PyExc_TypeError,
1460 "%.200s attribute must be unicode", name);
1461 return NULL;
1462 }
1463 Py_INCREF(attr);
1464 return attr;
1465}
1466
Walter Dörwaldd2034312007-05-18 16:29:38 +00001467static int
1468set_unicodefromstring(PyObject **attr, const char *value)
1469{
1470 PyObject *obj = PyUnicode_FromString(value);
1471 if (!obj)
1472 return -1;
1473 Py_CLEAR(*attr);
1474 *attr = obj;
1475 return 0;
1476}
1477
Thomas Wouters477c8d52006-05-27 19:21:47 +00001478PyObject *
1479PyUnicodeEncodeError_GetEncoding(PyObject *exc)
1480{
Walter Dörwaldd2034312007-05-18 16:29:38 +00001481 return get_unicode(((PyUnicodeErrorObject *)exc)->encoding, "encoding");
Thomas Wouters477c8d52006-05-27 19:21:47 +00001482}
1483
1484PyObject *
1485PyUnicodeDecodeError_GetEncoding(PyObject *exc)
1486{
Walter Dörwaldd2034312007-05-18 16:29:38 +00001487 return get_unicode(((PyUnicodeErrorObject *)exc)->encoding, "encoding");
Thomas Wouters477c8d52006-05-27 19:21:47 +00001488}
1489
1490PyObject *
1491PyUnicodeEncodeError_GetObject(PyObject *exc)
1492{
1493 return get_unicode(((PyUnicodeErrorObject *)exc)->object, "object");
1494}
1495
1496PyObject *
1497PyUnicodeDecodeError_GetObject(PyObject *exc)
1498{
Guido van Rossum98297ee2007-11-06 21:34:58 +00001499 return get_string(((PyUnicodeErrorObject *)exc)->object, "object");
Thomas Wouters477c8d52006-05-27 19:21:47 +00001500}
1501
1502PyObject *
1503PyUnicodeTranslateError_GetObject(PyObject *exc)
1504{
1505 return get_unicode(((PyUnicodeErrorObject *)exc)->object, "object");
1506}
1507
1508int
1509PyUnicodeEncodeError_GetStart(PyObject *exc, Py_ssize_t *start)
1510{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001511 Py_ssize_t size;
1512 PyObject *obj = get_unicode(((PyUnicodeErrorObject *)exc)->object,
1513 "object");
1514 if (!obj)
1515 return -1;
1516 *start = ((PyUnicodeErrorObject *)exc)->start;
Victor Stinner9e30aa52011-11-21 02:49:52 +01001517 size = PyUnicode_GET_LENGTH(obj);
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001518 if (*start<0)
1519 *start = 0; /*XXX check for values <0*/
1520 if (*start>=size)
1521 *start = size-1;
1522 Py_DECREF(obj);
1523 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001524}
1525
1526
1527int
1528PyUnicodeDecodeError_GetStart(PyObject *exc, Py_ssize_t *start)
1529{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001530 Py_ssize_t size;
Guido van Rossum98297ee2007-11-06 21:34:58 +00001531 PyObject *obj = get_string(((PyUnicodeErrorObject *)exc)->object, "object");
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001532 if (!obj)
1533 return -1;
Christian Heimes72b710a2008-05-26 13:28:38 +00001534 size = PyBytes_GET_SIZE(obj);
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001535 *start = ((PyUnicodeErrorObject *)exc)->start;
1536 if (*start<0)
1537 *start = 0;
1538 if (*start>=size)
1539 *start = size-1;
1540 Py_DECREF(obj);
1541 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001542}
1543
1544
1545int
1546PyUnicodeTranslateError_GetStart(PyObject *exc, Py_ssize_t *start)
1547{
1548 return PyUnicodeEncodeError_GetStart(exc, start);
1549}
1550
1551
1552int
1553PyUnicodeEncodeError_SetStart(PyObject *exc, Py_ssize_t start)
1554{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001555 ((PyUnicodeErrorObject *)exc)->start = start;
1556 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001557}
1558
1559
1560int
1561PyUnicodeDecodeError_SetStart(PyObject *exc, Py_ssize_t start)
1562{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001563 ((PyUnicodeErrorObject *)exc)->start = start;
1564 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001565}
1566
1567
1568int
1569PyUnicodeTranslateError_SetStart(PyObject *exc, Py_ssize_t start)
1570{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001571 ((PyUnicodeErrorObject *)exc)->start = start;
1572 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001573}
1574
1575
1576int
1577PyUnicodeEncodeError_GetEnd(PyObject *exc, Py_ssize_t *end)
1578{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001579 Py_ssize_t size;
1580 PyObject *obj = get_unicode(((PyUnicodeErrorObject *)exc)->object,
1581 "object");
1582 if (!obj)
1583 return -1;
1584 *end = ((PyUnicodeErrorObject *)exc)->end;
Victor Stinner9e30aa52011-11-21 02:49:52 +01001585 size = PyUnicode_GET_LENGTH(obj);
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001586 if (*end<1)
1587 *end = 1;
1588 if (*end>size)
1589 *end = size;
1590 Py_DECREF(obj);
1591 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001592}
1593
1594
1595int
1596PyUnicodeDecodeError_GetEnd(PyObject *exc, Py_ssize_t *end)
1597{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001598 Py_ssize_t size;
Guido van Rossum98297ee2007-11-06 21:34:58 +00001599 PyObject *obj = get_string(((PyUnicodeErrorObject *)exc)->object, "object");
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001600 if (!obj)
1601 return -1;
Christian Heimes72b710a2008-05-26 13:28:38 +00001602 size = PyBytes_GET_SIZE(obj);
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001603 *end = ((PyUnicodeErrorObject *)exc)->end;
1604 if (*end<1)
1605 *end = 1;
1606 if (*end>size)
1607 *end = size;
1608 Py_DECREF(obj);
1609 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001610}
1611
1612
1613int
1614PyUnicodeTranslateError_GetEnd(PyObject *exc, Py_ssize_t *start)
1615{
1616 return PyUnicodeEncodeError_GetEnd(exc, start);
1617}
1618
1619
1620int
1621PyUnicodeEncodeError_SetEnd(PyObject *exc, Py_ssize_t end)
1622{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001623 ((PyUnicodeErrorObject *)exc)->end = end;
1624 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001625}
1626
1627
1628int
1629PyUnicodeDecodeError_SetEnd(PyObject *exc, Py_ssize_t end)
1630{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001631 ((PyUnicodeErrorObject *)exc)->end = end;
1632 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001633}
1634
1635
1636int
1637PyUnicodeTranslateError_SetEnd(PyObject *exc, Py_ssize_t end)
1638{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001639 ((PyUnicodeErrorObject *)exc)->end = end;
1640 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001641}
1642
1643PyObject *
1644PyUnicodeEncodeError_GetReason(PyObject *exc)
1645{
Walter Dörwaldd2034312007-05-18 16:29:38 +00001646 return get_unicode(((PyUnicodeErrorObject *)exc)->reason, "reason");
Thomas Wouters477c8d52006-05-27 19:21:47 +00001647}
1648
1649
1650PyObject *
1651PyUnicodeDecodeError_GetReason(PyObject *exc)
1652{
Walter Dörwaldd2034312007-05-18 16:29:38 +00001653 return get_unicode(((PyUnicodeErrorObject *)exc)->reason, "reason");
Thomas Wouters477c8d52006-05-27 19:21:47 +00001654}
1655
1656
1657PyObject *
1658PyUnicodeTranslateError_GetReason(PyObject *exc)
1659{
Walter Dörwaldd2034312007-05-18 16:29:38 +00001660 return get_unicode(((PyUnicodeErrorObject *)exc)->reason, "reason");
Thomas Wouters477c8d52006-05-27 19:21:47 +00001661}
1662
1663
1664int
1665PyUnicodeEncodeError_SetReason(PyObject *exc, const char *reason)
1666{
Walter Dörwaldd2034312007-05-18 16:29:38 +00001667 return set_unicodefromstring(&((PyUnicodeErrorObject *)exc)->reason,
1668 reason);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001669}
1670
1671
1672int
1673PyUnicodeDecodeError_SetReason(PyObject *exc, const char *reason)
1674{
Walter Dörwaldd2034312007-05-18 16:29:38 +00001675 return set_unicodefromstring(&((PyUnicodeErrorObject *)exc)->reason,
1676 reason);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001677}
1678
1679
1680int
1681PyUnicodeTranslateError_SetReason(PyObject *exc, const char *reason)
1682{
Walter Dörwaldd2034312007-05-18 16:29:38 +00001683 return set_unicodefromstring(&((PyUnicodeErrorObject *)exc)->reason,
1684 reason);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001685}
1686
1687
Thomas Wouters477c8d52006-05-27 19:21:47 +00001688static int
Thomas Wouters477c8d52006-05-27 19:21:47 +00001689UnicodeError_clear(PyUnicodeErrorObject *self)
1690{
1691 Py_CLEAR(self->encoding);
1692 Py_CLEAR(self->object);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001693 Py_CLEAR(self->reason);
1694 return BaseException_clear((PyBaseExceptionObject *)self);
1695}
1696
1697static void
1698UnicodeError_dealloc(PyUnicodeErrorObject *self)
1699{
Thomas Wouters89f507f2006-12-13 04:49:30 +00001700 _PyObject_GC_UNTRACK(self);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001701 UnicodeError_clear(self);
Christian Heimes90aa7642007-12-19 02:45:37 +00001702 Py_TYPE(self)->tp_free((PyObject *)self);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001703}
1704
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001705static int
Thomas Wouters477c8d52006-05-27 19:21:47 +00001706UnicodeError_traverse(PyUnicodeErrorObject *self, visitproc visit, void *arg)
1707{
1708 Py_VISIT(self->encoding);
1709 Py_VISIT(self->object);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001710 Py_VISIT(self->reason);
1711 return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
1712}
1713
1714static PyMemberDef UnicodeError_members[] = {
Thomas Wouters477c8d52006-05-27 19:21:47 +00001715 {"encoding", T_OBJECT, offsetof(PyUnicodeErrorObject, encoding), 0,
1716 PyDoc_STR("exception encoding")},
1717 {"object", T_OBJECT, offsetof(PyUnicodeErrorObject, object), 0,
1718 PyDoc_STR("exception object")},
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001719 {"start", T_PYSSIZET, offsetof(PyUnicodeErrorObject, start), 0,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001720 PyDoc_STR("exception start")},
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001721 {"end", T_PYSSIZET, offsetof(PyUnicodeErrorObject, end), 0,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001722 PyDoc_STR("exception end")},
1723 {"reason", T_OBJECT, offsetof(PyUnicodeErrorObject, reason), 0,
1724 PyDoc_STR("exception reason")},
1725 {NULL} /* Sentinel */
1726};
1727
1728
1729/*
1730 * UnicodeEncodeError extends UnicodeError
1731 */
Thomas Wouters477c8d52006-05-27 19:21:47 +00001732
1733static int
1734UnicodeEncodeError_init(PyObject *self, PyObject *args, PyObject *kwds)
1735{
Guido van Rossum98297ee2007-11-06 21:34:58 +00001736 PyUnicodeErrorObject *err;
1737
Thomas Wouters477c8d52006-05-27 19:21:47 +00001738 if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
1739 return -1;
Guido van Rossum98297ee2007-11-06 21:34:58 +00001740
1741 err = (PyUnicodeErrorObject *)self;
1742
1743 Py_CLEAR(err->encoding);
1744 Py_CLEAR(err->object);
1745 Py_CLEAR(err->reason);
1746
1747 if (!PyArg_ParseTuple(args, "O!O!nnO!",
1748 &PyUnicode_Type, &err->encoding,
1749 &PyUnicode_Type, &err->object,
1750 &err->start,
1751 &err->end,
1752 &PyUnicode_Type, &err->reason)) {
1753 err->encoding = err->object = err->reason = NULL;
1754 return -1;
1755 }
1756
Martin v. Löwisb09af032011-11-04 11:16:41 +01001757 if (PyUnicode_READY(err->object) < -1) {
1758 err->encoding = NULL;
1759 return -1;
1760 }
1761
Guido van Rossum98297ee2007-11-06 21:34:58 +00001762 Py_INCREF(err->encoding);
1763 Py_INCREF(err->object);
1764 Py_INCREF(err->reason);
1765
1766 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001767}
1768
1769static PyObject *
1770UnicodeEncodeError_str(PyObject *self)
1771{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001772 PyUnicodeErrorObject *uself = (PyUnicodeErrorObject *)self;
Eric Smith0facd772010-02-24 15:42:29 +00001773 PyObject *result = NULL;
1774 PyObject *reason_str = NULL;
1775 PyObject *encoding_str = NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001776
Eric Smith0facd772010-02-24 15:42:29 +00001777 /* Get reason and encoding as strings, which they might not be if
1778 they've been modified after we were contructed. */
1779 reason_str = PyObject_Str(uself->reason);
1780 if (reason_str == NULL)
1781 goto done;
1782 encoding_str = PyObject_Str(uself->encoding);
1783 if (encoding_str == NULL)
1784 goto done;
1785
Victor Stinnerda1ddf32011-11-20 22:50:23 +01001786 if (uself->start < PyUnicode_GET_LENGTH(uself->object) && uself->end == uself->start+1) {
1787 Py_UCS4 badchar = PyUnicode_ReadChar(uself->object, uself->start);
Walter Dörwald787b03b2007-06-05 13:29:29 +00001788 const char *fmt;
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001789 if (badchar <= 0xff)
Walter Dörwald32a4c712007-06-20 09:25:34 +00001790 fmt = "'%U' codec can't encode character '\\x%02x' in position %zd: %U";
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001791 else if (badchar <= 0xffff)
Walter Dörwald32a4c712007-06-20 09:25:34 +00001792 fmt = "'%U' codec can't encode character '\\u%04x' in position %zd: %U";
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001793 else
Walter Dörwald32a4c712007-06-20 09:25:34 +00001794 fmt = "'%U' codec can't encode character '\\U%08x' in position %zd: %U";
Eric Smith0facd772010-02-24 15:42:29 +00001795 result = PyUnicode_FromFormat(
Walter Dörwald787b03b2007-06-05 13:29:29 +00001796 fmt,
Eric Smith0facd772010-02-24 15:42:29 +00001797 encoding_str,
Victor Stinnerda1ddf32011-11-20 22:50:23 +01001798 (int)badchar,
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001799 uself->start,
Eric Smith0facd772010-02-24 15:42:29 +00001800 reason_str);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001801 }
Eric Smith0facd772010-02-24 15:42:29 +00001802 else {
1803 result = PyUnicode_FromFormat(
1804 "'%U' codec can't encode characters in position %zd-%zd: %U",
1805 encoding_str,
1806 uself->start,
1807 uself->end-1,
1808 reason_str);
1809 }
1810done:
1811 Py_XDECREF(reason_str);
1812 Py_XDECREF(encoding_str);
1813 return result;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001814}
1815
1816static PyTypeObject _PyExc_UnicodeEncodeError = {
Martin v. Löwis9f2e3462007-07-21 17:22:18 +00001817 PyVarObject_HEAD_INIT(NULL, 0)
Neal Norwitz2633c692007-02-26 22:22:47 +00001818 "UnicodeEncodeError",
Thomas Wouters477c8d52006-05-27 19:21:47 +00001819 sizeof(PyUnicodeErrorObject), 0,
1820 (destructor)UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1821 (reprfunc)UnicodeEncodeError_str, 0, 0, 0,
1822 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001823 PyDoc_STR("Unicode encoding error."), (traverseproc)UnicodeError_traverse,
1824 (inquiry)UnicodeError_clear, 0, 0, 0, 0, 0, UnicodeError_members,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001825 0, &_PyExc_UnicodeError, 0, 0, 0, offsetof(PyUnicodeErrorObject, dict),
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001826 (initproc)UnicodeEncodeError_init, 0, BaseException_new,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001827};
1828PyObject *PyExc_UnicodeEncodeError = (PyObject *)&_PyExc_UnicodeEncodeError;
1829
1830PyObject *
1831PyUnicodeEncodeError_Create(
1832 const char *encoding, const Py_UNICODE *object, Py_ssize_t length,
1833 Py_ssize_t start, Py_ssize_t end, const char *reason)
1834{
Victor Stinner7eeb5b52010-06-07 19:57:46 +00001835 return PyObject_CallFunction(PyExc_UnicodeEncodeError, "su#nns",
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001836 encoding, object, length, start, end, reason);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001837}
1838
1839
1840/*
1841 * UnicodeDecodeError extends UnicodeError
1842 */
Thomas Wouters477c8d52006-05-27 19:21:47 +00001843
1844static int
1845UnicodeDecodeError_init(PyObject *self, PyObject *args, PyObject *kwds)
1846{
Guido van Rossum98297ee2007-11-06 21:34:58 +00001847 PyUnicodeErrorObject *ude;
1848 const char *data;
1849 Py_ssize_t size;
1850
Thomas Wouters477c8d52006-05-27 19:21:47 +00001851 if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
1852 return -1;
Guido van Rossum98297ee2007-11-06 21:34:58 +00001853
1854 ude = (PyUnicodeErrorObject *)self;
1855
1856 Py_CLEAR(ude->encoding);
1857 Py_CLEAR(ude->object);
1858 Py_CLEAR(ude->reason);
1859
1860 if (!PyArg_ParseTuple(args, "O!OnnO!",
1861 &PyUnicode_Type, &ude->encoding,
1862 &ude->object,
1863 &ude->start,
1864 &ude->end,
1865 &PyUnicode_Type, &ude->reason)) {
1866 ude->encoding = ude->object = ude->reason = NULL;
1867 return -1;
1868 }
1869
Christian Heimes72b710a2008-05-26 13:28:38 +00001870 if (!PyBytes_Check(ude->object)) {
Guido van Rossum98297ee2007-11-06 21:34:58 +00001871 if (PyObject_AsReadBuffer(ude->object, (const void **)&data, &size)) {
1872 ude->encoding = ude->object = ude->reason = NULL;
1873 return -1;
1874 }
Christian Heimes72b710a2008-05-26 13:28:38 +00001875 ude->object = PyBytes_FromStringAndSize(data, size);
Guido van Rossum98297ee2007-11-06 21:34:58 +00001876 }
1877 else {
1878 Py_INCREF(ude->object);
1879 }
1880
1881 Py_INCREF(ude->encoding);
1882 Py_INCREF(ude->reason);
1883
1884 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001885}
1886
1887static PyObject *
1888UnicodeDecodeError_str(PyObject *self)
1889{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001890 PyUnicodeErrorObject *uself = (PyUnicodeErrorObject *)self;
Eric Smith0facd772010-02-24 15:42:29 +00001891 PyObject *result = NULL;
1892 PyObject *reason_str = NULL;
1893 PyObject *encoding_str = NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001894
Eric Smith0facd772010-02-24 15:42:29 +00001895 /* Get reason and encoding as strings, which they might not be if
1896 they've been modified after we were contructed. */
1897 reason_str = PyObject_Str(uself->reason);
1898 if (reason_str == NULL)
1899 goto done;
1900 encoding_str = PyObject_Str(uself->encoding);
1901 if (encoding_str == NULL)
1902 goto done;
1903
1904 if (uself->start < PyBytes_GET_SIZE(uself->object) && uself->end == uself->start+1) {
Christian Heimes72b710a2008-05-26 13:28:38 +00001905 int byte = (int)(PyBytes_AS_STRING(((PyUnicodeErrorObject *)self)->object)[uself->start]&0xff);
Eric Smith0facd772010-02-24 15:42:29 +00001906 result = PyUnicode_FromFormat(
Walter Dörwald787b03b2007-06-05 13:29:29 +00001907 "'%U' codec can't decode byte 0x%02x in position %zd: %U",
Eric Smith0facd772010-02-24 15:42:29 +00001908 encoding_str,
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001909 byte,
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001910 uself->start,
Eric Smith0facd772010-02-24 15:42:29 +00001911 reason_str);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001912 }
Eric Smith0facd772010-02-24 15:42:29 +00001913 else {
1914 result = PyUnicode_FromFormat(
1915 "'%U' codec can't decode bytes in position %zd-%zd: %U",
1916 encoding_str,
1917 uself->start,
1918 uself->end-1,
1919 reason_str
1920 );
1921 }
1922done:
1923 Py_XDECREF(reason_str);
1924 Py_XDECREF(encoding_str);
1925 return result;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001926}
1927
1928static PyTypeObject _PyExc_UnicodeDecodeError = {
Martin v. Löwis9f2e3462007-07-21 17:22:18 +00001929 PyVarObject_HEAD_INIT(NULL, 0)
Neal Norwitz2633c692007-02-26 22:22:47 +00001930 "UnicodeDecodeError",
Thomas Wouters477c8d52006-05-27 19:21:47 +00001931 sizeof(PyUnicodeErrorObject), 0,
1932 (destructor)UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1933 (reprfunc)UnicodeDecodeError_str, 0, 0, 0,
1934 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001935 PyDoc_STR("Unicode decoding error."), (traverseproc)UnicodeError_traverse,
1936 (inquiry)UnicodeError_clear, 0, 0, 0, 0, 0, UnicodeError_members,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001937 0, &_PyExc_UnicodeError, 0, 0, 0, offsetof(PyUnicodeErrorObject, dict),
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001938 (initproc)UnicodeDecodeError_init, 0, BaseException_new,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001939};
1940PyObject *PyExc_UnicodeDecodeError = (PyObject *)&_PyExc_UnicodeDecodeError;
1941
1942PyObject *
1943PyUnicodeDecodeError_Create(
1944 const char *encoding, const char *object, Py_ssize_t length,
1945 Py_ssize_t start, Py_ssize_t end, const char *reason)
1946{
Victor Stinner7eeb5b52010-06-07 19:57:46 +00001947 return PyObject_CallFunction(PyExc_UnicodeDecodeError, "sy#nns",
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001948 encoding, object, length, start, end, reason);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001949}
1950
1951
1952/*
1953 * UnicodeTranslateError extends UnicodeError
1954 */
Thomas Wouters477c8d52006-05-27 19:21:47 +00001955
1956static int
1957UnicodeTranslateError_init(PyUnicodeErrorObject *self, PyObject *args,
1958 PyObject *kwds)
1959{
1960 if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
1961 return -1;
1962
1963 Py_CLEAR(self->object);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001964 Py_CLEAR(self->reason);
1965
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001966 if (!PyArg_ParseTuple(args, "O!nnO!",
Thomas Wouters477c8d52006-05-27 19:21:47 +00001967 &PyUnicode_Type, &self->object,
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001968 &self->start,
1969 &self->end,
Walter Dörwaldd2034312007-05-18 16:29:38 +00001970 &PyUnicode_Type, &self->reason)) {
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001971 self->object = self->reason = NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001972 return -1;
1973 }
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001974
Thomas Wouters477c8d52006-05-27 19:21:47 +00001975 Py_INCREF(self->object);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001976 Py_INCREF(self->reason);
1977
1978 return 0;
1979}
1980
1981
1982static PyObject *
1983UnicodeTranslateError_str(PyObject *self)
1984{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001985 PyUnicodeErrorObject *uself = (PyUnicodeErrorObject *)self;
Eric Smith0facd772010-02-24 15:42:29 +00001986 PyObject *result = NULL;
1987 PyObject *reason_str = NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001988
Eric Smith0facd772010-02-24 15:42:29 +00001989 /* Get reason as a string, which it might not be if it's been
1990 modified after we were contructed. */
1991 reason_str = PyObject_Str(uself->reason);
1992 if (reason_str == NULL)
1993 goto done;
1994
Victor Stinner53b33e72011-11-21 01:17:27 +01001995 if (uself->start < PyUnicode_GET_LENGTH(uself->object) && uself->end == uself->start+1) {
1996 Py_UCS4 badchar = PyUnicode_ReadChar(uself->object, uself->start);
Walter Dörwald787b03b2007-06-05 13:29:29 +00001997 const char *fmt;
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001998 if (badchar <= 0xff)
Walter Dörwald32a4c712007-06-20 09:25:34 +00001999 fmt = "can't translate character '\\x%02x' in position %zd: %U";
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00002000 else if (badchar <= 0xffff)
Walter Dörwald32a4c712007-06-20 09:25:34 +00002001 fmt = "can't translate character '\\u%04x' in position %zd: %U";
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00002002 else
Walter Dörwald32a4c712007-06-20 09:25:34 +00002003 fmt = "can't translate character '\\U%08x' in position %zd: %U";
Benjamin Petersonc5f4e1e2010-02-25 01:22:28 +00002004 result = PyUnicode_FromFormat(
Walter Dörwald787b03b2007-06-05 13:29:29 +00002005 fmt,
Victor Stinner53b33e72011-11-21 01:17:27 +01002006 (int)badchar,
Guido van Rossum7eaf8222007-06-18 17:58:50 +00002007 uself->start,
Eric Smith0facd772010-02-24 15:42:29 +00002008 reason_str
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00002009 );
Eric Smith0facd772010-02-24 15:42:29 +00002010 } else {
2011 result = PyUnicode_FromFormat(
2012 "can't translate characters in position %zd-%zd: %U",
2013 uself->start,
2014 uself->end-1,
2015 reason_str
2016 );
Thomas Wouters477c8d52006-05-27 19:21:47 +00002017 }
Eric Smith0facd772010-02-24 15:42:29 +00002018done:
2019 Py_XDECREF(reason_str);
2020 return result;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002021}
2022
2023static PyTypeObject _PyExc_UnicodeTranslateError = {
Martin v. Löwis9f2e3462007-07-21 17:22:18 +00002024 PyVarObject_HEAD_INIT(NULL, 0)
Neal Norwitz2633c692007-02-26 22:22:47 +00002025 "UnicodeTranslateError",
Thomas Wouters477c8d52006-05-27 19:21:47 +00002026 sizeof(PyUnicodeErrorObject), 0,
2027 (destructor)UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2028 (reprfunc)UnicodeTranslateError_str, 0, 0, 0,
2029 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
Thomas Wouters89f507f2006-12-13 04:49:30 +00002030 PyDoc_STR("Unicode translation error."), (traverseproc)UnicodeError_traverse,
Thomas Wouters477c8d52006-05-27 19:21:47 +00002031 (inquiry)UnicodeError_clear, 0, 0, 0, 0, 0, UnicodeError_members,
2032 0, &_PyExc_UnicodeError, 0, 0, 0, offsetof(PyUnicodeErrorObject, dict),
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00002033 (initproc)UnicodeTranslateError_init, 0, BaseException_new,
Thomas Wouters477c8d52006-05-27 19:21:47 +00002034};
2035PyObject *PyExc_UnicodeTranslateError = (PyObject *)&_PyExc_UnicodeTranslateError;
2036
Martin v. Löwisd63a3b82011-09-28 07:41:54 +02002037/* Deprecated. */
Thomas Wouters477c8d52006-05-27 19:21:47 +00002038PyObject *
2039PyUnicodeTranslateError_Create(
2040 const Py_UNICODE *object, Py_ssize_t length,
2041 Py_ssize_t start, Py_ssize_t end, const char *reason)
2042{
2043 return PyObject_CallFunction(PyExc_UnicodeTranslateError, "u#nns",
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00002044 object, length, start, end, reason);
Thomas Wouters477c8d52006-05-27 19:21:47 +00002045}
Thomas Wouters477c8d52006-05-27 19:21:47 +00002046
Martin v. Löwisd63a3b82011-09-28 07:41:54 +02002047PyObject *
2048_PyUnicodeTranslateError_Create(
2049 PyObject *object,
2050 Py_ssize_t start, Py_ssize_t end, const char *reason)
2051{
2052 return PyObject_CallFunction(PyExc_UnicodeTranslateError, "Ons",
2053 object, start, end, reason);
2054}
Thomas Wouters477c8d52006-05-27 19:21:47 +00002055
2056/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00002057 * AssertionError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00002058 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +00002059SimpleExtendsException(PyExc_Exception, AssertionError,
Thomas Wouters477c8d52006-05-27 19:21:47 +00002060 "Assertion failed.");
2061
2062
2063/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00002064 * ArithmeticError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00002065 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +00002066SimpleExtendsException(PyExc_Exception, ArithmeticError,
Thomas Wouters477c8d52006-05-27 19:21:47 +00002067 "Base class for arithmetic errors.");
2068
2069
2070/*
2071 * FloatingPointError extends ArithmeticError
2072 */
2073SimpleExtendsException(PyExc_ArithmeticError, FloatingPointError,
2074 "Floating point operation failed.");
2075
2076
2077/*
2078 * OverflowError extends ArithmeticError
2079 */
2080SimpleExtendsException(PyExc_ArithmeticError, OverflowError,
2081 "Result too large to be represented.");
2082
2083
2084/*
2085 * ZeroDivisionError extends ArithmeticError
2086 */
2087SimpleExtendsException(PyExc_ArithmeticError, ZeroDivisionError,
2088 "Second argument to a division or modulo operation was zero.");
2089
2090
2091/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00002092 * SystemError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00002093 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +00002094SimpleExtendsException(PyExc_Exception, SystemError,
Thomas Wouters477c8d52006-05-27 19:21:47 +00002095 "Internal error in the Python interpreter.\n"
2096 "\n"
2097 "Please report this to the Python maintainer, along with the traceback,\n"
2098 "the Python version, and the hardware/OS platform and version.");
2099
2100
2101/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00002102 * ReferenceError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00002103 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +00002104SimpleExtendsException(PyExc_Exception, ReferenceError,
Thomas Wouters477c8d52006-05-27 19:21:47 +00002105 "Weak ref proxy used after referent went away.");
2106
2107
2108/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00002109 * MemoryError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00002110 */
Antoine Pitrou07e20ef2010-10-28 22:56:58 +00002111
2112#define MEMERRORS_SAVE 16
2113static PyBaseExceptionObject *memerrors_freelist = NULL;
2114static int memerrors_numfree = 0;
2115
2116static PyObject *
2117MemoryError_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
2118{
2119 PyBaseExceptionObject *self;
2120
2121 if (type != (PyTypeObject *) PyExc_MemoryError)
2122 return BaseException_new(type, args, kwds);
2123 if (memerrors_freelist == NULL)
2124 return BaseException_new(type, args, kwds);
2125 /* Fetch object from freelist and revive it */
2126 self = memerrors_freelist;
2127 self->args = PyTuple_New(0);
2128 /* This shouldn't happen since the empty tuple is persistent */
2129 if (self->args == NULL)
2130 return NULL;
2131 memerrors_freelist = (PyBaseExceptionObject *) self->dict;
2132 memerrors_numfree--;
2133 self->dict = NULL;
2134 _Py_NewReference((PyObject *)self);
2135 _PyObject_GC_TRACK(self);
2136 return (PyObject *)self;
2137}
2138
2139static void
2140MemoryError_dealloc(PyBaseExceptionObject *self)
2141{
2142 _PyObject_GC_UNTRACK(self);
2143 BaseException_clear(self);
2144 if (memerrors_numfree >= MEMERRORS_SAVE)
2145 Py_TYPE(self)->tp_free((PyObject *)self);
2146 else {
2147 self->dict = (PyObject *) memerrors_freelist;
2148 memerrors_freelist = self;
2149 memerrors_numfree++;
2150 }
2151}
2152
2153static void
2154preallocate_memerrors(void)
2155{
2156 /* We create enough MemoryErrors and then decref them, which will fill
2157 up the freelist. */
2158 int i;
2159 PyObject *errors[MEMERRORS_SAVE];
2160 for (i = 0; i < MEMERRORS_SAVE; i++) {
2161 errors[i] = MemoryError_new((PyTypeObject *) PyExc_MemoryError,
2162 NULL, NULL);
2163 if (!errors[i])
2164 Py_FatalError("Could not preallocate MemoryError object");
2165 }
2166 for (i = 0; i < MEMERRORS_SAVE; i++) {
2167 Py_DECREF(errors[i]);
2168 }
2169}
2170
2171static void
2172free_preallocated_memerrors(void)
2173{
2174 while (memerrors_freelist != NULL) {
2175 PyObject *self = (PyObject *) memerrors_freelist;
2176 memerrors_freelist = (PyBaseExceptionObject *) memerrors_freelist->dict;
2177 Py_TYPE(self)->tp_free((PyObject *)self);
2178 }
2179}
2180
2181
2182static PyTypeObject _PyExc_MemoryError = {
2183 PyVarObject_HEAD_INIT(NULL, 0)
2184 "MemoryError",
2185 sizeof(PyBaseExceptionObject),
2186 0, (destructor)MemoryError_dealloc, 0, 0, 0, 0, 0, 0, 0,
2187 0, 0, 0, 0, 0, 0, 0,
2188 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
2189 PyDoc_STR("Out of memory."), (traverseproc)BaseException_traverse,
2190 (inquiry)BaseException_clear, 0, 0, 0, 0, 0, 0, 0, &_PyExc_Exception,
2191 0, 0, 0, offsetof(PyBaseExceptionObject, dict),
2192 (initproc)BaseException_init, 0, MemoryError_new
2193};
2194PyObject *PyExc_MemoryError = (PyObject *) &_PyExc_MemoryError;
2195
Thomas Wouters477c8d52006-05-27 19:21:47 +00002196
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00002197/*
2198 * BufferError extends Exception
2199 */
2200SimpleExtendsException(PyExc_Exception, BufferError, "Buffer error.");
2201
Thomas Wouters477c8d52006-05-27 19:21:47 +00002202
2203/* Warning category docstrings */
2204
2205/*
2206 * Warning extends Exception
2207 */
2208SimpleExtendsException(PyExc_Exception, Warning,
2209 "Base class for warning categories.");
2210
2211
2212/*
2213 * UserWarning extends Warning
2214 */
2215SimpleExtendsException(PyExc_Warning, UserWarning,
2216 "Base class for warnings generated by user code.");
2217
2218
2219/*
2220 * DeprecationWarning extends Warning
2221 */
2222SimpleExtendsException(PyExc_Warning, DeprecationWarning,
2223 "Base class for warnings about deprecated features.");
2224
2225
2226/*
2227 * PendingDeprecationWarning extends Warning
2228 */
2229SimpleExtendsException(PyExc_Warning, PendingDeprecationWarning,
2230 "Base class for warnings about features which will be deprecated\n"
2231 "in the future.");
2232
2233
2234/*
2235 * SyntaxWarning extends Warning
2236 */
2237SimpleExtendsException(PyExc_Warning, SyntaxWarning,
2238 "Base class for warnings about dubious syntax.");
2239
2240
2241/*
2242 * RuntimeWarning extends Warning
2243 */
2244SimpleExtendsException(PyExc_Warning, RuntimeWarning,
2245 "Base class for warnings about dubious runtime behavior.");
2246
2247
2248/*
2249 * FutureWarning extends Warning
2250 */
2251SimpleExtendsException(PyExc_Warning, FutureWarning,
2252 "Base class for warnings about constructs that will change semantically\n"
2253 "in the future.");
2254
2255
2256/*
2257 * ImportWarning extends Warning
2258 */
2259SimpleExtendsException(PyExc_Warning, ImportWarning,
2260 "Base class for warnings about probable mistakes in module imports");
2261
2262
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00002263/*
2264 * UnicodeWarning extends Warning
2265 */
2266SimpleExtendsException(PyExc_Warning, UnicodeWarning,
2267 "Base class for warnings about Unicode related problems, mostly\n"
2268 "related to conversion problems.");
2269
Georg Brandl08be72d2010-10-24 15:11:22 +00002270
Guido van Rossum98297ee2007-11-06 21:34:58 +00002271/*
2272 * BytesWarning extends Warning
2273 */
2274SimpleExtendsException(PyExc_Warning, BytesWarning,
2275 "Base class for warnings about bytes and buffer related problems, mostly\n"
2276 "related to conversion from str or comparing to str.");
2277
2278
Georg Brandl08be72d2010-10-24 15:11:22 +00002279/*
2280 * ResourceWarning extends Warning
2281 */
2282SimpleExtendsException(PyExc_Warning, ResourceWarning,
2283 "Base class for warnings about resource usage.");
2284
2285
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00002286
Thomas Wouters89d996e2007-09-08 17:39:28 +00002287/* Pre-computed RuntimeError instance for when recursion depth is reached.
2288 Meant to be used when normalizing the exception for exceeding the recursion
2289 depth will cause its own infinite recursion.
2290*/
2291PyObject *PyExc_RecursionErrorInst = NULL;
2292
Antoine Pitrou55f217f2012-01-18 21:23:13 +01002293#define PRE_INIT(TYPE) \
2294 if (!(_PyExc_ ## TYPE.tp_flags & Py_TPFLAGS_READY)) { \
2295 if (PyType_Ready(&_PyExc_ ## TYPE) < 0) \
2296 Py_FatalError("exceptions bootstrapping error."); \
2297 Py_INCREF(PyExc_ ## TYPE); \
2298 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002299
Antoine Pitrou55f217f2012-01-18 21:23:13 +01002300#define POST_INIT(TYPE) \
Thomas Wouters477c8d52006-05-27 19:21:47 +00002301 if (PyDict_SetItemString(bdict, # TYPE, PyExc_ ## TYPE)) \
2302 Py_FatalError("Module dictionary insertion problem.");
2303
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002304#define INIT_ALIAS(NAME, TYPE) Py_INCREF(PyExc_ ## TYPE); \
Antoine Pitrou8b0a74e2012-01-18 21:29:05 +01002305 Py_XDECREF(PyExc_ ## NAME); \
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002306 PyExc_ ## NAME = PyExc_ ## TYPE; \
2307 if (PyDict_SetItemString(bdict, # NAME, PyExc_ ## NAME)) \
2308 Py_FatalError("Module dictionary insertion problem.");
2309
2310#define ADD_ERRNO(TYPE, CODE) { \
2311 PyObject *_code = PyLong_FromLong(CODE); \
2312 assert(_PyObject_RealIsSubclass(PyExc_ ## TYPE, PyExc_OSError)); \
2313 if (!_code || PyDict_SetItem(errnomap, _code, PyExc_ ## TYPE)) \
2314 Py_FatalError("errmap insertion problem."); \
Antoine Pitrou8b0a74e2012-01-18 21:29:05 +01002315 Py_DECREF(_code); \
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002316 }
2317
2318#ifdef MS_WINDOWS
2319#include <Winsock2.h>
Brian Curtin401f9f32012-05-13 11:19:23 -05002320/* The following constants were added to errno.h in VS2010 but have
2321 preferred WSA equivalents. */
2322#undef EADDRINUSE
2323#undef EADDRNOTAVAIL
2324#undef EAFNOSUPPORT
2325#undef EALREADY
2326#undef ECONNABORTED
2327#undef ECONNREFUSED
2328#undef ECONNRESET
2329#undef EDESTADDRREQ
2330#undef EHOSTUNREACH
2331#undef EINPROGRESS
2332#undef EISCONN
2333#undef ELOOP
2334#undef EMSGSIZE
2335#undef ENETDOWN
2336#undef ENETRESET
2337#undef ENETUNREACH
2338#undef ENOBUFS
2339#undef ENOPROTOOPT
2340#undef ENOTCONN
2341#undef ENOTSOCK
2342#undef EOPNOTSUPP
2343#undef EPROTONOSUPPORT
2344#undef EPROTOTYPE
2345#undef ETIMEDOUT
2346#undef EWOULDBLOCK
2347
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002348#if defined(WSAEALREADY) && !defined(EALREADY)
2349#define EALREADY WSAEALREADY
2350#endif
2351#if defined(WSAECONNABORTED) && !defined(ECONNABORTED)
2352#define ECONNABORTED WSAECONNABORTED
2353#endif
2354#if defined(WSAECONNREFUSED) && !defined(ECONNREFUSED)
2355#define ECONNREFUSED WSAECONNREFUSED
2356#endif
2357#if defined(WSAECONNRESET) && !defined(ECONNRESET)
2358#define ECONNRESET WSAECONNRESET
2359#endif
2360#if defined(WSAEINPROGRESS) && !defined(EINPROGRESS)
2361#define EINPROGRESS WSAEINPROGRESS
2362#endif
2363#if defined(WSAESHUTDOWN) && !defined(ESHUTDOWN)
2364#define ESHUTDOWN WSAESHUTDOWN
2365#endif
2366#if defined(WSAETIMEDOUT) && !defined(ETIMEDOUT)
2367#define ETIMEDOUT WSAETIMEDOUT
2368#endif
2369#if defined(WSAEWOULDBLOCK) && !defined(EWOULDBLOCK)
2370#define EWOULDBLOCK WSAEWOULDBLOCK
2371#endif
2372#endif /* MS_WINDOWS */
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002373
Martin v. Löwis1a214512008-06-11 05:26:20 +00002374void
Brett Cannonfd074152012-04-14 14:10:13 -04002375_PyExc_Init(PyObject *bltinmod)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002376{
Brett Cannonfd074152012-04-14 14:10:13 -04002377 PyObject *bdict;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002378
2379 PRE_INIT(BaseException)
2380 PRE_INIT(Exception)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002381 PRE_INIT(TypeError)
2382 PRE_INIT(StopIteration)
2383 PRE_INIT(GeneratorExit)
2384 PRE_INIT(SystemExit)
2385 PRE_INIT(KeyboardInterrupt)
2386 PRE_INIT(ImportError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002387 PRE_INIT(OSError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002388 PRE_INIT(EOFError)
2389 PRE_INIT(RuntimeError)
2390 PRE_INIT(NotImplementedError)
2391 PRE_INIT(NameError)
2392 PRE_INIT(UnboundLocalError)
2393 PRE_INIT(AttributeError)
2394 PRE_INIT(SyntaxError)
2395 PRE_INIT(IndentationError)
2396 PRE_INIT(TabError)
2397 PRE_INIT(LookupError)
2398 PRE_INIT(IndexError)
2399 PRE_INIT(KeyError)
2400 PRE_INIT(ValueError)
2401 PRE_INIT(UnicodeError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002402 PRE_INIT(UnicodeEncodeError)
2403 PRE_INIT(UnicodeDecodeError)
2404 PRE_INIT(UnicodeTranslateError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002405 PRE_INIT(AssertionError)
2406 PRE_INIT(ArithmeticError)
2407 PRE_INIT(FloatingPointError)
2408 PRE_INIT(OverflowError)
2409 PRE_INIT(ZeroDivisionError)
2410 PRE_INIT(SystemError)
2411 PRE_INIT(ReferenceError)
Neal Norwitzfaa54a32007-08-19 04:23:20 +00002412 PRE_INIT(BufferError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002413 PRE_INIT(MemoryError)
Benjamin Peterson2b968d62008-07-05 23:38:30 +00002414 PRE_INIT(BufferError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002415 PRE_INIT(Warning)
2416 PRE_INIT(UserWarning)
2417 PRE_INIT(DeprecationWarning)
2418 PRE_INIT(PendingDeprecationWarning)
2419 PRE_INIT(SyntaxWarning)
2420 PRE_INIT(RuntimeWarning)
2421 PRE_INIT(FutureWarning)
2422 PRE_INIT(ImportWarning)
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00002423 PRE_INIT(UnicodeWarning)
Guido van Rossum98297ee2007-11-06 21:34:58 +00002424 PRE_INIT(BytesWarning)
Georg Brandl08be72d2010-10-24 15:11:22 +00002425 PRE_INIT(ResourceWarning)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002426
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002427 /* OSError subclasses */
2428 PRE_INIT(ConnectionError);
2429
2430 PRE_INIT(BlockingIOError);
2431 PRE_INIT(BrokenPipeError);
2432 PRE_INIT(ChildProcessError);
2433 PRE_INIT(ConnectionAbortedError);
2434 PRE_INIT(ConnectionRefusedError);
2435 PRE_INIT(ConnectionResetError);
2436 PRE_INIT(FileExistsError);
2437 PRE_INIT(FileNotFoundError);
2438 PRE_INIT(IsADirectoryError);
2439 PRE_INIT(NotADirectoryError);
2440 PRE_INIT(InterruptedError);
2441 PRE_INIT(PermissionError);
2442 PRE_INIT(ProcessLookupError);
2443 PRE_INIT(TimeoutError);
2444
Thomas Wouters477c8d52006-05-27 19:21:47 +00002445 bdict = PyModule_GetDict(bltinmod);
2446 if (bdict == NULL)
2447 Py_FatalError("exceptions bootstrapping error.");
2448
2449 POST_INIT(BaseException)
2450 POST_INIT(Exception)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002451 POST_INIT(TypeError)
2452 POST_INIT(StopIteration)
2453 POST_INIT(GeneratorExit)
2454 POST_INIT(SystemExit)
2455 POST_INIT(KeyboardInterrupt)
2456 POST_INIT(ImportError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002457 POST_INIT(OSError)
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002458 INIT_ALIAS(EnvironmentError, OSError)
2459 INIT_ALIAS(IOError, OSError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002460#ifdef MS_WINDOWS
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002461 INIT_ALIAS(WindowsError, OSError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002462#endif
2463#ifdef __VMS
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002464 INIT_ALIAS(VMSError, OSError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002465#endif
2466 POST_INIT(EOFError)
2467 POST_INIT(RuntimeError)
2468 POST_INIT(NotImplementedError)
2469 POST_INIT(NameError)
2470 POST_INIT(UnboundLocalError)
2471 POST_INIT(AttributeError)
2472 POST_INIT(SyntaxError)
2473 POST_INIT(IndentationError)
2474 POST_INIT(TabError)
2475 POST_INIT(LookupError)
2476 POST_INIT(IndexError)
2477 POST_INIT(KeyError)
2478 POST_INIT(ValueError)
2479 POST_INIT(UnicodeError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002480 POST_INIT(UnicodeEncodeError)
2481 POST_INIT(UnicodeDecodeError)
2482 POST_INIT(UnicodeTranslateError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002483 POST_INIT(AssertionError)
2484 POST_INIT(ArithmeticError)
2485 POST_INIT(FloatingPointError)
2486 POST_INIT(OverflowError)
2487 POST_INIT(ZeroDivisionError)
2488 POST_INIT(SystemError)
2489 POST_INIT(ReferenceError)
Neal Norwitzfaa54a32007-08-19 04:23:20 +00002490 POST_INIT(BufferError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002491 POST_INIT(MemoryError)
Benjamin Peterson2b968d62008-07-05 23:38:30 +00002492 POST_INIT(BufferError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002493 POST_INIT(Warning)
2494 POST_INIT(UserWarning)
2495 POST_INIT(DeprecationWarning)
2496 POST_INIT(PendingDeprecationWarning)
2497 POST_INIT(SyntaxWarning)
2498 POST_INIT(RuntimeWarning)
2499 POST_INIT(FutureWarning)
2500 POST_INIT(ImportWarning)
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00002501 POST_INIT(UnicodeWarning)
Guido van Rossum98297ee2007-11-06 21:34:58 +00002502 POST_INIT(BytesWarning)
Georg Brandl08be72d2010-10-24 15:11:22 +00002503 POST_INIT(ResourceWarning)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002504
Antoine Pitrouac456a12012-01-18 21:35:21 +01002505 if (!errnomap) {
2506 errnomap = PyDict_New();
2507 if (!errnomap)
2508 Py_FatalError("Cannot allocate map from errnos to OSError subclasses");
2509 }
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002510
2511 /* OSError subclasses */
2512 POST_INIT(ConnectionError);
2513
2514 POST_INIT(BlockingIOError);
2515 ADD_ERRNO(BlockingIOError, EAGAIN);
2516 ADD_ERRNO(BlockingIOError, EALREADY);
2517 ADD_ERRNO(BlockingIOError, EINPROGRESS);
2518 ADD_ERRNO(BlockingIOError, EWOULDBLOCK);
2519 POST_INIT(BrokenPipeError);
2520 ADD_ERRNO(BrokenPipeError, EPIPE);
2521 ADD_ERRNO(BrokenPipeError, ESHUTDOWN);
2522 POST_INIT(ChildProcessError);
2523 ADD_ERRNO(ChildProcessError, ECHILD);
2524 POST_INIT(ConnectionAbortedError);
2525 ADD_ERRNO(ConnectionAbortedError, ECONNABORTED);
2526 POST_INIT(ConnectionRefusedError);
2527 ADD_ERRNO(ConnectionRefusedError, ECONNREFUSED);
2528 POST_INIT(ConnectionResetError);
2529 ADD_ERRNO(ConnectionResetError, ECONNRESET);
2530 POST_INIT(FileExistsError);
2531 ADD_ERRNO(FileExistsError, EEXIST);
2532 POST_INIT(FileNotFoundError);
2533 ADD_ERRNO(FileNotFoundError, ENOENT);
2534 POST_INIT(IsADirectoryError);
2535 ADD_ERRNO(IsADirectoryError, EISDIR);
2536 POST_INIT(NotADirectoryError);
2537 ADD_ERRNO(NotADirectoryError, ENOTDIR);
2538 POST_INIT(InterruptedError);
2539 ADD_ERRNO(InterruptedError, EINTR);
2540 POST_INIT(PermissionError);
2541 ADD_ERRNO(PermissionError, EACCES);
2542 ADD_ERRNO(PermissionError, EPERM);
2543 POST_INIT(ProcessLookupError);
2544 ADD_ERRNO(ProcessLookupError, ESRCH);
2545 POST_INIT(TimeoutError);
2546 ADD_ERRNO(TimeoutError, ETIMEDOUT);
2547
Antoine Pitrou07e20ef2010-10-28 22:56:58 +00002548 preallocate_memerrors();
Thomas Wouters477c8d52006-05-27 19:21:47 +00002549
Antoine Pitrou1c7ade52012-01-18 16:13:31 +01002550 if (!PyExc_RecursionErrorInst) {
2551 PyExc_RecursionErrorInst = BaseException_new(&_PyExc_RuntimeError, NULL, NULL);
2552 if (!PyExc_RecursionErrorInst)
2553 Py_FatalError("Cannot pre-allocate RuntimeError instance for "
2554 "recursion errors");
2555 else {
2556 PyBaseExceptionObject *err_inst =
2557 (PyBaseExceptionObject *)PyExc_RecursionErrorInst;
2558 PyObject *args_tuple;
2559 PyObject *exc_message;
2560 exc_message = PyUnicode_FromString("maximum recursion depth exceeded");
2561 if (!exc_message)
2562 Py_FatalError("cannot allocate argument for RuntimeError "
2563 "pre-allocation");
2564 args_tuple = PyTuple_Pack(1, exc_message);
2565 if (!args_tuple)
2566 Py_FatalError("cannot allocate tuple for RuntimeError "
2567 "pre-allocation");
2568 Py_DECREF(exc_message);
2569 if (BaseException_init(err_inst, args_tuple, NULL))
2570 Py_FatalError("init of pre-allocated RuntimeError failed");
2571 Py_DECREF(args_tuple);
2572 }
Thomas Wouters89d996e2007-09-08 17:39:28 +00002573 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002574}
2575
2576void
2577_PyExc_Fini(void)
2578{
Benjamin Peterson78565b22009-06-28 19:19:51 +00002579 Py_CLEAR(PyExc_RecursionErrorInst);
Antoine Pitrou07e20ef2010-10-28 22:56:58 +00002580 free_preallocated_memerrors();
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002581 Py_CLEAR(errnomap);
Thomas Wouters477c8d52006-05-27 19:21:47 +00002582}