blob: 23f6605e3fa56d3802b10b60cb3c2f3392cc6d29 [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;
Benjamin Petersond5a1c442012-05-14 22:09:31 -070045 self->suppress_context = 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +000046
Richard Oudkerk5562d9d2012-07-28 17:45:28 +010047 if (args) {
48 self->args = args;
49 Py_INCREF(args);
50 return (PyObject *)self;
51 }
52
Thomas Wouters477c8d52006-05-27 19:21:47 +000053 self->args = PyTuple_New(0);
54 if (!self->args) {
55 Py_DECREF(self);
56 return NULL;
57 }
58
Thomas Wouters477c8d52006-05-27 19:21:47 +000059 return (PyObject *)self;
60}
61
62static int
63BaseException_init(PyBaseExceptionObject *self, PyObject *args, PyObject *kwds)
64{
Richard Oudkerk5562d9d2012-07-28 17:45:28 +010065 PyObject *tmp;
66
Christian Heimes90aa7642007-12-19 02:45:37 +000067 if (!_PyArg_NoKeywords(Py_TYPE(self)->tp_name, kwds))
Thomas Wouters4d70c3d2006-06-08 14:42:34 +000068 return -1;
69
Richard Oudkerk5562d9d2012-07-28 17:45:28 +010070 tmp = self->args;
Thomas Wouters477c8d52006-05-27 19:21:47 +000071 self->args = args;
72 Py_INCREF(self->args);
Richard Oudkerk5562d9d2012-07-28 17:45:28 +010073 Py_XDECREF(tmp);
Thomas Wouters477c8d52006-05-27 19:21:47 +000074
Thomas Wouters477c8d52006-05-27 19:21:47 +000075 return 0;
76}
77
Thomas Wouters4d70c3d2006-06-08 14:42:34 +000078static int
Thomas Wouters477c8d52006-05-27 19:21:47 +000079BaseException_clear(PyBaseExceptionObject *self)
80{
81 Py_CLEAR(self->dict);
82 Py_CLEAR(self->args);
Collin Winter828f04a2007-08-31 00:04:24 +000083 Py_CLEAR(self->traceback);
Collin Winter1966f1c2007-09-01 20:26:44 +000084 Py_CLEAR(self->cause);
85 Py_CLEAR(self->context);
Thomas Wouters477c8d52006-05-27 19:21:47 +000086 return 0;
87}
88
89static void
90BaseException_dealloc(PyBaseExceptionObject *self)
91{
Thomas Wouters89f507f2006-12-13 04:49:30 +000092 _PyObject_GC_UNTRACK(self);
Thomas Wouters477c8d52006-05-27 19:21:47 +000093 BaseException_clear(self);
Christian Heimes90aa7642007-12-19 02:45:37 +000094 Py_TYPE(self)->tp_free((PyObject *)self);
Thomas Wouters477c8d52006-05-27 19:21:47 +000095}
96
Thomas Wouters4d70c3d2006-06-08 14:42:34 +000097static int
Thomas Wouters477c8d52006-05-27 19:21:47 +000098BaseException_traverse(PyBaseExceptionObject *self, visitproc visit, void *arg)
99{
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000100 Py_VISIT(self->dict);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000101 Py_VISIT(self->args);
Collin Winter828f04a2007-08-31 00:04:24 +0000102 Py_VISIT(self->traceback);
Collin Winter1966f1c2007-09-01 20:26:44 +0000103 Py_VISIT(self->cause);
104 Py_VISIT(self->context);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000105 return 0;
106}
107
108static PyObject *
109BaseException_str(PyBaseExceptionObject *self)
110{
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000111 switch (PyTuple_GET_SIZE(self->args)) {
Thomas Wouters477c8d52006-05-27 19:21:47 +0000112 case 0:
Walter Dörwaldf5bec7c2007-05-26 15:03:32 +0000113 return PyUnicode_FromString("");
Thomas Wouters477c8d52006-05-27 19:21:47 +0000114 case 1:
Thomas Heller519a0422007-11-15 20:48:54 +0000115 return PyObject_Str(PyTuple_GET_ITEM(self->args, 0));
Thomas Wouters477c8d52006-05-27 19:21:47 +0000116 default:
Thomas Heller519a0422007-11-15 20:48:54 +0000117 return PyObject_Str(self->args);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000118 }
Thomas Wouters477c8d52006-05-27 19:21:47 +0000119}
120
121static PyObject *
122BaseException_repr(PyBaseExceptionObject *self)
123{
Thomas Wouters477c8d52006-05-27 19:21:47 +0000124 char *name;
125 char *dot;
126
Christian Heimes90aa7642007-12-19 02:45:37 +0000127 name = (char *)Py_TYPE(self)->tp_name;
Thomas Wouters477c8d52006-05-27 19:21:47 +0000128 dot = strrchr(name, '.');
129 if (dot != NULL) name = dot+1;
130
Walter Dörwald7569dfe2007-05-19 21:49:49 +0000131 return PyUnicode_FromFormat("%s%R", name, self->args);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000132}
133
134/* Pickling support */
135static PyObject *
136BaseException_reduce(PyBaseExceptionObject *self)
137{
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000138 if (self->args && self->dict)
Christian Heimes90aa7642007-12-19 02:45:37 +0000139 return PyTuple_Pack(3, Py_TYPE(self), self->args, self->dict);
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000140 else
Christian Heimes90aa7642007-12-19 02:45:37 +0000141 return PyTuple_Pack(2, Py_TYPE(self), self->args);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000142}
143
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000144/*
145 * Needed for backward compatibility, since exceptions used to store
146 * all their attributes in the __dict__. Code is taken from cPickle's
147 * load_build function.
148 */
149static PyObject *
150BaseException_setstate(PyObject *self, PyObject *state)
151{
152 PyObject *d_key, *d_value;
153 Py_ssize_t i = 0;
154
155 if (state != Py_None) {
156 if (!PyDict_Check(state)) {
157 PyErr_SetString(PyExc_TypeError, "state is not a dictionary");
158 return NULL;
159 }
160 while (PyDict_Next(state, &i, &d_key, &d_value)) {
161 if (PyObject_SetAttr(self, d_key, d_value) < 0)
162 return NULL;
163 }
164 }
165 Py_RETURN_NONE;
166}
Thomas Wouters477c8d52006-05-27 19:21:47 +0000167
Collin Winter828f04a2007-08-31 00:04:24 +0000168static PyObject *
169BaseException_with_traceback(PyObject *self, PyObject *tb) {
170 if (PyException_SetTraceback(self, tb))
171 return NULL;
172
173 Py_INCREF(self);
174 return self;
175}
176
Georg Brandl76941002008-05-05 21:38:47 +0000177PyDoc_STRVAR(with_traceback_doc,
178"Exception.with_traceback(tb) --\n\
179 set self.__traceback__ to tb and return self.");
180
Thomas Wouters477c8d52006-05-27 19:21:47 +0000181
182static PyMethodDef BaseException_methods[] = {
183 {"__reduce__", (PyCFunction)BaseException_reduce, METH_NOARGS },
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000184 {"__setstate__", (PyCFunction)BaseException_setstate, METH_O },
Georg Brandl76941002008-05-05 21:38:47 +0000185 {"with_traceback", (PyCFunction)BaseException_with_traceback, METH_O,
186 with_traceback_doc},
Thomas Wouters477c8d52006-05-27 19:21:47 +0000187 {NULL, NULL, 0, NULL},
188};
189
Thomas Wouters477c8d52006-05-27 19:21:47 +0000190static PyObject *
191BaseException_get_args(PyBaseExceptionObject *self)
192{
193 if (self->args == NULL) {
194 Py_INCREF(Py_None);
195 return Py_None;
196 }
197 Py_INCREF(self->args);
198 return self->args;
199}
200
201static int
202BaseException_set_args(PyBaseExceptionObject *self, PyObject *val)
203{
204 PyObject *seq;
205 if (val == NULL) {
206 PyErr_SetString(PyExc_TypeError, "args may not be deleted");
207 return -1;
208 }
209 seq = PySequence_Tuple(val);
Benjamin Peterson90b13582012-02-03 19:22:31 -0500210 if (!seq)
211 return -1;
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000212 Py_CLEAR(self->args);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000213 self->args = seq;
214 return 0;
215}
216
Collin Winter828f04a2007-08-31 00:04:24 +0000217static PyObject *
218BaseException_get_tb(PyBaseExceptionObject *self)
219{
220 if (self->traceback == NULL) {
221 Py_INCREF(Py_None);
222 return Py_None;
223 }
224 Py_INCREF(self->traceback);
225 return self->traceback;
226}
227
228static int
229BaseException_set_tb(PyBaseExceptionObject *self, PyObject *tb)
230{
231 if (tb == NULL) {
232 PyErr_SetString(PyExc_TypeError, "__traceback__ may not be deleted");
233 return -1;
234 }
235 else if (!(tb == Py_None || PyTraceBack_Check(tb))) {
236 PyErr_SetString(PyExc_TypeError,
237 "__traceback__ must be a traceback or None");
238 return -1;
239 }
240
241 Py_XINCREF(tb);
242 Py_XDECREF(self->traceback);
243 self->traceback = tb;
244 return 0;
245}
246
Georg Brandlab6f2f62009-03-31 04:16:10 +0000247static PyObject *
248BaseException_get_context(PyObject *self) {
249 PyObject *res = PyException_GetContext(self);
Benjamin Peterson90b13582012-02-03 19:22:31 -0500250 if (res)
251 return res; /* new reference already returned above */
Georg Brandlab6f2f62009-03-31 04:16:10 +0000252 Py_RETURN_NONE;
253}
254
255static int
256BaseException_set_context(PyObject *self, PyObject *arg) {
257 if (arg == NULL) {
258 PyErr_SetString(PyExc_TypeError, "__context__ may not be deleted");
259 return -1;
260 } else if (arg == Py_None) {
261 arg = NULL;
262 } else if (!PyExceptionInstance_Check(arg)) {
263 PyErr_SetString(PyExc_TypeError, "exception context must be None "
264 "or derive from BaseException");
265 return -1;
266 } else {
267 /* PyException_SetContext steals this reference */
268 Py_INCREF(arg);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000269 }
Georg Brandlab6f2f62009-03-31 04:16:10 +0000270 PyException_SetContext(self, arg);
271 return 0;
272}
273
274static PyObject *
275BaseException_get_cause(PyObject *self) {
276 PyObject *res = PyException_GetCause(self);
Benjamin Peterson90b13582012-02-03 19:22:31 -0500277 if (res)
278 return res; /* new reference already returned above */
Benjamin Petersond5a1c442012-05-14 22:09:31 -0700279 Py_RETURN_NONE;
Georg Brandlab6f2f62009-03-31 04:16:10 +0000280}
281
282static int
283BaseException_set_cause(PyObject *self, PyObject *arg) {
284 if (arg == NULL) {
285 PyErr_SetString(PyExc_TypeError, "__cause__ may not be deleted");
286 return -1;
Benjamin Petersond5a1c442012-05-14 22:09:31 -0700287 } else if (arg == Py_None) {
288 arg = NULL;
289 } else if (!PyExceptionInstance_Check(arg)) {
290 PyErr_SetString(PyExc_TypeError, "exception cause must be None "
291 "or derive from BaseException");
292 return -1;
293 } else {
294 /* PyException_SetCause steals this reference */
295 Py_INCREF(arg);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000296 }
Benjamin Petersond5a1c442012-05-14 22:09:31 -0700297 PyException_SetCause(self, arg);
298 return 0;
Georg Brandlab6f2f62009-03-31 04:16:10 +0000299}
300
Guido van Rossum360e4b82007-05-14 22:51:27 +0000301
Thomas Wouters477c8d52006-05-27 19:21:47 +0000302static PyGetSetDef BaseException_getset[] = {
Benjamin Peterson23d7f122012-02-19 20:02:57 -0500303 {"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict},
Thomas Wouters477c8d52006-05-27 19:21:47 +0000304 {"args", (getter)BaseException_get_args, (setter)BaseException_set_args},
Collin Winter828f04a2007-08-31 00:04:24 +0000305 {"__traceback__", (getter)BaseException_get_tb, (setter)BaseException_set_tb},
Georg Brandlab6f2f62009-03-31 04:16:10 +0000306 {"__context__", (getter)BaseException_get_context,
307 (setter)BaseException_set_context, PyDoc_STR("exception context")},
308 {"__cause__", (getter)BaseException_get_cause,
309 (setter)BaseException_set_cause, PyDoc_STR("exception cause")},
Thomas Wouters477c8d52006-05-27 19:21:47 +0000310 {NULL},
311};
312
313
Collin Winter828f04a2007-08-31 00:04:24 +0000314PyObject *
315PyException_GetTraceback(PyObject *self) {
316 PyBaseExceptionObject *base_self = (PyBaseExceptionObject *)self;
317 Py_XINCREF(base_self->traceback);
318 return base_self->traceback;
319}
320
321
322int
323PyException_SetTraceback(PyObject *self, PyObject *tb) {
324 return BaseException_set_tb((PyBaseExceptionObject *)self, tb);
325}
326
327PyObject *
328PyException_GetCause(PyObject *self) {
329 PyObject *cause = ((PyBaseExceptionObject *)self)->cause;
330 Py_XINCREF(cause);
331 return cause;
332}
333
334/* Steals a reference to cause */
335void
336PyException_SetCause(PyObject *self, PyObject *cause) {
337 PyObject *old_cause = ((PyBaseExceptionObject *)self)->cause;
338 ((PyBaseExceptionObject *)self)->cause = cause;
Benjamin Petersond5a1c442012-05-14 22:09:31 -0700339 ((PyBaseExceptionObject *)self)->suppress_context = 1;
Collin Winter828f04a2007-08-31 00:04:24 +0000340 Py_XDECREF(old_cause);
341}
342
343PyObject *
344PyException_GetContext(PyObject *self) {
345 PyObject *context = ((PyBaseExceptionObject *)self)->context;
346 Py_XINCREF(context);
347 return context;
348}
349
350/* Steals a reference to context */
351void
352PyException_SetContext(PyObject *self, PyObject *context) {
353 PyObject *old_context = ((PyBaseExceptionObject *)self)->context;
354 ((PyBaseExceptionObject *)self)->context = context;
355 Py_XDECREF(old_context);
356}
357
358
Benjamin Petersond5a1c442012-05-14 22:09:31 -0700359static struct PyMemberDef BaseException_members[] = {
360 {"__suppress_context__", T_BOOL,
Antoine Pitrou32bc80c2012-05-16 12:51:55 +0200361 offsetof(PyBaseExceptionObject, suppress_context)},
362 {NULL}
Benjamin Petersond5a1c442012-05-14 22:09:31 -0700363};
364
365
Thomas Wouters477c8d52006-05-27 19:21:47 +0000366static PyTypeObject _PyExc_BaseException = {
Martin v. Löwis9f2e3462007-07-21 17:22:18 +0000367 PyVarObject_HEAD_INIT(NULL, 0)
Neal Norwitz2633c692007-02-26 22:22:47 +0000368 "BaseException", /*tp_name*/
Thomas Wouters477c8d52006-05-27 19:21:47 +0000369 sizeof(PyBaseExceptionObject), /*tp_basicsize*/
370 0, /*tp_itemsize*/
371 (destructor)BaseException_dealloc, /*tp_dealloc*/
372 0, /*tp_print*/
373 0, /*tp_getattr*/
374 0, /*tp_setattr*/
Mark Dickinsone94c6792009-02-02 20:36:42 +0000375 0, /* tp_reserved; */
Thomas Wouters477c8d52006-05-27 19:21:47 +0000376 (reprfunc)BaseException_repr, /*tp_repr*/
377 0, /*tp_as_number*/
Brett Cannonba7bf492007-02-27 00:15:55 +0000378 0, /*tp_as_sequence*/
Thomas Wouters477c8d52006-05-27 19:21:47 +0000379 0, /*tp_as_mapping*/
380 0, /*tp_hash */
381 0, /*tp_call*/
382 (reprfunc)BaseException_str, /*tp_str*/
383 PyObject_GenericGetAttr, /*tp_getattro*/
384 PyObject_GenericSetAttr, /*tp_setattro*/
385 0, /*tp_as_buffer*/
Thomas Wouters27d517b2007-02-25 20:39:11 +0000386 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC |
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000387 Py_TPFLAGS_BASE_EXC_SUBCLASS, /*tp_flags*/
Thomas Wouters477c8d52006-05-27 19:21:47 +0000388 PyDoc_STR("Common base class for all exceptions"), /* tp_doc */
389 (traverseproc)BaseException_traverse, /* tp_traverse */
390 (inquiry)BaseException_clear, /* tp_clear */
391 0, /* tp_richcompare */
392 0, /* tp_weaklistoffset */
393 0, /* tp_iter */
394 0, /* tp_iternext */
395 BaseException_methods, /* tp_methods */
Benjamin Petersond5a1c442012-05-14 22:09:31 -0700396 BaseException_members, /* tp_members */
Thomas Wouters477c8d52006-05-27 19:21:47 +0000397 BaseException_getset, /* tp_getset */
398 0, /* tp_base */
399 0, /* tp_dict */
400 0, /* tp_descr_get */
401 0, /* tp_descr_set */
402 offsetof(PyBaseExceptionObject, dict), /* tp_dictoffset */
403 (initproc)BaseException_init, /* tp_init */
404 0, /* tp_alloc */
405 BaseException_new, /* tp_new */
406};
407/* the CPython API expects exceptions to be (PyObject *) - both a hold-over
408from the previous implmentation and also allowing Python objects to be used
409in the API */
410PyObject *PyExc_BaseException = (PyObject *)&_PyExc_BaseException;
411
412/* note these macros omit the last semicolon so the macro invocation may
413 * include it and not look strange.
414 */
415#define SimpleExtendsException(EXCBASE, EXCNAME, EXCDOC) \
416static PyTypeObject _PyExc_ ## EXCNAME = { \
Martin v. Löwis9f2e3462007-07-21 17:22:18 +0000417 PyVarObject_HEAD_INIT(NULL, 0) \
Neal Norwitz2633c692007-02-26 22:22:47 +0000418 # EXCNAME, \
Thomas Wouters477c8d52006-05-27 19:21:47 +0000419 sizeof(PyBaseExceptionObject), \
420 0, (destructor)BaseException_dealloc, 0, 0, 0, 0, 0, 0, 0, \
421 0, 0, 0, 0, 0, 0, 0, \
422 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \
423 PyDoc_STR(EXCDOC), (traverseproc)BaseException_traverse, \
424 (inquiry)BaseException_clear, 0, 0, 0, 0, 0, 0, 0, &_ ## EXCBASE, \
425 0, 0, 0, offsetof(PyBaseExceptionObject, dict), \
426 (initproc)BaseException_init, 0, BaseException_new,\
427}; \
428PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME
429
430#define MiddlingExtendsException(EXCBASE, EXCNAME, EXCSTORE, EXCDOC) \
431static PyTypeObject _PyExc_ ## EXCNAME = { \
Martin v. Löwis9f2e3462007-07-21 17:22:18 +0000432 PyVarObject_HEAD_INIT(NULL, 0) \
Neal Norwitz2633c692007-02-26 22:22:47 +0000433 # EXCNAME, \
Thomas Wouters477c8d52006-05-27 19:21:47 +0000434 sizeof(Py ## EXCSTORE ## Object), \
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000435 0, (destructor)EXCSTORE ## _dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
Thomas Wouters477c8d52006-05-27 19:21:47 +0000436 0, 0, 0, 0, 0, \
437 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000438 PyDoc_STR(EXCDOC), (traverseproc)EXCSTORE ## _traverse, \
439 (inquiry)EXCSTORE ## _clear, 0, 0, 0, 0, 0, 0, 0, &_ ## EXCBASE, \
Thomas Wouters477c8d52006-05-27 19:21:47 +0000440 0, 0, 0, offsetof(Py ## EXCSTORE ## Object, dict), \
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200441 (initproc)EXCSTORE ## _init, 0, 0, \
Thomas Wouters477c8d52006-05-27 19:21:47 +0000442}; \
443PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME
444
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200445#define ComplexExtendsException(EXCBASE, EXCNAME, EXCSTORE, EXCNEW, \
446 EXCMETHODS, EXCMEMBERS, EXCGETSET, \
447 EXCSTR, EXCDOC) \
Thomas Wouters477c8d52006-05-27 19:21:47 +0000448static PyTypeObject _PyExc_ ## EXCNAME = { \
Martin v. Löwis9f2e3462007-07-21 17:22:18 +0000449 PyVarObject_HEAD_INIT(NULL, 0) \
Neal Norwitz2633c692007-02-26 22:22:47 +0000450 # EXCNAME, \
Thomas Wouters477c8d52006-05-27 19:21:47 +0000451 sizeof(Py ## EXCSTORE ## Object), 0, \
452 (destructor)EXCSTORE ## _dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
453 (reprfunc)EXCSTR, 0, 0, 0, \
454 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \
455 PyDoc_STR(EXCDOC), (traverseproc)EXCSTORE ## _traverse, \
456 (inquiry)EXCSTORE ## _clear, 0, 0, 0, 0, EXCMETHODS, \
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200457 EXCMEMBERS, EXCGETSET, &_ ## EXCBASE, \
Thomas Wouters477c8d52006-05-27 19:21:47 +0000458 0, 0, 0, offsetof(Py ## EXCSTORE ## Object, dict), \
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200459 (initproc)EXCSTORE ## _init, 0, EXCNEW,\
Thomas Wouters477c8d52006-05-27 19:21:47 +0000460}; \
461PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME
462
463
464/*
465 * Exception extends BaseException
466 */
467SimpleExtendsException(PyExc_BaseException, Exception,
468 "Common base class for all non-exit exceptions.");
469
470
471/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +0000472 * TypeError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +0000473 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +0000474SimpleExtendsException(PyExc_Exception, TypeError,
Thomas Wouters477c8d52006-05-27 19:21:47 +0000475 "Inappropriate argument type.");
476
477
478/*
479 * StopIteration extends Exception
480 */
Nick Coghlan1f7ce622012-01-13 21:43:40 +1000481
482static PyMemberDef StopIteration_members[] = {
483 {"value", T_OBJECT, offsetof(PyStopIterationObject, value), 0,
484 PyDoc_STR("generator return value")},
485 {NULL} /* Sentinel */
486};
487
488static int
489StopIteration_init(PyStopIterationObject *self, PyObject *args, PyObject *kwds)
490{
491 Py_ssize_t size = PyTuple_GET_SIZE(args);
492 PyObject *value;
493
494 if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
495 return -1;
496 Py_CLEAR(self->value);
497 if (size > 0)
498 value = PyTuple_GET_ITEM(args, 0);
499 else
500 value = Py_None;
501 Py_INCREF(value);
502 self->value = value;
503 return 0;
504}
505
506static int
507StopIteration_clear(PyStopIterationObject *self)
508{
509 Py_CLEAR(self->value);
510 return BaseException_clear((PyBaseExceptionObject *)self);
511}
512
513static void
514StopIteration_dealloc(PyStopIterationObject *self)
515{
516 _PyObject_GC_UNTRACK(self);
517 StopIteration_clear(self);
518 Py_TYPE(self)->tp_free((PyObject *)self);
519}
520
521static int
522StopIteration_traverse(PyStopIterationObject *self, visitproc visit, void *arg)
523{
524 Py_VISIT(self->value);
525 return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
526}
527
Nick Coghlan1f7ce622012-01-13 21:43:40 +1000528ComplexExtendsException(
529 PyExc_Exception, /* base */
530 StopIteration, /* name */
531 StopIteration, /* prefix for *_init, etc */
532 0, /* new */
533 0, /* methods */
534 StopIteration_members, /* members */
535 0, /* getset */
536 0, /* str */
537 "Signal the end from iterator.__next__()."
538);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000539
540
541/*
Christian Heimescbf3b5c2007-12-03 21:02:03 +0000542 * GeneratorExit extends BaseException
Thomas Wouters477c8d52006-05-27 19:21:47 +0000543 */
Christian Heimescbf3b5c2007-12-03 21:02:03 +0000544SimpleExtendsException(PyExc_BaseException, GeneratorExit,
Thomas Wouters477c8d52006-05-27 19:21:47 +0000545 "Request that a generator exit.");
546
547
548/*
549 * SystemExit extends BaseException
550 */
Thomas Wouters477c8d52006-05-27 19:21:47 +0000551
552static int
553SystemExit_init(PySystemExitObject *self, PyObject *args, PyObject *kwds)
554{
555 Py_ssize_t size = PyTuple_GET_SIZE(args);
556
557 if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
558 return -1;
559
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000560 if (size == 0)
561 return 0;
562 Py_CLEAR(self->code);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000563 if (size == 1)
564 self->code = PyTuple_GET_ITEM(args, 0);
Victor Stinner92236e52011-05-26 14:25:54 +0200565 else /* size > 1 */
Thomas Wouters477c8d52006-05-27 19:21:47 +0000566 self->code = args;
567 Py_INCREF(self->code);
568 return 0;
569}
570
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000571static int
Thomas Wouters477c8d52006-05-27 19:21:47 +0000572SystemExit_clear(PySystemExitObject *self)
573{
574 Py_CLEAR(self->code);
575 return BaseException_clear((PyBaseExceptionObject *)self);
576}
577
578static void
579SystemExit_dealloc(PySystemExitObject *self)
580{
Thomas Wouters89f507f2006-12-13 04:49:30 +0000581 _PyObject_GC_UNTRACK(self);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000582 SystemExit_clear(self);
Christian Heimes90aa7642007-12-19 02:45:37 +0000583 Py_TYPE(self)->tp_free((PyObject *)self);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000584}
585
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000586static int
Thomas Wouters477c8d52006-05-27 19:21:47 +0000587SystemExit_traverse(PySystemExitObject *self, visitproc visit, void *arg)
588{
589 Py_VISIT(self->code);
590 return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
591}
592
593static PyMemberDef SystemExit_members[] = {
Thomas Wouters477c8d52006-05-27 19:21:47 +0000594 {"code", T_OBJECT, offsetof(PySystemExitObject, code), 0,
595 PyDoc_STR("exception code")},
596 {NULL} /* Sentinel */
597};
598
599ComplexExtendsException(PyExc_BaseException, SystemExit, SystemExit,
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200600 0, 0, SystemExit_members, 0, 0,
Thomas Wouters477c8d52006-05-27 19:21:47 +0000601 "Request to exit from the interpreter.");
602
603/*
604 * KeyboardInterrupt extends BaseException
605 */
606SimpleExtendsException(PyExc_BaseException, KeyboardInterrupt,
607 "Program interrupted by user.");
608
609
610/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +0000611 * ImportError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +0000612 */
Thomas Wouters477c8d52006-05-27 19:21:47 +0000613
Brett Cannon79ec55e2012-04-12 20:24:54 -0400614static int
615ImportError_init(PyImportErrorObject *self, PyObject *args, PyObject *kwds)
616{
617 PyObject *msg = NULL;
618 PyObject *name = NULL;
619 PyObject *path = NULL;
620
621/* Macro replacement doesn't allow ## to start the first line of a macro,
622 so we move the assignment and NULL check into the if-statement. */
623#define GET_KWD(kwd) { \
624 kwd = PyDict_GetItemString(kwds, #kwd); \
625 if (kwd) { \
626 Py_CLEAR(self->kwd); \
627 self->kwd = kwd; \
628 Py_INCREF(self->kwd);\
629 if (PyDict_DelItemString(kwds, #kwd)) \
630 return -1; \
631 } \
632 }
633
634 if (kwds) {
635 GET_KWD(name);
636 GET_KWD(path);
637 }
638
639 if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
640 return -1;
641 if (PyTuple_GET_SIZE(args) != 1)
642 return 0;
643 if (!PyArg_UnpackTuple(args, "ImportError", 1, 1, &msg))
644 return -1;
645
646 Py_CLEAR(self->msg); /* replacing */
647 self->msg = msg;
648 Py_INCREF(self->msg);
649
650 return 0;
651}
652
653static int
654ImportError_clear(PyImportErrorObject *self)
655{
656 Py_CLEAR(self->msg);
657 Py_CLEAR(self->name);
658 Py_CLEAR(self->path);
659 return BaseException_clear((PyBaseExceptionObject *)self);
660}
661
662static void
663ImportError_dealloc(PyImportErrorObject *self)
664{
665 _PyObject_GC_UNTRACK(self);
666 ImportError_clear(self);
667 Py_TYPE(self)->tp_free((PyObject *)self);
668}
669
670static int
671ImportError_traverse(PyImportErrorObject *self, visitproc visit, void *arg)
672{
673 Py_VISIT(self->msg);
674 Py_VISIT(self->name);
675 Py_VISIT(self->path);
676 return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
677}
678
679static PyObject *
680ImportError_str(PyImportErrorObject *self)
681{
Brett Cannon07c6e712012-08-24 13:05:09 -0400682 if (self->msg && PyUnicode_CheckExact(self->msg)) {
Brett Cannon79ec55e2012-04-12 20:24:54 -0400683 Py_INCREF(self->msg);
684 return self->msg;
685 }
686 else {
687 return BaseException_str((PyBaseExceptionObject *)self);
688 }
689}
690
691static PyMemberDef ImportError_members[] = {
692 {"msg", T_OBJECT, offsetof(PyImportErrorObject, msg), 0,
693 PyDoc_STR("exception message")},
694 {"name", T_OBJECT, offsetof(PyImportErrorObject, name), 0,
695 PyDoc_STR("module name")},
696 {"path", T_OBJECT, offsetof(PyImportErrorObject, path), 0,
697 PyDoc_STR("module path")},
698 {NULL} /* Sentinel */
699};
700
701static PyMethodDef ImportError_methods[] = {
702 {NULL}
703};
704
705ComplexExtendsException(PyExc_Exception, ImportError,
706 ImportError, 0 /* new */,
707 ImportError_methods, ImportError_members,
708 0 /* getset */, ImportError_str,
709 "Import can't find module, or can't find name in "
710 "module.");
Thomas Wouters477c8d52006-05-27 19:21:47 +0000711
712/*
Brett Cannonb1611e22013-06-12 16:59:46 -0400713 * ModuleNotFoundError extends ImportError
714 */
715
716MiddlingExtendsException(PyExc_ImportError, ModuleNotFoundError, ImportError,
717 "Module not found.");
718
719/*
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200720 * OSError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +0000721 */
722
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200723#ifdef MS_WINDOWS
724#include "errmap.h"
725#endif
726
Thomas Wouters477c8d52006-05-27 19:21:47 +0000727/* Where a function has a single filename, such as open() or some
728 * of the os module functions, PyErr_SetFromErrnoWithFilename() is
729 * called, giving a third argument which is the filename. But, so
730 * that old code using in-place unpacking doesn't break, e.g.:
731 *
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200732 * except OSError, (errno, strerror):
Thomas Wouters477c8d52006-05-27 19:21:47 +0000733 *
734 * we hack args so that it only contains two items. This also
735 * means we need our own __str__() which prints out the filename
736 * when it was supplied.
737 */
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200738
Antoine Pitroue0e27352011-12-15 14:31:28 +0100739/* This function doesn't cleanup on error, the caller should */
740static int
741oserror_parse_args(PyObject **p_args,
742 PyObject **myerrno, PyObject **strerror,
743 PyObject **filename
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200744#ifdef MS_WINDOWS
Antoine Pitroue0e27352011-12-15 14:31:28 +0100745 , PyObject **winerror
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200746#endif
Antoine Pitroue0e27352011-12-15 14:31:28 +0100747 )
748{
749 Py_ssize_t nargs;
750 PyObject *args = *p_args;
Thomas Wouters477c8d52006-05-27 19:21:47 +0000751
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200752 nargs = PyTuple_GET_SIZE(args);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000753
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200754#ifdef MS_WINDOWS
755 if (nargs >= 2 && nargs <= 4) {
756 if (!PyArg_UnpackTuple(args, "OSError", 2, 4,
Antoine Pitroue0e27352011-12-15 14:31:28 +0100757 myerrno, strerror, filename, winerror))
758 return -1;
759 if (*winerror && PyLong_Check(*winerror)) {
760 long errcode, winerrcode;
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200761 PyObject *newargs;
762 Py_ssize_t i;
763
Antoine Pitroue0e27352011-12-15 14:31:28 +0100764 winerrcode = PyLong_AsLong(*winerror);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200765 if (winerrcode == -1 && PyErr_Occurred())
Antoine Pitroue0e27352011-12-15 14:31:28 +0100766 return -1;
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200767 /* Set errno to the corresponding POSIX errno (overriding
768 first argument). Windows Socket error codes (>= 10000)
769 have the same value as their POSIX counterparts.
770 */
771 if (winerrcode < 10000)
772 errcode = winerror_to_errno(winerrcode);
773 else
774 errcode = winerrcode;
Antoine Pitroue0e27352011-12-15 14:31:28 +0100775 *myerrno = PyLong_FromLong(errcode);
776 if (!*myerrno)
777 return -1;
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200778 newargs = PyTuple_New(nargs);
779 if (!newargs)
Antoine Pitroue0e27352011-12-15 14:31:28 +0100780 return -1;
781 PyTuple_SET_ITEM(newargs, 0, *myerrno);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200782 for (i = 1; i < nargs; i++) {
783 PyObject *val = PyTuple_GET_ITEM(args, i);
784 Py_INCREF(val);
785 PyTuple_SET_ITEM(newargs, i, val);
786 }
787 Py_DECREF(args);
Antoine Pitroue0e27352011-12-15 14:31:28 +0100788 args = *p_args = newargs;
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200789 }
790 }
791#else
792 if (nargs >= 2 && nargs <= 3) {
793 if (!PyArg_UnpackTuple(args, "OSError", 2, 3,
Antoine Pitroue0e27352011-12-15 14:31:28 +0100794 myerrno, strerror, filename))
795 return -1;
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200796 }
797#endif
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000798
Antoine Pitroue0e27352011-12-15 14:31:28 +0100799 return 0;
800}
Thomas Wouters477c8d52006-05-27 19:21:47 +0000801
Antoine Pitroue0e27352011-12-15 14:31:28 +0100802static int
803oserror_init(PyOSErrorObject *self, PyObject **p_args,
804 PyObject *myerrno, PyObject *strerror,
805 PyObject *filename
806#ifdef MS_WINDOWS
807 , PyObject *winerror
808#endif
809 )
810{
811 PyObject *args = *p_args;
812 Py_ssize_t nargs = PyTuple_GET_SIZE(args);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000813
814 /* self->filename will remain Py_None otherwise */
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200815 if (filename && filename != Py_None) {
Antoine Pitroue0e27352011-12-15 14:31:28 +0100816 if (Py_TYPE(self) == (PyTypeObject *) PyExc_BlockingIOError &&
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200817 PyNumber_Check(filename)) {
818 /* BlockingIOError's 3rd argument can be the number of
819 * characters written.
820 */
821 self->written = PyNumber_AsSsize_t(filename, PyExc_ValueError);
822 if (self->written == -1 && PyErr_Occurred())
Antoine Pitroue0e27352011-12-15 14:31:28 +0100823 return -1;
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200824 }
825 else {
826 Py_INCREF(filename);
827 self->filename = filename;
Thomas Wouters477c8d52006-05-27 19:21:47 +0000828
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200829 if (nargs >= 2 && nargs <= 3) {
830 /* filename is removed from the args tuple (for compatibility
831 purposes, see test_exceptions.py) */
Antoine Pitroue0e27352011-12-15 14:31:28 +0100832 PyObject *subslice = PyTuple_GetSlice(args, 0, 2);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200833 if (!subslice)
Antoine Pitroue0e27352011-12-15 14:31:28 +0100834 return -1;
Thomas Wouters477c8d52006-05-27 19:21:47 +0000835
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200836 Py_DECREF(args); /* replacing args */
Antoine Pitroue0e27352011-12-15 14:31:28 +0100837 *p_args = args = subslice;
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200838 }
839 }
Thomas Wouters477c8d52006-05-27 19:21:47 +0000840 }
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200841 Py_XINCREF(myerrno);
842 self->myerrno = myerrno;
843
844 Py_XINCREF(strerror);
845 self->strerror = strerror;
846
847#ifdef MS_WINDOWS
848 Py_XINCREF(winerror);
849 self->winerror = winerror;
850#endif
851
Antoine Pitroue0e27352011-12-15 14:31:28 +0100852 /* Steals the reference to args */
Antoine Pitrouf87289b2012-06-30 23:37:47 +0200853 Py_CLEAR(self->args);
Antoine Pitroue0e27352011-12-15 14:31:28 +0100854 self->args = args;
855 args = NULL;
856
857 return 0;
858}
859
860static PyObject *
861OSError_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
862static int
863OSError_init(PyOSErrorObject *self, PyObject *args, PyObject *kwds);
864
865static int
866oserror_use_init(PyTypeObject *type)
867{
868 /* When __init__ is defined in a OSError subclass, we want any
869 extraneous argument to __new__ to be ignored. The only reasonable
870 solution, given __new__ takes a variable number of arguments,
871 is to defer arg parsing and initialization to __init__.
872
873 But when __new__ is overriden as well, it should call our __new__
874 with the right arguments.
875
876 (see http://bugs.python.org/issue12555#msg148829 )
877 */
878 if (type->tp_init != (initproc) OSError_init &&
879 type->tp_new == (newfunc) OSError_new) {
880 assert((PyObject *) type != PyExc_OSError);
881 return 1;
882 }
883 return 0;
884}
885
886static PyObject *
887OSError_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
888{
889 PyOSErrorObject *self = NULL;
890 PyObject *myerrno = NULL, *strerror = NULL, *filename = NULL;
891#ifdef MS_WINDOWS
892 PyObject *winerror = NULL;
893#endif
894
895 if (!oserror_use_init(type)) {
896 if (!_PyArg_NoKeywords(type->tp_name, kwds))
897 return NULL;
898
899 Py_INCREF(args);
900 if (oserror_parse_args(&args, &myerrno, &strerror, &filename
901#ifdef MS_WINDOWS
902 , &winerror
903#endif
904 ))
905 goto error;
906
907 if (myerrno && PyLong_Check(myerrno) &&
908 errnomap && (PyObject *) type == PyExc_OSError) {
909 PyObject *newtype;
910 newtype = PyDict_GetItem(errnomap, myerrno);
911 if (newtype) {
912 assert(PyType_Check(newtype));
913 type = (PyTypeObject *) newtype;
914 }
915 else if (PyErr_Occurred())
916 goto error;
917 }
918 }
919
920 self = (PyOSErrorObject *) type->tp_alloc(type, 0);
921 if (!self)
922 goto error;
923
924 self->dict = NULL;
925 self->traceback = self->cause = self->context = NULL;
926 self->written = -1;
927
928 if (!oserror_use_init(type)) {
929 if (oserror_init(self, &args, myerrno, strerror, filename
930#ifdef MS_WINDOWS
931 , winerror
932#endif
933 ))
934 goto error;
935 }
Antoine Pitrouf87289b2012-06-30 23:37:47 +0200936 else {
937 self->args = PyTuple_New(0);
938 if (self->args == NULL)
939 goto error;
940 }
Antoine Pitroue0e27352011-12-15 14:31:28 +0100941
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200942 return (PyObject *) self;
943
944error:
945 Py_XDECREF(args);
946 Py_XDECREF(self);
947 return NULL;
948}
949
950static int
Antoine Pitroue0e27352011-12-15 14:31:28 +0100951OSError_init(PyOSErrorObject *self, PyObject *args, PyObject *kwds)
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200952{
Antoine Pitroue0e27352011-12-15 14:31:28 +0100953 PyObject *myerrno = NULL, *strerror = NULL, *filename = NULL;
954#ifdef MS_WINDOWS
955 PyObject *winerror = NULL;
956#endif
957
958 if (!oserror_use_init(Py_TYPE(self)))
959 /* Everything already done in OSError_new */
960 return 0;
961
962 if (!_PyArg_NoKeywords(Py_TYPE(self)->tp_name, kwds))
963 return -1;
964
965 Py_INCREF(args);
966 if (oserror_parse_args(&args, &myerrno, &strerror, &filename
967#ifdef MS_WINDOWS
968 , &winerror
969#endif
970 ))
971 goto error;
972
973 if (oserror_init(self, &args, myerrno, strerror, filename
974#ifdef MS_WINDOWS
975 , winerror
976#endif
977 ))
978 goto error;
979
Thomas Wouters477c8d52006-05-27 19:21:47 +0000980 return 0;
Antoine Pitroue0e27352011-12-15 14:31:28 +0100981
982error:
983 Py_XDECREF(args);
984 return -1;
Thomas Wouters477c8d52006-05-27 19:21:47 +0000985}
986
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000987static int
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200988OSError_clear(PyOSErrorObject *self)
Thomas Wouters477c8d52006-05-27 19:21:47 +0000989{
990 Py_CLEAR(self->myerrno);
991 Py_CLEAR(self->strerror);
992 Py_CLEAR(self->filename);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200993#ifdef MS_WINDOWS
994 Py_CLEAR(self->winerror);
995#endif
Thomas Wouters477c8d52006-05-27 19:21:47 +0000996 return BaseException_clear((PyBaseExceptionObject *)self);
997}
998
999static void
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001000OSError_dealloc(PyOSErrorObject *self)
Thomas Wouters477c8d52006-05-27 19:21:47 +00001001{
Thomas Wouters89f507f2006-12-13 04:49:30 +00001002 _PyObject_GC_UNTRACK(self);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001003 OSError_clear(self);
Christian Heimes90aa7642007-12-19 02:45:37 +00001004 Py_TYPE(self)->tp_free((PyObject *)self);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001005}
1006
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001007static int
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001008OSError_traverse(PyOSErrorObject *self, visitproc visit,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001009 void *arg)
1010{
1011 Py_VISIT(self->myerrno);
1012 Py_VISIT(self->strerror);
1013 Py_VISIT(self->filename);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001014#ifdef MS_WINDOWS
1015 Py_VISIT(self->winerror);
1016#endif
Thomas Wouters477c8d52006-05-27 19:21:47 +00001017 return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
1018}
1019
1020static PyObject *
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001021OSError_str(PyOSErrorObject *self)
Thomas Wouters477c8d52006-05-27 19:21:47 +00001022{
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001023#ifdef MS_WINDOWS
1024 /* If available, winerror has the priority over myerrno */
1025 if (self->winerror && self->filename)
Richard Oudkerk30147712012-08-28 19:33:26 +01001026 return PyUnicode_FromFormat("[WinError %S] %S: %R",
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001027 self->winerror ? self->winerror: Py_None,
1028 self->strerror ? self->strerror: Py_None,
1029 self->filename);
1030 if (self->winerror && self->strerror)
Richard Oudkerk30147712012-08-28 19:33:26 +01001031 return PyUnicode_FromFormat("[WinError %S] %S",
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001032 self->winerror ? self->winerror: Py_None,
1033 self->strerror ? self->strerror: Py_None);
1034#endif
Walter Dörwaldf5bec7c2007-05-26 15:03:32 +00001035 if (self->filename)
1036 return PyUnicode_FromFormat("[Errno %S] %S: %R",
1037 self->myerrno ? self->myerrno: Py_None,
1038 self->strerror ? self->strerror: Py_None,
1039 self->filename);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001040 if (self->myerrno && self->strerror)
Walter Dörwaldf5bec7c2007-05-26 15:03:32 +00001041 return PyUnicode_FromFormat("[Errno %S] %S",
1042 self->myerrno ? self->myerrno: Py_None,
1043 self->strerror ? self->strerror: Py_None);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001044 return BaseException_str((PyBaseExceptionObject *)self);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001045}
1046
Thomas Wouters477c8d52006-05-27 19:21:47 +00001047static PyObject *
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001048OSError_reduce(PyOSErrorObject *self)
Thomas Wouters477c8d52006-05-27 19:21:47 +00001049{
1050 PyObject *args = self->args;
1051 PyObject *res = NULL, *tmp;
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001052
Thomas Wouters477c8d52006-05-27 19:21:47 +00001053 /* self->args is only the first two real arguments if there was a
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001054 * file name given to OSError. */
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001055 if (PyTuple_GET_SIZE(args) == 2 && self->filename) {
Thomas Wouters477c8d52006-05-27 19:21:47 +00001056 args = PyTuple_New(3);
Benjamin Peterson90b13582012-02-03 19:22:31 -05001057 if (!args)
1058 return NULL;
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001059
1060 tmp = PyTuple_GET_ITEM(self->args, 0);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001061 Py_INCREF(tmp);
1062 PyTuple_SET_ITEM(args, 0, tmp);
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001063
1064 tmp = PyTuple_GET_ITEM(self->args, 1);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001065 Py_INCREF(tmp);
1066 PyTuple_SET_ITEM(args, 1, tmp);
1067
1068 Py_INCREF(self->filename);
1069 PyTuple_SET_ITEM(args, 2, self->filename);
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001070 } else
Thomas Wouters477c8d52006-05-27 19:21:47 +00001071 Py_INCREF(args);
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001072
1073 if (self->dict)
Christian Heimes90aa7642007-12-19 02:45:37 +00001074 res = PyTuple_Pack(3, Py_TYPE(self), args, self->dict);
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001075 else
Christian Heimes90aa7642007-12-19 02:45:37 +00001076 res = PyTuple_Pack(2, Py_TYPE(self), args);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001077 Py_DECREF(args);
1078 return res;
1079}
1080
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001081static PyObject *
1082OSError_written_get(PyOSErrorObject *self, void *context)
1083{
1084 if (self->written == -1) {
1085 PyErr_SetString(PyExc_AttributeError, "characters_written");
1086 return NULL;
1087 }
1088 return PyLong_FromSsize_t(self->written);
1089}
Thomas Wouters477c8d52006-05-27 19:21:47 +00001090
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001091static int
1092OSError_written_set(PyOSErrorObject *self, PyObject *arg, void *context)
1093{
1094 Py_ssize_t n;
1095 n = PyNumber_AsSsize_t(arg, PyExc_ValueError);
1096 if (n == -1 && PyErr_Occurred())
1097 return -1;
1098 self->written = n;
1099 return 0;
1100}
1101
1102static PyMemberDef OSError_members[] = {
1103 {"errno", T_OBJECT, offsetof(PyOSErrorObject, myerrno), 0,
1104 PyDoc_STR("POSIX exception code")},
1105 {"strerror", T_OBJECT, offsetof(PyOSErrorObject, strerror), 0,
1106 PyDoc_STR("exception strerror")},
1107 {"filename", T_OBJECT, offsetof(PyOSErrorObject, filename), 0,
1108 PyDoc_STR("exception filename")},
1109#ifdef MS_WINDOWS
1110 {"winerror", T_OBJECT, offsetof(PyOSErrorObject, winerror), 0,
1111 PyDoc_STR("Win32 exception code")},
1112#endif
1113 {NULL} /* Sentinel */
1114};
1115
1116static PyMethodDef OSError_methods[] = {
1117 {"__reduce__", (PyCFunction)OSError_reduce, METH_NOARGS},
Thomas Wouters477c8d52006-05-27 19:21:47 +00001118 {NULL}
1119};
1120
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001121static PyGetSetDef OSError_getset[] = {
1122 {"characters_written", (getter) OSError_written_get,
1123 (setter) OSError_written_set, NULL},
1124 {NULL}
1125};
1126
1127
1128ComplexExtendsException(PyExc_Exception, OSError,
1129 OSError, OSError_new,
1130 OSError_methods, OSError_members, OSError_getset,
1131 OSError_str,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001132 "Base class for I/O related errors.");
1133
1134
1135/*
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001136 * Various OSError subclasses
Thomas Wouters477c8d52006-05-27 19:21:47 +00001137 */
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001138MiddlingExtendsException(PyExc_OSError, BlockingIOError, OSError,
1139 "I/O operation would block.");
1140MiddlingExtendsException(PyExc_OSError, ConnectionError, OSError,
1141 "Connection error.");
1142MiddlingExtendsException(PyExc_OSError, ChildProcessError, OSError,
1143 "Child process error.");
1144MiddlingExtendsException(PyExc_ConnectionError, BrokenPipeError, OSError,
1145 "Broken pipe.");
1146MiddlingExtendsException(PyExc_ConnectionError, ConnectionAbortedError, OSError,
1147 "Connection aborted.");
1148MiddlingExtendsException(PyExc_ConnectionError, ConnectionRefusedError, OSError,
1149 "Connection refused.");
1150MiddlingExtendsException(PyExc_ConnectionError, ConnectionResetError, OSError,
1151 "Connection reset.");
1152MiddlingExtendsException(PyExc_OSError, FileExistsError, OSError,
1153 "File already exists.");
1154MiddlingExtendsException(PyExc_OSError, FileNotFoundError, OSError,
1155 "File not found.");
1156MiddlingExtendsException(PyExc_OSError, IsADirectoryError, OSError,
1157 "Operation doesn't work on directories.");
1158MiddlingExtendsException(PyExc_OSError, NotADirectoryError, OSError,
1159 "Operation only works on directories.");
1160MiddlingExtendsException(PyExc_OSError, InterruptedError, OSError,
1161 "Interrupted by signal.");
1162MiddlingExtendsException(PyExc_OSError, PermissionError, OSError,
1163 "Not enough permissions.");
1164MiddlingExtendsException(PyExc_OSError, ProcessLookupError, OSError,
1165 "Process not found.");
1166MiddlingExtendsException(PyExc_OSError, TimeoutError, OSError,
1167 "Timeout expired.");
Thomas Wouters477c8d52006-05-27 19:21:47 +00001168
1169/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001170 * EOFError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00001171 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001172SimpleExtendsException(PyExc_Exception, EOFError,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001173 "Read beyond end of file.");
1174
1175
1176/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001177 * RuntimeError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00001178 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001179SimpleExtendsException(PyExc_Exception, RuntimeError,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001180 "Unspecified run-time error.");
1181
1182
1183/*
1184 * NotImplementedError extends RuntimeError
1185 */
1186SimpleExtendsException(PyExc_RuntimeError, NotImplementedError,
1187 "Method or function hasn't been implemented yet.");
1188
1189/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001190 * NameError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00001191 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001192SimpleExtendsException(PyExc_Exception, NameError,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001193 "Name not found globally.");
1194
1195/*
1196 * UnboundLocalError extends NameError
1197 */
1198SimpleExtendsException(PyExc_NameError, UnboundLocalError,
1199 "Local name referenced but not bound to a value.");
1200
1201/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001202 * AttributeError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00001203 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001204SimpleExtendsException(PyExc_Exception, AttributeError,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001205 "Attribute not found.");
1206
1207
1208/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001209 * SyntaxError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00001210 */
Thomas Wouters477c8d52006-05-27 19:21:47 +00001211
1212static int
1213SyntaxError_init(PySyntaxErrorObject *self, PyObject *args, PyObject *kwds)
1214{
1215 PyObject *info = NULL;
1216 Py_ssize_t lenargs = PyTuple_GET_SIZE(args);
1217
1218 if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
1219 return -1;
1220
1221 if (lenargs >= 1) {
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001222 Py_CLEAR(self->msg);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001223 self->msg = PyTuple_GET_ITEM(args, 0);
1224 Py_INCREF(self->msg);
1225 }
1226 if (lenargs == 2) {
1227 info = PyTuple_GET_ITEM(args, 1);
1228 info = PySequence_Tuple(info);
Benjamin Peterson90b13582012-02-03 19:22:31 -05001229 if (!info)
1230 return -1;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001231
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001232 if (PyTuple_GET_SIZE(info) != 4) {
1233 /* not a very good error message, but it's what Python 2.4 gives */
1234 PyErr_SetString(PyExc_IndexError, "tuple index out of range");
1235 Py_DECREF(info);
1236 return -1;
1237 }
1238
1239 Py_CLEAR(self->filename);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001240 self->filename = PyTuple_GET_ITEM(info, 0);
1241 Py_INCREF(self->filename);
1242
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001243 Py_CLEAR(self->lineno);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001244 self->lineno = PyTuple_GET_ITEM(info, 1);
1245 Py_INCREF(self->lineno);
1246
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001247 Py_CLEAR(self->offset);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001248 self->offset = PyTuple_GET_ITEM(info, 2);
1249 Py_INCREF(self->offset);
1250
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001251 Py_CLEAR(self->text);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001252 self->text = PyTuple_GET_ITEM(info, 3);
1253 Py_INCREF(self->text);
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001254
1255 Py_DECREF(info);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001256 }
1257 return 0;
1258}
1259
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001260static int
Thomas Wouters477c8d52006-05-27 19:21:47 +00001261SyntaxError_clear(PySyntaxErrorObject *self)
1262{
1263 Py_CLEAR(self->msg);
1264 Py_CLEAR(self->filename);
1265 Py_CLEAR(self->lineno);
1266 Py_CLEAR(self->offset);
1267 Py_CLEAR(self->text);
1268 Py_CLEAR(self->print_file_and_line);
1269 return BaseException_clear((PyBaseExceptionObject *)self);
1270}
1271
1272static void
1273SyntaxError_dealloc(PySyntaxErrorObject *self)
1274{
Thomas Wouters89f507f2006-12-13 04:49:30 +00001275 _PyObject_GC_UNTRACK(self);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001276 SyntaxError_clear(self);
Christian Heimes90aa7642007-12-19 02:45:37 +00001277 Py_TYPE(self)->tp_free((PyObject *)self);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001278}
1279
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001280static int
Thomas Wouters477c8d52006-05-27 19:21:47 +00001281SyntaxError_traverse(PySyntaxErrorObject *self, visitproc visit, void *arg)
1282{
1283 Py_VISIT(self->msg);
1284 Py_VISIT(self->filename);
1285 Py_VISIT(self->lineno);
1286 Py_VISIT(self->offset);
1287 Py_VISIT(self->text);
1288 Py_VISIT(self->print_file_and_line);
1289 return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
1290}
1291
1292/* This is called "my_basename" instead of just "basename" to avoid name
1293 conflicts with glibc; basename is already prototyped if _GNU_SOURCE is
1294 defined, and Python does define that. */
Victor Stinner6237daf2010-04-28 17:26:19 +00001295static PyObject*
1296my_basename(PyObject *name)
Thomas Wouters477c8d52006-05-27 19:21:47 +00001297{
Victor Stinner6237daf2010-04-28 17:26:19 +00001298 Py_ssize_t i, size, offset;
Victor Stinner31392e72011-10-05 20:14:23 +02001299 int kind;
1300 void *data;
1301
1302 if (PyUnicode_READY(name))
1303 return NULL;
1304 kind = PyUnicode_KIND(name);
1305 data = PyUnicode_DATA(name);
Martin v. Löwisd63a3b82011-09-28 07:41:54 +02001306 size = PyUnicode_GET_LENGTH(name);
Victor Stinner6237daf2010-04-28 17:26:19 +00001307 offset = 0;
1308 for(i=0; i < size; i++) {
Martin v. Löwisd63a3b82011-09-28 07:41:54 +02001309 if (PyUnicode_READ(kind, data, i) == SEP)
Victor Stinner6237daf2010-04-28 17:26:19 +00001310 offset = i + 1;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001311 }
Martin v. Löwisd63a3b82011-09-28 07:41:54 +02001312 if (offset != 0)
1313 return PyUnicode_Substring(name, offset, size);
1314 else {
Victor Stinner6237daf2010-04-28 17:26:19 +00001315 Py_INCREF(name);
1316 return name;
1317 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00001318}
1319
1320
1321static PyObject *
1322SyntaxError_str(PySyntaxErrorObject *self)
1323{
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001324 int have_lineno = 0;
Victor Stinner6237daf2010-04-28 17:26:19 +00001325 PyObject *filename;
1326 PyObject *result;
Martin v. Löwisd1a1d1e2007-12-04 22:10:37 +00001327 /* Below, we always ignore overflow errors, just printing -1.
1328 Still, we cannot allow an OverflowError to be raised, so
1329 we need to call PyLong_AsLongAndOverflow. */
1330 int overflow;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001331
1332 /* XXX -- do all the additional formatting with filename and
1333 lineno here */
1334
Neal Norwitzed2b7392007-08-26 04:51:10 +00001335 if (self->filename && PyUnicode_Check(self->filename)) {
Victor Stinner6237daf2010-04-28 17:26:19 +00001336 filename = my_basename(self->filename);
1337 if (filename == NULL)
1338 return NULL;
1339 } else {
1340 filename = NULL;
Martin v. Löwis10a60b32007-07-18 02:28:27 +00001341 }
Martin v. Löwisd1a1d1e2007-12-04 22:10:37 +00001342 have_lineno = (self->lineno != NULL) && PyLong_CheckExact(self->lineno);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001343
Martin v. Löwis10a60b32007-07-18 02:28:27 +00001344 if (!filename && !have_lineno)
Thomas Heller519a0422007-11-15 20:48:54 +00001345 return PyObject_Str(self->msg ? self->msg : Py_None);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001346
Martin v. Löwis10a60b32007-07-18 02:28:27 +00001347 if (filename && have_lineno)
Victor Stinner6237daf2010-04-28 17:26:19 +00001348 result = PyUnicode_FromFormat("%S (%U, line %ld)",
Walter Dörwaldf5bec7c2007-05-26 15:03:32 +00001349 self->msg ? self->msg : Py_None,
Victor Stinner6237daf2010-04-28 17:26:19 +00001350 filename,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001351 PyLong_AsLongAndOverflow(self->lineno, &overflow));
Martin v. Löwis10a60b32007-07-18 02:28:27 +00001352 else if (filename)
Victor Stinner6237daf2010-04-28 17:26:19 +00001353 result = PyUnicode_FromFormat("%S (%U)",
Walter Dörwaldf5bec7c2007-05-26 15:03:32 +00001354 self->msg ? self->msg : Py_None,
Victor Stinner6237daf2010-04-28 17:26:19 +00001355 filename);
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001356 else /* only have_lineno */
Victor Stinner6237daf2010-04-28 17:26:19 +00001357 result = PyUnicode_FromFormat("%S (line %ld)",
Walter Dörwaldf5bec7c2007-05-26 15:03:32 +00001358 self->msg ? self->msg : Py_None,
Martin v. Löwisd1a1d1e2007-12-04 22:10:37 +00001359 PyLong_AsLongAndOverflow(self->lineno, &overflow));
Victor Stinner6237daf2010-04-28 17:26:19 +00001360 Py_XDECREF(filename);
1361 return result;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001362}
1363
1364static PyMemberDef SyntaxError_members[] = {
Thomas Wouters477c8d52006-05-27 19:21:47 +00001365 {"msg", T_OBJECT, offsetof(PySyntaxErrorObject, msg), 0,
1366 PyDoc_STR("exception msg")},
1367 {"filename", T_OBJECT, offsetof(PySyntaxErrorObject, filename), 0,
1368 PyDoc_STR("exception filename")},
1369 {"lineno", T_OBJECT, offsetof(PySyntaxErrorObject, lineno), 0,
1370 PyDoc_STR("exception lineno")},
1371 {"offset", T_OBJECT, offsetof(PySyntaxErrorObject, offset), 0,
1372 PyDoc_STR("exception offset")},
1373 {"text", T_OBJECT, offsetof(PySyntaxErrorObject, text), 0,
1374 PyDoc_STR("exception text")},
1375 {"print_file_and_line", T_OBJECT,
1376 offsetof(PySyntaxErrorObject, print_file_and_line), 0,
1377 PyDoc_STR("exception print_file_and_line")},
1378 {NULL} /* Sentinel */
1379};
1380
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001381ComplexExtendsException(PyExc_Exception, SyntaxError, SyntaxError,
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001382 0, 0, SyntaxError_members, 0,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001383 SyntaxError_str, "Invalid syntax.");
1384
1385
1386/*
1387 * IndentationError extends SyntaxError
1388 */
1389MiddlingExtendsException(PyExc_SyntaxError, IndentationError, SyntaxError,
1390 "Improper indentation.");
1391
1392
1393/*
1394 * TabError extends IndentationError
1395 */
1396MiddlingExtendsException(PyExc_IndentationError, TabError, SyntaxError,
1397 "Improper mixture of spaces and tabs.");
1398
1399
1400/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001401 * LookupError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00001402 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001403SimpleExtendsException(PyExc_Exception, LookupError,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001404 "Base class for lookup errors.");
1405
1406
1407/*
1408 * IndexError extends LookupError
1409 */
1410SimpleExtendsException(PyExc_LookupError, IndexError,
1411 "Sequence index out of range.");
1412
1413
1414/*
1415 * KeyError extends LookupError
1416 */
1417static PyObject *
1418KeyError_str(PyBaseExceptionObject *self)
1419{
1420 /* If args is a tuple of exactly one item, apply repr to args[0].
1421 This is done so that e.g. the exception raised by {}[''] prints
1422 KeyError: ''
1423 rather than the confusing
1424 KeyError
1425 alone. The downside is that if KeyError is raised with an explanatory
1426 string, that string will be displayed in quotes. Too bad.
1427 If args is anything else, use the default BaseException__str__().
1428 */
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001429 if (PyTuple_GET_SIZE(self->args) == 1) {
Walter Dörwaldf5bec7c2007-05-26 15:03:32 +00001430 return PyObject_Repr(PyTuple_GET_ITEM(self->args, 0));
Thomas Wouters477c8d52006-05-27 19:21:47 +00001431 }
1432 return BaseException_str(self);
1433}
1434
1435ComplexExtendsException(PyExc_LookupError, KeyError, BaseException,
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001436 0, 0, 0, 0, KeyError_str, "Mapping key not found.");
Thomas Wouters477c8d52006-05-27 19:21:47 +00001437
1438
1439/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001440 * ValueError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00001441 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001442SimpleExtendsException(PyExc_Exception, ValueError,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001443 "Inappropriate argument value (of correct type).");
1444
1445/*
1446 * UnicodeError extends ValueError
1447 */
1448
1449SimpleExtendsException(PyExc_ValueError, UnicodeError,
1450 "Unicode related error.");
1451
Thomas Wouters477c8d52006-05-27 19:21:47 +00001452static PyObject *
Guido van Rossum98297ee2007-11-06 21:34:58 +00001453get_string(PyObject *attr, const char *name)
Walter Dörwald612344f2007-05-04 19:28:21 +00001454{
1455 if (!attr) {
1456 PyErr_Format(PyExc_TypeError, "%.200s attribute not set", name);
1457 return NULL;
1458 }
1459
Christian Heimes72b710a2008-05-26 13:28:38 +00001460 if (!PyBytes_Check(attr)) {
Walter Dörwald612344f2007-05-04 19:28:21 +00001461 PyErr_Format(PyExc_TypeError, "%.200s attribute must be bytes", name);
1462 return NULL;
1463 }
1464 Py_INCREF(attr);
1465 return attr;
1466}
1467
1468static PyObject *
Thomas Wouters477c8d52006-05-27 19:21:47 +00001469get_unicode(PyObject *attr, const char *name)
1470{
1471 if (!attr) {
1472 PyErr_Format(PyExc_TypeError, "%.200s attribute not set", name);
1473 return NULL;
1474 }
1475
1476 if (!PyUnicode_Check(attr)) {
1477 PyErr_Format(PyExc_TypeError,
1478 "%.200s attribute must be unicode", name);
1479 return NULL;
1480 }
1481 Py_INCREF(attr);
1482 return attr;
1483}
1484
Walter Dörwaldd2034312007-05-18 16:29:38 +00001485static int
1486set_unicodefromstring(PyObject **attr, const char *value)
1487{
1488 PyObject *obj = PyUnicode_FromString(value);
1489 if (!obj)
1490 return -1;
1491 Py_CLEAR(*attr);
1492 *attr = obj;
1493 return 0;
1494}
1495
Thomas Wouters477c8d52006-05-27 19:21:47 +00001496PyObject *
1497PyUnicodeEncodeError_GetEncoding(PyObject *exc)
1498{
Walter Dörwaldd2034312007-05-18 16:29:38 +00001499 return get_unicode(((PyUnicodeErrorObject *)exc)->encoding, "encoding");
Thomas Wouters477c8d52006-05-27 19:21:47 +00001500}
1501
1502PyObject *
1503PyUnicodeDecodeError_GetEncoding(PyObject *exc)
1504{
Walter Dörwaldd2034312007-05-18 16:29:38 +00001505 return get_unicode(((PyUnicodeErrorObject *)exc)->encoding, "encoding");
Thomas Wouters477c8d52006-05-27 19:21:47 +00001506}
1507
1508PyObject *
1509PyUnicodeEncodeError_GetObject(PyObject *exc)
1510{
1511 return get_unicode(((PyUnicodeErrorObject *)exc)->object, "object");
1512}
1513
1514PyObject *
1515PyUnicodeDecodeError_GetObject(PyObject *exc)
1516{
Guido van Rossum98297ee2007-11-06 21:34:58 +00001517 return get_string(((PyUnicodeErrorObject *)exc)->object, "object");
Thomas Wouters477c8d52006-05-27 19:21:47 +00001518}
1519
1520PyObject *
1521PyUnicodeTranslateError_GetObject(PyObject *exc)
1522{
1523 return get_unicode(((PyUnicodeErrorObject *)exc)->object, "object");
1524}
1525
1526int
1527PyUnicodeEncodeError_GetStart(PyObject *exc, Py_ssize_t *start)
1528{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001529 Py_ssize_t size;
1530 PyObject *obj = get_unicode(((PyUnicodeErrorObject *)exc)->object,
1531 "object");
1532 if (!obj)
1533 return -1;
1534 *start = ((PyUnicodeErrorObject *)exc)->start;
Victor Stinner9e30aa52011-11-21 02:49:52 +01001535 size = PyUnicode_GET_LENGTH(obj);
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001536 if (*start<0)
1537 *start = 0; /*XXX check for values <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
1546PyUnicodeDecodeError_GetStart(PyObject *exc, Py_ssize_t *start)
1547{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001548 Py_ssize_t size;
Guido van Rossum98297ee2007-11-06 21:34:58 +00001549 PyObject *obj = get_string(((PyUnicodeErrorObject *)exc)->object, "object");
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001550 if (!obj)
1551 return -1;
Christian Heimes72b710a2008-05-26 13:28:38 +00001552 size = PyBytes_GET_SIZE(obj);
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001553 *start = ((PyUnicodeErrorObject *)exc)->start;
1554 if (*start<0)
1555 *start = 0;
1556 if (*start>=size)
1557 *start = size-1;
1558 Py_DECREF(obj);
1559 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001560}
1561
1562
1563int
1564PyUnicodeTranslateError_GetStart(PyObject *exc, Py_ssize_t *start)
1565{
1566 return PyUnicodeEncodeError_GetStart(exc, start);
1567}
1568
1569
1570int
1571PyUnicodeEncodeError_SetStart(PyObject *exc, Py_ssize_t start)
1572{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001573 ((PyUnicodeErrorObject *)exc)->start = start;
1574 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001575}
1576
1577
1578int
1579PyUnicodeDecodeError_SetStart(PyObject *exc, Py_ssize_t start)
1580{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001581 ((PyUnicodeErrorObject *)exc)->start = start;
1582 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001583}
1584
1585
1586int
1587PyUnicodeTranslateError_SetStart(PyObject *exc, Py_ssize_t start)
1588{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001589 ((PyUnicodeErrorObject *)exc)->start = start;
1590 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001591}
1592
1593
1594int
1595PyUnicodeEncodeError_GetEnd(PyObject *exc, Py_ssize_t *end)
1596{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001597 Py_ssize_t size;
1598 PyObject *obj = get_unicode(((PyUnicodeErrorObject *)exc)->object,
1599 "object");
1600 if (!obj)
1601 return -1;
1602 *end = ((PyUnicodeErrorObject *)exc)->end;
Victor Stinner9e30aa52011-11-21 02:49:52 +01001603 size = PyUnicode_GET_LENGTH(obj);
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001604 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
1614PyUnicodeDecodeError_GetEnd(PyObject *exc, Py_ssize_t *end)
1615{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001616 Py_ssize_t size;
Guido van Rossum98297ee2007-11-06 21:34:58 +00001617 PyObject *obj = get_string(((PyUnicodeErrorObject *)exc)->object, "object");
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001618 if (!obj)
1619 return -1;
Christian Heimes72b710a2008-05-26 13:28:38 +00001620 size = PyBytes_GET_SIZE(obj);
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001621 *end = ((PyUnicodeErrorObject *)exc)->end;
1622 if (*end<1)
1623 *end = 1;
1624 if (*end>size)
1625 *end = size;
1626 Py_DECREF(obj);
1627 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001628}
1629
1630
1631int
1632PyUnicodeTranslateError_GetEnd(PyObject *exc, Py_ssize_t *start)
1633{
1634 return PyUnicodeEncodeError_GetEnd(exc, start);
1635}
1636
1637
1638int
1639PyUnicodeEncodeError_SetEnd(PyObject *exc, Py_ssize_t end)
1640{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001641 ((PyUnicodeErrorObject *)exc)->end = end;
1642 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001643}
1644
1645
1646int
1647PyUnicodeDecodeError_SetEnd(PyObject *exc, Py_ssize_t end)
1648{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001649 ((PyUnicodeErrorObject *)exc)->end = end;
1650 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001651}
1652
1653
1654int
1655PyUnicodeTranslateError_SetEnd(PyObject *exc, Py_ssize_t end)
1656{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001657 ((PyUnicodeErrorObject *)exc)->end = end;
1658 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001659}
1660
1661PyObject *
1662PyUnicodeEncodeError_GetReason(PyObject *exc)
1663{
Walter Dörwaldd2034312007-05-18 16:29:38 +00001664 return get_unicode(((PyUnicodeErrorObject *)exc)->reason, "reason");
Thomas Wouters477c8d52006-05-27 19:21:47 +00001665}
1666
1667
1668PyObject *
1669PyUnicodeDecodeError_GetReason(PyObject *exc)
1670{
Walter Dörwaldd2034312007-05-18 16:29:38 +00001671 return get_unicode(((PyUnicodeErrorObject *)exc)->reason, "reason");
Thomas Wouters477c8d52006-05-27 19:21:47 +00001672}
1673
1674
1675PyObject *
1676PyUnicodeTranslateError_GetReason(PyObject *exc)
1677{
Walter Dörwaldd2034312007-05-18 16:29:38 +00001678 return get_unicode(((PyUnicodeErrorObject *)exc)->reason, "reason");
Thomas Wouters477c8d52006-05-27 19:21:47 +00001679}
1680
1681
1682int
1683PyUnicodeEncodeError_SetReason(PyObject *exc, const char *reason)
1684{
Walter Dörwaldd2034312007-05-18 16:29:38 +00001685 return set_unicodefromstring(&((PyUnicodeErrorObject *)exc)->reason,
1686 reason);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001687}
1688
1689
1690int
1691PyUnicodeDecodeError_SetReason(PyObject *exc, const char *reason)
1692{
Walter Dörwaldd2034312007-05-18 16:29:38 +00001693 return set_unicodefromstring(&((PyUnicodeErrorObject *)exc)->reason,
1694 reason);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001695}
1696
1697
1698int
1699PyUnicodeTranslateError_SetReason(PyObject *exc, const char *reason)
1700{
Walter Dörwaldd2034312007-05-18 16:29:38 +00001701 return set_unicodefromstring(&((PyUnicodeErrorObject *)exc)->reason,
1702 reason);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001703}
1704
1705
Thomas Wouters477c8d52006-05-27 19:21:47 +00001706static int
Thomas Wouters477c8d52006-05-27 19:21:47 +00001707UnicodeError_clear(PyUnicodeErrorObject *self)
1708{
1709 Py_CLEAR(self->encoding);
1710 Py_CLEAR(self->object);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001711 Py_CLEAR(self->reason);
1712 return BaseException_clear((PyBaseExceptionObject *)self);
1713}
1714
1715static void
1716UnicodeError_dealloc(PyUnicodeErrorObject *self)
1717{
Thomas Wouters89f507f2006-12-13 04:49:30 +00001718 _PyObject_GC_UNTRACK(self);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001719 UnicodeError_clear(self);
Christian Heimes90aa7642007-12-19 02:45:37 +00001720 Py_TYPE(self)->tp_free((PyObject *)self);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001721}
1722
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001723static int
Thomas Wouters477c8d52006-05-27 19:21:47 +00001724UnicodeError_traverse(PyUnicodeErrorObject *self, visitproc visit, void *arg)
1725{
1726 Py_VISIT(self->encoding);
1727 Py_VISIT(self->object);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001728 Py_VISIT(self->reason);
1729 return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
1730}
1731
1732static PyMemberDef UnicodeError_members[] = {
Thomas Wouters477c8d52006-05-27 19:21:47 +00001733 {"encoding", T_OBJECT, offsetof(PyUnicodeErrorObject, encoding), 0,
1734 PyDoc_STR("exception encoding")},
1735 {"object", T_OBJECT, offsetof(PyUnicodeErrorObject, object), 0,
1736 PyDoc_STR("exception object")},
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001737 {"start", T_PYSSIZET, offsetof(PyUnicodeErrorObject, start), 0,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001738 PyDoc_STR("exception start")},
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001739 {"end", T_PYSSIZET, offsetof(PyUnicodeErrorObject, end), 0,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001740 PyDoc_STR("exception end")},
1741 {"reason", T_OBJECT, offsetof(PyUnicodeErrorObject, reason), 0,
1742 PyDoc_STR("exception reason")},
1743 {NULL} /* Sentinel */
1744};
1745
1746
1747/*
1748 * UnicodeEncodeError extends UnicodeError
1749 */
Thomas Wouters477c8d52006-05-27 19:21:47 +00001750
1751static int
1752UnicodeEncodeError_init(PyObject *self, PyObject *args, PyObject *kwds)
1753{
Guido van Rossum98297ee2007-11-06 21:34:58 +00001754 PyUnicodeErrorObject *err;
1755
Thomas Wouters477c8d52006-05-27 19:21:47 +00001756 if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
1757 return -1;
Guido van Rossum98297ee2007-11-06 21:34:58 +00001758
1759 err = (PyUnicodeErrorObject *)self;
1760
1761 Py_CLEAR(err->encoding);
1762 Py_CLEAR(err->object);
1763 Py_CLEAR(err->reason);
1764
1765 if (!PyArg_ParseTuple(args, "O!O!nnO!",
1766 &PyUnicode_Type, &err->encoding,
1767 &PyUnicode_Type, &err->object,
1768 &err->start,
1769 &err->end,
1770 &PyUnicode_Type, &err->reason)) {
1771 err->encoding = err->object = err->reason = NULL;
1772 return -1;
1773 }
1774
Martin v. Löwisb09af032011-11-04 11:16:41 +01001775 if (PyUnicode_READY(err->object) < -1) {
1776 err->encoding = NULL;
1777 return -1;
1778 }
1779
Guido van Rossum98297ee2007-11-06 21:34:58 +00001780 Py_INCREF(err->encoding);
1781 Py_INCREF(err->object);
1782 Py_INCREF(err->reason);
1783
1784 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001785}
1786
1787static PyObject *
1788UnicodeEncodeError_str(PyObject *self)
1789{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001790 PyUnicodeErrorObject *uself = (PyUnicodeErrorObject *)self;
Eric Smith0facd772010-02-24 15:42:29 +00001791 PyObject *result = NULL;
1792 PyObject *reason_str = NULL;
1793 PyObject *encoding_str = NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001794
Eric Smith0facd772010-02-24 15:42:29 +00001795 /* Get reason and encoding as strings, which they might not be if
1796 they've been modified after we were contructed. */
1797 reason_str = PyObject_Str(uself->reason);
1798 if (reason_str == NULL)
1799 goto done;
1800 encoding_str = PyObject_Str(uself->encoding);
1801 if (encoding_str == NULL)
1802 goto done;
1803
Victor Stinnerda1ddf32011-11-20 22:50:23 +01001804 if (uself->start < PyUnicode_GET_LENGTH(uself->object) && uself->end == uself->start+1) {
1805 Py_UCS4 badchar = PyUnicode_ReadChar(uself->object, uself->start);
Walter Dörwald787b03b2007-06-05 13:29:29 +00001806 const char *fmt;
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001807 if (badchar <= 0xff)
Walter Dörwald32a4c712007-06-20 09:25:34 +00001808 fmt = "'%U' codec can't encode character '\\x%02x' in position %zd: %U";
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001809 else if (badchar <= 0xffff)
Walter Dörwald32a4c712007-06-20 09:25:34 +00001810 fmt = "'%U' codec can't encode character '\\u%04x' in position %zd: %U";
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001811 else
Walter Dörwald32a4c712007-06-20 09:25:34 +00001812 fmt = "'%U' codec can't encode character '\\U%08x' in position %zd: %U";
Eric Smith0facd772010-02-24 15:42:29 +00001813 result = PyUnicode_FromFormat(
Walter Dörwald787b03b2007-06-05 13:29:29 +00001814 fmt,
Eric Smith0facd772010-02-24 15:42:29 +00001815 encoding_str,
Victor Stinnerda1ddf32011-11-20 22:50:23 +01001816 (int)badchar,
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001817 uself->start,
Eric Smith0facd772010-02-24 15:42:29 +00001818 reason_str);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001819 }
Eric Smith0facd772010-02-24 15:42:29 +00001820 else {
1821 result = PyUnicode_FromFormat(
1822 "'%U' codec can't encode characters in position %zd-%zd: %U",
1823 encoding_str,
1824 uself->start,
1825 uself->end-1,
1826 reason_str);
1827 }
1828done:
1829 Py_XDECREF(reason_str);
1830 Py_XDECREF(encoding_str);
1831 return result;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001832}
1833
1834static PyTypeObject _PyExc_UnicodeEncodeError = {
Martin v. Löwis9f2e3462007-07-21 17:22:18 +00001835 PyVarObject_HEAD_INIT(NULL, 0)
Neal Norwitz2633c692007-02-26 22:22:47 +00001836 "UnicodeEncodeError",
Thomas Wouters477c8d52006-05-27 19:21:47 +00001837 sizeof(PyUnicodeErrorObject), 0,
1838 (destructor)UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1839 (reprfunc)UnicodeEncodeError_str, 0, 0, 0,
1840 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001841 PyDoc_STR("Unicode encoding error."), (traverseproc)UnicodeError_traverse,
1842 (inquiry)UnicodeError_clear, 0, 0, 0, 0, 0, UnicodeError_members,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001843 0, &_PyExc_UnicodeError, 0, 0, 0, offsetof(PyUnicodeErrorObject, dict),
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001844 (initproc)UnicodeEncodeError_init, 0, BaseException_new,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001845};
1846PyObject *PyExc_UnicodeEncodeError = (PyObject *)&_PyExc_UnicodeEncodeError;
1847
1848PyObject *
1849PyUnicodeEncodeError_Create(
1850 const char *encoding, const Py_UNICODE *object, Py_ssize_t length,
1851 Py_ssize_t start, Py_ssize_t end, const char *reason)
1852{
Victor Stinner7eeb5b52010-06-07 19:57:46 +00001853 return PyObject_CallFunction(PyExc_UnicodeEncodeError, "su#nns",
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001854 encoding, object, length, start, end, reason);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001855}
1856
1857
1858/*
1859 * UnicodeDecodeError extends UnicodeError
1860 */
Thomas Wouters477c8d52006-05-27 19:21:47 +00001861
1862static int
1863UnicodeDecodeError_init(PyObject *self, PyObject *args, PyObject *kwds)
1864{
Guido van Rossum98297ee2007-11-06 21:34:58 +00001865 PyUnicodeErrorObject *ude;
1866 const char *data;
1867 Py_ssize_t size;
1868
Thomas Wouters477c8d52006-05-27 19:21:47 +00001869 if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
1870 return -1;
Guido van Rossum98297ee2007-11-06 21:34:58 +00001871
1872 ude = (PyUnicodeErrorObject *)self;
1873
1874 Py_CLEAR(ude->encoding);
1875 Py_CLEAR(ude->object);
1876 Py_CLEAR(ude->reason);
1877
1878 if (!PyArg_ParseTuple(args, "O!OnnO!",
1879 &PyUnicode_Type, &ude->encoding,
1880 &ude->object,
1881 &ude->start,
1882 &ude->end,
1883 &PyUnicode_Type, &ude->reason)) {
1884 ude->encoding = ude->object = ude->reason = NULL;
1885 return -1;
1886 }
1887
Christian Heimes72b710a2008-05-26 13:28:38 +00001888 if (!PyBytes_Check(ude->object)) {
Guido van Rossum98297ee2007-11-06 21:34:58 +00001889 if (PyObject_AsReadBuffer(ude->object, (const void **)&data, &size)) {
1890 ude->encoding = ude->object = ude->reason = NULL;
1891 return -1;
1892 }
Christian Heimes72b710a2008-05-26 13:28:38 +00001893 ude->object = PyBytes_FromStringAndSize(data, size);
Guido van Rossum98297ee2007-11-06 21:34:58 +00001894 }
1895 else {
1896 Py_INCREF(ude->object);
1897 }
1898
1899 Py_INCREF(ude->encoding);
1900 Py_INCREF(ude->reason);
1901
1902 return 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001903}
1904
1905static PyObject *
1906UnicodeDecodeError_str(PyObject *self)
1907{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001908 PyUnicodeErrorObject *uself = (PyUnicodeErrorObject *)self;
Eric Smith0facd772010-02-24 15:42:29 +00001909 PyObject *result = NULL;
1910 PyObject *reason_str = NULL;
1911 PyObject *encoding_str = NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001912
Eric Smith0facd772010-02-24 15:42:29 +00001913 /* Get reason and encoding as strings, which they might not be if
1914 they've been modified after we were contructed. */
1915 reason_str = PyObject_Str(uself->reason);
1916 if (reason_str == NULL)
1917 goto done;
1918 encoding_str = PyObject_Str(uself->encoding);
1919 if (encoding_str == NULL)
1920 goto done;
1921
1922 if (uself->start < PyBytes_GET_SIZE(uself->object) && uself->end == uself->start+1) {
Christian Heimes72b710a2008-05-26 13:28:38 +00001923 int byte = (int)(PyBytes_AS_STRING(((PyUnicodeErrorObject *)self)->object)[uself->start]&0xff);
Eric Smith0facd772010-02-24 15:42:29 +00001924 result = PyUnicode_FromFormat(
Walter Dörwald787b03b2007-06-05 13:29:29 +00001925 "'%U' codec can't decode byte 0x%02x in position %zd: %U",
Eric Smith0facd772010-02-24 15:42:29 +00001926 encoding_str,
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001927 byte,
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001928 uself->start,
Eric Smith0facd772010-02-24 15:42:29 +00001929 reason_str);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001930 }
Eric Smith0facd772010-02-24 15:42:29 +00001931 else {
1932 result = PyUnicode_FromFormat(
1933 "'%U' codec can't decode bytes in position %zd-%zd: %U",
1934 encoding_str,
1935 uself->start,
1936 uself->end-1,
1937 reason_str
1938 );
1939 }
1940done:
1941 Py_XDECREF(reason_str);
1942 Py_XDECREF(encoding_str);
1943 return result;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001944}
1945
1946static PyTypeObject _PyExc_UnicodeDecodeError = {
Martin v. Löwis9f2e3462007-07-21 17:22:18 +00001947 PyVarObject_HEAD_INIT(NULL, 0)
Neal Norwitz2633c692007-02-26 22:22:47 +00001948 "UnicodeDecodeError",
Thomas Wouters477c8d52006-05-27 19:21:47 +00001949 sizeof(PyUnicodeErrorObject), 0,
1950 (destructor)UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1951 (reprfunc)UnicodeDecodeError_str, 0, 0, 0,
1952 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001953 PyDoc_STR("Unicode decoding error."), (traverseproc)UnicodeError_traverse,
1954 (inquiry)UnicodeError_clear, 0, 0, 0, 0, 0, UnicodeError_members,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001955 0, &_PyExc_UnicodeError, 0, 0, 0, offsetof(PyUnicodeErrorObject, dict),
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001956 (initproc)UnicodeDecodeError_init, 0, BaseException_new,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001957};
1958PyObject *PyExc_UnicodeDecodeError = (PyObject *)&_PyExc_UnicodeDecodeError;
1959
1960PyObject *
1961PyUnicodeDecodeError_Create(
1962 const char *encoding, const char *object, Py_ssize_t length,
1963 Py_ssize_t start, Py_ssize_t end, const char *reason)
1964{
Victor Stinner7eeb5b52010-06-07 19:57:46 +00001965 return PyObject_CallFunction(PyExc_UnicodeDecodeError, "sy#nns",
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001966 encoding, object, length, start, end, reason);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001967}
1968
1969
1970/*
1971 * UnicodeTranslateError extends UnicodeError
1972 */
Thomas Wouters477c8d52006-05-27 19:21:47 +00001973
1974static int
1975UnicodeTranslateError_init(PyUnicodeErrorObject *self, PyObject *args,
1976 PyObject *kwds)
1977{
1978 if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
1979 return -1;
1980
1981 Py_CLEAR(self->object);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001982 Py_CLEAR(self->reason);
1983
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001984 if (!PyArg_ParseTuple(args, "O!nnO!",
Thomas Wouters477c8d52006-05-27 19:21:47 +00001985 &PyUnicode_Type, &self->object,
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001986 &self->start,
1987 &self->end,
Walter Dörwaldd2034312007-05-18 16:29:38 +00001988 &PyUnicode_Type, &self->reason)) {
Guido van Rossum7eaf8222007-06-18 17:58:50 +00001989 self->object = self->reason = NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001990 return -1;
1991 }
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001992
Thomas Wouters477c8d52006-05-27 19:21:47 +00001993 Py_INCREF(self->object);
Thomas Wouters477c8d52006-05-27 19:21:47 +00001994 Py_INCREF(self->reason);
1995
1996 return 0;
1997}
1998
1999
2000static PyObject *
2001UnicodeTranslateError_str(PyObject *self)
2002{
Guido van Rossum7eaf8222007-06-18 17:58:50 +00002003 PyUnicodeErrorObject *uself = (PyUnicodeErrorObject *)self;
Eric Smith0facd772010-02-24 15:42:29 +00002004 PyObject *result = NULL;
2005 PyObject *reason_str = NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002006
Eric Smith0facd772010-02-24 15:42:29 +00002007 /* Get reason as a string, which it might not be if it's been
2008 modified after we were contructed. */
2009 reason_str = PyObject_Str(uself->reason);
2010 if (reason_str == NULL)
2011 goto done;
2012
Victor Stinner53b33e72011-11-21 01:17:27 +01002013 if (uself->start < PyUnicode_GET_LENGTH(uself->object) && uself->end == uself->start+1) {
2014 Py_UCS4 badchar = PyUnicode_ReadChar(uself->object, uself->start);
Walter Dörwald787b03b2007-06-05 13:29:29 +00002015 const char *fmt;
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00002016 if (badchar <= 0xff)
Walter Dörwald32a4c712007-06-20 09:25:34 +00002017 fmt = "can't translate character '\\x%02x' in position %zd: %U";
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00002018 else if (badchar <= 0xffff)
Walter Dörwald32a4c712007-06-20 09:25:34 +00002019 fmt = "can't translate character '\\u%04x' in position %zd: %U";
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00002020 else
Walter Dörwald32a4c712007-06-20 09:25:34 +00002021 fmt = "can't translate character '\\U%08x' in position %zd: %U";
Benjamin Petersonc5f4e1e2010-02-25 01:22:28 +00002022 result = PyUnicode_FromFormat(
Walter Dörwald787b03b2007-06-05 13:29:29 +00002023 fmt,
Victor Stinner53b33e72011-11-21 01:17:27 +01002024 (int)badchar,
Guido van Rossum7eaf8222007-06-18 17:58:50 +00002025 uself->start,
Eric Smith0facd772010-02-24 15:42:29 +00002026 reason_str
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00002027 );
Eric Smith0facd772010-02-24 15:42:29 +00002028 } else {
2029 result = PyUnicode_FromFormat(
2030 "can't translate characters in position %zd-%zd: %U",
2031 uself->start,
2032 uself->end-1,
2033 reason_str
2034 );
Thomas Wouters477c8d52006-05-27 19:21:47 +00002035 }
Eric Smith0facd772010-02-24 15:42:29 +00002036done:
2037 Py_XDECREF(reason_str);
2038 return result;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002039}
2040
2041static PyTypeObject _PyExc_UnicodeTranslateError = {
Martin v. Löwis9f2e3462007-07-21 17:22:18 +00002042 PyVarObject_HEAD_INIT(NULL, 0)
Neal Norwitz2633c692007-02-26 22:22:47 +00002043 "UnicodeTranslateError",
Thomas Wouters477c8d52006-05-27 19:21:47 +00002044 sizeof(PyUnicodeErrorObject), 0,
2045 (destructor)UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2046 (reprfunc)UnicodeTranslateError_str, 0, 0, 0,
2047 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
Thomas Wouters89f507f2006-12-13 04:49:30 +00002048 PyDoc_STR("Unicode translation error."), (traverseproc)UnicodeError_traverse,
Thomas Wouters477c8d52006-05-27 19:21:47 +00002049 (inquiry)UnicodeError_clear, 0, 0, 0, 0, 0, UnicodeError_members,
2050 0, &_PyExc_UnicodeError, 0, 0, 0, offsetof(PyUnicodeErrorObject, dict),
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00002051 (initproc)UnicodeTranslateError_init, 0, BaseException_new,
Thomas Wouters477c8d52006-05-27 19:21:47 +00002052};
2053PyObject *PyExc_UnicodeTranslateError = (PyObject *)&_PyExc_UnicodeTranslateError;
2054
Martin v. Löwisd63a3b82011-09-28 07:41:54 +02002055/* Deprecated. */
Thomas Wouters477c8d52006-05-27 19:21:47 +00002056PyObject *
2057PyUnicodeTranslateError_Create(
2058 const Py_UNICODE *object, Py_ssize_t length,
2059 Py_ssize_t start, Py_ssize_t end, const char *reason)
2060{
2061 return PyObject_CallFunction(PyExc_UnicodeTranslateError, "u#nns",
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00002062 object, length, start, end, reason);
Thomas Wouters477c8d52006-05-27 19:21:47 +00002063}
Thomas Wouters477c8d52006-05-27 19:21:47 +00002064
Martin v. Löwisd63a3b82011-09-28 07:41:54 +02002065PyObject *
2066_PyUnicodeTranslateError_Create(
2067 PyObject *object,
2068 Py_ssize_t start, Py_ssize_t end, const char *reason)
2069{
2070 return PyObject_CallFunction(PyExc_UnicodeTranslateError, "Ons",
2071 object, start, end, reason);
2072}
Thomas Wouters477c8d52006-05-27 19:21:47 +00002073
2074/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00002075 * AssertionError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00002076 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +00002077SimpleExtendsException(PyExc_Exception, AssertionError,
Thomas Wouters477c8d52006-05-27 19:21:47 +00002078 "Assertion failed.");
2079
2080
2081/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00002082 * ArithmeticError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00002083 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +00002084SimpleExtendsException(PyExc_Exception, ArithmeticError,
Thomas Wouters477c8d52006-05-27 19:21:47 +00002085 "Base class for arithmetic errors.");
2086
2087
2088/*
2089 * FloatingPointError extends ArithmeticError
2090 */
2091SimpleExtendsException(PyExc_ArithmeticError, FloatingPointError,
2092 "Floating point operation failed.");
2093
2094
2095/*
2096 * OverflowError extends ArithmeticError
2097 */
2098SimpleExtendsException(PyExc_ArithmeticError, OverflowError,
2099 "Result too large to be represented.");
2100
2101
2102/*
2103 * ZeroDivisionError extends ArithmeticError
2104 */
2105SimpleExtendsException(PyExc_ArithmeticError, ZeroDivisionError,
2106 "Second argument to a division or modulo operation was zero.");
2107
2108
2109/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00002110 * SystemError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00002111 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +00002112SimpleExtendsException(PyExc_Exception, SystemError,
Thomas Wouters477c8d52006-05-27 19:21:47 +00002113 "Internal error in the Python interpreter.\n"
2114 "\n"
2115 "Please report this to the Python maintainer, along with the traceback,\n"
2116 "the Python version, and the hardware/OS platform and version.");
2117
2118
2119/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00002120 * ReferenceError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00002121 */
Guido van Rossumcd16bf62007-06-13 18:07:49 +00002122SimpleExtendsException(PyExc_Exception, ReferenceError,
Thomas Wouters477c8d52006-05-27 19:21:47 +00002123 "Weak ref proxy used after referent went away.");
2124
2125
2126/*
Guido van Rossumcd16bf62007-06-13 18:07:49 +00002127 * MemoryError extends Exception
Thomas Wouters477c8d52006-05-27 19:21:47 +00002128 */
Antoine Pitrou07e20ef2010-10-28 22:56:58 +00002129
2130#define MEMERRORS_SAVE 16
2131static PyBaseExceptionObject *memerrors_freelist = NULL;
2132static int memerrors_numfree = 0;
2133
2134static PyObject *
2135MemoryError_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
2136{
2137 PyBaseExceptionObject *self;
2138
2139 if (type != (PyTypeObject *) PyExc_MemoryError)
2140 return BaseException_new(type, args, kwds);
2141 if (memerrors_freelist == NULL)
2142 return BaseException_new(type, args, kwds);
2143 /* Fetch object from freelist and revive it */
2144 self = memerrors_freelist;
2145 self->args = PyTuple_New(0);
2146 /* This shouldn't happen since the empty tuple is persistent */
2147 if (self->args == NULL)
2148 return NULL;
2149 memerrors_freelist = (PyBaseExceptionObject *) self->dict;
2150 memerrors_numfree--;
2151 self->dict = NULL;
2152 _Py_NewReference((PyObject *)self);
2153 _PyObject_GC_TRACK(self);
2154 return (PyObject *)self;
2155}
2156
2157static void
2158MemoryError_dealloc(PyBaseExceptionObject *self)
2159{
2160 _PyObject_GC_UNTRACK(self);
2161 BaseException_clear(self);
2162 if (memerrors_numfree >= MEMERRORS_SAVE)
2163 Py_TYPE(self)->tp_free((PyObject *)self);
2164 else {
2165 self->dict = (PyObject *) memerrors_freelist;
2166 memerrors_freelist = self;
2167 memerrors_numfree++;
2168 }
2169}
2170
2171static void
2172preallocate_memerrors(void)
2173{
2174 /* We create enough MemoryErrors and then decref them, which will fill
2175 up the freelist. */
2176 int i;
2177 PyObject *errors[MEMERRORS_SAVE];
2178 for (i = 0; i < MEMERRORS_SAVE; i++) {
2179 errors[i] = MemoryError_new((PyTypeObject *) PyExc_MemoryError,
2180 NULL, NULL);
2181 if (!errors[i])
2182 Py_FatalError("Could not preallocate MemoryError object");
2183 }
2184 for (i = 0; i < MEMERRORS_SAVE; i++) {
2185 Py_DECREF(errors[i]);
2186 }
2187}
2188
2189static void
2190free_preallocated_memerrors(void)
2191{
2192 while (memerrors_freelist != NULL) {
2193 PyObject *self = (PyObject *) memerrors_freelist;
2194 memerrors_freelist = (PyBaseExceptionObject *) memerrors_freelist->dict;
2195 Py_TYPE(self)->tp_free((PyObject *)self);
2196 }
2197}
2198
2199
2200static PyTypeObject _PyExc_MemoryError = {
2201 PyVarObject_HEAD_INIT(NULL, 0)
2202 "MemoryError",
2203 sizeof(PyBaseExceptionObject),
2204 0, (destructor)MemoryError_dealloc, 0, 0, 0, 0, 0, 0, 0,
2205 0, 0, 0, 0, 0, 0, 0,
2206 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
2207 PyDoc_STR("Out of memory."), (traverseproc)BaseException_traverse,
2208 (inquiry)BaseException_clear, 0, 0, 0, 0, 0, 0, 0, &_PyExc_Exception,
2209 0, 0, 0, offsetof(PyBaseExceptionObject, dict),
2210 (initproc)BaseException_init, 0, MemoryError_new
2211};
2212PyObject *PyExc_MemoryError = (PyObject *) &_PyExc_MemoryError;
2213
Thomas Wouters477c8d52006-05-27 19:21:47 +00002214
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00002215/*
2216 * BufferError extends Exception
2217 */
2218SimpleExtendsException(PyExc_Exception, BufferError, "Buffer error.");
2219
Thomas Wouters477c8d52006-05-27 19:21:47 +00002220
2221/* Warning category docstrings */
2222
2223/*
2224 * Warning extends Exception
2225 */
2226SimpleExtendsException(PyExc_Exception, Warning,
2227 "Base class for warning categories.");
2228
2229
2230/*
2231 * UserWarning extends Warning
2232 */
2233SimpleExtendsException(PyExc_Warning, UserWarning,
2234 "Base class for warnings generated by user code.");
2235
2236
2237/*
2238 * DeprecationWarning extends Warning
2239 */
2240SimpleExtendsException(PyExc_Warning, DeprecationWarning,
2241 "Base class for warnings about deprecated features.");
2242
2243
2244/*
2245 * PendingDeprecationWarning extends Warning
2246 */
2247SimpleExtendsException(PyExc_Warning, PendingDeprecationWarning,
2248 "Base class for warnings about features which will be deprecated\n"
2249 "in the future.");
2250
2251
2252/*
2253 * SyntaxWarning extends Warning
2254 */
2255SimpleExtendsException(PyExc_Warning, SyntaxWarning,
2256 "Base class for warnings about dubious syntax.");
2257
2258
2259/*
2260 * RuntimeWarning extends Warning
2261 */
2262SimpleExtendsException(PyExc_Warning, RuntimeWarning,
2263 "Base class for warnings about dubious runtime behavior.");
2264
2265
2266/*
2267 * FutureWarning extends Warning
2268 */
2269SimpleExtendsException(PyExc_Warning, FutureWarning,
2270 "Base class for warnings about constructs that will change semantically\n"
2271 "in the future.");
2272
2273
2274/*
2275 * ImportWarning extends Warning
2276 */
2277SimpleExtendsException(PyExc_Warning, ImportWarning,
2278 "Base class for warnings about probable mistakes in module imports");
2279
2280
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00002281/*
2282 * UnicodeWarning extends Warning
2283 */
2284SimpleExtendsException(PyExc_Warning, UnicodeWarning,
2285 "Base class for warnings about Unicode related problems, mostly\n"
2286 "related to conversion problems.");
2287
Georg Brandl08be72d2010-10-24 15:11:22 +00002288
Guido van Rossum98297ee2007-11-06 21:34:58 +00002289/*
2290 * BytesWarning extends Warning
2291 */
2292SimpleExtendsException(PyExc_Warning, BytesWarning,
2293 "Base class for warnings about bytes and buffer related problems, mostly\n"
2294 "related to conversion from str or comparing to str.");
2295
2296
Georg Brandl08be72d2010-10-24 15:11:22 +00002297/*
2298 * ResourceWarning extends Warning
2299 */
2300SimpleExtendsException(PyExc_Warning, ResourceWarning,
2301 "Base class for warnings about resource usage.");
2302
2303
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00002304
Thomas Wouters89d996e2007-09-08 17:39:28 +00002305/* Pre-computed RuntimeError instance for when recursion depth is reached.
2306 Meant to be used when normalizing the exception for exceeding the recursion
2307 depth will cause its own infinite recursion.
2308*/
2309PyObject *PyExc_RecursionErrorInst = NULL;
2310
Antoine Pitrou55f217f2012-01-18 21:23:13 +01002311#define PRE_INIT(TYPE) \
2312 if (!(_PyExc_ ## TYPE.tp_flags & Py_TPFLAGS_READY)) { \
2313 if (PyType_Ready(&_PyExc_ ## TYPE) < 0) \
2314 Py_FatalError("exceptions bootstrapping error."); \
2315 Py_INCREF(PyExc_ ## TYPE); \
2316 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002317
Antoine Pitrou55f217f2012-01-18 21:23:13 +01002318#define POST_INIT(TYPE) \
Thomas Wouters477c8d52006-05-27 19:21:47 +00002319 if (PyDict_SetItemString(bdict, # TYPE, PyExc_ ## TYPE)) \
2320 Py_FatalError("Module dictionary insertion problem.");
2321
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002322#define INIT_ALIAS(NAME, TYPE) Py_INCREF(PyExc_ ## TYPE); \
Antoine Pitrou8b0a74e2012-01-18 21:29:05 +01002323 Py_XDECREF(PyExc_ ## NAME); \
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002324 PyExc_ ## NAME = PyExc_ ## TYPE; \
2325 if (PyDict_SetItemString(bdict, # NAME, PyExc_ ## NAME)) \
2326 Py_FatalError("Module dictionary insertion problem.");
2327
2328#define ADD_ERRNO(TYPE, CODE) { \
2329 PyObject *_code = PyLong_FromLong(CODE); \
2330 assert(_PyObject_RealIsSubclass(PyExc_ ## TYPE, PyExc_OSError)); \
2331 if (!_code || PyDict_SetItem(errnomap, _code, PyExc_ ## TYPE)) \
2332 Py_FatalError("errmap insertion problem."); \
Antoine Pitrou8b0a74e2012-01-18 21:29:05 +01002333 Py_DECREF(_code); \
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002334 }
2335
2336#ifdef MS_WINDOWS
Antoine Pitrou7faf7052013-03-31 22:48:04 +02002337#include <winsock2.h>
Brian Curtin401f9f32012-05-13 11:19:23 -05002338/* The following constants were added to errno.h in VS2010 but have
2339 preferred WSA equivalents. */
2340#undef EADDRINUSE
2341#undef EADDRNOTAVAIL
2342#undef EAFNOSUPPORT
2343#undef EALREADY
2344#undef ECONNABORTED
2345#undef ECONNREFUSED
2346#undef ECONNRESET
2347#undef EDESTADDRREQ
2348#undef EHOSTUNREACH
2349#undef EINPROGRESS
2350#undef EISCONN
2351#undef ELOOP
2352#undef EMSGSIZE
2353#undef ENETDOWN
2354#undef ENETRESET
2355#undef ENETUNREACH
2356#undef ENOBUFS
2357#undef ENOPROTOOPT
2358#undef ENOTCONN
2359#undef ENOTSOCK
2360#undef EOPNOTSUPP
2361#undef EPROTONOSUPPORT
2362#undef EPROTOTYPE
2363#undef ETIMEDOUT
2364#undef EWOULDBLOCK
2365
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002366#if defined(WSAEALREADY) && !defined(EALREADY)
2367#define EALREADY WSAEALREADY
2368#endif
2369#if defined(WSAECONNABORTED) && !defined(ECONNABORTED)
2370#define ECONNABORTED WSAECONNABORTED
2371#endif
2372#if defined(WSAECONNREFUSED) && !defined(ECONNREFUSED)
2373#define ECONNREFUSED WSAECONNREFUSED
2374#endif
2375#if defined(WSAECONNRESET) && !defined(ECONNRESET)
2376#define ECONNRESET WSAECONNRESET
2377#endif
2378#if defined(WSAEINPROGRESS) && !defined(EINPROGRESS)
2379#define EINPROGRESS WSAEINPROGRESS
2380#endif
2381#if defined(WSAESHUTDOWN) && !defined(ESHUTDOWN)
2382#define ESHUTDOWN WSAESHUTDOWN
2383#endif
2384#if defined(WSAETIMEDOUT) && !defined(ETIMEDOUT)
2385#define ETIMEDOUT WSAETIMEDOUT
2386#endif
2387#if defined(WSAEWOULDBLOCK) && !defined(EWOULDBLOCK)
2388#define EWOULDBLOCK WSAEWOULDBLOCK
2389#endif
2390#endif /* MS_WINDOWS */
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002391
Martin v. Löwis1a214512008-06-11 05:26:20 +00002392void
Brett Cannonfd074152012-04-14 14:10:13 -04002393_PyExc_Init(PyObject *bltinmod)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002394{
Brett Cannonfd074152012-04-14 14:10:13 -04002395 PyObject *bdict;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002396
2397 PRE_INIT(BaseException)
2398 PRE_INIT(Exception)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002399 PRE_INIT(TypeError)
2400 PRE_INIT(StopIteration)
2401 PRE_INIT(GeneratorExit)
2402 PRE_INIT(SystemExit)
2403 PRE_INIT(KeyboardInterrupt)
2404 PRE_INIT(ImportError)
Brett Cannonb1611e22013-06-12 16:59:46 -04002405 PRE_INIT(ModuleNotFoundError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002406 PRE_INIT(OSError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002407 PRE_INIT(EOFError)
2408 PRE_INIT(RuntimeError)
2409 PRE_INIT(NotImplementedError)
2410 PRE_INIT(NameError)
2411 PRE_INIT(UnboundLocalError)
2412 PRE_INIT(AttributeError)
2413 PRE_INIT(SyntaxError)
2414 PRE_INIT(IndentationError)
2415 PRE_INIT(TabError)
2416 PRE_INIT(LookupError)
2417 PRE_INIT(IndexError)
2418 PRE_INIT(KeyError)
2419 PRE_INIT(ValueError)
2420 PRE_INIT(UnicodeError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002421 PRE_INIT(UnicodeEncodeError)
2422 PRE_INIT(UnicodeDecodeError)
2423 PRE_INIT(UnicodeTranslateError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002424 PRE_INIT(AssertionError)
2425 PRE_INIT(ArithmeticError)
2426 PRE_INIT(FloatingPointError)
2427 PRE_INIT(OverflowError)
2428 PRE_INIT(ZeroDivisionError)
2429 PRE_INIT(SystemError)
2430 PRE_INIT(ReferenceError)
Neal Norwitzfaa54a32007-08-19 04:23:20 +00002431 PRE_INIT(BufferError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002432 PRE_INIT(MemoryError)
Benjamin Peterson2b968d62008-07-05 23:38:30 +00002433 PRE_INIT(BufferError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002434 PRE_INIT(Warning)
2435 PRE_INIT(UserWarning)
2436 PRE_INIT(DeprecationWarning)
2437 PRE_INIT(PendingDeprecationWarning)
2438 PRE_INIT(SyntaxWarning)
2439 PRE_INIT(RuntimeWarning)
2440 PRE_INIT(FutureWarning)
2441 PRE_INIT(ImportWarning)
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00002442 PRE_INIT(UnicodeWarning)
Guido van Rossum98297ee2007-11-06 21:34:58 +00002443 PRE_INIT(BytesWarning)
Georg Brandl08be72d2010-10-24 15:11:22 +00002444 PRE_INIT(ResourceWarning)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002445
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002446 /* OSError subclasses */
2447 PRE_INIT(ConnectionError);
2448
2449 PRE_INIT(BlockingIOError);
2450 PRE_INIT(BrokenPipeError);
2451 PRE_INIT(ChildProcessError);
2452 PRE_INIT(ConnectionAbortedError);
2453 PRE_INIT(ConnectionRefusedError);
2454 PRE_INIT(ConnectionResetError);
2455 PRE_INIT(FileExistsError);
2456 PRE_INIT(FileNotFoundError);
2457 PRE_INIT(IsADirectoryError);
2458 PRE_INIT(NotADirectoryError);
2459 PRE_INIT(InterruptedError);
2460 PRE_INIT(PermissionError);
2461 PRE_INIT(ProcessLookupError);
2462 PRE_INIT(TimeoutError);
2463
Thomas Wouters477c8d52006-05-27 19:21:47 +00002464 bdict = PyModule_GetDict(bltinmod);
2465 if (bdict == NULL)
2466 Py_FatalError("exceptions bootstrapping error.");
2467
2468 POST_INIT(BaseException)
2469 POST_INIT(Exception)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002470 POST_INIT(TypeError)
2471 POST_INIT(StopIteration)
2472 POST_INIT(GeneratorExit)
2473 POST_INIT(SystemExit)
2474 POST_INIT(KeyboardInterrupt)
2475 POST_INIT(ImportError)
Brett Cannonb1611e22013-06-12 16:59:46 -04002476 POST_INIT(ModuleNotFoundError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002477 POST_INIT(OSError)
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002478 INIT_ALIAS(EnvironmentError, OSError)
2479 INIT_ALIAS(IOError, OSError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002480#ifdef MS_WINDOWS
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002481 INIT_ALIAS(WindowsError, OSError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002482#endif
2483#ifdef __VMS
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002484 INIT_ALIAS(VMSError, OSError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002485#endif
2486 POST_INIT(EOFError)
2487 POST_INIT(RuntimeError)
2488 POST_INIT(NotImplementedError)
2489 POST_INIT(NameError)
2490 POST_INIT(UnboundLocalError)
2491 POST_INIT(AttributeError)
2492 POST_INIT(SyntaxError)
2493 POST_INIT(IndentationError)
2494 POST_INIT(TabError)
2495 POST_INIT(LookupError)
2496 POST_INIT(IndexError)
2497 POST_INIT(KeyError)
2498 POST_INIT(ValueError)
2499 POST_INIT(UnicodeError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002500 POST_INIT(UnicodeEncodeError)
2501 POST_INIT(UnicodeDecodeError)
2502 POST_INIT(UnicodeTranslateError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002503 POST_INIT(AssertionError)
2504 POST_INIT(ArithmeticError)
2505 POST_INIT(FloatingPointError)
2506 POST_INIT(OverflowError)
2507 POST_INIT(ZeroDivisionError)
2508 POST_INIT(SystemError)
2509 POST_INIT(ReferenceError)
Neal Norwitzfaa54a32007-08-19 04:23:20 +00002510 POST_INIT(BufferError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002511 POST_INIT(MemoryError)
Benjamin Peterson2b968d62008-07-05 23:38:30 +00002512 POST_INIT(BufferError)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002513 POST_INIT(Warning)
2514 POST_INIT(UserWarning)
2515 POST_INIT(DeprecationWarning)
2516 POST_INIT(PendingDeprecationWarning)
2517 POST_INIT(SyntaxWarning)
2518 POST_INIT(RuntimeWarning)
2519 POST_INIT(FutureWarning)
2520 POST_INIT(ImportWarning)
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00002521 POST_INIT(UnicodeWarning)
Guido van Rossum98297ee2007-11-06 21:34:58 +00002522 POST_INIT(BytesWarning)
Georg Brandl08be72d2010-10-24 15:11:22 +00002523 POST_INIT(ResourceWarning)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002524
Antoine Pitrouac456a12012-01-18 21:35:21 +01002525 if (!errnomap) {
2526 errnomap = PyDict_New();
2527 if (!errnomap)
2528 Py_FatalError("Cannot allocate map from errnos to OSError subclasses");
2529 }
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002530
2531 /* OSError subclasses */
2532 POST_INIT(ConnectionError);
2533
2534 POST_INIT(BlockingIOError);
2535 ADD_ERRNO(BlockingIOError, EAGAIN);
2536 ADD_ERRNO(BlockingIOError, EALREADY);
2537 ADD_ERRNO(BlockingIOError, EINPROGRESS);
2538 ADD_ERRNO(BlockingIOError, EWOULDBLOCK);
2539 POST_INIT(BrokenPipeError);
2540 ADD_ERRNO(BrokenPipeError, EPIPE);
2541 ADD_ERRNO(BrokenPipeError, ESHUTDOWN);
2542 POST_INIT(ChildProcessError);
2543 ADD_ERRNO(ChildProcessError, ECHILD);
2544 POST_INIT(ConnectionAbortedError);
2545 ADD_ERRNO(ConnectionAbortedError, ECONNABORTED);
2546 POST_INIT(ConnectionRefusedError);
2547 ADD_ERRNO(ConnectionRefusedError, ECONNREFUSED);
2548 POST_INIT(ConnectionResetError);
2549 ADD_ERRNO(ConnectionResetError, ECONNRESET);
2550 POST_INIT(FileExistsError);
2551 ADD_ERRNO(FileExistsError, EEXIST);
2552 POST_INIT(FileNotFoundError);
2553 ADD_ERRNO(FileNotFoundError, ENOENT);
2554 POST_INIT(IsADirectoryError);
2555 ADD_ERRNO(IsADirectoryError, EISDIR);
2556 POST_INIT(NotADirectoryError);
2557 ADD_ERRNO(NotADirectoryError, ENOTDIR);
2558 POST_INIT(InterruptedError);
2559 ADD_ERRNO(InterruptedError, EINTR);
2560 POST_INIT(PermissionError);
2561 ADD_ERRNO(PermissionError, EACCES);
2562 ADD_ERRNO(PermissionError, EPERM);
2563 POST_INIT(ProcessLookupError);
2564 ADD_ERRNO(ProcessLookupError, ESRCH);
2565 POST_INIT(TimeoutError);
2566 ADD_ERRNO(TimeoutError, ETIMEDOUT);
2567
Antoine Pitrou07e20ef2010-10-28 22:56:58 +00002568 preallocate_memerrors();
Thomas Wouters477c8d52006-05-27 19:21:47 +00002569
Antoine Pitrou1c7ade52012-01-18 16:13:31 +01002570 if (!PyExc_RecursionErrorInst) {
2571 PyExc_RecursionErrorInst = BaseException_new(&_PyExc_RuntimeError, NULL, NULL);
2572 if (!PyExc_RecursionErrorInst)
2573 Py_FatalError("Cannot pre-allocate RuntimeError instance for "
2574 "recursion errors");
2575 else {
2576 PyBaseExceptionObject *err_inst =
2577 (PyBaseExceptionObject *)PyExc_RecursionErrorInst;
2578 PyObject *args_tuple;
2579 PyObject *exc_message;
2580 exc_message = PyUnicode_FromString("maximum recursion depth exceeded");
2581 if (!exc_message)
2582 Py_FatalError("cannot allocate argument for RuntimeError "
2583 "pre-allocation");
2584 args_tuple = PyTuple_Pack(1, exc_message);
2585 if (!args_tuple)
2586 Py_FatalError("cannot allocate tuple for RuntimeError "
2587 "pre-allocation");
2588 Py_DECREF(exc_message);
2589 if (BaseException_init(err_inst, args_tuple, NULL))
2590 Py_FatalError("init of pre-allocated RuntimeError failed");
2591 Py_DECREF(args_tuple);
2592 }
Thomas Wouters89d996e2007-09-08 17:39:28 +00002593 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002594}
2595
2596void
2597_PyExc_Fini(void)
2598{
Benjamin Peterson78565b22009-06-28 19:19:51 +00002599 Py_CLEAR(PyExc_RecursionErrorInst);
Antoine Pitrou07e20ef2010-10-28 22:56:58 +00002600 free_preallocated_memerrors();
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002601 Py_CLEAR(errnomap);
Thomas Wouters477c8d52006-05-27 19:21:47 +00002602}