Objects/exceptions.c

   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 "structmember.h"
  10 #include "osdefs.h"
  11
  12 #define EXC_MODULE_NAME "exceptions."
  13
  14 /* NOTE: If the exception class hierarchy changes, don't forget to update
  15  * Lib/test/exception_hierarchy.txt
  16  */
  17
  18 PyDoc_STRVAR(exceptions_doc, "Python's standard exception class hierarchy.\n\
  19 \n\
  20 Exceptions found here are defined both in the exceptions module and the\n\
  21 built-in namespace.  It is recommended that user-defined exceptions\n\
  22 inherit from Exception.  See the documentation for the exception\n\
  23 inheritance hierarchy.\n\
  24 ");
  25
  26 /*
  27  *    BaseException
  28  */
  29 static PyObject *
  30 BaseException_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
  31 {
  32     PyBaseExceptionObject *self;
  33
  34     self = (PyBaseExceptionObject *)type->tp_alloc(type, 0);
  35     if (!self)
  36         return NULL;
  37     /* the dict is created on the fly in PyObject_GenericSetAttr */
  38     self->message = self->dict = NULL;
  39
  40     self->args = PyTuple_New(0);
  41     if (!self->args) {
  42         Py_DECREF(self);
  43         return NULL;
  44     }
  45
  46     self->message = PyString_FromString("");
  47     if (!self->message) {
  48         Py_DECREF(self);
  49         return NULL;
  50     }
  51
  52     return (PyObject *)self;
  53 }
  54
  55 static int
  56 BaseException_init(PyBaseExceptionObject *self, PyObject *args, PyObject *kwds)
  57 {
  58     if (!_PyArg_NoKeywords(Py_TYPE(self)->tp_name, kwds))
  59         return -1;
  60
  61     Py_DECREF(self->args);
  62     self->args = args;
  63     Py_INCREF(self->args);
  64
  65     if (PyTuple_GET_SIZE(self->args) == 1) {
  66         Py_CLEAR(self->message);
  67         self->message = PyTuple_GET_ITEM(self->args, 0);
  68         Py_INCREF(self->message);
  69     }
  70     return 0;
  71 }
  72
  73 static int
  74 BaseException_clear(PyBaseExceptionObject *self)
  75 {
  76     Py_CLEAR(self->dict);
  77     Py_CLEAR(self->args);
  78     Py_CLEAR(self->message);
  79     return 0;
  80 }
  81
  82 static void
  83 BaseException_dealloc(PyBaseExceptionObject *self)
  84 {
  85     _PyObject_GC_UNTRACK(self);
  86     BaseException_clear(self);
  87     Py_TYPE(self)->tp_free((PyObject *)self);
  88 }
  89
  90 static int
  91 BaseException_traverse(PyBaseExceptionObject *self, visitproc visit, void *arg)
  92 {
  93     Py_VISIT(self->dict);
  94     Py_VISIT(self->args);
  95     Py_VISIT(self->message);
  96     return 0;
  97 }
  98
  99 static PyObject *
 100 BaseException_str(PyBaseExceptionObject *self)
 101 {
 102     PyObject *out;
 103
 104     switch (PyTuple_GET_SIZE(self->args)) {
 105     case 0:
 106         out = PyString_FromString("");
 107         break;
 108     case 1:
 109         out = PyObject_Str(PyTuple_GET_ITEM(self->args, 0));
 110         break;
 111     default:
 112         out = PyObject_Str(self->args);
 113         break;
 114     }
 115
 116     return out;
 117 }
 118
 119 #ifdef Py_USING_UNICODE
 120 static PyObject *
 121 BaseException_unicode(PyBaseExceptionObject *self)
 122 {
 123     PyObject *out;
 124
 125     switch (PyTuple_GET_SIZE(self->args)) {
 126     case 0:
 127         out = PyUnicode_FromString("");
 128         break;
 129     case 1:
 130         out = PyObject_Unicode(PyTuple_GET_ITEM(self->args, 0));
 131         break;
 132     default:
 133         out = PyObject_Unicode(self->args);
 134         break;
 135     }
 136
 137     return out;
 138 }
 139 #endif
 140
 141 static PyObject *
 142 BaseException_repr(PyBaseExceptionObject *self)
 143 {
 144     PyObject *repr_suffix;
 145     PyObject *repr;
 146     char *name;
 147     char *dot;
 148
 149     repr_suffix = PyObject_Repr(self->args);
 150     if (!repr_suffix)
 151         return NULL;
 152
 153     name = (char *)Py_TYPE(self)->tp_name;
 154     dot = strrchr(name, '.');
 155     if (dot != NULL) name = dot+1;
 156
 157     repr = PyString_FromString(name);
 158     if (!repr) {
 159         Py_DECREF(repr_suffix);
 160         return NULL;
 161     }
 162
 163     PyString_ConcatAndDel(&repr, repr_suffix);
 164     return repr;
 165 }
 166
 167 /* Pickling support */
 168 static PyObject *
 169 BaseException_reduce(PyBaseExceptionObject *self)
 170 {
 171     if (self->args && self->dict)
 172         return PyTuple_Pack(3, Py_TYPE(self), self->args, self->dict);
 173     else
 174         return PyTuple_Pack(2, Py_TYPE(self), self->args);
 175 }
 176
 177 /*
 178  * Needed for backward compatibility, since exceptions used to store
 179  * all their attributes in the __dict__. Code is taken from cPickle's
 180  * load_build function.
 181  */
 182 static PyObject *
 183 BaseException_setstate(PyObject *self, PyObject *state)
 184 {
 185     PyObject *d_key, *d_value;
 186     Py_ssize_t i = 0;
 187
 188     if (state != Py_None) {
 189         if (!PyDict_Check(state)) {
 190             PyErr_SetString(PyExc_TypeError, "state is not a dictionary");
 191             return NULL;
 192         }
 193         while (PyDict_Next(state, &i, &d_key, &d_value)) {
 194             if (PyObject_SetAttr(self, d_key, d_value) < 0)
 195                 return NULL;
 196         }
 197     }
 198     Py_RETURN_NONE;
 199 }
 200
 201
 202 static PyMethodDef BaseException_methods[] = {
 203    {"__reduce__", (PyCFunction)BaseException_reduce, METH_NOARGS },
 204    {"__setstate__", (PyCFunction)BaseException_setstate, METH_O },
 205 #ifdef Py_USING_UNICODE
 206    {"__unicode__", (PyCFunction)BaseException_unicode, METH_NOARGS },
 207 #endif
 208    {NULL, NULL, 0, NULL},
 209 };
 210
 211
 212
 213 static PyObject *
 214 BaseException_getitem(PyBaseExceptionObject *self, Py_ssize_t index)
 215 {
 216     if (PyErr_WarnPy3k("__getitem__ not supported for exception "
 217                        "classes in 3.x; use args attribute", 1) < 0)
 218         return NULL;
 219     return PySequence_GetItem(self->args, index);
 220 }
 221
 222 static PyObject *
 223 BaseException_getslice(PyBaseExceptionObject *self,
 224                         Py_ssize_t start, Py_ssize_t stop)
 225 {
 226     if (PyErr_WarnPy3k("__getslice__ not supported for exception "
 227                        "classes in 3.x; use args attribute", 1) < 0)
 228         return NULL;
 229     return PySequence_GetSlice(self->args, start, stop);
 230 }
 231
 232 static PySequenceMethods BaseException_as_sequence = {
 233     0,                      /* sq_length; */
 234     0,                      /* sq_concat; */
 235     0,                      /* sq_repeat; */
 236     (ssizeargfunc)BaseException_getitem,  /* sq_item; */
 237     (ssizessizeargfunc)BaseException_getslice,  /* sq_slice; */
 238     0,                      /* sq_ass_item; */
 239     0,                      /* sq_ass_slice; */
 240     0,                      /* sq_contains; */
 241     0,                      /* sq_inplace_concat; */
 242     0                       /* sq_inplace_repeat; */
 243 };
 244
 245 static PyObject *
 246 BaseException_get_dict(PyBaseExceptionObject *self)
 247 {
 248     if (self->dict == NULL) {
 249         self->dict = PyDict_New();
 250         if (!self->dict)
 251             return NULL;
 252     }
 253     Py_INCREF(self->dict);
 254     return self->dict;
 255 }
 256
 257 static int
 258 BaseException_set_dict(PyBaseExceptionObject *self, PyObject *val)
 259 {
 260     if (val == NULL) {
 261         PyErr_SetString(PyExc_TypeError, "__dict__ may not be deleted");
 262         return -1;
 263     }
 264     if (!PyDict_Check(val)) {
 265         PyErr_SetString(PyExc_TypeError, "__dict__ must be a dictionary");
 266         return -1;
 267     }
 268     Py_CLEAR(self->dict);
 269     Py_INCREF(val);
 270     self->dict = val;
 271     return 0;
 272 }
 273
 274 static PyObject *
 275 BaseException_get_args(PyBaseExceptionObject *self)
 276 {
 277     if (self->args == NULL) {
 278         Py_INCREF(Py_None);
 279         return Py_None;
 280     }
 281     Py_INCREF(self->args);
 282     return self->args;
 283 }
 284
 285 static int
 286 BaseException_set_args(PyBaseExceptionObject *self, PyObject *val)
 287 {
 288     PyObject *seq;
 289     if (val == NULL) {
 290         PyErr_SetString(PyExc_TypeError, "args may not be deleted");
 291         return -1;
 292     }
 293     seq = PySequence_Tuple(val);
 294     if (!seq) return -1;
 295     Py_CLEAR(self->args);
 296     self->args = seq;
 297     return 0;
 298 }
 299
 300 static PyObject *
 301 BaseException_get_message(PyBaseExceptionObject *self)
 302 {
 303         int ret;
 304         ret = PyErr_WarnEx(PyExc_DeprecationWarning,
 305                                 "BaseException.message has been deprecated as "
 306                                 "of Python 2.6", 1);
 307         if (ret < 0)
 308                 return NULL;
 309
 310         Py_INCREF(self->message);
 311         return self->message;
 312 }
 313
 314 static int
 315 BaseException_set_message(PyBaseExceptionObject *self, PyObject *val)
 316 {
 317         int ret;
 318         ret = PyErr_WarnEx(PyExc_DeprecationWarning,
 319                                 "BaseException.message has been deprecated as "
 320                                 "of Python 2.6", 1);
 321         if (ret < 0)
 322                 return -1;
 323         Py_INCREF(val);
 324         Py_DECREF(self->message);
 325         self->message = val;
 326         return 0;
 327 }
 328
 329 static PyGetSetDef BaseException_getset[] = {
 330     {"__dict__", (getter)BaseException_get_dict, (setter)BaseException_set_dict},
 331     {"args", (getter)BaseException_get_args, (setter)BaseException_set_args},
 332     {"message", (getter)BaseException_get_message,
 333             (setter)BaseException_set_message},
 334     {NULL},
 335 };
 336
 337
 338 static PyTypeObject _PyExc_BaseException = {
 339     PyObject_HEAD_INIT(NULL)
 340     0,                          /*ob_size*/
 341     EXC_MODULE_NAME "BaseException", /*tp_name*/
 342     sizeof(PyBaseExceptionObject), /*tp_basicsize*/
 343     0,                          /*tp_itemsize*/
 344     (destructor)BaseException_dealloc, /*tp_dealloc*/
 345     0,                          /*tp_print*/
 346     0,                          /*tp_getattr*/
 347     0,                          /*tp_setattr*/
 348     0,                          /* tp_compare; */
 349     (reprfunc)BaseException_repr, /*tp_repr*/
 350     0,                          /*tp_as_number*/
 351     &BaseException_as_sequence, /*tp_as_sequence*/
 352     0,                          /*tp_as_mapping*/
 353     0,                          /*tp_hash */
 354     0,                          /*tp_call*/
 355     (reprfunc)BaseException_str,  /*tp_str*/
 356     PyObject_GenericGetAttr,    /*tp_getattro*/
 357     PyObject_GenericSetAttr,    /*tp_setattro*/
 358     0,                          /*tp_as_buffer*/
 359     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC |
 360         Py_TPFLAGS_BASE_EXC_SUBCLASS,  /*tp_flags*/
 361     PyDoc_STR("Common base class for all exceptions"), /* tp_doc */
 362     (traverseproc)BaseException_traverse, /* tp_traverse */
 363     (inquiry)BaseException_clear, /* tp_clear */
 364     0,                          /* tp_richcompare */
 365     0,                          /* tp_weaklistoffset */
 366     0,                          /* tp_iter */
 367     0,                          /* tp_iternext */
 368     BaseException_methods,      /* tp_methods */
 369     0,                          /* tp_members */
 370     BaseException_getset,       /* tp_getset */
 371     0,                          /* tp_base */
 372     0,                          /* tp_dict */
 373     0,                          /* tp_descr_get */
 374     0,                          /* tp_descr_set */
 375     offsetof(PyBaseExceptionObject, dict), /* tp_dictoffset */
 376     (initproc)BaseException_init, /* tp_init */
 377     0,                          /* tp_alloc */
 378     BaseException_new,          /* tp_new */
 379 };
 380 /* the CPython API expects exceptions to be (PyObject *) - both a hold-over
 381 from the previous implmentation and also allowing Python objects to be used
 382 in the API */
 383 PyObject *PyExc_BaseException = (PyObject *)&_PyExc_BaseException;
 384
 385 /* note these macros omit the last semicolon so the macro invocation may
 386  * include it and not look strange.
 387  */
 388 #define SimpleExtendsException(EXCBASE, EXCNAME, EXCDOC) \
 389 static PyTypeObject _PyExc_ ## EXCNAME = { \
 390     PyObject_HEAD_INIT(NULL) \
 391     0, \
 392     EXC_MODULE_NAME # EXCNAME, \
 393     sizeof(PyBaseExceptionObject), \
 394     0, (destructor)BaseException_dealloc, 0, 0, 0, 0, 0, 0, 0, \
 395     0, 0, 0, 0, 0, 0, 0, \
 396     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \
 397     PyDoc_STR(EXCDOC), (traverseproc)BaseException_traverse, \
 398     (inquiry)BaseException_clear, 0, 0, 0, 0, 0, 0, 0, &_ ## EXCBASE, \
 399     0, 0, 0, offsetof(PyBaseExceptionObject, dict), \
 400     (initproc)BaseException_init, 0, BaseException_new,\
 401 }; \
 402 PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME
 403
 404 #define MiddlingExtendsException(EXCBASE, EXCNAME, EXCSTORE, EXCDOC) \
 405 static PyTypeObject _PyExc_ ## EXCNAME = { \
 406     PyObject_HEAD_INIT(NULL) \
 407     0, \
 408     EXC_MODULE_NAME # EXCNAME, \
 409     sizeof(Py ## EXCSTORE ## Object), \
 410     0, (destructor)EXCSTORE ## _dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
 411     0, 0, 0, 0, 0, \
 412     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \
 413     PyDoc_STR(EXCDOC), (traverseproc)EXCSTORE ## _traverse, \
 414     (inquiry)EXCSTORE ## _clear, 0, 0, 0, 0, 0, 0, 0, &_ ## EXCBASE, \
 415     0, 0, 0, offsetof(Py ## EXCSTORE ## Object, dict), \
 416     (initproc)EXCSTORE ## _init, 0, BaseException_new,\
 417 }; \
 418 PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME
 419
 420 #define ComplexExtendsException(EXCBASE, EXCNAME, EXCSTORE, EXCDEALLOC, EXCMETHODS, EXCMEMBERS, EXCSTR, EXCDOC) \
 421 static PyTypeObject _PyExc_ ## EXCNAME = { \
 422     PyObject_HEAD_INIT(NULL) \
 423     0, \
 424     EXC_MODULE_NAME # EXCNAME, \
 425     sizeof(Py ## EXCSTORE ## Object), 0, \
 426     (destructor)EXCSTORE ## _dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
 427     (reprfunc)EXCSTR, 0, 0, 0, \
 428     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \
 429     PyDoc_STR(EXCDOC), (traverseproc)EXCSTORE ## _traverse, \
 430     (inquiry)EXCSTORE ## _clear, 0, 0, 0, 0, EXCMETHODS, \
 431     EXCMEMBERS, 0, &_ ## EXCBASE, \
 432     0, 0, 0, offsetof(Py ## EXCSTORE ## Object, dict), \
 433     (initproc)EXCSTORE ## _init, 0, BaseException_new,\
 434 }; \
 435 PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME
 436
 437
 438 /*
 439  *    Exception extends BaseException
 440  */
 441 SimpleExtendsException(PyExc_BaseException, Exception,
 442                        "Common base class for all non-exit exceptions.");
 443
 444
 445 /*
 446  *    StandardError extends Exception
 447  */
 448 SimpleExtendsException(PyExc_Exception, StandardError,
 449     "Base class for all standard Python exceptions that do not represent\n"
 450     "interpreter exiting.");
 451
 452
 453 /*
 454  *    TypeError extends StandardError
 455  */
 456 SimpleExtendsException(PyExc_StandardError, TypeError,
 457                        "Inappropriate argument type.");
 458
 459
 460 /*
 461  *    StopIteration extends Exception
 462  */
 463 SimpleExtendsException(PyExc_Exception, StopIteration,
 464                        "Signal the end from iterator.next().");
 465
 466
 467 /*
 468  *    GeneratorExit extends BaseException
 469  */
 470 SimpleExtendsException(PyExc_BaseException, GeneratorExit,
 471                        "Request that a generator exit.");
 472
 473
 474 /*
 475  *    SystemExit extends BaseException
 476  */
 477
 478 static int
 479 SystemExit_init(PySystemExitObject *self, PyObject *args, PyObject *kwds)
 480 {
 481     Py_ssize_t size = PyTuple_GET_SIZE(args);
 482
 483     if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
 484         return -1;
 485
 486     if (size == 0)
 487         return 0;
 488     Py_CLEAR(self->code);
 489     if (size == 1)
 490         self->code = PyTuple_GET_ITEM(args, 0);
 491     else if (size > 1)
 492         self->code = args;
 493     Py_INCREF(self->code);
 494     return 0;
 495 }
 496
 497 static int
 498 SystemExit_clear(PySystemExitObject *self)
 499 {
 500     Py_CLEAR(self->code);
 501     return BaseException_clear((PyBaseExceptionObject *)self);
 502 }
 503
 504 static void
 505 SystemExit_dealloc(PySystemExitObject *self)
 506 {
 507     _PyObject_GC_UNTRACK(self);
 508     SystemExit_clear(self);
 509     Py_TYPE(self)->tp_free((PyObject *)self);
 510 }
 511
 512 static int
 513 SystemExit_traverse(PySystemExitObject *self, visitproc visit, void *arg)
 514 {
 515     Py_VISIT(self->code);
 516     return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
 517 }
 518
 519 static PyMemberDef SystemExit_members[] = {
 520     {"code", T_OBJECT, offsetof(PySystemExitObject, code), 0,
 521         PyDoc_STR("exception code")},
 522     {NULL}  /* Sentinel */
 523 };
 524
 525 ComplexExtendsException(PyExc_BaseException, SystemExit, SystemExit,
 526                         SystemExit_dealloc, 0, SystemExit_members, 0,
 527                         "Request to exit from the interpreter.");
 528
 529 /*
 530  *    KeyboardInterrupt extends BaseException
 531  */
 532 SimpleExtendsException(PyExc_BaseException, KeyboardInterrupt,
 533                        "Program interrupted by user.");
 534
 535
 536 /*
 537  *    ImportError extends StandardError
 538  */
 539 SimpleExtendsException(PyExc_StandardError, ImportError,
 540           "Import can't find module, or can't find name in module.");
 541
 542
 543 /*
 544  *    EnvironmentError extends StandardError
 545  */
 546
 547 /* Where a function has a single filename, such as open() or some
 548  * of the os module functions, PyErr_SetFromErrnoWithFilename() is
 549  * called, giving a third argument which is the filename.  But, so
 550  * that old code using in-place unpacking doesn't break, e.g.:
 551  *
 552  * except IOError, (errno, strerror):
 553  *
 554  * we hack args so that it only contains two items.  This also
 555  * means we need our own __str__() which prints out the filename
 556  * when it was supplied.
 557  */
 558 static int
 559 EnvironmentError_init(PyEnvironmentErrorObject *self, PyObject *args,
 560     PyObject *kwds)
 561 {
 562     PyObject *myerrno = NULL, *strerror = NULL, *filename = NULL;
 563     PyObject *subslice = NULL;
 564
 565     if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
 566         return -1;
 567
 568     if (PyTuple_GET_SIZE(args) <= 1 || PyTuple_GET_SIZE(args) > 3) {
 569         return 0;
 570     }
 571
 572     if (!PyArg_UnpackTuple(args, "EnvironmentError", 2, 3,
 573                            &myerrno, &strerror, &filename)) {
 574         return -1;
 575     }
 576     Py_CLEAR(self->myerrno);       /* replacing */
 577     self->myerrno = myerrno;
 578     Py_INCREF(self->myerrno);
 579
 580     Py_CLEAR(self->strerror);      /* replacing */
 581     self->strerror = strerror;
 582     Py_INCREF(self->strerror);
 583
 584     /* self->filename will remain Py_None otherwise */
 585     if (filename != NULL) {
 586         Py_CLEAR(self->filename);      /* replacing */
 587         self->filename = filename;
 588         Py_INCREF(self->filename);
 589
 590         subslice = PyTuple_GetSlice(args, 0, 2);
 591         if (!subslice)
 592             return -1;
 593
 594         Py_DECREF(self->args);  /* replacing args */
 595         self->args = subslice;
 596     }
 597     return 0;
 598 }
 599
 600 static int
 601 EnvironmentError_clear(PyEnvironmentErrorObject *self)
 602 {
 603     Py_CLEAR(self->myerrno);
 604     Py_CLEAR(self->strerror);
 605     Py_CLEAR(self->filename);
 606     return BaseException_clear((PyBaseExceptionObject *)self);
 607 }
 608
 609 static void
 610 EnvironmentError_dealloc(PyEnvironmentErrorObject *self)
 611 {
 612     _PyObject_GC_UNTRACK(self);
 613     EnvironmentError_clear(self);
 614     Py_TYPE(self)->tp_free((PyObject *)self);
 615 }
 616
 617 static int
 618 EnvironmentError_traverse(PyEnvironmentErrorObject *self, visitproc visit,
 619         void *arg)
 620 {
 621     Py_VISIT(self->myerrno);
 622     Py_VISIT(self->strerror);
 623     Py_VISIT(self->filename);
 624     return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
 625 }
 626
 627 static PyObject *
 628 EnvironmentError_str(PyEnvironmentErrorObject *self)
 629 {
 630     PyObject *rtnval = NULL;
 631
 632     if (self->filename) {
 633         PyObject *fmt;
 634         PyObject *repr;
 635         PyObject *tuple;
 636
 637         fmt = PyString_FromString("[Errno %s] %s: %s");
 638         if (!fmt)
 639             return NULL;
 640
 641         repr = PyObject_Repr(self->filename);
 642         if (!repr) {
 643             Py_DECREF(fmt);
 644             return NULL;
 645         }
 646         tuple = PyTuple_New(3);
 647         if (!tuple) {
 648             Py_DECREF(repr);
 649             Py_DECREF(fmt);
 650             return NULL;
 651         }
 652
 653         if (self->myerrno) {
 654             Py_INCREF(self->myerrno);
 655             PyTuple_SET_ITEM(tuple, 0, self->myerrno);
 656         }
 657         else {
 658             Py_INCREF(Py_None);
 659             PyTuple_SET_ITEM(tuple, 0, Py_None);
 660         }
 661         if (self->strerror) {
 662             Py_INCREF(self->strerror);
 663             PyTuple_SET_ITEM(tuple, 1, self->strerror);
 664         }
 665         else {
 666             Py_INCREF(Py_None);
 667             PyTuple_SET_ITEM(tuple, 1, Py_None);
 668         }
 669
 670         PyTuple_SET_ITEM(tuple, 2, repr);
 671
 672         rtnval = PyString_Format(fmt, tuple);
 673
 674         Py_DECREF(fmt);
 675         Py_DECREF(tuple);
 676     }
 677     else if (self->myerrno && self->strerror) {
 678         PyObject *fmt;
 679         PyObject *tuple;
 680
 681         fmt = PyString_FromString("[Errno %s] %s");
 682         if (!fmt)
 683             return NULL;
 684
 685         tuple = PyTuple_New(2);
 686         if (!tuple) {
 687             Py_DECREF(fmt);
 688             return NULL;
 689         }
 690
 691         if (self->myerrno) {
 692             Py_INCREF(self->myerrno);
 693             PyTuple_SET_ITEM(tuple, 0, self->myerrno);
 694         }
 695         else {
 696             Py_INCREF(Py_None);
 697             PyTuple_SET_ITEM(tuple, 0, Py_None);
 698         }
 699         if (self->strerror) {
 700             Py_INCREF(self->strerror);
 701             PyTuple_SET_ITEM(tuple, 1, self->strerror);
 702         }
 703         else {
 704             Py_INCREF(Py_None);
 705             PyTuple_SET_ITEM(tuple, 1, Py_None);
 706         }
 707
 708         rtnval = PyString_Format(fmt, tuple);
 709
 710         Py_DECREF(fmt);
 711         Py_DECREF(tuple);
 712     }
 713     else
 714         rtnval = BaseException_str((PyBaseExceptionObject *)self);
 715
 716     return rtnval;
 717 }
 718
 719 static PyMemberDef EnvironmentError_members[] = {
 720     {"errno", T_OBJECT, offsetof(PyEnvironmentErrorObject, myerrno), 0,
 721         PyDoc_STR("exception errno")},
 722     {"strerror", T_OBJECT, offsetof(PyEnvironmentErrorObject, strerror), 0,
 723         PyDoc_STR("exception strerror")},
 724     {"filename", T_OBJECT, offsetof(PyEnvironmentErrorObject, filename), 0,
 725         PyDoc_STR("exception filename")},
 726     {NULL}  /* Sentinel */
 727 };
 728
 729
 730 static PyObject *
 731 EnvironmentError_reduce(PyEnvironmentErrorObject *self)
 732 {
 733     PyObject *args = self->args;
 734     PyObject *res = NULL, *tmp;
 735
 736     /* self->args is only the first two real arguments if there was a
 737      * file name given to EnvironmentError. */
 738     if (PyTuple_GET_SIZE(args) == 2 && self->filename) {
 739         args = PyTuple_New(3);
 740         if (!args) return NULL;
 741
 742         tmp = PyTuple_GET_ITEM(self->args, 0);
 743         Py_INCREF(tmp);
 744         PyTuple_SET_ITEM(args, 0, tmp);
 745
 746         tmp = PyTuple_GET_ITEM(self->args, 1);
 747         Py_INCREF(tmp);
 748         PyTuple_SET_ITEM(args, 1, tmp);
 749
 750         Py_INCREF(self->filename);
 751         PyTuple_SET_ITEM(args, 2, self->filename);
 752     } else
 753         Py_INCREF(args);
 754
 755     if (self->dict)
 756         res = PyTuple_Pack(3, Py_TYPE(self), args, self->dict);
 757     else
 758         res = PyTuple_Pack(2, Py_TYPE(self), args);
 759     Py_DECREF(args);
 760     return res;
 761 }
 762
 763
 764 static PyMethodDef EnvironmentError_methods[] = {
 765     {"__reduce__", (PyCFunction)EnvironmentError_reduce, METH_NOARGS},
 766     {NULL}
 767 };
 768
 769 ComplexExtendsException(PyExc_StandardError, EnvironmentError,
 770                         EnvironmentError, EnvironmentError_dealloc,
 771                         EnvironmentError_methods, EnvironmentError_members,
 772                         EnvironmentError_str,
 773                         "Base class for I/O related errors.");
 774
 775
 776 /*
 777  *    IOError extends EnvironmentError
 778  */
 779 MiddlingExtendsException(PyExc_EnvironmentError, IOError,
 780                          EnvironmentError, "I/O operation failed.");
 781
 782
 783 /*
 784  *    OSError extends EnvironmentError
 785  */
 786 MiddlingExtendsException(PyExc_EnvironmentError, OSError,
 787                          EnvironmentError, "OS system call failed.");
 788
 789
 790 /*
 791  *    WindowsError extends OSError
 792  */
 793 #ifdef MS_WINDOWS
 794 #include "errmap.h"
 795
 796 static int
 797 WindowsError_clear(PyWindowsErrorObject *self)
 798 {
 799     Py_CLEAR(self->myerrno);
 800     Py_CLEAR(self->strerror);
 801     Py_CLEAR(self->filename);
 802     Py_CLEAR(self->winerror);
 803     return BaseException_clear((PyBaseExceptionObject *)self);
 804 }
 805
 806 static void
 807 WindowsError_dealloc(PyWindowsErrorObject *self)
 808 {
 809     _PyObject_GC_UNTRACK(self);
 810     WindowsError_clear(self);
 811     Py_TYPE(self)->tp_free((PyObject *)self);
 812 }
 813
 814 static int
 815 WindowsError_traverse(PyWindowsErrorObject *self, visitproc visit, void *arg)
 816 {
 817     Py_VISIT(self->myerrno);
 818     Py_VISIT(self->strerror);
 819     Py_VISIT(self->filename);
 820     Py_VISIT(self->winerror);
 821     return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
 822 }
 823
 824 static int
 825 WindowsError_init(PyWindowsErrorObject *self, PyObject *args, PyObject *kwds)
 826 {
 827     PyObject *o_errcode = NULL;
 828     long errcode;
 829     long posix_errno;
 830
 831     if (EnvironmentError_init((PyEnvironmentErrorObject *)self, args, kwds)
 832             == -1)
 833         return -1;
 834
 835     if (self->myerrno == NULL)
 836         return 0;
 837
 838     /* Set errno to the POSIX errno, and winerror to the Win32
 839        error code. */
 840     errcode = PyInt_AsLong(self->myerrno);
 841     if (errcode == -1 && PyErr_Occurred())
 842         return -1;
 843     posix_errno = winerror_to_errno(errcode);
 844
 845     Py_CLEAR(self->winerror);
 846     self->winerror = self->myerrno;
 847
 848     o_errcode = PyInt_FromLong(posix_errno);
 849     if (!o_errcode)
 850         return -1;
 851
 852     self->myerrno = o_errcode;
 853
 854     return 0;
 855 }
 856
 857
 858 static PyObject *
 859 WindowsError_str(PyWindowsErrorObject *self)
 860 {
 861     PyObject *rtnval = NULL;
 862
 863     if (self->filename) {
 864         PyObject *fmt;
 865         PyObject *repr;
 866         PyObject *tuple;
 867
 868         fmt = PyString_FromString("[Error %s] %s: %s");
 869         if (!fmt)
 870             return NULL;
 871
 872         repr = PyObject_Repr(self->filename);
 873         if (!repr) {
 874             Py_DECREF(fmt);
 875             return NULL;
 876         }
 877         tuple = PyTuple_New(3);
 878         if (!tuple) {
 879             Py_DECREF(repr);
 880             Py_DECREF(fmt);
 881             return NULL;
 882         }
 883
 884         if (self->winerror) {
 885             Py_INCREF(self->winerror);
 886             PyTuple_SET_ITEM(tuple, 0, self->winerror);
 887         }
 888         else {
 889             Py_INCREF(Py_None);
 890             PyTuple_SET_ITEM(tuple, 0, Py_None);
 891         }
 892         if (self->strerror) {
 893             Py_INCREF(self->strerror);
 894             PyTuple_SET_ITEM(tuple, 1, self->strerror);
 895         }
 896         else {
 897             Py_INCREF(Py_None);
 898             PyTuple_SET_ITEM(tuple, 1, Py_None);
 899         }
 900
 901         PyTuple_SET_ITEM(tuple, 2, repr);
 902
 903         rtnval = PyString_Format(fmt, tuple);
 904
 905         Py_DECREF(fmt);
 906         Py_DECREF(tuple);
 907     }
 908     else if (self->winerror && self->strerror) {
 909         PyObject *fmt;
 910         PyObject *tuple;
 911
 912         fmt = PyString_FromString("[Error %s] %s");
 913         if (!fmt)
 914             return NULL;
 915
 916         tuple = PyTuple_New(2);
 917         if (!tuple) {
 918             Py_DECREF(fmt);
 919             return NULL;
 920         }
 921
 922         if (self->winerror) {
 923             Py_INCREF(self->winerror);
 924             PyTuple_SET_ITEM(tuple, 0, self->winerror);
 925         }
 926         else {
 927             Py_INCREF(Py_None);
 928             PyTuple_SET_ITEM(tuple, 0, Py_None);
 929         }
 930         if (self->strerror) {
 931             Py_INCREF(self->strerror);
 932             PyTuple_SET_ITEM(tuple, 1, self->strerror);
 933         }
 934         else {
 935             Py_INCREF(Py_None);
 936             PyTuple_SET_ITEM(tuple, 1, Py_None);
 937         }
 938
 939         rtnval = PyString_Format(fmt, tuple);
 940
 941         Py_DECREF(fmt);
 942         Py_DECREF(tuple);
 943     }
 944     else
 945         rtnval = EnvironmentError_str((PyEnvironmentErrorObject *)self);
 946
 947     return rtnval;
 948 }
 949
 950 static PyMemberDef WindowsError_members[] = {
 951     {"errno", T_OBJECT, offsetof(PyWindowsErrorObject, myerrno), 0,
 952         PyDoc_STR("POSIX exception code")},
 953     {"strerror", T_OBJECT, offsetof(PyWindowsErrorObject, strerror), 0,
 954         PyDoc_STR("exception strerror")},
 955     {"filename", T_OBJECT, offsetof(PyWindowsErrorObject, filename), 0,
 956         PyDoc_STR("exception filename")},
 957     {"winerror", T_OBJECT, offsetof(PyWindowsErrorObject, winerror), 0,
 958         PyDoc_STR("Win32 exception code")},
 959     {NULL}  /* Sentinel */
 960 };
 961
 962 ComplexExtendsException(PyExc_OSError, WindowsError, WindowsError,
 963                         WindowsError_dealloc, 0, WindowsError_members,
 964                         WindowsError_str, "MS-Windows OS system call failed.");
 965
 966 #endif /* MS_WINDOWS */
 967
 968
 969 /*
 970  *    VMSError extends OSError (I think)
 971  */
 972 #ifdef __VMS
 973 MiddlingExtendsException(PyExc_OSError, VMSError, EnvironmentError,
 974                          "OpenVMS OS system call failed.");
 975 #endif
 976
 977
 978 /*
 979  *    EOFError extends StandardError
 980  */
 981 SimpleExtendsException(PyExc_StandardError, EOFError,
 982                        "Read beyond end of file.");
 983
 984
 985 /*
 986  *    RuntimeError extends StandardError
 987  */
 988 SimpleExtendsException(PyExc_StandardError, RuntimeError,
 989                        "Unspecified run-time error.");
 990
 991
 992 /*
 993  *    NotImplementedError extends RuntimeError
 994  */
 995 SimpleExtendsException(PyExc_RuntimeError, NotImplementedError,
 996                        "Method or function hasn't been implemented yet.");
 997
 998 /*
 999  *    NameError extends StandardError
1000  */
1001 SimpleExtendsException(PyExc_StandardError, NameError,
1002                        "Name not found globally.");
1003
1004 /*
1005  *    UnboundLocalError extends NameError
1006  */
1007 SimpleExtendsException(PyExc_NameError, UnboundLocalError,
1008                        "Local name referenced but not bound to a value.");
1009
1010 /*
1011  *    AttributeError extends StandardError
1012  */
1013 SimpleExtendsException(PyExc_StandardError, AttributeError,
1014                        "Attribute not found.");
1015
1016
1017 /*
1018  *    SyntaxError extends StandardError
1019  */
1020
1021 static int
1022 SyntaxError_init(PySyntaxErrorObject *self, PyObject *args, PyObject *kwds)
1023 {
1024     PyObject *info = NULL;
1025     Py_ssize_t lenargs = PyTuple_GET_SIZE(args);
1026
1027     if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
1028         return -1;
1029
1030     if (lenargs >= 1) {
1031         Py_CLEAR(self->msg);
1032         self->msg = PyTuple_GET_ITEM(args, 0);
1033         Py_INCREF(self->msg);
1034     }
1035     if (lenargs == 2) {
1036         info = PyTuple_GET_ITEM(args, 1);
1037         info = PySequence_Tuple(info);
1038         if (!info) return -1;
1039
1040         if (PyTuple_GET_SIZE(info) != 4) {
1041             /* not a very good error message, but it's what Python 2.4 gives */
1042             PyErr_SetString(PyExc_IndexError, "tuple index out of range");
1043             Py_DECREF(info);
1044             return -1;
1045         }
1046
1047         Py_CLEAR(self->filename);
1048         self->filename = PyTuple_GET_ITEM(info, 0);
1049         Py_INCREF(self->filename);
1050
1051         Py_CLEAR(self->lineno);
1052         self->lineno = PyTuple_GET_ITEM(info, 1);
1053         Py_INCREF(self->lineno);
1054
1055         Py_CLEAR(self->offset);
1056         self->offset = PyTuple_GET_ITEM(info, 2);
1057         Py_INCREF(self->offset);
1058
1059         Py_CLEAR(self->text);
1060         self->text = PyTuple_GET_ITEM(info, 3);
1061         Py_INCREF(self->text);
1062
1063         Py_DECREF(info);
1064     }
1065     return 0;
1066 }
1067
1068 static int
1069 SyntaxError_clear(PySyntaxErrorObject *self)
1070 {
1071     Py_CLEAR(self->msg);
1072     Py_CLEAR(self->filename);
1073     Py_CLEAR(self->lineno);
1074     Py_CLEAR(self->offset);
1075     Py_CLEAR(self->text);
1076     Py_CLEAR(self->print_file_and_line);
1077     return BaseException_clear((PyBaseExceptionObject *)self);
1078 }
1079
1080 static void
1081 SyntaxError_dealloc(PySyntaxErrorObject *self)
1082 {
1083     _PyObject_GC_UNTRACK(self);
1084     SyntaxError_clear(self);
1085     Py_TYPE(self)->tp_free((PyObject *)self);
1086 }
1087
1088 static int
1089 SyntaxError_traverse(PySyntaxErrorObject *self, visitproc visit, void *arg)
1090 {
1091     Py_VISIT(self->msg);
1092     Py_VISIT(self->filename);
1093     Py_VISIT(self->lineno);
1094     Py_VISIT(self->offset);
1095     Py_VISIT(self->text);
1096     Py_VISIT(self->print_file_and_line);
1097     return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
1098 }
1099
1100 /* This is called "my_basename" instead of just "basename" to avoid name
1101    conflicts with glibc; basename is already prototyped if _GNU_SOURCE is
1102    defined, and Python does define that. */
1103 static char *
1104 my_basename(char *name)
1105 {
1106     char *cp = name;
1107     char *result = name;
1108
1109     if (name == NULL)
1110         return "???";
1111     while (*cp != '\0') {
1112         if (*cp == SEP)
1113             result = cp + 1;
1114         ++cp;
1115     }
1116     return result;
1117 }
1118
1119
1120 static PyObject *
1121 SyntaxError_str(PySyntaxErrorObject *self)
1122 {
1123     PyObject *str;
1124     PyObject *result;
1125     int have_filename = 0;
1126     int have_lineno = 0;
1127     char *buffer = NULL;
1128     Py_ssize_t bufsize;
1129
1130     if (self->msg)
1131         str = PyObject_Str(self->msg);
1132     else
1133         str = PyObject_Str(Py_None);
1134     if (!str) return NULL;
1135     /* Don't fiddle with non-string return (shouldn't happen anyway) */
1136     if (!PyString_Check(str)) return str;
1137
1138     /* XXX -- do all the additional formatting with filename and
1139        lineno here */
1140
1141     have_filename = (self->filename != NULL) &&
1142         PyString_Check(self->filename);
1143     have_lineno = (self->lineno != NULL) && PyInt_Check(self->lineno);
1144
1145     if (!have_filename && !have_lineno)
1146         return str;
1147
1148     bufsize = PyString_GET_SIZE(str) + 64;
1149     if (have_filename)
1150         bufsize += PyString_GET_SIZE(self->filename);
1151
1152     buffer = PyMem_MALLOC(bufsize);
1153     if (buffer == NULL)
1154         return str;
1155
1156     if (have_filename && have_lineno)
1157         PyOS_snprintf(buffer, bufsize, "%s (%s, line %ld)",
1158             PyString_AS_STRING(str),
1159             my_basename(PyString_AS_STRING(self->filename)),
1160             PyInt_AsLong(self->lineno));
1161     else if (have_filename)
1162         PyOS_snprintf(buffer, bufsize, "%s (%s)",
1163             PyString_AS_STRING(str),
1164             my_basename(PyString_AS_STRING(self->filename)));
1165     else /* only have_lineno */
1166         PyOS_snprintf(buffer, bufsize, "%s (line %ld)",
1167             PyString_AS_STRING(str),
1168             PyInt_AsLong(self->lineno));
1169
1170     result = PyString_FromString(buffer);
1171     PyMem_FREE(buffer);
1172
1173     if (result == NULL)
1174         result = str;
1175     else
1176         Py_DECREF(str);
1177     return result;
1178 }
1179
1180 static PyMemberDef SyntaxError_members[] = {
1181     {"msg", T_OBJECT, offsetof(PySyntaxErrorObject, msg), 0,
1182         PyDoc_STR("exception msg")},
1183     {"filename", T_OBJECT, offsetof(PySyntaxErrorObject, filename), 0,
1184         PyDoc_STR("exception filename")},
1185     {"lineno", T_OBJECT, offsetof(PySyntaxErrorObject, lineno), 0,
1186         PyDoc_STR("exception lineno")},
1187     {"offset", T_OBJECT, offsetof(PySyntaxErrorObject, offset), 0,
1188         PyDoc_STR("exception offset")},
1189     {"text", T_OBJECT, offsetof(PySyntaxErrorObject, text), 0,
1190         PyDoc_STR("exception text")},
1191     {"print_file_and_line", T_OBJECT,
1192         offsetof(PySyntaxErrorObject, print_file_and_line), 0,
1193         PyDoc_STR("exception print_file_and_line")},
1194     {NULL}  /* Sentinel */
1195 };
1196
1197 ComplexExtendsException(PyExc_StandardError, SyntaxError, SyntaxError,
1198                         SyntaxError_dealloc, 0, SyntaxError_members,
1199                         SyntaxError_str, "Invalid syntax.");
1200
1201
1202 /*
1203  *    IndentationError extends SyntaxError
1204  */
1205 MiddlingExtendsException(PyExc_SyntaxError, IndentationError, SyntaxError,
1206                          "Improper indentation.");
1207
1208
1209 /*
1210  *    TabError extends IndentationError
1211  */
1212 MiddlingExtendsException(PyExc_IndentationError, TabError, SyntaxError,
1213                          "Improper mixture of spaces and tabs.");
1214
1215
1216 /*
1217  *    LookupError extends StandardError
1218  */
1219 SimpleExtendsException(PyExc_StandardError, LookupError,
1220                        "Base class for lookup errors.");
1221
1222
1223 /*
1224  *    IndexError extends LookupError
1225  */
1226 SimpleExtendsException(PyExc_LookupError, IndexError,
1227                        "Sequence index out of range.");
1228
1229
1230 /*
1231  *    KeyError extends LookupError
1232  */
1233 static PyObject *
1234 KeyError_str(PyBaseExceptionObject *self)
1235 {
1236     /* If args is a tuple of exactly one item, apply repr to args[0].
1237        This is done so that e.g. the exception raised by {}[''] prints
1238          KeyError: ''
1239        rather than the confusing
1240          KeyError
1241        alone.  The downside is that if KeyError is raised with an explanatory
1242        string, that string will be displayed in quotes.  Too bad.
1243        If args is anything else, use the default BaseException__str__().
1244     */
1245     if (PyTuple_GET_SIZE(self->args) == 1) {
1246         return PyObject_Repr(PyTuple_GET_ITEM(self->args, 0));
1247     }
1248     return BaseException_str(self);
1249 }
1250
1251 ComplexExtendsException(PyExc_LookupError, KeyError, BaseException,
1252                         0, 0, 0, KeyError_str, "Mapping key not found.");
1253
1254
1255 /*
1256  *    ValueError extends StandardError
1257  */
1258 SimpleExtendsException(PyExc_StandardError, ValueError,
1259                        "Inappropriate argument value (of correct type).");
1260
1261 /*
1262  *    UnicodeError extends ValueError
1263  */
1264
1265 SimpleExtendsException(PyExc_ValueError, UnicodeError,
1266                        "Unicode related error.");
1267
1268 #ifdef Py_USING_UNICODE
1269 static PyObject *
1270 get_string(PyObject *attr, const char *name)
1271 {
1272     if (!attr) {
1273         PyErr_Format(PyExc_TypeError, "%.200s attribute not set", name);
1274         return NULL;
1275     }
1276
1277     if (!PyString_Check(attr)) {
1278         PyErr_Format(PyExc_TypeError, "%.200s attribute must be str", name);
1279         return NULL;
1280     }
1281     Py_INCREF(attr);
1282     return attr;
1283 }
1284
1285
1286 static int
1287 set_string(PyObject **attr, const char *value)
1288 {
1289     PyObject *obj = PyString_FromString(value);
1290     if (!obj)
1291         return -1;
1292     Py_CLEAR(*attr);
1293     *attr = obj;
1294     return 0;
1295 }
1296
1297
1298 static PyObject *
1299 get_unicode(PyObject *attr, const char *name)
1300 {
1301     if (!attr) {
1302         PyErr_Format(PyExc_TypeError, "%.200s attribute not set", name);
1303         return NULL;
1304     }
1305
1306     if (!PyUnicode_Check(attr)) {
1307         PyErr_Format(PyExc_TypeError,
1308                      "%.200s attribute must be unicode", name);
1309         return NULL;
1310     }
1311     Py_INCREF(attr);
1312     return attr;
1313 }
1314
1315 PyObject *
1316 PyUnicodeEncodeError_GetEncoding(PyObject *exc)
1317 {
1318     return get_string(((PyUnicodeErrorObject *)exc)->encoding, "encoding");
1319 }
1320
1321 PyObject *
1322 PyUnicodeDecodeError_GetEncoding(PyObject *exc)
1323 {
1324     return get_string(((PyUnicodeErrorObject *)exc)->encoding, "encoding");
1325 }
1326
1327 PyObject *
1328 PyUnicodeEncodeError_GetObject(PyObject *exc)
1329 {
1330     return get_unicode(((PyUnicodeErrorObject *)exc)->object, "object");
1331 }
1332
1333 PyObject *
1334 PyUnicodeDecodeError_GetObject(PyObject *exc)
1335 {
1336     return get_string(((PyUnicodeErrorObject *)exc)->object, "object");
1337 }
1338
1339 PyObject *
1340 PyUnicodeTranslateError_GetObject(PyObject *exc)
1341 {
1342     return get_unicode(((PyUnicodeErrorObject *)exc)->object, "object");
1343 }
1344
1345 int
1346 PyUnicodeEncodeError_GetStart(PyObject *exc, Py_ssize_t *start)
1347 {
1348     Py_ssize_t size;
1349     PyObject *obj = get_unicode(((PyUnicodeErrorObject *)exc)->object,
1350                                 "object");
1351     if (!obj)
1352         return -1;
1353     *start = ((PyUnicodeErrorObject *)exc)->start;
1354     size = PyUnicode_GET_SIZE(obj);
1355     if (*start<0)
1356         *start = 0; /*XXX check for values <0*/
1357     if (*start>=size)
1358         *start = size-1;
1359     Py_DECREF(obj);
1360     return 0;
1361 }
1362
1363
1364 int
1365 PyUnicodeDecodeError_GetStart(PyObject *exc, Py_ssize_t *start)
1366 {
1367     Py_ssize_t size;
1368     PyObject *obj = get_string(((PyUnicodeErrorObject *)exc)->object,
1369                                "object");
1370     if (!obj)
1371         return -1;
1372     size = PyString_GET_SIZE(obj);
1373     *start = ((PyUnicodeErrorObject *)exc)->start;
1374     if (*start<0)
1375         *start = 0;
1376     if (*start>=size)
1377         *start = size-1;
1378     Py_DECREF(obj);
1379     return 0;
1380 }
1381
1382
1383 int
1384 PyUnicodeTranslateError_GetStart(PyObject *exc, Py_ssize_t *start)
1385 {
1386     return PyUnicodeEncodeError_GetStart(exc, start);
1387 }
1388
1389
1390 int
1391 PyUnicodeEncodeError_SetStart(PyObject *exc, Py_ssize_t start)
1392 {
1393     ((PyUnicodeErrorObject *)exc)->start = start;
1394     return 0;
1395 }
1396
1397
1398 int
1399 PyUnicodeDecodeError_SetStart(PyObject *exc, Py_ssize_t start)
1400 {
1401     ((PyUnicodeErrorObject *)exc)->start = start;
1402     return 0;
1403 }
1404
1405
1406 int
1407 PyUnicodeTranslateError_SetStart(PyObject *exc, Py_ssize_t start)
1408 {
1409     ((PyUnicodeErrorObject *)exc)->start = start;
1410     return 0;
1411 }
1412
1413
1414 int
1415 PyUnicodeEncodeError_GetEnd(PyObject *exc, Py_ssize_t *end)
1416 {
1417     Py_ssize_t size;
1418     PyObject *obj = get_unicode(((PyUnicodeErrorObject *)exc)->object,
1419                                 "object");
1420     if (!obj)
1421         return -1;
1422     *end = ((PyUnicodeErrorObject *)exc)->end;
1423     size = PyUnicode_GET_SIZE(obj);
1424     if (*end<1)
1425         *end = 1;
1426     if (*end>size)
1427         *end = size;
1428     Py_DECREF(obj);
1429     return 0;
1430 }
1431
1432
1433 int
1434 PyUnicodeDecodeError_GetEnd(PyObject *exc, Py_ssize_t *end)
1435 {
1436     Py_ssize_t size;
1437     PyObject *obj = get_string(((PyUnicodeErrorObject *)exc)->object,
1438                                "object");
1439     if (!obj)
1440         return -1;
1441     *end = ((PyUnicodeErrorObject *)exc)->end;
1442     size = PyString_GET_SIZE(obj);
1443     if (*end<1)
1444         *end = 1;
1445     if (*end>size)
1446         *end = size;
1447     Py_DECREF(obj);
1448     return 0;
1449 }
1450
1451
1452 int
1453 PyUnicodeTranslateError_GetEnd(PyObject *exc, Py_ssize_t *start)
1454 {
1455     return PyUnicodeEncodeError_GetEnd(exc, start);
1456 }
1457
1458
1459 int
1460 PyUnicodeEncodeError_SetEnd(PyObject *exc, Py_ssize_t end)
1461 {
1462     ((PyUnicodeErrorObject *)exc)->end = end;
1463     return 0;
1464 }
1465
1466
1467 int
1468 PyUnicodeDecodeError_SetEnd(PyObject *exc, Py_ssize_t end)
1469 {
1470     ((PyUnicodeErrorObject *)exc)->end = end;
1471     return 0;
1472 }
1473
1474
1475 int
1476 PyUnicodeTranslateError_SetEnd(PyObject *exc, Py_ssize_t end)
1477 {
1478     ((PyUnicodeErrorObject *)exc)->end = end;
1479     return 0;
1480 }
1481
1482 PyObject *
1483 PyUnicodeEncodeError_GetReason(PyObject *exc)
1484 {
1485     return get_string(((PyUnicodeErrorObject *)exc)->reason, "reason");
1486 }
1487
1488
1489 PyObject *
1490 PyUnicodeDecodeError_GetReason(PyObject *exc)
1491 {
1492     return get_string(((PyUnicodeErrorObject *)exc)->reason, "reason");
1493 }
1494
1495
1496 PyObject *
1497 PyUnicodeTranslateError_GetReason(PyObject *exc)
1498 {
1499     return get_string(((PyUnicodeErrorObject *)exc)->reason, "reason");
1500 }
1501
1502
1503 int
1504 PyUnicodeEncodeError_SetReason(PyObject *exc, const char *reason)
1505 {
1506     return set_string(&((PyUnicodeErrorObject *)exc)->reason, reason);
1507 }
1508
1509
1510 int
1511 PyUnicodeDecodeError_SetReason(PyObject *exc, const char *reason)
1512 {
1513     return set_string(&((PyUnicodeErrorObject *)exc)->reason, reason);
1514 }
1515
1516
1517 int
1518 PyUnicodeTranslateError_SetReason(PyObject *exc, const char *reason)
1519 {
1520     return set_string(&((PyUnicodeErrorObject *)exc)->reason, reason);
1521 }
1522
1523
1524 static int
1525 UnicodeError_init(PyUnicodeErrorObject *self, PyObject *args, PyObject *kwds,
1526                   PyTypeObject *objecttype)
1527 {
1528     Py_CLEAR(self->encoding);
1529     Py_CLEAR(self->object);
1530     Py_CLEAR(self->reason);
1531
1532     if (!PyArg_ParseTuple(args, "O!O!nnO!",
1533         &PyString_Type, &self->encoding,
1534         objecttype, &self->object,
1535         &self->start,
1536         &self->end,
1537         &PyString_Type, &self->reason)) {
1538         self->encoding = self->object = self->reason = NULL;
1539         return -1;
1540     }
1541
1542     Py_INCREF(self->encoding);
1543     Py_INCREF(self->object);
1544     Py_INCREF(self->reason);
1545
1546     return 0;
1547 }
1548
1549 static int
1550 UnicodeError_clear(PyUnicodeErrorObject *self)
1551 {
1552     Py_CLEAR(self->encoding);
1553     Py_CLEAR(self->object);
1554     Py_CLEAR(self->reason);
1555     return BaseException_clear((PyBaseExceptionObject *)self);
1556 }
1557
1558 static void
1559 UnicodeError_dealloc(PyUnicodeErrorObject *self)
1560 {
1561     _PyObject_GC_UNTRACK(self);
1562     UnicodeError_clear(self);
1563     Py_TYPE(self)->tp_free((PyObject *)self);
1564 }
1565
1566 static int
1567 UnicodeError_traverse(PyUnicodeErrorObject *self, visitproc visit, void *arg)
1568 {
1569     Py_VISIT(self->encoding);
1570     Py_VISIT(self->object);
1571     Py_VISIT(self->reason);
1572     return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);
1573 }
1574
1575 static PyMemberDef UnicodeError_members[] = {
1576     {"encoding", T_OBJECT, offsetof(PyUnicodeErrorObject, encoding), 0,
1577         PyDoc_STR("exception encoding")},
1578     {"object", T_OBJECT, offsetof(PyUnicodeErrorObject, object), 0,
1579         PyDoc_STR("exception object")},
1580     {"start", T_PYSSIZET, offsetof(PyUnicodeErrorObject, start), 0,
1581         PyDoc_STR("exception start")},
1582     {"end", T_PYSSIZET, offsetof(PyUnicodeErrorObject, end), 0,
1583         PyDoc_STR("exception end")},
1584     {"reason", T_OBJECT, offsetof(PyUnicodeErrorObject, reason), 0,
1585         PyDoc_STR("exception reason")},
1586     {NULL}  /* Sentinel */
1587 };
1588
1589
1590 /*
1591  *    UnicodeEncodeError extends UnicodeError
1592  */
1593
1594 static int
1595 UnicodeEncodeError_init(PyObject *self, PyObject *args, PyObject *kwds)
1596 {
1597     if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
1598         return -1;
1599     return UnicodeError_init((PyUnicodeErrorObject *)self, args,
1600                              kwds, &PyUnicode_Type);
1601 }
1602
1603 static PyObject *
1604 UnicodeEncodeError_str(PyObject *self)
1605 {
1606     PyUnicodeErrorObject *uself = (PyUnicodeErrorObject *)self;
1607
1608     if (uself->end==uself->start+1) {
1609         int badchar = (int)PyUnicode_AS_UNICODE(uself->object)[uself->start];
1610         char badchar_str[20];
1611         if (badchar <= 0xff)
1612             PyOS_snprintf(badchar_str, sizeof(badchar_str), "x%02x", badchar);
1613         else if (badchar <= 0xffff)
1614             PyOS_snprintf(badchar_str, sizeof(badchar_str), "u%04x", badchar);
1615         else
1616             PyOS_snprintf(badchar_str, sizeof(badchar_str), "U%08x", badchar);
1617         return PyString_FromFormat(
1618             "'%.400s' codec can't encode character u'\\%s' in position %zd: %.400s",
1619             PyString_AS_STRING(uself->encoding),
1620             badchar_str,
1621             uself->start,
1622             PyString_AS_STRING(uself->reason)
1623         );
1624     }
1625     return PyString_FromFormat(
1626         "'%.400s' codec can't encode characters in position %zd-%zd: %.400s",
1627         PyString_AS_STRING(uself->encoding),
1628         uself->start,
1629         uself->end-1,
1630         PyString_AS_STRING(uself->reason)
1631     );
1632 }
1633
1634 static PyTypeObject _PyExc_UnicodeEncodeError = {
1635     PyObject_HEAD_INIT(NULL)
1636     0,
1637     EXC_MODULE_NAME "UnicodeEncodeError",
1638     sizeof(PyUnicodeErrorObject), 0,
1639     (destructor)UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1640     (reprfunc)UnicodeEncodeError_str, 0, 0, 0,
1641     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
1642     PyDoc_STR("Unicode encoding error."), (traverseproc)UnicodeError_traverse,
1643     (inquiry)UnicodeError_clear, 0, 0, 0, 0, 0, UnicodeError_members,
1644     0, &_PyExc_UnicodeError, 0, 0, 0, offsetof(PyUnicodeErrorObject, dict),
1645     (initproc)UnicodeEncodeError_init, 0, BaseException_new,
1646 };
1647 PyObject *PyExc_UnicodeEncodeError = (PyObject *)&_PyExc_UnicodeEncodeError;
1648
1649 PyObject *
1650 PyUnicodeEncodeError_Create(
1651     const char *encoding, const Py_UNICODE *object, Py_ssize_t length,
1652     Py_ssize_t start, Py_ssize_t end, const char *reason)
1653 {
1654     return PyObject_CallFunction(PyExc_UnicodeEncodeError, "su#nns",
1655                                  encoding, object, length, start, end, reason);
1656 }
1657
1658
1659 /*
1660  *    UnicodeDecodeError extends UnicodeError
1661  */
1662
1663 static int
1664 UnicodeDecodeError_init(PyObject *self, PyObject *args, PyObject *kwds)
1665 {
1666     if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
1667         return -1;
1668     return UnicodeError_init((PyUnicodeErrorObject *)self, args,
1669                              kwds, &PyString_Type);
1670 }
1671
1672 static PyObject *
1673 UnicodeDecodeError_str(PyObject *self)
1674 {
1675     PyUnicodeErrorObject *uself = (PyUnicodeErrorObject *)self;
1676
1677     if (uself->end==uself->start+1) {
1678         /* FromFormat does not support %02x, so format that separately */
1679         char byte[4];
1680         PyOS_snprintf(byte, sizeof(byte), "%02x",
1681                       ((int)PyString_AS_STRING(uself->object)[uself->start])&0xff);
1682         return PyString_FromFormat(
1683             "'%.400s' codec can't decode byte 0x%s in position %zd: %.400s",
1684             PyString_AS_STRING(uself->encoding),
1685             byte,
1686             uself->start,
1687             PyString_AS_STRING(uself->reason)
1688         );
1689     }
1690     return PyString_FromFormat(
1691         "'%.400s' codec can't decode bytes in position %zd-%zd: %.400s",
1692         PyString_AS_STRING(uself->encoding),
1693         uself->start,
1694         uself->end-1,
1695         PyString_AS_STRING(uself->reason)
1696     );
1697 }
1698
1699 static PyTypeObject _PyExc_UnicodeDecodeError = {
1700     PyObject_HEAD_INIT(NULL)
1701     0,
1702     EXC_MODULE_NAME "UnicodeDecodeError",
1703     sizeof(PyUnicodeErrorObject), 0,
1704     (destructor)UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1705     (reprfunc)UnicodeDecodeError_str, 0, 0, 0,
1706     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
1707     PyDoc_STR("Unicode decoding error."), (traverseproc)UnicodeError_traverse,
1708     (inquiry)UnicodeError_clear, 0, 0, 0, 0, 0, UnicodeError_members,
1709     0, &_PyExc_UnicodeError, 0, 0, 0, offsetof(PyUnicodeErrorObject, dict),
1710     (initproc)UnicodeDecodeError_init, 0, BaseException_new,
1711 };
1712 PyObject *PyExc_UnicodeDecodeError = (PyObject *)&_PyExc_UnicodeDecodeError;
1713
1714 PyObject *
1715 PyUnicodeDecodeError_Create(
1716     const char *encoding, const char *object, Py_ssize_t length,
1717     Py_ssize_t start, Py_ssize_t end, const char *reason)
1718 {
1719     assert(length < INT_MAX);
1720     assert(start < INT_MAX);
1721     assert(end < INT_MAX);
1722     return PyObject_CallFunction(PyExc_UnicodeDecodeError, "ss#nns",
1723                                  encoding, object, length, start, end, reason);
1724 }
1725
1726
1727 /*
1728  *    UnicodeTranslateError extends UnicodeError
1729  */
1730
1731 static int
1732 UnicodeTranslateError_init(PyUnicodeErrorObject *self, PyObject *args,
1733                            PyObject *kwds)
1734 {
1735     if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
1736         return -1;
1737
1738     Py_CLEAR(self->object);
1739     Py_CLEAR(self->reason);
1740
1741     if (!PyArg_ParseTuple(args, "O!nnO!",
1742         &PyUnicode_Type, &self->object,
1743         &self->start,
1744         &self->end,
1745         &PyString_Type, &self->reason)) {
1746         self->object = self->reason = NULL;
1747         return -1;
1748     }
1749
1750     Py_INCREF(self->object);
1751     Py_INCREF(self->reason);
1752
1753     return 0;
1754 }
1755
1756
1757 static PyObject *
1758 UnicodeTranslateError_str(PyObject *self)
1759 {
1760     PyUnicodeErrorObject *uself = (PyUnicodeErrorObject *)self;
1761
1762     if (uself->end==uself->start+1) {
1763         int badchar = (int)PyUnicode_AS_UNICODE(uself->object)[uself->start];
1764         char badchar_str[20];
1765         if (badchar <= 0xff)
1766             PyOS_snprintf(badchar_str, sizeof(badchar_str), "x%02x", badchar);
1767         else if (badchar <= 0xffff)
1768             PyOS_snprintf(badchar_str, sizeof(badchar_str), "u%04x", badchar);
1769         else
1770             PyOS_snprintf(badchar_str, sizeof(badchar_str), "U%08x", badchar);
1771         return PyString_FromFormat(
1772             "can't translate character u'\\%s' in position %zd: %.400s",
1773             badchar_str,
1774             uself->start,
1775             PyString_AS_STRING(uself->reason)
1776         );
1777     }
1778     return PyString_FromFormat(
1779         "can't translate characters in position %zd-%zd: %.400s",
1780         uself->start,
1781         uself->end-1,
1782         PyString_AS_STRING(uself->reason)
1783     );
1784 }
1785
1786 static PyTypeObject _PyExc_UnicodeTranslateError = {
1787     PyObject_HEAD_INIT(NULL)
1788     0,
1789     EXC_MODULE_NAME "UnicodeTranslateError",
1790     sizeof(PyUnicodeErrorObject), 0,
1791     (destructor)UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1792     (reprfunc)UnicodeTranslateError_str, 0, 0, 0,
1793     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
1794     PyDoc_STR("Unicode translation error."), (traverseproc)UnicodeError_traverse,
1795     (inquiry)UnicodeError_clear, 0, 0, 0, 0, 0, UnicodeError_members,
1796     0, &_PyExc_UnicodeError, 0, 0, 0, offsetof(PyUnicodeErrorObject, dict),
1797     (initproc)UnicodeTranslateError_init, 0, BaseException_new,
1798 };
1799 PyObject *PyExc_UnicodeTranslateError = (PyObject *)&_PyExc_UnicodeTranslateError;
1800
1801 PyObject *
1802 PyUnicodeTranslateError_Create(
1803     const Py_UNICODE *object, Py_ssize_t length,
1804     Py_ssize_t start, Py_ssize_t end, const char *reason)
1805 {
1806     return PyObject_CallFunction(PyExc_UnicodeTranslateError, "u#nns",
1807                                  object, length, start, end, reason);
1808 }
1809 #endif
1810
1811
1812 /*
1813  *    AssertionError extends StandardError
1814  */
1815 SimpleExtendsException(PyExc_StandardError, AssertionError,
1816                        "Assertion failed.");
1817
1818
1819 /*
1820  *    ArithmeticError extends StandardError
1821  */
1822 SimpleExtendsException(PyExc_StandardError, ArithmeticError,
1823                        "Base class for arithmetic errors.");
1824
1825
1826 /*
1827  *    FloatingPointError extends ArithmeticError
1828  */
1829 SimpleExtendsException(PyExc_ArithmeticError, FloatingPointError,
1830                        "Floating point operation failed.");
1831
1832
1833 /*
1834  *    OverflowError extends ArithmeticError
1835  */
1836 SimpleExtendsException(PyExc_ArithmeticError, OverflowError,
1837                        "Result too large to be represented.");
1838
1839
1840 /*
1841  *    ZeroDivisionError extends ArithmeticError
1842  */
1843 SimpleExtendsException(PyExc_ArithmeticError, ZeroDivisionError,
1844           "Second argument to a division or modulo operation was zero.");
1845
1846
1847 /*
1848  *    SystemError extends StandardError
1849  */
1850 SimpleExtendsException(PyExc_StandardError, SystemError,
1851     "Internal error in the Python interpreter.\n"
1852     "\n"
1853     "Please report this to the Python maintainer, along with the traceback,\n"
1854     "the Python version, and the hardware/OS platform and version.");
1855
1856
1857 /*
1858  *    ReferenceError extends StandardError
1859  */
1860 SimpleExtendsException(PyExc_StandardError, ReferenceError,
1861                        "Weak ref proxy used after referent went away.");
1862
1863
1864 /*
1865  *    MemoryError extends StandardError
1866  */
1867 SimpleExtendsException(PyExc_StandardError, MemoryError, "Out of memory.");
1868
1869 /*
1870  *    BufferError extends StandardError
1871  */
1872 SimpleExtendsException(PyExc_StandardError, BufferError, "Buffer error.");
1873
1874
1875 /* Warning category docstrings */
1876
1877 /*
1878  *    Warning extends Exception
1879  */
1880 SimpleExtendsException(PyExc_Exception, Warning,
1881                        "Base class for warning categories.");
1882
1883
1884 /*
1885  *    UserWarning extends Warning
1886  */
1887 SimpleExtendsException(PyExc_Warning, UserWarning,
1888                        "Base class for warnings generated by user code.");
1889
1890
1891 /*
1892  *    DeprecationWarning extends Warning
1893  */
1894 SimpleExtendsException(PyExc_Warning, DeprecationWarning,
1895                        "Base class for warnings about deprecated features.");
1896
1897
1898 /*
1899  *    PendingDeprecationWarning extends Warning
1900  */
1901 SimpleExtendsException(PyExc_Warning, PendingDeprecationWarning,
1902     "Base class for warnings about features which will be deprecated\n"
1903     "in the future.");
1904
1905
1906 /*
1907  *    SyntaxWarning extends Warning
1908  */
1909 SimpleExtendsException(PyExc_Warning, SyntaxWarning,
1910                        "Base class for warnings about dubious syntax.");
1911
1912
1913 /*
1914  *    RuntimeWarning extends Warning
1915  */
1916 SimpleExtendsException(PyExc_Warning, RuntimeWarning,
1917                  "Base class for warnings about dubious runtime behavior.");
1918
1919
1920 /*
1921  *    FutureWarning extends Warning
1922  */
1923 SimpleExtendsException(PyExc_Warning, FutureWarning,
1924     "Base class for warnings about constructs that will change semantically\n"
1925     "in the future.");
1926
1927
1928 /*
1929  *    ImportWarning extends Warning
1930  */
1931 SimpleExtendsException(PyExc_Warning, ImportWarning,
1932           "Base class for warnings about probable mistakes in module imports");
1933
1934
1935 /*
1936  *    UnicodeWarning extends Warning
1937  */
1938 SimpleExtendsException(PyExc_Warning, UnicodeWarning,
1939     "Base class for warnings about Unicode related problems, mostly\n"
1940     "related to conversion problems.");
1941
1942 /*
1943  *    BytesWarning extends Warning
1944  */
1945 SimpleExtendsException(PyExc_Warning, BytesWarning,
1946     "Base class for warnings about bytes and buffer related problems, mostly\n"
1947     "related to conversion from str or comparing to str.");
1948
1949 /* Pre-computed MemoryError instance.  Best to create this as early as
1950  * possible and not wait until a MemoryError is actually raised!
1951  */
1952 PyObject *PyExc_MemoryErrorInst=NULL;
1953
1954 /* Pre-computed RuntimeError instance for when recursion depth is reached.
1955    Meant to be used when normalizing the exception for exceeding the recursion
1956    depth will cause its own infinite recursion.
1957 */
1958 PyObject *PyExc_RecursionErrorInst = NULL;
1959
1960 /* module global functions */
1961 static PyMethodDef functions[] = {
1962     /* Sentinel */
1963     {NULL, NULL}
1964 };
1965
1966 #define PRE_INIT(TYPE) if (PyType_Ready(&_PyExc_ ## TYPE) < 0) \
1967     Py_FatalError("exceptions bootstrapping error.");
1968
1969 #define POST_INIT(TYPE) Py_INCREF(PyExc_ ## TYPE); \
1970     PyModule_AddObject(m, # TYPE, PyExc_ ## TYPE); \
1971     if (PyDict_SetItemString(bdict, # TYPE, PyExc_ ## TYPE)) \
1972         Py_FatalError("Module dictionary insertion problem.");
1973
1974
1975 PyMODINIT_FUNC
1976 _PyExc_Init(void)
1977 {
1978     PyObject *m, *bltinmod, *bdict;
1979
1980     PRE_INIT(BaseException)
1981     PRE_INIT(Exception)
1982     PRE_INIT(StandardError)
1983     PRE_INIT(TypeError)
1984     PRE_INIT(StopIteration)
1985     PRE_INIT(GeneratorExit)
1986     PRE_INIT(SystemExit)
1987     PRE_INIT(KeyboardInterrupt)
1988     PRE_INIT(ImportError)
1989     PRE_INIT(EnvironmentError)
1990     PRE_INIT(IOError)
1991     PRE_INIT(OSError)
1992 #ifdef MS_WINDOWS
1993     PRE_INIT(WindowsError)
1994 #endif
1995 #ifdef __VMS
1996     PRE_INIT(VMSError)
1997 #endif
1998     PRE_INIT(EOFError)
1999     PRE_INIT(RuntimeError)
2000     PRE_INIT(NotImplementedError)
2001     PRE_INIT(NameError)
2002     PRE_INIT(UnboundLocalError)
2003     PRE_INIT(AttributeError)
2004     PRE_INIT(SyntaxError)
2005     PRE_INIT(IndentationError)
2006     PRE_INIT(TabError)
2007     PRE_INIT(LookupError)
2008     PRE_INIT(IndexError)
2009     PRE_INIT(KeyError)
2010     PRE_INIT(ValueError)
2011     PRE_INIT(UnicodeError)
2012 #ifdef Py_USING_UNICODE
2013     PRE_INIT(UnicodeEncodeError)
2014     PRE_INIT(UnicodeDecodeError)
2015     PRE_INIT(UnicodeTranslateError)
2016 #endif
2017     PRE_INIT(AssertionError)
2018     PRE_INIT(ArithmeticError)
2019     PRE_INIT(FloatingPointError)
2020     PRE_INIT(OverflowError)
2021     PRE_INIT(ZeroDivisionError)
2022     PRE_INIT(SystemError)
2023     PRE_INIT(ReferenceError)
2024     PRE_INIT(MemoryError)
2025     PRE_INIT(BufferError)
2026     PRE_INIT(Warning)
2027     PRE_INIT(UserWarning)
2028     PRE_INIT(DeprecationWarning)
2029     PRE_INIT(PendingDeprecationWarning)
2030     PRE_INIT(SyntaxWarning)
2031     PRE_INIT(RuntimeWarning)
2032     PRE_INIT(FutureWarning)
2033     PRE_INIT(ImportWarning)
2034     PRE_INIT(UnicodeWarning)
2035     PRE_INIT(BytesWarning)
2036
2037     m = Py_InitModule4("exceptions", functions, exceptions_doc,
2038         (PyObject *)NULL, PYTHON_API_VERSION);
2039     if (m == NULL) return;
2040
2041     bltinmod = PyImport_ImportModule("__builtin__");
2042     if (bltinmod == NULL)
2043         Py_FatalError("exceptions bootstrapping error.");
2044     bdict = PyModule_GetDict(bltinmod);
2045     if (bdict == NULL)
2046         Py_FatalError("exceptions bootstrapping error.");
2047
2048     POST_INIT(BaseException)
2049     POST_INIT(Exception)
2050     POST_INIT(StandardError)
2051     POST_INIT(TypeError)
2052     POST_INIT(StopIteration)
2053     POST_INIT(GeneratorExit)
2054     POST_INIT(SystemExit)
2055     POST_INIT(KeyboardInterrupt)
2056     POST_INIT(ImportError)
2057     POST_INIT(EnvironmentError)
2058     POST_INIT(IOError)
2059     POST_INIT(OSError)
2060 #ifdef MS_WINDOWS
2061     POST_INIT(WindowsError)
2062 #endif
2063 #ifdef __VMS
2064     POST_INIT(VMSError)
2065 #endif
2066     POST_INIT(EOFError)
2067     POST_INIT(RuntimeError)
2068     POST_INIT(NotImplementedError)
2069     POST_INIT(NameError)
2070     POST_INIT(UnboundLocalError)
2071     POST_INIT(AttributeError)
2072     POST_INIT(SyntaxError)
2073     POST_INIT(IndentationError)
2074     POST_INIT(TabError)
2075     POST_INIT(LookupError)
2076     POST_INIT(IndexError)
2077     POST_INIT(KeyError)
2078     POST_INIT(ValueError)
2079     POST_INIT(UnicodeError)
2080 #ifdef Py_USING_UNICODE
2081     POST_INIT(UnicodeEncodeError)
2082     POST_INIT(UnicodeDecodeError)
2083     POST_INIT(UnicodeTranslateError)
2084 #endif
2085     POST_INIT(AssertionError)
2086     POST_INIT(ArithmeticError)
2087     POST_INIT(FloatingPointError)
2088     POST_INIT(OverflowError)
2089     POST_INIT(ZeroDivisionError)
2090     POST_INIT(SystemError)
2091     POST_INIT(ReferenceError)
2092     POST_INIT(MemoryError)
2093     POST_INIT(BufferError)
2094     POST_INIT(Warning)
2095     POST_INIT(UserWarning)
2096     POST_INIT(DeprecationWarning)
2097     POST_INIT(PendingDeprecationWarning)
2098     POST_INIT(SyntaxWarning)
2099     POST_INIT(RuntimeWarning)
2100     POST_INIT(FutureWarning)
2101     POST_INIT(ImportWarning)
2102     POST_INIT(UnicodeWarning)
2103     POST_INIT(BytesWarning)
2104
2105     PyExc_MemoryErrorInst = BaseException_new(&_PyExc_MemoryError, NULL, NULL);
2106     if (!PyExc_MemoryErrorInst)
2107         Py_FatalError("Cannot pre-allocate MemoryError instance");
2108
2109     PyExc_RecursionErrorInst = BaseException_new(&_PyExc_RuntimeError, NULL, NULL);
2110     if (!PyExc_RecursionErrorInst)
2111         Py_FatalError("Cannot pre-allocate RuntimeError instance for "
2112                         "recursion errors");
2113     else {
2114         PyBaseExceptionObject *err_inst =
2115             (PyBaseExceptionObject *)PyExc_RecursionErrorInst;
2116         PyObject *args_tuple;
2117         PyObject *exc_message;
2118         exc_message = PyString_FromString("maximum recursion depth exceeded");
2119         if (!exc_message)
2120             Py_FatalError("cannot allocate argument for RuntimeError "
2121                             "pre-allocation");
2122         args_tuple = PyTuple_Pack(1, exc_message);
2123         if (!args_tuple)
2124             Py_FatalError("cannot allocate tuple for RuntimeError "
2125                             "pre-allocation");
2126         Py_DECREF(exc_message);
2127         if (BaseException_init(err_inst, args_tuple, NULL))
2128             Py_FatalError("init of pre-allocated RuntimeError failed");
2129         Py_DECREF(args_tuple);
2130     }
2131
2132     Py_DECREF(bltinmod);
2133 }
2134
2135 void
2136 _PyExc_Fini(void)
2137 {
2138     Py_CLEAR(PyExc_MemoryErrorInst);
2139     Py_CLEAR(PyExc_RecursionErrorInst);
2140 }