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