• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
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 
7 #define PY_SSIZE_T_CLEAN
8 #include <Python.h>
9 #include "internal/mem.h"
10 #include "internal/pystate.h"
11 #include "structmember.h"
12 #include "osdefs.h"
13 
14 
15 /* Compatibility aliases */
16 PyObject *PyExc_EnvironmentError = NULL;
17 PyObject *PyExc_IOError = NULL;
18 #ifdef MS_WINDOWS
19 PyObject *PyExc_WindowsError = NULL;
20 #endif
21 
22 /* The dict map from errno codes to OSError subclasses */
23 static PyObject *errnomap = NULL;
24 
25 
26 /* NOTE: If the exception class hierarchy changes, don't forget to update
27  * Lib/test/exception_hierarchy.txt
28  */
29 
30 /*
31  *    BaseException
32  */
33 static PyObject *
BaseException_new(PyTypeObject * type,PyObject * args,PyObject * kwds)34 BaseException_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
35 {
36     PyBaseExceptionObject *self;
37 
38     self = (PyBaseExceptionObject *)type->tp_alloc(type, 0);
39     if (!self)
40         return NULL;
41     /* the dict is created on the fly in PyObject_GenericSetAttr */
42     self->dict = NULL;
43     self->traceback = self->cause = self->context = NULL;
44     self->suppress_context = 0;
45 
46     if (args) {
47         self->args = args;
48         Py_INCREF(args);
49         return (PyObject *)self;
50     }
51 
52     self->args = PyTuple_New(0);
53     if (!self->args) {
54         Py_DECREF(self);
55         return NULL;
56     }
57 
58     return (PyObject *)self;
59 }
60 
61 static int
BaseException_init(PyBaseExceptionObject * self,PyObject * args,PyObject * kwds)62 BaseException_init(PyBaseExceptionObject *self, PyObject *args, PyObject *kwds)
63 {
64     if (!_PyArg_NoKeywords(Py_TYPE(self)->tp_name, kwds))
65         return -1;
66 
67     Py_INCREF(args);
68     Py_XSETREF(self->args, args);
69 
70     return 0;
71 }
72 
73 static int
BaseException_clear(PyBaseExceptionObject * self)74 BaseException_clear(PyBaseExceptionObject *self)
75 {
76     Py_CLEAR(self->dict);
77     Py_CLEAR(self->args);
78     Py_CLEAR(self->traceback);
79     Py_CLEAR(self->cause);
80     Py_CLEAR(self->context);
81     return 0;
82 }
83 
84 static void
BaseException_dealloc(PyBaseExceptionObject * self)85 BaseException_dealloc(PyBaseExceptionObject *self)
86 {
87     _PyObject_GC_UNTRACK(self);
88     BaseException_clear(self);
89     Py_TYPE(self)->tp_free((PyObject *)self);
90 }
91 
92 static int
BaseException_traverse(PyBaseExceptionObject * self,visitproc visit,void * arg)93 BaseException_traverse(PyBaseExceptionObject *self, visitproc visit, void *arg)
94 {
95     Py_VISIT(self->dict);
96     Py_VISIT(self->args);
97     Py_VISIT(self->traceback);
98     Py_VISIT(self->cause);
99     Py_VISIT(self->context);
100     return 0;
101 }
102 
103 static PyObject *
BaseException_str(PyBaseExceptionObject * self)104 BaseException_str(PyBaseExceptionObject *self)
105 {
106     switch (PyTuple_GET_SIZE(self->args)) {
107     case 0:
108         return PyUnicode_FromString("");
109     case 1:
110         return PyObject_Str(PyTuple_GET_ITEM(self->args, 0));
111     default:
112         return PyObject_Str(self->args);
113     }
114 }
115 
116 static PyObject *
BaseException_repr(PyBaseExceptionObject * self)117 BaseException_repr(PyBaseExceptionObject *self)
118 {
119     const char *name = _PyType_Name(Py_TYPE(self));
120     if (PyTuple_GET_SIZE(self->args) == 1)
121         return PyUnicode_FromFormat("%s(%R)", name,
122                                     PyTuple_GET_ITEM(self->args, 0));
123     else
124         return PyUnicode_FromFormat("%s%R", name, self->args);
125 }
126 
127 /* Pickling support */
128 static PyObject *
BaseException_reduce(PyBaseExceptionObject * self)129 BaseException_reduce(PyBaseExceptionObject *self)
130 {
131     if (self->args && self->dict)
132         return PyTuple_Pack(3, Py_TYPE(self), self->args, self->dict);
133     else
134         return PyTuple_Pack(2, Py_TYPE(self), self->args);
135 }
136 
137 /*
138  * Needed for backward compatibility, since exceptions used to store
139  * all their attributes in the __dict__. Code is taken from cPickle's
140  * load_build function.
141  */
142 static PyObject *
BaseException_setstate(PyObject * self,PyObject * state)143 BaseException_setstate(PyObject *self, PyObject *state)
144 {
145     PyObject *d_key, *d_value;
146     Py_ssize_t i = 0;
147 
148     if (state != Py_None) {
149         if (!PyDict_Check(state)) {
150             PyErr_SetString(PyExc_TypeError, "state is not a dictionary");
151             return NULL;
152         }
153         while (PyDict_Next(state, &i, &d_key, &d_value)) {
154             if (PyObject_SetAttr(self, d_key, d_value) < 0)
155                 return NULL;
156         }
157     }
158     Py_RETURN_NONE;
159 }
160 
161 static PyObject *
BaseException_with_traceback(PyObject * self,PyObject * tb)162 BaseException_with_traceback(PyObject *self, PyObject *tb) {
163     if (PyException_SetTraceback(self, tb))
164         return NULL;
165 
166     Py_INCREF(self);
167     return self;
168 }
169 
170 PyDoc_STRVAR(with_traceback_doc,
171 "Exception.with_traceback(tb) --\n\
172     set self.__traceback__ to tb and return self.");
173 
174 
175 static PyMethodDef BaseException_methods[] = {
176    {"__reduce__", (PyCFunction)BaseException_reduce, METH_NOARGS },
177    {"__setstate__", (PyCFunction)BaseException_setstate, METH_O },
178    {"with_traceback", (PyCFunction)BaseException_with_traceback, METH_O,
179     with_traceback_doc},
180    {NULL, NULL, 0, NULL},
181 };
182 
183 static PyObject *
BaseException_get_args(PyBaseExceptionObject * self,void * Py_UNUSED (ignored))184 BaseException_get_args(PyBaseExceptionObject *self, void *Py_UNUSED(ignored))
185 {
186     if (self->args == NULL) {
187         Py_RETURN_NONE;
188     }
189     Py_INCREF(self->args);
190     return self->args;
191 }
192 
193 static int
BaseException_set_args(PyBaseExceptionObject * self,PyObject * val,void * Py_UNUSED (ignored))194 BaseException_set_args(PyBaseExceptionObject *self, PyObject *val, void *Py_UNUSED(ignored))
195 {
196     PyObject *seq;
197     if (val == NULL) {
198         PyErr_SetString(PyExc_TypeError, "args may not be deleted");
199         return -1;
200     }
201     seq = PySequence_Tuple(val);
202     if (!seq)
203         return -1;
204     Py_XSETREF(self->args, seq);
205     return 0;
206 }
207 
208 static PyObject *
BaseException_get_tb(PyBaseExceptionObject * self,void * Py_UNUSED (ignored))209 BaseException_get_tb(PyBaseExceptionObject *self, void *Py_UNUSED(ignored))
210 {
211     if (self->traceback == NULL) {
212         Py_RETURN_NONE;
213     }
214     Py_INCREF(self->traceback);
215     return self->traceback;
216 }
217 
218 static int
BaseException_set_tb(PyBaseExceptionObject * self,PyObject * tb,void * Py_UNUSED (ignored))219 BaseException_set_tb(PyBaseExceptionObject *self, PyObject *tb, void *Py_UNUSED(ignored))
220 {
221     if (tb == NULL) {
222         PyErr_SetString(PyExc_TypeError, "__traceback__ may not be deleted");
223         return -1;
224     }
225     else if (!(tb == Py_None || PyTraceBack_Check(tb))) {
226         PyErr_SetString(PyExc_TypeError,
227                         "__traceback__ must be a traceback or None");
228         return -1;
229     }
230 
231     Py_INCREF(tb);
232     Py_XSETREF(self->traceback, tb);
233     return 0;
234 }
235 
236 static PyObject *
BaseException_get_context(PyObject * self,void * Py_UNUSED (ignored))237 BaseException_get_context(PyObject *self, void *Py_UNUSED(ignored))
238 {
239     PyObject *res = PyException_GetContext(self);
240     if (res)
241         return res;  /* new reference already returned above */
242     Py_RETURN_NONE;
243 }
244 
245 static int
BaseException_set_context(PyObject * self,PyObject * arg,void * Py_UNUSED (ignored))246 BaseException_set_context(PyObject *self, PyObject *arg, void *Py_UNUSED(ignored))
247 {
248     if (arg == NULL) {
249         PyErr_SetString(PyExc_TypeError, "__context__ may not be deleted");
250         return -1;
251     } else if (arg == Py_None) {
252         arg = NULL;
253     } else if (!PyExceptionInstance_Check(arg)) {
254         PyErr_SetString(PyExc_TypeError, "exception context must be None "
255                         "or derive from BaseException");
256         return -1;
257     } else {
258         /* PyException_SetContext steals this reference */
259         Py_INCREF(arg);
260     }
261     PyException_SetContext(self, arg);
262     return 0;
263 }
264 
265 static PyObject *
BaseException_get_cause(PyObject * self,void * Py_UNUSED (ignored))266 BaseException_get_cause(PyObject *self, void *Py_UNUSED(ignored))
267 {
268     PyObject *res = PyException_GetCause(self);
269     if (res)
270         return res;  /* new reference already returned above */
271     Py_RETURN_NONE;
272 }
273 
274 static int
BaseException_set_cause(PyObject * self,PyObject * arg,void * Py_UNUSED (ignored))275 BaseException_set_cause(PyObject *self, PyObject *arg, void *Py_UNUSED(ignored))
276 {
277     if (arg == NULL) {
278         PyErr_SetString(PyExc_TypeError, "__cause__ may not be deleted");
279         return -1;
280     } else if (arg == Py_None) {
281         arg = NULL;
282     } else if (!PyExceptionInstance_Check(arg)) {
283         PyErr_SetString(PyExc_TypeError, "exception cause must be None "
284                         "or derive from BaseException");
285         return -1;
286     } else {
287         /* PyException_SetCause steals this reference */
288         Py_INCREF(arg);
289     }
290     PyException_SetCause(self, arg);
291     return 0;
292 }
293 
294 
295 static PyGetSetDef BaseException_getset[] = {
296     {"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict},
297     {"args", (getter)BaseException_get_args, (setter)BaseException_set_args},
298     {"__traceback__", (getter)BaseException_get_tb, (setter)BaseException_set_tb},
299     {"__context__", BaseException_get_context,
300      BaseException_set_context, PyDoc_STR("exception context")},
301     {"__cause__", BaseException_get_cause,
302      BaseException_set_cause, PyDoc_STR("exception cause")},
303     {NULL},
304 };
305 
306 
307 PyObject *
PyException_GetTraceback(PyObject * self)308 PyException_GetTraceback(PyObject *self) {
309     PyBaseExceptionObject *base_self = (PyBaseExceptionObject *)self;
310     Py_XINCREF(base_self->traceback);
311     return base_self->traceback;
312 }
313 
314 
315 int
PyException_SetTraceback(PyObject * self,PyObject * tb)316 PyException_SetTraceback(PyObject *self, PyObject *tb) {
317     return BaseException_set_tb((PyBaseExceptionObject *)self, tb, NULL);
318 }
319 
320 PyObject *
PyException_GetCause(PyObject * self)321 PyException_GetCause(PyObject *self) {
322     PyObject *cause = ((PyBaseExceptionObject *)self)->cause;
323     Py_XINCREF(cause);
324     return cause;
325 }
326 
327 /* Steals a reference to cause */
328 void
PyException_SetCause(PyObject * self,PyObject * cause)329 PyException_SetCause(PyObject *self, PyObject *cause)
330 {
331     ((PyBaseExceptionObject *)self)->suppress_context = 1;
332     Py_XSETREF(((PyBaseExceptionObject *)self)->cause, cause);
333 }
334 
335 PyObject *
PyException_GetContext(PyObject * self)336 PyException_GetContext(PyObject *self) {
337     PyObject *context = ((PyBaseExceptionObject *)self)->context;
338     Py_XINCREF(context);
339     return context;
340 }
341 
342 /* Steals a reference to context */
343 void
PyException_SetContext(PyObject * self,PyObject * context)344 PyException_SetContext(PyObject *self, PyObject *context)
345 {
346     Py_XSETREF(((PyBaseExceptionObject *)self)->context, context);
347 }
348 
349 
350 static struct PyMemberDef BaseException_members[] = {
351     {"__suppress_context__", T_BOOL,
352      offsetof(PyBaseExceptionObject, suppress_context)},
353     {NULL}
354 };
355 
356 
357 static PyTypeObject _PyExc_BaseException = {
358     PyVarObject_HEAD_INIT(NULL, 0)
359     "BaseException", /*tp_name*/
360     sizeof(PyBaseExceptionObject), /*tp_basicsize*/
361     0,                          /*tp_itemsize*/
362     (destructor)BaseException_dealloc, /*tp_dealloc*/
363     0,                          /*tp_print*/
364     0,                          /*tp_getattr*/
365     0,                          /*tp_setattr*/
366     0,                          /* tp_reserved; */
367     (reprfunc)BaseException_repr, /*tp_repr*/
368     0,                          /*tp_as_number*/
369     0,                          /*tp_as_sequence*/
370     0,                          /*tp_as_mapping*/
371     0,                          /*tp_hash */
372     0,                          /*tp_call*/
373     (reprfunc)BaseException_str,  /*tp_str*/
374     PyObject_GenericGetAttr,    /*tp_getattro*/
375     PyObject_GenericSetAttr,    /*tp_setattro*/
376     0,                          /*tp_as_buffer*/
377     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC |
378         Py_TPFLAGS_BASE_EXC_SUBCLASS,  /*tp_flags*/
379     PyDoc_STR("Common base class for all exceptions"), /* tp_doc */
380     (traverseproc)BaseException_traverse, /* tp_traverse */
381     (inquiry)BaseException_clear, /* tp_clear */
382     0,                          /* tp_richcompare */
383     0,                          /* tp_weaklistoffset */
384     0,                          /* tp_iter */
385     0,                          /* tp_iternext */
386     BaseException_methods,      /* tp_methods */
387     BaseException_members,      /* tp_members */
388     BaseException_getset,       /* tp_getset */
389     0,                          /* tp_base */
390     0,                          /* tp_dict */
391     0,                          /* tp_descr_get */
392     0,                          /* tp_descr_set */
393     offsetof(PyBaseExceptionObject, dict), /* tp_dictoffset */
394     (initproc)BaseException_init, /* tp_init */
395     0,                          /* tp_alloc */
396     BaseException_new,          /* tp_new */
397 };
398 /* the CPython API expects exceptions to be (PyObject *) - both a hold-over
399 from the previous implmentation and also allowing Python objects to be used
400 in the API */
401 PyObject *PyExc_BaseException = (PyObject *)&_PyExc_BaseException;
402 
403 /* note these macros omit the last semicolon so the macro invocation may
404  * include it and not look strange.
405  */
406 #define SimpleExtendsException(EXCBASE, EXCNAME, EXCDOC) \
407 static PyTypeObject _PyExc_ ## EXCNAME = { \
408     PyVarObject_HEAD_INIT(NULL, 0) \
409     # EXCNAME, \
410     sizeof(PyBaseExceptionObject), \
411     0, (destructor)BaseException_dealloc, 0, 0, 0, 0, 0, 0, 0, \
412     0, 0, 0, 0, 0, 0, 0, \
413     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \
414     PyDoc_STR(EXCDOC), (traverseproc)BaseException_traverse, \
415     (inquiry)BaseException_clear, 0, 0, 0, 0, 0, 0, 0, &_ ## EXCBASE, \
416     0, 0, 0, offsetof(PyBaseExceptionObject, dict), \
417     (initproc)BaseException_init, 0, BaseException_new,\
418 }; \
419 PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME
420 
421 #define MiddlingExtendsException(EXCBASE, EXCNAME, EXCSTORE, EXCDOC) \
422 static PyTypeObject _PyExc_ ## EXCNAME = { \
423     PyVarObject_HEAD_INIT(NULL, 0) \
424     # EXCNAME, \
425     sizeof(Py ## EXCSTORE ## Object), \
426     0, (destructor)EXCSTORE ## _dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
427     0, 0, 0, 0, 0, \
428     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \
429     PyDoc_STR(EXCDOC), (traverseproc)EXCSTORE ## _traverse, \
430     (inquiry)EXCSTORE ## _clear, 0, 0, 0, 0, 0, 0, 0, &_ ## EXCBASE, \
431     0, 0, 0, offsetof(Py ## EXCSTORE ## Object, dict), \
432     (initproc)EXCSTORE ## _init, 0, 0, \
433 }; \
434 PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME
435 
436 #define ComplexExtendsException(EXCBASE, EXCNAME, EXCSTORE, EXCNEW, \
437                                 EXCMETHODS, EXCMEMBERS, EXCGETSET, \
438                                 EXCSTR, EXCDOC) \
439 static PyTypeObject _PyExc_ ## EXCNAME = { \
440     PyVarObject_HEAD_INIT(NULL, 0) \
441     # EXCNAME, \
442     sizeof(Py ## EXCSTORE ## Object), 0, \
443     (destructor)EXCSTORE ## _dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
444     (reprfunc)EXCSTR, 0, 0, 0, \
445     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \
446     PyDoc_STR(EXCDOC), (traverseproc)EXCSTORE ## _traverse, \
447     (inquiry)EXCSTORE ## _clear, 0, 0, 0, 0, EXCMETHODS, \
448     EXCMEMBERS, EXCGETSET, &_ ## EXCBASE, \
449     0, 0, 0, offsetof(Py ## EXCSTORE ## Object, dict), \
450     (initproc)EXCSTORE ## _init, 0, EXCNEW,\
451 }; \
452 PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME
453 
454 
455 /*
456  *    Exception extends BaseException
457  */
458 SimpleExtendsException(PyExc_BaseException, Exception,
459                        "Common base class for all non-exit exceptions.");
460 
461 
462 /*
463  *    TypeError extends Exception
464  */
465 SimpleExtendsException(PyExc_Exception, TypeError,
466                        "Inappropriate argument type.");
467 
468 
469 /*
470  *    StopAsyncIteration extends Exception
471  */
472 SimpleExtendsException(PyExc_Exception, StopAsyncIteration,
473                        "Signal the end from iterator.__anext__().");
474 
475 
476 /*
477  *    StopIteration extends Exception
478  */
479 
480 static PyMemberDef StopIteration_members[] = {
481     {"value", T_OBJECT, offsetof(PyStopIterationObject, value), 0,
482         PyDoc_STR("generator return value")},
483     {NULL}  /* Sentinel */
484 };
485 
486 static int
StopIteration_init(PyStopIterationObject * self,PyObject * args,PyObject * kwds)487 StopIteration_init(PyStopIterationObject *self, PyObject *args, PyObject *kwds)
488 {
489     Py_ssize_t size = PyTuple_GET_SIZE(args);
490     PyObject *value;
491 
492     if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
493         return -1;
494     Py_CLEAR(self->value);
495     if (size > 0)
496         value = PyTuple_GET_ITEM(args, 0);
497     else
498         value = Py_None;
499     Py_INCREF(value);
500     self->value = value;
501     return 0;
502 }
503 
504 static int
StopIteration_clear(PyStopIterationObject * self)505 StopIteration_clear(PyStopIterationObject *self)
506 {
507     Py_CLEAR(self->value);
508     return BaseException_clear((PyBaseExceptionObject *)self);
509 }
510 
511 static void
StopIteration_dealloc(PyStopIterationObject * self)512 StopIteration_dealloc(PyStopIterationObject *self)
513 {
514     _PyObject_GC_UNTRACK(self);
515     StopIteration_clear(self);
516     Py_TYPE(self)->tp_free((PyObject *)self);
517 }
518 
519 static int
StopIteration_traverse(PyStopIterationObject * self,visitproc visit,void * arg)520 StopIteration_traverse(PyStopIterationObject *self, visitproc visit, void *arg)
521 {
522     Py_VISIT(self->value);
523     return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
524 }
525 
526 ComplexExtendsException(
527     PyExc_Exception,       /* base */
528     StopIteration,         /* name */
529     StopIteration,         /* prefix for *_init, etc */
530     0,                     /* new */
531     0,                     /* methods */
532     StopIteration_members, /* members */
533     0,                     /* getset */
534     0,                     /* str */
535     "Signal the end from iterator.__next__()."
536 );
537 
538 
539 /*
540  *    GeneratorExit extends BaseException
541  */
542 SimpleExtendsException(PyExc_BaseException, GeneratorExit,
543                        "Request that a generator exit.");
544 
545 
546 /*
547  *    SystemExit extends BaseException
548  */
549 
550 static int
SystemExit_init(PySystemExitObject * self,PyObject * args,PyObject * kwds)551 SystemExit_init(PySystemExitObject *self, PyObject *args, PyObject *kwds)
552 {
553     Py_ssize_t size = PyTuple_GET_SIZE(args);
554 
555     if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
556         return -1;
557 
558     if (size == 0)
559         return 0;
560     if (size == 1) {
561         Py_INCREF(PyTuple_GET_ITEM(args, 0));
562         Py_XSETREF(self->code, PyTuple_GET_ITEM(args, 0));
563     }
564     else { /* size > 1 */
565         Py_INCREF(args);
566         Py_XSETREF(self->code, args);
567     }
568     return 0;
569 }
570 
571 static int
SystemExit_clear(PySystemExitObject * self)572 SystemExit_clear(PySystemExitObject *self)
573 {
574     Py_CLEAR(self->code);
575     return BaseException_clear((PyBaseExceptionObject *)self);
576 }
577 
578 static void
SystemExit_dealloc(PySystemExitObject * self)579 SystemExit_dealloc(PySystemExitObject *self)
580 {
581     _PyObject_GC_UNTRACK(self);
582     SystemExit_clear(self);
583     Py_TYPE(self)->tp_free((PyObject *)self);
584 }
585 
586 static int
SystemExit_traverse(PySystemExitObject * self,visitproc visit,void * arg)587 SystemExit_traverse(PySystemExitObject *self, visitproc visit, void *arg)
588 {
589     Py_VISIT(self->code);
590     return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
591 }
592 
593 static PyMemberDef SystemExit_members[] = {
594     {"code", T_OBJECT, offsetof(PySystemExitObject, code), 0,
595         PyDoc_STR("exception code")},
596     {NULL}  /* Sentinel */
597 };
598 
599 ComplexExtendsException(PyExc_BaseException, SystemExit, SystemExit,
600                         0, 0, SystemExit_members, 0, 0,
601                         "Request to exit from the interpreter.");
602 
603 /*
604  *    KeyboardInterrupt extends BaseException
605  */
606 SimpleExtendsException(PyExc_BaseException, KeyboardInterrupt,
607                        "Program interrupted by user.");
608 
609 
610 /*
611  *    ImportError extends Exception
612  */
613 
614 static int
ImportError_init(PyImportErrorObject * self,PyObject * args,PyObject * kwds)615 ImportError_init(PyImportErrorObject *self, PyObject *args, PyObject *kwds)
616 {
617     static char *kwlist[] = {"name", "path", 0};
618     PyObject *empty_tuple;
619     PyObject *msg = NULL;
620     PyObject *name = NULL;
621     PyObject *path = NULL;
622 
623     if (BaseException_init((PyBaseExceptionObject *)self, args, NULL) == -1)
624         return -1;
625 
626     empty_tuple = PyTuple_New(0);
627     if (!empty_tuple)
628         return -1;
629     if (!PyArg_ParseTupleAndKeywords(empty_tuple, kwds, "|$OO:ImportError", kwlist,
630                                      &name, &path)) {
631         Py_DECREF(empty_tuple);
632         return -1;
633     }
634     Py_DECREF(empty_tuple);
635 
636     Py_XINCREF(name);
637     Py_XSETREF(self->name, name);
638 
639     Py_XINCREF(path);
640     Py_XSETREF(self->path, path);
641 
642     if (PyTuple_GET_SIZE(args) == 1) {
643         msg = PyTuple_GET_ITEM(args, 0);
644         Py_INCREF(msg);
645     }
646     Py_XSETREF(self->msg, msg);
647 
648     return 0;
649 }
650 
651 static int
ImportError_clear(PyImportErrorObject * self)652 ImportError_clear(PyImportErrorObject *self)
653 {
654     Py_CLEAR(self->msg);
655     Py_CLEAR(self->name);
656     Py_CLEAR(self->path);
657     return BaseException_clear((PyBaseExceptionObject *)self);
658 }
659 
660 static void
ImportError_dealloc(PyImportErrorObject * self)661 ImportError_dealloc(PyImportErrorObject *self)
662 {
663     _PyObject_GC_UNTRACK(self);
664     ImportError_clear(self);
665     Py_TYPE(self)->tp_free((PyObject *)self);
666 }
667 
668 static int
ImportError_traverse(PyImportErrorObject * self,visitproc visit,void * arg)669 ImportError_traverse(PyImportErrorObject *self, visitproc visit, void *arg)
670 {
671     Py_VISIT(self->msg);
672     Py_VISIT(self->name);
673     Py_VISIT(self->path);
674     return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
675 }
676 
677 static PyObject *
ImportError_str(PyImportErrorObject * self)678 ImportError_str(PyImportErrorObject *self)
679 {
680     if (self->msg && PyUnicode_CheckExact(self->msg)) {
681         Py_INCREF(self->msg);
682         return self->msg;
683     }
684     else {
685         return BaseException_str((PyBaseExceptionObject *)self);
686     }
687 }
688 
689 static PyObject *
ImportError_getstate(PyImportErrorObject * self)690 ImportError_getstate(PyImportErrorObject *self)
691 {
692     PyObject *dict = ((PyBaseExceptionObject *)self)->dict;
693     if (self->name || self->path) {
694         _Py_IDENTIFIER(name);
695         _Py_IDENTIFIER(path);
696         dict = dict ? PyDict_Copy(dict) : PyDict_New();
697         if (dict == NULL)
698             return NULL;
699         if (self->name && _PyDict_SetItemId(dict, &PyId_name, self->name) < 0) {
700             Py_DECREF(dict);
701             return NULL;
702         }
703         if (self->path && _PyDict_SetItemId(dict, &PyId_path, self->path) < 0) {
704             Py_DECREF(dict);
705             return NULL;
706         }
707         return dict;
708     }
709     else if (dict) {
710         Py_INCREF(dict);
711         return dict;
712     }
713     else {
714         Py_RETURN_NONE;
715     }
716 }
717 
718 /* Pickling support */
719 static PyObject *
ImportError_reduce(PyImportErrorObject * self)720 ImportError_reduce(PyImportErrorObject *self)
721 {
722     PyObject *res;
723     PyObject *args;
724     PyObject *state = ImportError_getstate(self);
725     if (state == NULL)
726         return NULL;
727     args = ((PyBaseExceptionObject *)self)->args;
728     if (state == Py_None)
729         res = PyTuple_Pack(2, Py_TYPE(self), args);
730     else
731         res = PyTuple_Pack(3, Py_TYPE(self), args, state);
732     Py_DECREF(state);
733     return res;
734 }
735 
736 static PyMemberDef ImportError_members[] = {
737     {"msg", T_OBJECT, offsetof(PyImportErrorObject, msg), 0,
738         PyDoc_STR("exception message")},
739     {"name", T_OBJECT, offsetof(PyImportErrorObject, name), 0,
740         PyDoc_STR("module name")},
741     {"path", T_OBJECT, offsetof(PyImportErrorObject, path), 0,
742         PyDoc_STR("module path")},
743     {NULL}  /* Sentinel */
744 };
745 
746 static PyMethodDef ImportError_methods[] = {
747     {"__reduce__", (PyCFunction)ImportError_reduce, METH_NOARGS},
748     {NULL}
749 };
750 
751 ComplexExtendsException(PyExc_Exception, ImportError,
752                         ImportError, 0 /* new */,
753                         ImportError_methods, ImportError_members,
754                         0 /* getset */, ImportError_str,
755                         "Import can't find module, or can't find name in "
756                         "module.");
757 
758 /*
759  *    ModuleNotFoundError extends ImportError
760  */
761 
762 MiddlingExtendsException(PyExc_ImportError, ModuleNotFoundError, ImportError,
763                          "Module not found.");
764 
765 /*
766  *    OSError extends Exception
767  */
768 
769 #ifdef MS_WINDOWS
770 #include "errmap.h"
771 #endif
772 
773 /* Where a function has a single filename, such as open() or some
774  * of the os module functions, PyErr_SetFromErrnoWithFilename() is
775  * called, giving a third argument which is the filename.  But, so
776  * that old code using in-place unpacking doesn't break, e.g.:
777  *
778  * except OSError, (errno, strerror):
779  *
780  * we hack args so that it only contains two items.  This also
781  * means we need our own __str__() which prints out the filename
782  * when it was supplied.
783  *
784  * (If a function has two filenames, such as rename(), symlink(),
785  * or copy(), PyErr_SetFromErrnoWithFilenameObjects() is called,
786  * which allows passing in a second filename.)
787  */
788 
789 /* This function doesn't cleanup on error, the caller should */
790 static int
oserror_parse_args(PyObject ** p_args,PyObject ** myerrno,PyObject ** strerror,PyObject ** filename,PyObject ** filename2,PyObject ** winerror)791 oserror_parse_args(PyObject **p_args,
792                    PyObject **myerrno, PyObject **strerror,
793                    PyObject **filename, PyObject **filename2
794 #ifdef MS_WINDOWS
795                    , PyObject **winerror
796 #endif
797                   )
798 {
799     Py_ssize_t nargs;
800     PyObject *args = *p_args;
801 #ifndef MS_WINDOWS
802     /*
803      * ignored on non-Windows platforms,
804      * but parsed so OSError has a consistent signature
805      */
806     PyObject *_winerror = NULL;
807     PyObject **winerror = &_winerror;
808 #endif /* MS_WINDOWS */
809 
810     nargs = PyTuple_GET_SIZE(args);
811 
812     if (nargs >= 2 && nargs <= 5) {
813         if (!PyArg_UnpackTuple(args, "OSError", 2, 5,
814                                myerrno, strerror,
815                                filename, winerror, filename2))
816             return -1;
817 #ifdef MS_WINDOWS
818         if (*winerror && PyLong_Check(*winerror)) {
819             long errcode, winerrcode;
820             PyObject *newargs;
821             Py_ssize_t i;
822 
823             winerrcode = PyLong_AsLong(*winerror);
824             if (winerrcode == -1 && PyErr_Occurred())
825                 return -1;
826             /* Set errno to the corresponding POSIX errno (overriding
827                first argument).  Windows Socket error codes (>= 10000)
828                have the same value as their POSIX counterparts.
829             */
830             if (winerrcode < 10000)
831                 errcode = winerror_to_errno(winerrcode);
832             else
833                 errcode = winerrcode;
834             *myerrno = PyLong_FromLong(errcode);
835             if (!*myerrno)
836                 return -1;
837             newargs = PyTuple_New(nargs);
838             if (!newargs)
839                 return -1;
840             PyTuple_SET_ITEM(newargs, 0, *myerrno);
841             for (i = 1; i < nargs; i++) {
842                 PyObject *val = PyTuple_GET_ITEM(args, i);
843                 Py_INCREF(val);
844                 PyTuple_SET_ITEM(newargs, i, val);
845             }
846             Py_DECREF(args);
847             args = *p_args = newargs;
848         }
849 #endif /* MS_WINDOWS */
850     }
851 
852     return 0;
853 }
854 
855 static int
oserror_init(PyOSErrorObject * self,PyObject ** p_args,PyObject * myerrno,PyObject * strerror,PyObject * filename,PyObject * filename2,PyObject * winerror)856 oserror_init(PyOSErrorObject *self, PyObject **p_args,
857              PyObject *myerrno, PyObject *strerror,
858              PyObject *filename, PyObject *filename2
859 #ifdef MS_WINDOWS
860              , PyObject *winerror
861 #endif
862              )
863 {
864     PyObject *args = *p_args;
865     Py_ssize_t nargs = PyTuple_GET_SIZE(args);
866 
867     /* self->filename will remain Py_None otherwise */
868     if (filename && filename != Py_None) {
869         if (Py_TYPE(self) == (PyTypeObject *) PyExc_BlockingIOError &&
870             PyNumber_Check(filename)) {
871             /* BlockingIOError's 3rd argument can be the number of
872              * characters written.
873              */
874             self->written = PyNumber_AsSsize_t(filename, PyExc_ValueError);
875             if (self->written == -1 && PyErr_Occurred())
876                 return -1;
877         }
878         else {
879             Py_INCREF(filename);
880             self->filename = filename;
881 
882             if (filename2 && filename2 != Py_None) {
883                 Py_INCREF(filename2);
884                 self->filename2 = filename2;
885             }
886 
887             if (nargs >= 2 && nargs <= 5) {
888                 /* filename, filename2, and winerror are removed from the args tuple
889                    (for compatibility purposes, see test_exceptions.py) */
890                 PyObject *subslice = PyTuple_GetSlice(args, 0, 2);
891                 if (!subslice)
892                     return -1;
893 
894                 Py_DECREF(args);  /* replacing args */
895                 *p_args = args = subslice;
896             }
897         }
898     }
899     Py_XINCREF(myerrno);
900     self->myerrno = myerrno;
901 
902     Py_XINCREF(strerror);
903     self->strerror = strerror;
904 
905 #ifdef MS_WINDOWS
906     Py_XINCREF(winerror);
907     self->winerror = winerror;
908 #endif
909 
910     /* Steals the reference to args */
911     Py_XSETREF(self->args, args);
912     *p_args = args = NULL;
913 
914     return 0;
915 }
916 
917 static PyObject *
918 OSError_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
919 static int
920 OSError_init(PyOSErrorObject *self, PyObject *args, PyObject *kwds);
921 
922 static int
oserror_use_init(PyTypeObject * type)923 oserror_use_init(PyTypeObject *type)
924 {
925     /* When __init__ is defined in an OSError subclass, we want any
926        extraneous argument to __new__ to be ignored.  The only reasonable
927        solution, given __new__ takes a variable number of arguments,
928        is to defer arg parsing and initialization to __init__.
929 
930        But when __new__ is overridden as well, it should call our __new__
931        with the right arguments.
932 
933        (see http://bugs.python.org/issue12555#msg148829 )
934     */
935     if (type->tp_init != (initproc) OSError_init &&
936         type->tp_new == (newfunc) OSError_new) {
937         assert((PyObject *) type != PyExc_OSError);
938         return 1;
939     }
940     return 0;
941 }
942 
943 static PyObject *
OSError_new(PyTypeObject * type,PyObject * args,PyObject * kwds)944 OSError_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
945 {
946     PyOSErrorObject *self = NULL;
947     PyObject *myerrno = NULL, *strerror = NULL;
948     PyObject *filename = NULL, *filename2 = NULL;
949 #ifdef MS_WINDOWS
950     PyObject *winerror = NULL;
951 #endif
952 
953     Py_INCREF(args);
954 
955     if (!oserror_use_init(type)) {
956         if (!_PyArg_NoKeywords(type->tp_name, kwds))
957             goto error;
958 
959         if (oserror_parse_args(&args, &myerrno, &strerror,
960                                &filename, &filename2
961 #ifdef MS_WINDOWS
962                                , &winerror
963 #endif
964             ))
965             goto error;
966 
967         if (myerrno && PyLong_Check(myerrno) &&
968             errnomap && (PyObject *) type == PyExc_OSError) {
969             PyObject *newtype;
970             newtype = PyDict_GetItem(errnomap, myerrno);
971             if (newtype) {
972                 assert(PyType_Check(newtype));
973                 type = (PyTypeObject *) newtype;
974             }
975             else if (PyErr_Occurred())
976                 goto error;
977         }
978     }
979 
980     self = (PyOSErrorObject *) type->tp_alloc(type, 0);
981     if (!self)
982         goto error;
983 
984     self->dict = NULL;
985     self->traceback = self->cause = self->context = NULL;
986     self->written = -1;
987 
988     if (!oserror_use_init(type)) {
989         if (oserror_init(self, &args, myerrno, strerror, filename, filename2
990 #ifdef MS_WINDOWS
991                          , winerror
992 #endif
993             ))
994             goto error;
995     }
996     else {
997         self->args = PyTuple_New(0);
998         if (self->args == NULL)
999             goto error;
1000     }
1001 
1002     Py_XDECREF(args);
1003     return (PyObject *) self;
1004 
1005 error:
1006     Py_XDECREF(args);
1007     Py_XDECREF(self);
1008     return NULL;
1009 }
1010 
1011 static int
OSError_init(PyOSErrorObject * self,PyObject * args,PyObject * kwds)1012 OSError_init(PyOSErrorObject *self, PyObject *args, PyObject *kwds)
1013 {
1014     PyObject *myerrno = NULL, *strerror = NULL;
1015     PyObject *filename = NULL, *filename2 = NULL;
1016 #ifdef MS_WINDOWS
1017     PyObject *winerror = NULL;
1018 #endif
1019 
1020     if (!oserror_use_init(Py_TYPE(self)))
1021         /* Everything already done in OSError_new */
1022         return 0;
1023 
1024     if (!_PyArg_NoKeywords(Py_TYPE(self)->tp_name, kwds))
1025         return -1;
1026 
1027     Py_INCREF(args);
1028     if (oserror_parse_args(&args, &myerrno, &strerror, &filename, &filename2
1029 #ifdef MS_WINDOWS
1030                            , &winerror
1031 #endif
1032         ))
1033         goto error;
1034 
1035     if (oserror_init(self, &args, myerrno, strerror, filename, filename2
1036 #ifdef MS_WINDOWS
1037                      , winerror
1038 #endif
1039         ))
1040         goto error;
1041 
1042     return 0;
1043 
1044 error:
1045     Py_DECREF(args);
1046     return -1;
1047 }
1048 
1049 static int
OSError_clear(PyOSErrorObject * self)1050 OSError_clear(PyOSErrorObject *self)
1051 {
1052     Py_CLEAR(self->myerrno);
1053     Py_CLEAR(self->strerror);
1054     Py_CLEAR(self->filename);
1055     Py_CLEAR(self->filename2);
1056 #ifdef MS_WINDOWS
1057     Py_CLEAR(self->winerror);
1058 #endif
1059     return BaseException_clear((PyBaseExceptionObject *)self);
1060 }
1061 
1062 static void
OSError_dealloc(PyOSErrorObject * self)1063 OSError_dealloc(PyOSErrorObject *self)
1064 {
1065     _PyObject_GC_UNTRACK(self);
1066     OSError_clear(self);
1067     Py_TYPE(self)->tp_free((PyObject *)self);
1068 }
1069 
1070 static int
OSError_traverse(PyOSErrorObject * self,visitproc visit,void * arg)1071 OSError_traverse(PyOSErrorObject *self, visitproc visit,
1072         void *arg)
1073 {
1074     Py_VISIT(self->myerrno);
1075     Py_VISIT(self->strerror);
1076     Py_VISIT(self->filename);
1077     Py_VISIT(self->filename2);
1078 #ifdef MS_WINDOWS
1079     Py_VISIT(self->winerror);
1080 #endif
1081     return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
1082 }
1083 
1084 static PyObject *
OSError_str(PyOSErrorObject * self)1085 OSError_str(PyOSErrorObject *self)
1086 {
1087 #define OR_NONE(x) ((x)?(x):Py_None)
1088 #ifdef MS_WINDOWS
1089     /* If available, winerror has the priority over myerrno */
1090     if (self->winerror && self->filename) {
1091         if (self->filename2) {
1092             return PyUnicode_FromFormat("[WinError %S] %S: %R -> %R",
1093                                         OR_NONE(self->winerror),
1094                                         OR_NONE(self->strerror),
1095                                         self->filename,
1096                                         self->filename2);
1097         } else {
1098             return PyUnicode_FromFormat("[WinError %S] %S: %R",
1099                                         OR_NONE(self->winerror),
1100                                         OR_NONE(self->strerror),
1101                                         self->filename);
1102         }
1103     }
1104     if (self->winerror && self->strerror)
1105         return PyUnicode_FromFormat("[WinError %S] %S",
1106                                     self->winerror ? self->winerror: Py_None,
1107                                     self->strerror ? self->strerror: Py_None);
1108 #endif
1109     if (self->filename) {
1110         if (self->filename2) {
1111             return PyUnicode_FromFormat("[Errno %S] %S: %R -> %R",
1112                                         OR_NONE(self->myerrno),
1113                                         OR_NONE(self->strerror),
1114                                         self->filename,
1115                                         self->filename2);
1116         } else {
1117             return PyUnicode_FromFormat("[Errno %S] %S: %R",
1118                                         OR_NONE(self->myerrno),
1119                                         OR_NONE(self->strerror),
1120                                         self->filename);
1121         }
1122     }
1123     if (self->myerrno && self->strerror)
1124         return PyUnicode_FromFormat("[Errno %S] %S",
1125                                     self->myerrno, self->strerror);
1126     return BaseException_str((PyBaseExceptionObject *)self);
1127 }
1128 
1129 static PyObject *
OSError_reduce(PyOSErrorObject * self)1130 OSError_reduce(PyOSErrorObject *self)
1131 {
1132     PyObject *args = self->args;
1133     PyObject *res = NULL, *tmp;
1134 
1135     /* self->args is only the first two real arguments if there was a
1136      * file name given to OSError. */
1137     if (PyTuple_GET_SIZE(args) == 2 && self->filename) {
1138         Py_ssize_t size = self->filename2 ? 5 : 3;
1139         args = PyTuple_New(size);
1140         if (!args)
1141             return NULL;
1142 
1143         tmp = PyTuple_GET_ITEM(self->args, 0);
1144         Py_INCREF(tmp);
1145         PyTuple_SET_ITEM(args, 0, tmp);
1146 
1147         tmp = PyTuple_GET_ITEM(self->args, 1);
1148         Py_INCREF(tmp);
1149         PyTuple_SET_ITEM(args, 1, tmp);
1150 
1151         Py_INCREF(self->filename);
1152         PyTuple_SET_ITEM(args, 2, self->filename);
1153 
1154         if (self->filename2) {
1155             /*
1156              * This tuple is essentially used as OSError(*args).
1157              * So, to recreate filename2, we need to pass in
1158              * winerror as well.
1159              */
1160             Py_INCREF(Py_None);
1161             PyTuple_SET_ITEM(args, 3, Py_None);
1162 
1163             /* filename2 */
1164             Py_INCREF(self->filename2);
1165             PyTuple_SET_ITEM(args, 4, self->filename2);
1166         }
1167     } else
1168         Py_INCREF(args);
1169 
1170     if (self->dict)
1171         res = PyTuple_Pack(3, Py_TYPE(self), args, self->dict);
1172     else
1173         res = PyTuple_Pack(2, Py_TYPE(self), args);
1174     Py_DECREF(args);
1175     return res;
1176 }
1177 
1178 static PyObject *
OSError_written_get(PyOSErrorObject * self,void * context)1179 OSError_written_get(PyOSErrorObject *self, void *context)
1180 {
1181     if (self->written == -1) {
1182         PyErr_SetString(PyExc_AttributeError, "characters_written");
1183         return NULL;
1184     }
1185     return PyLong_FromSsize_t(self->written);
1186 }
1187 
1188 static int
OSError_written_set(PyOSErrorObject * self,PyObject * arg,void * context)1189 OSError_written_set(PyOSErrorObject *self, PyObject *arg, void *context)
1190 {
1191     Py_ssize_t n;
1192     n = PyNumber_AsSsize_t(arg, PyExc_ValueError);
1193     if (n == -1 && PyErr_Occurred())
1194         return -1;
1195     self->written = n;
1196     return 0;
1197 }
1198 
1199 static PyMemberDef OSError_members[] = {
1200     {"errno", T_OBJECT, offsetof(PyOSErrorObject, myerrno), 0,
1201         PyDoc_STR("POSIX exception code")},
1202     {"strerror", T_OBJECT, offsetof(PyOSErrorObject, strerror), 0,
1203         PyDoc_STR("exception strerror")},
1204     {"filename", T_OBJECT, offsetof(PyOSErrorObject, filename), 0,
1205         PyDoc_STR("exception filename")},
1206     {"filename2", T_OBJECT, offsetof(PyOSErrorObject, filename2), 0,
1207         PyDoc_STR("second exception filename")},
1208 #ifdef MS_WINDOWS
1209     {"winerror", T_OBJECT, offsetof(PyOSErrorObject, winerror), 0,
1210         PyDoc_STR("Win32 exception code")},
1211 #endif
1212     {NULL}  /* Sentinel */
1213 };
1214 
1215 static PyMethodDef OSError_methods[] = {
1216     {"__reduce__", (PyCFunction)OSError_reduce, METH_NOARGS},
1217     {NULL}
1218 };
1219 
1220 static PyGetSetDef OSError_getset[] = {
1221     {"characters_written", (getter) OSError_written_get,
1222                            (setter) OSError_written_set, NULL},
1223     {NULL}
1224 };
1225 
1226 
1227 ComplexExtendsException(PyExc_Exception, OSError,
1228                         OSError, OSError_new,
1229                         OSError_methods, OSError_members, OSError_getset,
1230                         OSError_str,
1231                         "Base class for I/O related errors.");
1232 
1233 
1234 /*
1235  *    Various OSError subclasses
1236  */
1237 MiddlingExtendsException(PyExc_OSError, BlockingIOError, OSError,
1238                          "I/O operation would block.");
1239 MiddlingExtendsException(PyExc_OSError, ConnectionError, OSError,
1240                          "Connection error.");
1241 MiddlingExtendsException(PyExc_OSError, ChildProcessError, OSError,
1242                          "Child process error.");
1243 MiddlingExtendsException(PyExc_ConnectionError, BrokenPipeError, OSError,
1244                          "Broken pipe.");
1245 MiddlingExtendsException(PyExc_ConnectionError, ConnectionAbortedError, OSError,
1246                          "Connection aborted.");
1247 MiddlingExtendsException(PyExc_ConnectionError, ConnectionRefusedError, OSError,
1248                          "Connection refused.");
1249 MiddlingExtendsException(PyExc_ConnectionError, ConnectionResetError, OSError,
1250                          "Connection reset.");
1251 MiddlingExtendsException(PyExc_OSError, FileExistsError, OSError,
1252                          "File already exists.");
1253 MiddlingExtendsException(PyExc_OSError, FileNotFoundError, OSError,
1254                          "File not found.");
1255 MiddlingExtendsException(PyExc_OSError, IsADirectoryError, OSError,
1256                          "Operation doesn't work on directories.");
1257 MiddlingExtendsException(PyExc_OSError, NotADirectoryError, OSError,
1258                          "Operation only works on directories.");
1259 MiddlingExtendsException(PyExc_OSError, InterruptedError, OSError,
1260                          "Interrupted by signal.");
1261 MiddlingExtendsException(PyExc_OSError, PermissionError, OSError,
1262                          "Not enough permissions.");
1263 MiddlingExtendsException(PyExc_OSError, ProcessLookupError, OSError,
1264                          "Process not found.");
1265 MiddlingExtendsException(PyExc_OSError, TimeoutError, OSError,
1266                          "Timeout expired.");
1267 
1268 /*
1269  *    EOFError extends Exception
1270  */
1271 SimpleExtendsException(PyExc_Exception, EOFError,
1272                        "Read beyond end of file.");
1273 
1274 
1275 /*
1276  *    RuntimeError extends Exception
1277  */
1278 SimpleExtendsException(PyExc_Exception, RuntimeError,
1279                        "Unspecified run-time error.");
1280 
1281 /*
1282  *    RecursionError extends RuntimeError
1283  */
1284 SimpleExtendsException(PyExc_RuntimeError, RecursionError,
1285                        "Recursion limit exceeded.");
1286 
1287 /*
1288  *    NotImplementedError extends RuntimeError
1289  */
1290 SimpleExtendsException(PyExc_RuntimeError, NotImplementedError,
1291                        "Method or function hasn't been implemented yet.");
1292 
1293 /*
1294  *    NameError extends Exception
1295  */
1296 SimpleExtendsException(PyExc_Exception, NameError,
1297                        "Name not found globally.");
1298 
1299 /*
1300  *    UnboundLocalError extends NameError
1301  */
1302 SimpleExtendsException(PyExc_NameError, UnboundLocalError,
1303                        "Local name referenced but not bound to a value.");
1304 
1305 /*
1306  *    AttributeError extends Exception
1307  */
1308 SimpleExtendsException(PyExc_Exception, AttributeError,
1309                        "Attribute not found.");
1310 
1311 
1312 /*
1313  *    SyntaxError extends Exception
1314  */
1315 
1316 /* Helper function to customize error message for some syntax errors */
1317 static int _report_missing_parentheses(PySyntaxErrorObject *self);
1318 
1319 static int
SyntaxError_init(PySyntaxErrorObject * self,PyObject * args,PyObject * kwds)1320 SyntaxError_init(PySyntaxErrorObject *self, PyObject *args, PyObject *kwds)
1321 {
1322     PyObject *info = NULL;
1323     Py_ssize_t lenargs = PyTuple_GET_SIZE(args);
1324 
1325     if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
1326         return -1;
1327 
1328     if (lenargs >= 1) {
1329         Py_INCREF(PyTuple_GET_ITEM(args, 0));
1330         Py_XSETREF(self->msg, PyTuple_GET_ITEM(args, 0));
1331     }
1332     if (lenargs == 2) {
1333         info = PyTuple_GET_ITEM(args, 1);
1334         info = PySequence_Tuple(info);
1335         if (!info)
1336             return -1;
1337 
1338         if (PyTuple_GET_SIZE(info) != 4) {
1339             /* not a very good error message, but it's what Python 2.4 gives */
1340             PyErr_SetString(PyExc_IndexError, "tuple index out of range");
1341             Py_DECREF(info);
1342             return -1;
1343         }
1344 
1345         Py_INCREF(PyTuple_GET_ITEM(info, 0));
1346         Py_XSETREF(self->filename, PyTuple_GET_ITEM(info, 0));
1347 
1348         Py_INCREF(PyTuple_GET_ITEM(info, 1));
1349         Py_XSETREF(self->lineno, PyTuple_GET_ITEM(info, 1));
1350 
1351         Py_INCREF(PyTuple_GET_ITEM(info, 2));
1352         Py_XSETREF(self->offset, PyTuple_GET_ITEM(info, 2));
1353 
1354         Py_INCREF(PyTuple_GET_ITEM(info, 3));
1355         Py_XSETREF(self->text, PyTuple_GET_ITEM(info, 3));
1356 
1357         Py_DECREF(info);
1358 
1359         /*
1360          * Issue #21669: Custom error for 'print' & 'exec' as statements
1361          *
1362          * Only applies to SyntaxError instances, not to subclasses such
1363          * as TabError or IndentationError (see issue #31161)
1364          */
1365         if ((PyObject*)Py_TYPE(self) == PyExc_SyntaxError &&
1366                 self->text && PyUnicode_Check(self->text) &&
1367                 _report_missing_parentheses(self) < 0) {
1368             return -1;
1369         }
1370     }
1371     return 0;
1372 }
1373 
1374 static int
SyntaxError_clear(PySyntaxErrorObject * self)1375 SyntaxError_clear(PySyntaxErrorObject *self)
1376 {
1377     Py_CLEAR(self->msg);
1378     Py_CLEAR(self->filename);
1379     Py_CLEAR(self->lineno);
1380     Py_CLEAR(self->offset);
1381     Py_CLEAR(self->text);
1382     Py_CLEAR(self->print_file_and_line);
1383     return BaseException_clear((PyBaseExceptionObject *)self);
1384 }
1385 
1386 static void
SyntaxError_dealloc(PySyntaxErrorObject * self)1387 SyntaxError_dealloc(PySyntaxErrorObject *self)
1388 {
1389     _PyObject_GC_UNTRACK(self);
1390     SyntaxError_clear(self);
1391     Py_TYPE(self)->tp_free((PyObject *)self);
1392 }
1393 
1394 static int
SyntaxError_traverse(PySyntaxErrorObject * self,visitproc visit,void * arg)1395 SyntaxError_traverse(PySyntaxErrorObject *self, visitproc visit, void *arg)
1396 {
1397     Py_VISIT(self->msg);
1398     Py_VISIT(self->filename);
1399     Py_VISIT(self->lineno);
1400     Py_VISIT(self->offset);
1401     Py_VISIT(self->text);
1402     Py_VISIT(self->print_file_and_line);
1403     return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
1404 }
1405 
1406 /* This is called "my_basename" instead of just "basename" to avoid name
1407    conflicts with glibc; basename is already prototyped if _GNU_SOURCE is
1408    defined, and Python does define that. */
1409 static PyObject*
my_basename(PyObject * name)1410 my_basename(PyObject *name)
1411 {
1412     Py_ssize_t i, size, offset;
1413     int kind;
1414     void *data;
1415 
1416     if (PyUnicode_READY(name))
1417         return NULL;
1418     kind = PyUnicode_KIND(name);
1419     data = PyUnicode_DATA(name);
1420     size = PyUnicode_GET_LENGTH(name);
1421     offset = 0;
1422     for(i=0; i < size; i++) {
1423         if (PyUnicode_READ(kind, data, i) == SEP)
1424             offset = i + 1;
1425     }
1426     if (offset != 0)
1427         return PyUnicode_Substring(name, offset, size);
1428     else {
1429         Py_INCREF(name);
1430         return name;
1431     }
1432 }
1433 
1434 
1435 static PyObject *
SyntaxError_str(PySyntaxErrorObject * self)1436 SyntaxError_str(PySyntaxErrorObject *self)
1437 {
1438     int have_lineno = 0;
1439     PyObject *filename;
1440     PyObject *result;
1441     /* Below, we always ignore overflow errors, just printing -1.
1442        Still, we cannot allow an OverflowError to be raised, so
1443        we need to call PyLong_AsLongAndOverflow. */
1444     int overflow;
1445 
1446     /* XXX -- do all the additional formatting with filename and
1447        lineno here */
1448 
1449     if (self->filename && PyUnicode_Check(self->filename)) {
1450         filename = my_basename(self->filename);
1451         if (filename == NULL)
1452             return NULL;
1453     } else {
1454         filename = NULL;
1455     }
1456     have_lineno = (self->lineno != NULL) && PyLong_CheckExact(self->lineno);
1457 
1458     if (!filename && !have_lineno)
1459         return PyObject_Str(self->msg ? self->msg : Py_None);
1460 
1461     if (filename && have_lineno)
1462         result = PyUnicode_FromFormat("%S (%U, line %ld)",
1463                    self->msg ? self->msg : Py_None,
1464                    filename,
1465                    PyLong_AsLongAndOverflow(self->lineno, &overflow));
1466     else if (filename)
1467         result = PyUnicode_FromFormat("%S (%U)",
1468                    self->msg ? self->msg : Py_None,
1469                    filename);
1470     else /* only have_lineno */
1471         result = PyUnicode_FromFormat("%S (line %ld)",
1472                    self->msg ? self->msg : Py_None,
1473                    PyLong_AsLongAndOverflow(self->lineno, &overflow));
1474     Py_XDECREF(filename);
1475     return result;
1476 }
1477 
1478 static PyMemberDef SyntaxError_members[] = {
1479     {"msg", T_OBJECT, offsetof(PySyntaxErrorObject, msg), 0,
1480         PyDoc_STR("exception msg")},
1481     {"filename", T_OBJECT, offsetof(PySyntaxErrorObject, filename), 0,
1482         PyDoc_STR("exception filename")},
1483     {"lineno", T_OBJECT, offsetof(PySyntaxErrorObject, lineno), 0,
1484         PyDoc_STR("exception lineno")},
1485     {"offset", T_OBJECT, offsetof(PySyntaxErrorObject, offset), 0,
1486         PyDoc_STR("exception offset")},
1487     {"text", T_OBJECT, offsetof(PySyntaxErrorObject, text), 0,
1488         PyDoc_STR("exception text")},
1489     {"print_file_and_line", T_OBJECT,
1490         offsetof(PySyntaxErrorObject, print_file_and_line), 0,
1491         PyDoc_STR("exception print_file_and_line")},
1492     {NULL}  /* Sentinel */
1493 };
1494 
1495 ComplexExtendsException(PyExc_Exception, SyntaxError, SyntaxError,
1496                         0, 0, SyntaxError_members, 0,
1497                         SyntaxError_str, "Invalid syntax.");
1498 
1499 
1500 /*
1501  *    IndentationError extends SyntaxError
1502  */
1503 MiddlingExtendsException(PyExc_SyntaxError, IndentationError, SyntaxError,
1504                          "Improper indentation.");
1505 
1506 
1507 /*
1508  *    TabError extends IndentationError
1509  */
1510 MiddlingExtendsException(PyExc_IndentationError, TabError, SyntaxError,
1511                          "Improper mixture of spaces and tabs.");
1512 
1513 
1514 /*
1515  *    LookupError extends Exception
1516  */
1517 SimpleExtendsException(PyExc_Exception, LookupError,
1518                        "Base class for lookup errors.");
1519 
1520 
1521 /*
1522  *    IndexError extends LookupError
1523  */
1524 SimpleExtendsException(PyExc_LookupError, IndexError,
1525                        "Sequence index out of range.");
1526 
1527 
1528 /*
1529  *    KeyError extends LookupError
1530  */
1531 static PyObject *
KeyError_str(PyBaseExceptionObject * self)1532 KeyError_str(PyBaseExceptionObject *self)
1533 {
1534     /* If args is a tuple of exactly one item, apply repr to args[0].
1535        This is done so that e.g. the exception raised by {}[''] prints
1536          KeyError: ''
1537        rather than the confusing
1538          KeyError
1539        alone.  The downside is that if KeyError is raised with an explanatory
1540        string, that string will be displayed in quotes.  Too bad.
1541        If args is anything else, use the default BaseException__str__().
1542     */
1543     if (PyTuple_GET_SIZE(self->args) == 1) {
1544         return PyObject_Repr(PyTuple_GET_ITEM(self->args, 0));
1545     }
1546     return BaseException_str(self);
1547 }
1548 
1549 ComplexExtendsException(PyExc_LookupError, KeyError, BaseException,
1550                         0, 0, 0, 0, KeyError_str, "Mapping key not found.");
1551 
1552 
1553 /*
1554  *    ValueError extends Exception
1555  */
1556 SimpleExtendsException(PyExc_Exception, ValueError,
1557                        "Inappropriate argument value (of correct type).");
1558 
1559 /*
1560  *    UnicodeError extends ValueError
1561  */
1562 
1563 SimpleExtendsException(PyExc_ValueError, UnicodeError,
1564                        "Unicode related error.");
1565 
1566 static PyObject *
get_string(PyObject * attr,const char * name)1567 get_string(PyObject *attr, const char *name)
1568 {
1569     if (!attr) {
1570         PyErr_Format(PyExc_TypeError, "%.200s attribute not set", name);
1571         return NULL;
1572     }
1573 
1574     if (!PyBytes_Check(attr)) {
1575         PyErr_Format(PyExc_TypeError, "%.200s attribute must be bytes", name);
1576         return NULL;
1577     }
1578     Py_INCREF(attr);
1579     return attr;
1580 }
1581 
1582 static PyObject *
get_unicode(PyObject * attr,const char * name)1583 get_unicode(PyObject *attr, const char *name)
1584 {
1585     if (!attr) {
1586         PyErr_Format(PyExc_TypeError, "%.200s attribute not set", name);
1587         return NULL;
1588     }
1589 
1590     if (!PyUnicode_Check(attr)) {
1591         PyErr_Format(PyExc_TypeError,
1592                      "%.200s attribute must be unicode", name);
1593         return NULL;
1594     }
1595     Py_INCREF(attr);
1596     return attr;
1597 }
1598 
1599 static int
set_unicodefromstring(PyObject ** attr,const char * value)1600 set_unicodefromstring(PyObject **attr, const char *value)
1601 {
1602     PyObject *obj = PyUnicode_FromString(value);
1603     if (!obj)
1604         return -1;
1605     Py_XSETREF(*attr, obj);
1606     return 0;
1607 }
1608 
1609 PyObject *
PyUnicodeEncodeError_GetEncoding(PyObject * exc)1610 PyUnicodeEncodeError_GetEncoding(PyObject *exc)
1611 {
1612     return get_unicode(((PyUnicodeErrorObject *)exc)->encoding, "encoding");
1613 }
1614 
1615 PyObject *
PyUnicodeDecodeError_GetEncoding(PyObject * exc)1616 PyUnicodeDecodeError_GetEncoding(PyObject *exc)
1617 {
1618     return get_unicode(((PyUnicodeErrorObject *)exc)->encoding, "encoding");
1619 }
1620 
1621 PyObject *
PyUnicodeEncodeError_GetObject(PyObject * exc)1622 PyUnicodeEncodeError_GetObject(PyObject *exc)
1623 {
1624     return get_unicode(((PyUnicodeErrorObject *)exc)->object, "object");
1625 }
1626 
1627 PyObject *
PyUnicodeDecodeError_GetObject(PyObject * exc)1628 PyUnicodeDecodeError_GetObject(PyObject *exc)
1629 {
1630     return get_string(((PyUnicodeErrorObject *)exc)->object, "object");
1631 }
1632 
1633 PyObject *
PyUnicodeTranslateError_GetObject(PyObject * exc)1634 PyUnicodeTranslateError_GetObject(PyObject *exc)
1635 {
1636     return get_unicode(((PyUnicodeErrorObject *)exc)->object, "object");
1637 }
1638 
1639 int
PyUnicodeEncodeError_GetStart(PyObject * exc,Py_ssize_t * start)1640 PyUnicodeEncodeError_GetStart(PyObject *exc, Py_ssize_t *start)
1641 {
1642     Py_ssize_t size;
1643     PyObject *obj = get_unicode(((PyUnicodeErrorObject *)exc)->object,
1644                                 "object");
1645     if (!obj)
1646         return -1;
1647     *start = ((PyUnicodeErrorObject *)exc)->start;
1648     size = PyUnicode_GET_LENGTH(obj);
1649     if (*start<0)
1650         *start = 0; /*XXX check for values <0*/
1651     if (*start>=size)
1652         *start = size-1;
1653     Py_DECREF(obj);
1654     return 0;
1655 }
1656 
1657 
1658 int
PyUnicodeDecodeError_GetStart(PyObject * exc,Py_ssize_t * start)1659 PyUnicodeDecodeError_GetStart(PyObject *exc, Py_ssize_t *start)
1660 {
1661     Py_ssize_t size;
1662     PyObject *obj = get_string(((PyUnicodeErrorObject *)exc)->object, "object");
1663     if (!obj)
1664         return -1;
1665     size = PyBytes_GET_SIZE(obj);
1666     *start = ((PyUnicodeErrorObject *)exc)->start;
1667     if (*start<0)
1668         *start = 0;
1669     if (*start>=size)
1670         *start = size-1;
1671     Py_DECREF(obj);
1672     return 0;
1673 }
1674 
1675 
1676 int
PyUnicodeTranslateError_GetStart(PyObject * exc,Py_ssize_t * start)1677 PyUnicodeTranslateError_GetStart(PyObject *exc, Py_ssize_t *start)
1678 {
1679     return PyUnicodeEncodeError_GetStart(exc, start);
1680 }
1681 
1682 
1683 int
PyUnicodeEncodeError_SetStart(PyObject * exc,Py_ssize_t start)1684 PyUnicodeEncodeError_SetStart(PyObject *exc, Py_ssize_t start)
1685 {
1686     ((PyUnicodeErrorObject *)exc)->start = start;
1687     return 0;
1688 }
1689 
1690 
1691 int
PyUnicodeDecodeError_SetStart(PyObject * exc,Py_ssize_t start)1692 PyUnicodeDecodeError_SetStart(PyObject *exc, Py_ssize_t start)
1693 {
1694     ((PyUnicodeErrorObject *)exc)->start = start;
1695     return 0;
1696 }
1697 
1698 
1699 int
PyUnicodeTranslateError_SetStart(PyObject * exc,Py_ssize_t start)1700 PyUnicodeTranslateError_SetStart(PyObject *exc, Py_ssize_t start)
1701 {
1702     ((PyUnicodeErrorObject *)exc)->start = start;
1703     return 0;
1704 }
1705 
1706 
1707 int
PyUnicodeEncodeError_GetEnd(PyObject * exc,Py_ssize_t * end)1708 PyUnicodeEncodeError_GetEnd(PyObject *exc, Py_ssize_t *end)
1709 {
1710     Py_ssize_t size;
1711     PyObject *obj = get_unicode(((PyUnicodeErrorObject *)exc)->object,
1712                                 "object");
1713     if (!obj)
1714         return -1;
1715     *end = ((PyUnicodeErrorObject *)exc)->end;
1716     size = PyUnicode_GET_LENGTH(obj);
1717     if (*end<1)
1718         *end = 1;
1719     if (*end>size)
1720         *end = size;
1721     Py_DECREF(obj);
1722     return 0;
1723 }
1724 
1725 
1726 int
PyUnicodeDecodeError_GetEnd(PyObject * exc,Py_ssize_t * end)1727 PyUnicodeDecodeError_GetEnd(PyObject *exc, Py_ssize_t *end)
1728 {
1729     Py_ssize_t size;
1730     PyObject *obj = get_string(((PyUnicodeErrorObject *)exc)->object, "object");
1731     if (!obj)
1732         return -1;
1733     size = PyBytes_GET_SIZE(obj);
1734     *end = ((PyUnicodeErrorObject *)exc)->end;
1735     if (*end<1)
1736         *end = 1;
1737     if (*end>size)
1738         *end = size;
1739     Py_DECREF(obj);
1740     return 0;
1741 }
1742 
1743 
1744 int
PyUnicodeTranslateError_GetEnd(PyObject * exc,Py_ssize_t * start)1745 PyUnicodeTranslateError_GetEnd(PyObject *exc, Py_ssize_t *start)
1746 {
1747     return PyUnicodeEncodeError_GetEnd(exc, start);
1748 }
1749 
1750 
1751 int
PyUnicodeEncodeError_SetEnd(PyObject * exc,Py_ssize_t end)1752 PyUnicodeEncodeError_SetEnd(PyObject *exc, Py_ssize_t end)
1753 {
1754     ((PyUnicodeErrorObject *)exc)->end = end;
1755     return 0;
1756 }
1757 
1758 
1759 int
PyUnicodeDecodeError_SetEnd(PyObject * exc,Py_ssize_t end)1760 PyUnicodeDecodeError_SetEnd(PyObject *exc, Py_ssize_t end)
1761 {
1762     ((PyUnicodeErrorObject *)exc)->end = end;
1763     return 0;
1764 }
1765 
1766 
1767 int
PyUnicodeTranslateError_SetEnd(PyObject * exc,Py_ssize_t end)1768 PyUnicodeTranslateError_SetEnd(PyObject *exc, Py_ssize_t end)
1769 {
1770     ((PyUnicodeErrorObject *)exc)->end = end;
1771     return 0;
1772 }
1773 
1774 PyObject *
PyUnicodeEncodeError_GetReason(PyObject * exc)1775 PyUnicodeEncodeError_GetReason(PyObject *exc)
1776 {
1777     return get_unicode(((PyUnicodeErrorObject *)exc)->reason, "reason");
1778 }
1779 
1780 
1781 PyObject *
PyUnicodeDecodeError_GetReason(PyObject * exc)1782 PyUnicodeDecodeError_GetReason(PyObject *exc)
1783 {
1784     return get_unicode(((PyUnicodeErrorObject *)exc)->reason, "reason");
1785 }
1786 
1787 
1788 PyObject *
PyUnicodeTranslateError_GetReason(PyObject * exc)1789 PyUnicodeTranslateError_GetReason(PyObject *exc)
1790 {
1791     return get_unicode(((PyUnicodeErrorObject *)exc)->reason, "reason");
1792 }
1793 
1794 
1795 int
PyUnicodeEncodeError_SetReason(PyObject * exc,const char * reason)1796 PyUnicodeEncodeError_SetReason(PyObject *exc, const char *reason)
1797 {
1798     return set_unicodefromstring(&((PyUnicodeErrorObject *)exc)->reason,
1799                                  reason);
1800 }
1801 
1802 
1803 int
PyUnicodeDecodeError_SetReason(PyObject * exc,const char * reason)1804 PyUnicodeDecodeError_SetReason(PyObject *exc, const char *reason)
1805 {
1806     return set_unicodefromstring(&((PyUnicodeErrorObject *)exc)->reason,
1807                                  reason);
1808 }
1809 
1810 
1811 int
PyUnicodeTranslateError_SetReason(PyObject * exc,const char * reason)1812 PyUnicodeTranslateError_SetReason(PyObject *exc, const char *reason)
1813 {
1814     return set_unicodefromstring(&((PyUnicodeErrorObject *)exc)->reason,
1815                                  reason);
1816 }
1817 
1818 
1819 static int
UnicodeError_clear(PyUnicodeErrorObject * self)1820 UnicodeError_clear(PyUnicodeErrorObject *self)
1821 {
1822     Py_CLEAR(self->encoding);
1823     Py_CLEAR(self->object);
1824     Py_CLEAR(self->reason);
1825     return BaseException_clear((PyBaseExceptionObject *)self);
1826 }
1827 
1828 static void
UnicodeError_dealloc(PyUnicodeErrorObject * self)1829 UnicodeError_dealloc(PyUnicodeErrorObject *self)
1830 {
1831     _PyObject_GC_UNTRACK(self);
1832     UnicodeError_clear(self);
1833     Py_TYPE(self)->tp_free((PyObject *)self);
1834 }
1835 
1836 static int
UnicodeError_traverse(PyUnicodeErrorObject * self,visitproc visit,void * arg)1837 UnicodeError_traverse(PyUnicodeErrorObject *self, visitproc visit, void *arg)
1838 {
1839     Py_VISIT(self->encoding);
1840     Py_VISIT(self->object);
1841     Py_VISIT(self->reason);
1842     return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
1843 }
1844 
1845 static PyMemberDef UnicodeError_members[] = {
1846     {"encoding", T_OBJECT, offsetof(PyUnicodeErrorObject, encoding), 0,
1847         PyDoc_STR("exception encoding")},
1848     {"object", T_OBJECT, offsetof(PyUnicodeErrorObject, object), 0,
1849         PyDoc_STR("exception object")},
1850     {"start", T_PYSSIZET, offsetof(PyUnicodeErrorObject, start), 0,
1851         PyDoc_STR("exception start")},
1852     {"end", T_PYSSIZET, offsetof(PyUnicodeErrorObject, end), 0,
1853         PyDoc_STR("exception end")},
1854     {"reason", T_OBJECT, offsetof(PyUnicodeErrorObject, reason), 0,
1855         PyDoc_STR("exception reason")},
1856     {NULL}  /* Sentinel */
1857 };
1858 
1859 
1860 /*
1861  *    UnicodeEncodeError extends UnicodeError
1862  */
1863 
1864 static int
UnicodeEncodeError_init(PyObject * self,PyObject * args,PyObject * kwds)1865 UnicodeEncodeError_init(PyObject *self, PyObject *args, PyObject *kwds)
1866 {
1867     PyUnicodeErrorObject *err;
1868 
1869     if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
1870         return -1;
1871 
1872     err = (PyUnicodeErrorObject *)self;
1873 
1874     Py_CLEAR(err->encoding);
1875     Py_CLEAR(err->object);
1876     Py_CLEAR(err->reason);
1877 
1878     if (!PyArg_ParseTuple(args, "UUnnU",
1879                           &err->encoding, &err->object,
1880                           &err->start, &err->end, &err->reason)) {
1881         err->encoding = err->object = err->reason = NULL;
1882         return -1;
1883     }
1884 
1885     Py_INCREF(err->encoding);
1886     Py_INCREF(err->object);
1887     Py_INCREF(err->reason);
1888 
1889     return 0;
1890 }
1891 
1892 static PyObject *
UnicodeEncodeError_str(PyObject * self)1893 UnicodeEncodeError_str(PyObject *self)
1894 {
1895     PyUnicodeErrorObject *uself = (PyUnicodeErrorObject *)self;
1896     PyObject *result = NULL;
1897     PyObject *reason_str = NULL;
1898     PyObject *encoding_str = NULL;
1899 
1900     if (!uself->object)
1901         /* Not properly initialized. */
1902         return PyUnicode_FromString("");
1903 
1904     /* Get reason and encoding as strings, which they might not be if
1905        they've been modified after we were constructed. */
1906     reason_str = PyObject_Str(uself->reason);
1907     if (reason_str == NULL)
1908         goto done;
1909     encoding_str = PyObject_Str(uself->encoding);
1910     if (encoding_str == NULL)
1911         goto done;
1912 
1913     if (uself->start < PyUnicode_GET_LENGTH(uself->object) && uself->end == uself->start+1) {
1914         Py_UCS4 badchar = PyUnicode_ReadChar(uself->object, uself->start);
1915         const char *fmt;
1916         if (badchar <= 0xff)
1917             fmt = "'%U' codec can't encode character '\\x%02x' in position %zd: %U";
1918         else if (badchar <= 0xffff)
1919             fmt = "'%U' codec can't encode character '\\u%04x' in position %zd: %U";
1920         else
1921             fmt = "'%U' codec can't encode character '\\U%08x' in position %zd: %U";
1922         result = PyUnicode_FromFormat(
1923             fmt,
1924             encoding_str,
1925             (int)badchar,
1926             uself->start,
1927             reason_str);
1928     }
1929     else {
1930         result = PyUnicode_FromFormat(
1931             "'%U' codec can't encode characters in position %zd-%zd: %U",
1932             encoding_str,
1933             uself->start,
1934             uself->end-1,
1935             reason_str);
1936     }
1937 done:
1938     Py_XDECREF(reason_str);
1939     Py_XDECREF(encoding_str);
1940     return result;
1941 }
1942 
1943 static PyTypeObject _PyExc_UnicodeEncodeError = {
1944     PyVarObject_HEAD_INIT(NULL, 0)
1945     "UnicodeEncodeError",
1946     sizeof(PyUnicodeErrorObject), 0,
1947     (destructor)UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1948     (reprfunc)UnicodeEncodeError_str, 0, 0, 0,
1949     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
1950     PyDoc_STR("Unicode encoding error."), (traverseproc)UnicodeError_traverse,
1951     (inquiry)UnicodeError_clear, 0, 0, 0, 0, 0, UnicodeError_members,
1952     0, &_PyExc_UnicodeError, 0, 0, 0, offsetof(PyUnicodeErrorObject, dict),
1953     (initproc)UnicodeEncodeError_init, 0, BaseException_new,
1954 };
1955 PyObject *PyExc_UnicodeEncodeError = (PyObject *)&_PyExc_UnicodeEncodeError;
1956 
1957 PyObject *
PyUnicodeEncodeError_Create(const char * encoding,const Py_UNICODE * object,Py_ssize_t length,Py_ssize_t start,Py_ssize_t end,const char * reason)1958 PyUnicodeEncodeError_Create(
1959     const char *encoding, const Py_UNICODE *object, Py_ssize_t length,
1960     Py_ssize_t start, Py_ssize_t end, const char *reason)
1961 {
1962     return PyObject_CallFunction(PyExc_UnicodeEncodeError, "su#nns",
1963                                  encoding, object, length, start, end, reason);
1964 }
1965 
1966 
1967 /*
1968  *    UnicodeDecodeError extends UnicodeError
1969  */
1970 
1971 static int
UnicodeDecodeError_init(PyObject * self,PyObject * args,PyObject * kwds)1972 UnicodeDecodeError_init(PyObject *self, PyObject *args, PyObject *kwds)
1973 {
1974     PyUnicodeErrorObject *ude;
1975 
1976     if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
1977         return -1;
1978 
1979     ude = (PyUnicodeErrorObject *)self;
1980 
1981     Py_CLEAR(ude->encoding);
1982     Py_CLEAR(ude->object);
1983     Py_CLEAR(ude->reason);
1984 
1985     if (!PyArg_ParseTuple(args, "UOnnU",
1986                           &ude->encoding, &ude->object,
1987                           &ude->start, &ude->end, &ude->reason)) {
1988              ude->encoding = ude->object = ude->reason = NULL;
1989              return -1;
1990     }
1991 
1992     Py_INCREF(ude->encoding);
1993     Py_INCREF(ude->object);
1994     Py_INCREF(ude->reason);
1995 
1996     if (!PyBytes_Check(ude->object)) {
1997         Py_buffer view;
1998         if (PyObject_GetBuffer(ude->object, &view, PyBUF_SIMPLE) != 0)
1999             goto error;
2000         Py_XSETREF(ude->object, PyBytes_FromStringAndSize(view.buf, view.len));
2001         PyBuffer_Release(&view);
2002         if (!ude->object)
2003             goto error;
2004     }
2005     return 0;
2006 
2007 error:
2008     Py_CLEAR(ude->encoding);
2009     Py_CLEAR(ude->object);
2010     Py_CLEAR(ude->reason);
2011     return -1;
2012 }
2013 
2014 static PyObject *
UnicodeDecodeError_str(PyObject * self)2015 UnicodeDecodeError_str(PyObject *self)
2016 {
2017     PyUnicodeErrorObject *uself = (PyUnicodeErrorObject *)self;
2018     PyObject *result = NULL;
2019     PyObject *reason_str = NULL;
2020     PyObject *encoding_str = NULL;
2021 
2022     if (!uself->object)
2023         /* Not properly initialized. */
2024         return PyUnicode_FromString("");
2025 
2026     /* Get reason and encoding as strings, which they might not be if
2027        they've been modified after we were constructed. */
2028     reason_str = PyObject_Str(uself->reason);
2029     if (reason_str == NULL)
2030         goto done;
2031     encoding_str = PyObject_Str(uself->encoding);
2032     if (encoding_str == NULL)
2033         goto done;
2034 
2035     if (uself->start < PyBytes_GET_SIZE(uself->object) && uself->end == uself->start+1) {
2036         int byte = (int)(PyBytes_AS_STRING(((PyUnicodeErrorObject *)self)->object)[uself->start]&0xff);
2037         result = PyUnicode_FromFormat(
2038             "'%U' codec can't decode byte 0x%02x in position %zd: %U",
2039             encoding_str,
2040             byte,
2041             uself->start,
2042             reason_str);
2043     }
2044     else {
2045         result = PyUnicode_FromFormat(
2046             "'%U' codec can't decode bytes in position %zd-%zd: %U",
2047             encoding_str,
2048             uself->start,
2049             uself->end-1,
2050             reason_str
2051             );
2052     }
2053 done:
2054     Py_XDECREF(reason_str);
2055     Py_XDECREF(encoding_str);
2056     return result;
2057 }
2058 
2059 static PyTypeObject _PyExc_UnicodeDecodeError = {
2060     PyVarObject_HEAD_INIT(NULL, 0)
2061     "UnicodeDecodeError",
2062     sizeof(PyUnicodeErrorObject), 0,
2063     (destructor)UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2064     (reprfunc)UnicodeDecodeError_str, 0, 0, 0,
2065     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
2066     PyDoc_STR("Unicode decoding error."), (traverseproc)UnicodeError_traverse,
2067     (inquiry)UnicodeError_clear, 0, 0, 0, 0, 0, UnicodeError_members,
2068     0, &_PyExc_UnicodeError, 0, 0, 0, offsetof(PyUnicodeErrorObject, dict),
2069     (initproc)UnicodeDecodeError_init, 0, BaseException_new,
2070 };
2071 PyObject *PyExc_UnicodeDecodeError = (PyObject *)&_PyExc_UnicodeDecodeError;
2072 
2073 PyObject *
PyUnicodeDecodeError_Create(const char * encoding,const char * object,Py_ssize_t length,Py_ssize_t start,Py_ssize_t end,const char * reason)2074 PyUnicodeDecodeError_Create(
2075     const char *encoding, const char *object, Py_ssize_t length,
2076     Py_ssize_t start, Py_ssize_t end, const char *reason)
2077 {
2078     return PyObject_CallFunction(PyExc_UnicodeDecodeError, "sy#nns",
2079                                  encoding, object, length, start, end, reason);
2080 }
2081 
2082 
2083 /*
2084  *    UnicodeTranslateError extends UnicodeError
2085  */
2086 
2087 static int
UnicodeTranslateError_init(PyUnicodeErrorObject * self,PyObject * args,PyObject * kwds)2088 UnicodeTranslateError_init(PyUnicodeErrorObject *self, PyObject *args,
2089                            PyObject *kwds)
2090 {
2091     if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
2092         return -1;
2093 
2094     Py_CLEAR(self->object);
2095     Py_CLEAR(self->reason);
2096 
2097     if (!PyArg_ParseTuple(args, "UnnU",
2098                           &self->object,
2099                           &self->start, &self->end, &self->reason)) {
2100         self->object = self->reason = NULL;
2101         return -1;
2102     }
2103 
2104     Py_INCREF(self->object);
2105     Py_INCREF(self->reason);
2106 
2107     return 0;
2108 }
2109 
2110 
2111 static PyObject *
UnicodeTranslateError_str(PyObject * self)2112 UnicodeTranslateError_str(PyObject *self)
2113 {
2114     PyUnicodeErrorObject *uself = (PyUnicodeErrorObject *)self;
2115     PyObject *result = NULL;
2116     PyObject *reason_str = NULL;
2117 
2118     if (!uself->object)
2119         /* Not properly initialized. */
2120         return PyUnicode_FromString("");
2121 
2122     /* Get reason as a string, which it might not be if it's been
2123        modified after we were constructed. */
2124     reason_str = PyObject_Str(uself->reason);
2125     if (reason_str == NULL)
2126         goto done;
2127 
2128     if (uself->start < PyUnicode_GET_LENGTH(uself->object) && uself->end == uself->start+1) {
2129         Py_UCS4 badchar = PyUnicode_ReadChar(uself->object, uself->start);
2130         const char *fmt;
2131         if (badchar <= 0xff)
2132             fmt = "can't translate character '\\x%02x' in position %zd: %U";
2133         else if (badchar <= 0xffff)
2134             fmt = "can't translate character '\\u%04x' in position %zd: %U";
2135         else
2136             fmt = "can't translate character '\\U%08x' in position %zd: %U";
2137         result = PyUnicode_FromFormat(
2138             fmt,
2139             (int)badchar,
2140             uself->start,
2141             reason_str
2142         );
2143     } else {
2144         result = PyUnicode_FromFormat(
2145             "can't translate characters in position %zd-%zd: %U",
2146             uself->start,
2147             uself->end-1,
2148             reason_str
2149             );
2150     }
2151 done:
2152     Py_XDECREF(reason_str);
2153     return result;
2154 }
2155 
2156 static PyTypeObject _PyExc_UnicodeTranslateError = {
2157     PyVarObject_HEAD_INIT(NULL, 0)
2158     "UnicodeTranslateError",
2159     sizeof(PyUnicodeErrorObject), 0,
2160     (destructor)UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2161     (reprfunc)UnicodeTranslateError_str, 0, 0, 0,
2162     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
2163     PyDoc_STR("Unicode translation error."), (traverseproc)UnicodeError_traverse,
2164     (inquiry)UnicodeError_clear, 0, 0, 0, 0, 0, UnicodeError_members,
2165     0, &_PyExc_UnicodeError, 0, 0, 0, offsetof(PyUnicodeErrorObject, dict),
2166     (initproc)UnicodeTranslateError_init, 0, BaseException_new,
2167 };
2168 PyObject *PyExc_UnicodeTranslateError = (PyObject *)&_PyExc_UnicodeTranslateError;
2169 
2170 /* Deprecated. */
2171 PyObject *
PyUnicodeTranslateError_Create(const Py_UNICODE * object,Py_ssize_t length,Py_ssize_t start,Py_ssize_t end,const char * reason)2172 PyUnicodeTranslateError_Create(
2173     const Py_UNICODE *object, Py_ssize_t length,
2174     Py_ssize_t start, Py_ssize_t end, const char *reason)
2175 {
2176     return PyObject_CallFunction(PyExc_UnicodeTranslateError, "u#nns",
2177                                  object, length, start, end, reason);
2178 }
2179 
2180 PyObject *
_PyUnicodeTranslateError_Create(PyObject * object,Py_ssize_t start,Py_ssize_t end,const char * reason)2181 _PyUnicodeTranslateError_Create(
2182     PyObject *object,
2183     Py_ssize_t start, Py_ssize_t end, const char *reason)
2184 {
2185     return PyObject_CallFunction(PyExc_UnicodeTranslateError, "Onns",
2186                                  object, start, end, reason);
2187 }
2188 
2189 /*
2190  *    AssertionError extends Exception
2191  */
2192 SimpleExtendsException(PyExc_Exception, AssertionError,
2193                        "Assertion failed.");
2194 
2195 
2196 /*
2197  *    ArithmeticError extends Exception
2198  */
2199 SimpleExtendsException(PyExc_Exception, ArithmeticError,
2200                        "Base class for arithmetic errors.");
2201 
2202 
2203 /*
2204  *    FloatingPointError extends ArithmeticError
2205  */
2206 SimpleExtendsException(PyExc_ArithmeticError, FloatingPointError,
2207                        "Floating point operation failed.");
2208 
2209 
2210 /*
2211  *    OverflowError extends ArithmeticError
2212  */
2213 SimpleExtendsException(PyExc_ArithmeticError, OverflowError,
2214                        "Result too large to be represented.");
2215 
2216 
2217 /*
2218  *    ZeroDivisionError extends ArithmeticError
2219  */
2220 SimpleExtendsException(PyExc_ArithmeticError, ZeroDivisionError,
2221           "Second argument to a division or modulo operation was zero.");
2222 
2223 
2224 /*
2225  *    SystemError extends Exception
2226  */
2227 SimpleExtendsException(PyExc_Exception, SystemError,
2228     "Internal error in the Python interpreter.\n"
2229     "\n"
2230     "Please report this to the Python maintainer, along with the traceback,\n"
2231     "the Python version, and the hardware/OS platform and version.");
2232 
2233 
2234 /*
2235  *    ReferenceError extends Exception
2236  */
2237 SimpleExtendsException(PyExc_Exception, ReferenceError,
2238                        "Weak ref proxy used after referent went away.");
2239 
2240 
2241 /*
2242  *    MemoryError extends Exception
2243  */
2244 
2245 #define MEMERRORS_SAVE 16
2246 static PyBaseExceptionObject *memerrors_freelist = NULL;
2247 static int memerrors_numfree = 0;
2248 
2249 static PyObject *
MemoryError_new(PyTypeObject * type,PyObject * args,PyObject * kwds)2250 MemoryError_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
2251 {
2252     PyBaseExceptionObject *self;
2253 
2254     if (type != (PyTypeObject *) PyExc_MemoryError)
2255         return BaseException_new(type, args, kwds);
2256     if (memerrors_freelist == NULL)
2257         return BaseException_new(type, args, kwds);
2258     /* Fetch object from freelist and revive it */
2259     self = memerrors_freelist;
2260     self->args = PyTuple_New(0);
2261     /* This shouldn't happen since the empty tuple is persistent */
2262     if (self->args == NULL)
2263         return NULL;
2264     memerrors_freelist = (PyBaseExceptionObject *) self->dict;
2265     memerrors_numfree--;
2266     self->dict = NULL;
2267     _Py_NewReference((PyObject *)self);
2268     _PyObject_GC_TRACK(self);
2269     return (PyObject *)self;
2270 }
2271 
2272 static void
MemoryError_dealloc(PyBaseExceptionObject * self)2273 MemoryError_dealloc(PyBaseExceptionObject *self)
2274 {
2275     _PyObject_GC_UNTRACK(self);
2276     BaseException_clear(self);
2277     if (memerrors_numfree >= MEMERRORS_SAVE)
2278         Py_TYPE(self)->tp_free((PyObject *)self);
2279     else {
2280         self->dict = (PyObject *) memerrors_freelist;
2281         memerrors_freelist = self;
2282         memerrors_numfree++;
2283     }
2284 }
2285 
2286 static void
preallocate_memerrors(void)2287 preallocate_memerrors(void)
2288 {
2289     /* We create enough MemoryErrors and then decref them, which will fill
2290        up the freelist. */
2291     int i;
2292     PyObject *errors[MEMERRORS_SAVE];
2293     for (i = 0; i < MEMERRORS_SAVE; i++) {
2294         errors[i] = MemoryError_new((PyTypeObject *) PyExc_MemoryError,
2295                                     NULL, NULL);
2296         if (!errors[i])
2297             Py_FatalError("Could not preallocate MemoryError object");
2298     }
2299     for (i = 0; i < MEMERRORS_SAVE; i++) {
2300         Py_DECREF(errors[i]);
2301     }
2302 }
2303 
2304 static void
free_preallocated_memerrors(void)2305 free_preallocated_memerrors(void)
2306 {
2307     while (memerrors_freelist != NULL) {
2308         PyObject *self = (PyObject *) memerrors_freelist;
2309         memerrors_freelist = (PyBaseExceptionObject *) memerrors_freelist->dict;
2310         Py_TYPE(self)->tp_free((PyObject *)self);
2311     }
2312 }
2313 
2314 
2315 static PyTypeObject _PyExc_MemoryError = {
2316     PyVarObject_HEAD_INIT(NULL, 0)
2317     "MemoryError",
2318     sizeof(PyBaseExceptionObject),
2319     0, (destructor)MemoryError_dealloc, 0, 0, 0, 0, 0, 0, 0,
2320     0, 0, 0, 0, 0, 0, 0,
2321     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
2322     PyDoc_STR("Out of memory."), (traverseproc)BaseException_traverse,
2323     (inquiry)BaseException_clear, 0, 0, 0, 0, 0, 0, 0, &_PyExc_Exception,
2324     0, 0, 0, offsetof(PyBaseExceptionObject, dict),
2325     (initproc)BaseException_init, 0, MemoryError_new
2326 };
2327 PyObject *PyExc_MemoryError = (PyObject *) &_PyExc_MemoryError;
2328 
2329 
2330 /*
2331  *    BufferError extends Exception
2332  */
2333 SimpleExtendsException(PyExc_Exception, BufferError, "Buffer error.");
2334 
2335 
2336 /* Warning category docstrings */
2337 
2338 /*
2339  *    Warning extends Exception
2340  */
2341 SimpleExtendsException(PyExc_Exception, Warning,
2342                        "Base class for warning categories.");
2343 
2344 
2345 /*
2346  *    UserWarning extends Warning
2347  */
2348 SimpleExtendsException(PyExc_Warning, UserWarning,
2349                        "Base class for warnings generated by user code.");
2350 
2351 
2352 /*
2353  *    DeprecationWarning extends Warning
2354  */
2355 SimpleExtendsException(PyExc_Warning, DeprecationWarning,
2356                        "Base class for warnings about deprecated features.");
2357 
2358 
2359 /*
2360  *    PendingDeprecationWarning extends Warning
2361  */
2362 SimpleExtendsException(PyExc_Warning, PendingDeprecationWarning,
2363     "Base class for warnings about features which will be deprecated\n"
2364     "in the future.");
2365 
2366 
2367 /*
2368  *    SyntaxWarning extends Warning
2369  */
2370 SimpleExtendsException(PyExc_Warning, SyntaxWarning,
2371                        "Base class for warnings about dubious syntax.");
2372 
2373 
2374 /*
2375  *    RuntimeWarning extends Warning
2376  */
2377 SimpleExtendsException(PyExc_Warning, RuntimeWarning,
2378                  "Base class for warnings about dubious runtime behavior.");
2379 
2380 
2381 /*
2382  *    FutureWarning extends Warning
2383  */
2384 SimpleExtendsException(PyExc_Warning, FutureWarning,
2385     "Base class for warnings about constructs that will change semantically\n"
2386     "in the future.");
2387 
2388 
2389 /*
2390  *    ImportWarning extends Warning
2391  */
2392 SimpleExtendsException(PyExc_Warning, ImportWarning,
2393           "Base class for warnings about probable mistakes in module imports");
2394 
2395 
2396 /*
2397  *    UnicodeWarning extends Warning
2398  */
2399 SimpleExtendsException(PyExc_Warning, UnicodeWarning,
2400     "Base class for warnings about Unicode related problems, mostly\n"
2401     "related to conversion problems.");
2402 
2403 
2404 /*
2405  *    BytesWarning extends Warning
2406  */
2407 SimpleExtendsException(PyExc_Warning, BytesWarning,
2408     "Base class for warnings about bytes and buffer related problems, mostly\n"
2409     "related to conversion from str or comparing to str.");
2410 
2411 
2412 /*
2413  *    ResourceWarning extends Warning
2414  */
2415 SimpleExtendsException(PyExc_Warning, ResourceWarning,
2416     "Base class for warnings about resource usage.");
2417 
2418 
2419 
2420 #define PRE_INIT(TYPE) \
2421     if (!(_PyExc_ ## TYPE.tp_flags & Py_TPFLAGS_READY)) { \
2422         if (PyType_Ready(&_PyExc_ ## TYPE) < 0) \
2423             Py_FatalError("exceptions bootstrapping error."); \
2424         Py_INCREF(PyExc_ ## TYPE); \
2425     }
2426 
2427 #define POST_INIT(TYPE) \
2428     if (PyDict_SetItemString(bdict, # TYPE, PyExc_ ## TYPE)) \
2429         Py_FatalError("Module dictionary insertion problem.");
2430 
2431 #define INIT_ALIAS(NAME, TYPE) Py_INCREF(PyExc_ ## TYPE); \
2432     Py_XDECREF(PyExc_ ## NAME); \
2433     PyExc_ ## NAME = PyExc_ ## TYPE; \
2434     if (PyDict_SetItemString(bdict, # NAME, PyExc_ ## NAME)) \
2435         Py_FatalError("Module dictionary insertion problem.");
2436 
2437 #define ADD_ERRNO(TYPE, CODE) { \
2438     PyObject *_code = PyLong_FromLong(CODE); \
2439     assert(_PyObject_RealIsSubclass(PyExc_ ## TYPE, PyExc_OSError)); \
2440     if (!_code || PyDict_SetItem(errnomap, _code, PyExc_ ## TYPE)) \
2441         Py_FatalError("errmap insertion problem."); \
2442     Py_DECREF(_code); \
2443     }
2444 
2445 #ifdef MS_WINDOWS
2446 #include <winsock2.h>
2447 /* The following constants were added to errno.h in VS2010 but have
2448    preferred WSA equivalents. */
2449 #undef EADDRINUSE
2450 #undef EADDRNOTAVAIL
2451 #undef EAFNOSUPPORT
2452 #undef EALREADY
2453 #undef ECONNABORTED
2454 #undef ECONNREFUSED
2455 #undef ECONNRESET
2456 #undef EDESTADDRREQ
2457 #undef EHOSTUNREACH
2458 #undef EINPROGRESS
2459 #undef EISCONN
2460 #undef ELOOP
2461 #undef EMSGSIZE
2462 #undef ENETDOWN
2463 #undef ENETRESET
2464 #undef ENETUNREACH
2465 #undef ENOBUFS
2466 #undef ENOPROTOOPT
2467 #undef ENOTCONN
2468 #undef ENOTSOCK
2469 #undef EOPNOTSUPP
2470 #undef EPROTONOSUPPORT
2471 #undef EPROTOTYPE
2472 #undef ETIMEDOUT
2473 #undef EWOULDBLOCK
2474 
2475 #if defined(WSAEALREADY) && !defined(EALREADY)
2476 #define EALREADY WSAEALREADY
2477 #endif
2478 #if defined(WSAECONNABORTED) && !defined(ECONNABORTED)
2479 #define ECONNABORTED WSAECONNABORTED
2480 #endif
2481 #if defined(WSAECONNREFUSED) && !defined(ECONNREFUSED)
2482 #define ECONNREFUSED WSAECONNREFUSED
2483 #endif
2484 #if defined(WSAECONNRESET) && !defined(ECONNRESET)
2485 #define ECONNRESET WSAECONNRESET
2486 #endif
2487 #if defined(WSAEINPROGRESS) && !defined(EINPROGRESS)
2488 #define EINPROGRESS WSAEINPROGRESS
2489 #endif
2490 #if defined(WSAESHUTDOWN) && !defined(ESHUTDOWN)
2491 #define ESHUTDOWN WSAESHUTDOWN
2492 #endif
2493 #if defined(WSAETIMEDOUT) && !defined(ETIMEDOUT)
2494 #define ETIMEDOUT WSAETIMEDOUT
2495 #endif
2496 #if defined(WSAEWOULDBLOCK) && !defined(EWOULDBLOCK)
2497 #define EWOULDBLOCK WSAEWOULDBLOCK
2498 #endif
2499 #endif /* MS_WINDOWS */
2500 
2501 void
_PyExc_Init(PyObject * bltinmod)2502 _PyExc_Init(PyObject *bltinmod)
2503 {
2504     PyObject *bdict;
2505 
2506     PRE_INIT(BaseException)
2507     PRE_INIT(Exception)
2508     PRE_INIT(TypeError)
2509     PRE_INIT(StopAsyncIteration)
2510     PRE_INIT(StopIteration)
2511     PRE_INIT(GeneratorExit)
2512     PRE_INIT(SystemExit)
2513     PRE_INIT(KeyboardInterrupt)
2514     PRE_INIT(ImportError)
2515     PRE_INIT(ModuleNotFoundError)
2516     PRE_INIT(OSError)
2517     PRE_INIT(EOFError)
2518     PRE_INIT(RuntimeError)
2519     PRE_INIT(RecursionError)
2520     PRE_INIT(NotImplementedError)
2521     PRE_INIT(NameError)
2522     PRE_INIT(UnboundLocalError)
2523     PRE_INIT(AttributeError)
2524     PRE_INIT(SyntaxError)
2525     PRE_INIT(IndentationError)
2526     PRE_INIT(TabError)
2527     PRE_INIT(LookupError)
2528     PRE_INIT(IndexError)
2529     PRE_INIT(KeyError)
2530     PRE_INIT(ValueError)
2531     PRE_INIT(UnicodeError)
2532     PRE_INIT(UnicodeEncodeError)
2533     PRE_INIT(UnicodeDecodeError)
2534     PRE_INIT(UnicodeTranslateError)
2535     PRE_INIT(AssertionError)
2536     PRE_INIT(ArithmeticError)
2537     PRE_INIT(FloatingPointError)
2538     PRE_INIT(OverflowError)
2539     PRE_INIT(ZeroDivisionError)
2540     PRE_INIT(SystemError)
2541     PRE_INIT(ReferenceError)
2542     PRE_INIT(MemoryError)
2543     PRE_INIT(BufferError)
2544     PRE_INIT(Warning)
2545     PRE_INIT(UserWarning)
2546     PRE_INIT(DeprecationWarning)
2547     PRE_INIT(PendingDeprecationWarning)
2548     PRE_INIT(SyntaxWarning)
2549     PRE_INIT(RuntimeWarning)
2550     PRE_INIT(FutureWarning)
2551     PRE_INIT(ImportWarning)
2552     PRE_INIT(UnicodeWarning)
2553     PRE_INIT(BytesWarning)
2554     PRE_INIT(ResourceWarning)
2555 
2556     /* OSError subclasses */
2557     PRE_INIT(ConnectionError)
2558 
2559     PRE_INIT(BlockingIOError)
2560     PRE_INIT(BrokenPipeError)
2561     PRE_INIT(ChildProcessError)
2562     PRE_INIT(ConnectionAbortedError)
2563     PRE_INIT(ConnectionRefusedError)
2564     PRE_INIT(ConnectionResetError)
2565     PRE_INIT(FileExistsError)
2566     PRE_INIT(FileNotFoundError)
2567     PRE_INIT(IsADirectoryError)
2568     PRE_INIT(NotADirectoryError)
2569     PRE_INIT(InterruptedError)
2570     PRE_INIT(PermissionError)
2571     PRE_INIT(ProcessLookupError)
2572     PRE_INIT(TimeoutError)
2573 
2574     bdict = PyModule_GetDict(bltinmod);
2575     if (bdict == NULL)
2576         Py_FatalError("exceptions bootstrapping error.");
2577 
2578     POST_INIT(BaseException)
2579     POST_INIT(Exception)
2580     POST_INIT(TypeError)
2581     POST_INIT(StopAsyncIteration)
2582     POST_INIT(StopIteration)
2583     POST_INIT(GeneratorExit)
2584     POST_INIT(SystemExit)
2585     POST_INIT(KeyboardInterrupt)
2586     POST_INIT(ImportError)
2587     POST_INIT(ModuleNotFoundError)
2588     POST_INIT(OSError)
2589     INIT_ALIAS(EnvironmentError, OSError)
2590     INIT_ALIAS(IOError, OSError)
2591 #ifdef MS_WINDOWS
2592     INIT_ALIAS(WindowsError, OSError)
2593 #endif
2594     POST_INIT(EOFError)
2595     POST_INIT(RuntimeError)
2596     POST_INIT(RecursionError)
2597     POST_INIT(NotImplementedError)
2598     POST_INIT(NameError)
2599     POST_INIT(UnboundLocalError)
2600     POST_INIT(AttributeError)
2601     POST_INIT(SyntaxError)
2602     POST_INIT(IndentationError)
2603     POST_INIT(TabError)
2604     POST_INIT(LookupError)
2605     POST_INIT(IndexError)
2606     POST_INIT(KeyError)
2607     POST_INIT(ValueError)
2608     POST_INIT(UnicodeError)
2609     POST_INIT(UnicodeEncodeError)
2610     POST_INIT(UnicodeDecodeError)
2611     POST_INIT(UnicodeTranslateError)
2612     POST_INIT(AssertionError)
2613     POST_INIT(ArithmeticError)
2614     POST_INIT(FloatingPointError)
2615     POST_INIT(OverflowError)
2616     POST_INIT(ZeroDivisionError)
2617     POST_INIT(SystemError)
2618     POST_INIT(ReferenceError)
2619     POST_INIT(MemoryError)
2620     POST_INIT(BufferError)
2621     POST_INIT(Warning)
2622     POST_INIT(UserWarning)
2623     POST_INIT(DeprecationWarning)
2624     POST_INIT(PendingDeprecationWarning)
2625     POST_INIT(SyntaxWarning)
2626     POST_INIT(RuntimeWarning)
2627     POST_INIT(FutureWarning)
2628     POST_INIT(ImportWarning)
2629     POST_INIT(UnicodeWarning)
2630     POST_INIT(BytesWarning)
2631     POST_INIT(ResourceWarning)
2632 
2633     if (!errnomap) {
2634         errnomap = PyDict_New();
2635         if (!errnomap)
2636             Py_FatalError("Cannot allocate map from errnos to OSError subclasses");
2637     }
2638 
2639     /* OSError subclasses */
2640     POST_INIT(ConnectionError)
2641 
2642     POST_INIT(BlockingIOError)
2643     ADD_ERRNO(BlockingIOError, EAGAIN)
2644     ADD_ERRNO(BlockingIOError, EALREADY)
2645     ADD_ERRNO(BlockingIOError, EINPROGRESS)
2646     ADD_ERRNO(BlockingIOError, EWOULDBLOCK)
2647     POST_INIT(BrokenPipeError)
2648     ADD_ERRNO(BrokenPipeError, EPIPE)
2649 #ifdef ESHUTDOWN
2650     ADD_ERRNO(BrokenPipeError, ESHUTDOWN)
2651 #endif
2652     POST_INIT(ChildProcessError)
2653     ADD_ERRNO(ChildProcessError, ECHILD)
2654     POST_INIT(ConnectionAbortedError)
2655     ADD_ERRNO(ConnectionAbortedError, ECONNABORTED)
2656     POST_INIT(ConnectionRefusedError)
2657     ADD_ERRNO(ConnectionRefusedError, ECONNREFUSED)
2658     POST_INIT(ConnectionResetError)
2659     ADD_ERRNO(ConnectionResetError, ECONNRESET)
2660     POST_INIT(FileExistsError)
2661     ADD_ERRNO(FileExistsError, EEXIST)
2662     POST_INIT(FileNotFoundError)
2663     ADD_ERRNO(FileNotFoundError, ENOENT)
2664     POST_INIT(IsADirectoryError)
2665     ADD_ERRNO(IsADirectoryError, EISDIR)
2666     POST_INIT(NotADirectoryError)
2667     ADD_ERRNO(NotADirectoryError, ENOTDIR)
2668     POST_INIT(InterruptedError)
2669     ADD_ERRNO(InterruptedError, EINTR)
2670     POST_INIT(PermissionError)
2671     ADD_ERRNO(PermissionError, EACCES)
2672     ADD_ERRNO(PermissionError, EPERM)
2673     POST_INIT(ProcessLookupError)
2674     ADD_ERRNO(ProcessLookupError, ESRCH)
2675     POST_INIT(TimeoutError)
2676     ADD_ERRNO(TimeoutError, ETIMEDOUT)
2677 
2678     preallocate_memerrors();
2679 }
2680 
2681 void
_PyExc_Fini(void)2682 _PyExc_Fini(void)
2683 {
2684     free_preallocated_memerrors();
2685     Py_CLEAR(errnomap);
2686 }
2687 
2688 /* Helper to do the equivalent of "raise X from Y" in C, but always using
2689  * the current exception rather than passing one in.
2690  *
2691  * We currently limit this to *only* exceptions that use the BaseException
2692  * tp_init and tp_new methods, since we can be reasonably sure we can wrap
2693  * those correctly without losing data and without losing backwards
2694  * compatibility.
2695  *
2696  * We also aim to rule out *all* exceptions that might be storing additional
2697  * state, whether by having a size difference relative to BaseException,
2698  * additional arguments passed in during construction or by having a
2699  * non-empty instance dict.
2700  *
2701  * We need to be very careful with what we wrap, since changing types to
2702  * a broader exception type would be backwards incompatible for
2703  * existing codecs, and with different init or new method implementations
2704  * may either not support instantiation with PyErr_Format or lose
2705  * information when instantiated that way.
2706  *
2707  * XXX (ncoghlan): This could be made more comprehensive by exploiting the
2708  * fact that exceptions are expected to support pickling. If more builtin
2709  * exceptions (e.g. AttributeError) start to be converted to rich
2710  * exceptions with additional attributes, that's probably a better approach
2711  * to pursue over adding special cases for particular stateful subclasses.
2712  *
2713  * Returns a borrowed reference to the new exception (if any), NULL if the
2714  * existing exception was left in place.
2715  */
2716 PyObject *
_PyErr_TrySetFromCause(const char * format,...)2717 _PyErr_TrySetFromCause(const char *format, ...)
2718 {
2719     PyObject* msg_prefix;
2720     PyObject *exc, *val, *tb;
2721     PyTypeObject *caught_type;
2722     PyObject **dictptr;
2723     PyObject *instance_args;
2724     Py_ssize_t num_args, caught_type_size, base_exc_size;
2725     PyObject *new_exc, *new_val, *new_tb;
2726     va_list vargs;
2727     int same_basic_size;
2728 
2729     PyErr_Fetch(&exc, &val, &tb);
2730     caught_type = (PyTypeObject *)exc;
2731     /* Ensure type info indicates no extra state is stored at the C level
2732      * and that the type can be reinstantiated using PyErr_Format
2733      */
2734     caught_type_size = caught_type->tp_basicsize;
2735     base_exc_size = _PyExc_BaseException.tp_basicsize;
2736     same_basic_size = (
2737         caught_type_size == base_exc_size ||
2738         (PyType_SUPPORTS_WEAKREFS(caught_type) &&
2739             (caught_type_size == base_exc_size + (Py_ssize_t)sizeof(PyObject *))
2740         )
2741     );
2742     if (caught_type->tp_init != (initproc)BaseException_init ||
2743         caught_type->tp_new != BaseException_new ||
2744         !same_basic_size ||
2745         caught_type->tp_itemsize != _PyExc_BaseException.tp_itemsize) {
2746         /* We can't be sure we can wrap this safely, since it may contain
2747          * more state than just the exception type. Accordingly, we just
2748          * leave it alone.
2749          */
2750         PyErr_Restore(exc, val, tb);
2751         return NULL;
2752     }
2753 
2754     /* Check the args are empty or contain a single string */
2755     PyErr_NormalizeException(&exc, &val, &tb);
2756     instance_args = ((PyBaseExceptionObject *)val)->args;
2757     num_args = PyTuple_GET_SIZE(instance_args);
2758     if (num_args > 1 ||
2759         (num_args == 1 &&
2760          !PyUnicode_CheckExact(PyTuple_GET_ITEM(instance_args, 0)))) {
2761         /* More than 1 arg, or the one arg we do have isn't a string
2762          */
2763         PyErr_Restore(exc, val, tb);
2764         return NULL;
2765     }
2766 
2767     /* Ensure the instance dict is also empty */
2768     dictptr = _PyObject_GetDictPtr(val);
2769     if (dictptr != NULL && *dictptr != NULL &&
2770         PyDict_GET_SIZE(*dictptr) > 0) {
2771         /* While we could potentially copy a non-empty instance dictionary
2772          * to the replacement exception, for now we take the more
2773          * conservative path of leaving exceptions with attributes set
2774          * alone.
2775          */
2776         PyErr_Restore(exc, val, tb);
2777         return NULL;
2778     }
2779 
2780     /* For exceptions that we can wrap safely, we chain the original
2781      * exception to a new one of the exact same type with an
2782      * error message that mentions the additional details and the
2783      * original exception.
2784      *
2785      * It would be nice to wrap OSError and various other exception
2786      * types as well, but that's quite a bit trickier due to the extra
2787      * state potentially stored on OSError instances.
2788      */
2789     /* Ensure the traceback is set correctly on the existing exception */
2790     if (tb != NULL) {
2791         PyException_SetTraceback(val, tb);
2792         Py_DECREF(tb);
2793     }
2794 
2795 #ifdef HAVE_STDARG_PROTOTYPES
2796     va_start(vargs, format);
2797 #else
2798     va_start(vargs);
2799 #endif
2800     msg_prefix = PyUnicode_FromFormatV(format, vargs);
2801     va_end(vargs);
2802     if (msg_prefix == NULL) {
2803         Py_DECREF(exc);
2804         Py_DECREF(val);
2805         return NULL;
2806     }
2807 
2808     PyErr_Format(exc, "%U (%s: %S)",
2809                  msg_prefix, Py_TYPE(val)->tp_name, val);
2810     Py_DECREF(exc);
2811     Py_DECREF(msg_prefix);
2812     PyErr_Fetch(&new_exc, &new_val, &new_tb);
2813     PyErr_NormalizeException(&new_exc, &new_val, &new_tb);
2814     PyException_SetCause(new_val, val);
2815     PyErr_Restore(new_exc, new_val, new_tb);
2816     return new_val;
2817 }
2818 
2819 
2820 /* To help with migration from Python 2, SyntaxError.__init__ applies some
2821  * heuristics to try to report a more meaningful exception when print and
2822  * exec are used like statements.
2823  *
2824  * The heuristics are currently expected to detect the following cases:
2825  *   - top level statement
2826  *   - statement in a nested suite
2827  *   - trailing section of a one line complex statement
2828  *
2829  * They're currently known not to trigger:
2830  *   - after a semi-colon
2831  *
2832  * The error message can be a bit odd in cases where the "arguments" are
2833  * completely illegal syntactically, but that isn't worth the hassle of
2834  * fixing.
2835  *
2836  * We also can't do anything about cases that are legal Python 3 syntax
2837  * but mean something entirely different from what they did in Python 2
2838  * (omitting the arguments entirely, printing items preceded by a unary plus
2839  * or minus, using the stream redirection syntax).
2840  */
2841 
2842 
2843 // Static helper for setting legacy print error message
2844 static int
_set_legacy_print_statement_msg(PySyntaxErrorObject * self,Py_ssize_t start)2845 _set_legacy_print_statement_msg(PySyntaxErrorObject *self, Py_ssize_t start)
2846 {
2847     // PRINT_OFFSET is to remove the `print ` prefix from the data.
2848     const int PRINT_OFFSET = 6;
2849     const int STRIP_BOTH = 2;
2850     Py_ssize_t start_pos = start + PRINT_OFFSET;
2851     Py_ssize_t text_len = PyUnicode_GET_LENGTH(self->text);
2852     Py_UCS4 semicolon = ';';
2853     Py_ssize_t end_pos = PyUnicode_FindChar(self->text, semicolon,
2854                                             start_pos, text_len, 1);
2855     if (end_pos < -1) {
2856       return -1;
2857     } else if (end_pos == -1) {
2858       end_pos = text_len;
2859     }
2860 
2861     PyObject *data = PyUnicode_Substring(self->text, start_pos, end_pos);
2862     if (data == NULL) {
2863         return -1;
2864     }
2865 
2866     PyObject *strip_sep_obj = PyUnicode_FromString(" \t\r\n");
2867     if (strip_sep_obj == NULL) {
2868         Py_DECREF(data);
2869         return -1;
2870     }
2871 
2872     PyObject *new_data = _PyUnicode_XStrip(data, STRIP_BOTH, strip_sep_obj);
2873     Py_DECREF(data);
2874     Py_DECREF(strip_sep_obj);
2875     if (new_data == NULL) {
2876         return -1;
2877     }
2878     // gets the modified text_len after stripping `print `
2879     text_len = PyUnicode_GET_LENGTH(new_data);
2880     const char *maybe_end_arg = "";
2881     if (text_len > 0 && PyUnicode_READ_CHAR(new_data, text_len-1) == ',') {
2882         maybe_end_arg = " end=\" \"";
2883     }
2884     PyObject *error_msg = PyUnicode_FromFormat(
2885         "Missing parentheses in call to 'print'. Did you mean print(%U%s)?",
2886         new_data, maybe_end_arg
2887     );
2888     Py_DECREF(new_data);
2889     if (error_msg == NULL)
2890         return -1;
2891 
2892     Py_XSETREF(self->msg, error_msg);
2893     return 1;
2894 }
2895 
2896 static int
_check_for_legacy_statements(PySyntaxErrorObject * self,Py_ssize_t start)2897 _check_for_legacy_statements(PySyntaxErrorObject *self, Py_ssize_t start)
2898 {
2899     /* Return values:
2900      *   -1: an error occurred
2901      *    0: nothing happened
2902      *    1: the check triggered & the error message was changed
2903      */
2904     static PyObject *print_prefix = NULL;
2905     static PyObject *exec_prefix = NULL;
2906     Py_ssize_t text_len = PyUnicode_GET_LENGTH(self->text);
2907     int kind = PyUnicode_KIND(self->text);
2908     void *data = PyUnicode_DATA(self->text);
2909 
2910     /* Ignore leading whitespace */
2911     while (start < text_len) {
2912         Py_UCS4 ch = PyUnicode_READ(kind, data, start);
2913         if (!Py_UNICODE_ISSPACE(ch))
2914             break;
2915         start++;
2916     }
2917     /* Checking against an empty or whitespace-only part of the string */
2918     if (start == text_len) {
2919         return 0;
2920     }
2921 
2922     /* Check for legacy print statements */
2923     if (print_prefix == NULL) {
2924         print_prefix = PyUnicode_InternFromString("print ");
2925         if (print_prefix == NULL) {
2926             return -1;
2927         }
2928     }
2929     if (PyUnicode_Tailmatch(self->text, print_prefix,
2930                             start, text_len, -1)) {
2931 
2932         return _set_legacy_print_statement_msg(self, start);
2933     }
2934 
2935     /* Check for legacy exec statements */
2936     if (exec_prefix == NULL) {
2937         exec_prefix = PyUnicode_InternFromString("exec ");
2938         if (exec_prefix == NULL) {
2939             return -1;
2940         }
2941     }
2942     if (PyUnicode_Tailmatch(self->text, exec_prefix,
2943                             start, text_len, -1)) {
2944         Py_XSETREF(self->msg,
2945                   PyUnicode_FromString("Missing parentheses in call to 'exec'"));
2946         return 1;
2947     }
2948     /* Fall back to the default error message */
2949     return 0;
2950 }
2951 
2952 static int
_report_missing_parentheses(PySyntaxErrorObject * self)2953 _report_missing_parentheses(PySyntaxErrorObject *self)
2954 {
2955     Py_UCS4 left_paren = 40;
2956     Py_ssize_t left_paren_index;
2957     Py_ssize_t text_len = PyUnicode_GET_LENGTH(self->text);
2958     int legacy_check_result = 0;
2959 
2960     /* Skip entirely if there is an opening parenthesis */
2961     left_paren_index = PyUnicode_FindChar(self->text, left_paren,
2962                                           0, text_len, 1);
2963     if (left_paren_index < -1) {
2964         return -1;
2965     }
2966     if (left_paren_index != -1) {
2967         /* Use default error message for any line with an opening paren */
2968         return 0;
2969     }
2970     /* Handle the simple statement case */
2971     legacy_check_result = _check_for_legacy_statements(self, 0);
2972     if (legacy_check_result < 0) {
2973         return -1;
2974 
2975     }
2976     if (legacy_check_result == 0) {
2977         /* Handle the one-line complex statement case */
2978         Py_UCS4 colon = 58;
2979         Py_ssize_t colon_index;
2980         colon_index = PyUnicode_FindChar(self->text, colon,
2981                                          0, text_len, 1);
2982         if (colon_index < -1) {
2983             return -1;
2984         }
2985         if (colon_index >= 0 && colon_index < text_len) {
2986             /* Check again, starting from just after the colon */
2987             if (_check_for_legacy_statements(self, colon_index+1) < 0) {
2988                 return -1;
2989             }
2990         }
2991     }
2992     return 0;
2993 }
2994