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