Python/exceptions.c

   1 /* This module provides the suite of standard class-based exceptions for
   2  * Python's builtin module.  This is a complete C implementation of what,
   3  * in Python 1.5.2, was contained in the exceptions.py module.  The problem
   4  * there was that if exceptions.py could not be imported for some reason,
   5  * the entire interpreter would abort.
   6  *
   7  * By moving the exceptions into C and statically linking, we can guarantee
   8  * that the standard exceptions will always be available.
   9  *
  10  * history:
  11  * 98-08-19    fl   created (for pyexe)
  12  * 00-02-08    fl   updated for 1.5.2
  13  * 26-May-2000 baw  vetted for Python 1.6
  14  *
  15  * written by Fredrik Lundh
  16  * modifications, additions, cleanups, and proofreading by Barry Warsaw
  17  *
  18  * Copyright (c) 1998-2000 by Secret Labs AB.  All rights reserved.
  19  */
  20
  21 #include "Python.h"
  22 #include "osdefs.h"
  23
  24 /* Caution:  MS Visual C++ 6 errors if a single string literal exceeds
  25  * 2Kb.  So the module docstring has been broken roughly in half, using
  26  * compile-time literal concatenation.
  27  */
  28
  29 /* NOTE: If the exception class hierarchy changes, don't forget to update
  30  * Doc/lib/libexcs.tex!
  31  */
  32
  33 PyDoc_STRVAR(module__doc__,
  34 "Python's standard exception class hierarchy.\n\
  35 \n\
  36 Before Python 1.5, the standard exceptions were all simple string objects.\n\
  37 In Python 1.5, the standard exceptions were converted to classes organized\n\
  38 into a relatively flat hierarchy.  String-based standard exceptions were\n\
  39 optional, or used as a fallback if some problem occurred while importing\n\
  40 the exception module.  With Python 1.6, optional string-based standard\n\
  41 exceptions were removed (along with the -X command line flag).\n\
  42 \n\
  43 The class exceptions were implemented in such a way as to be almost\n\
  44 completely backward compatible.  Some tricky uses of IOError could\n\
  45 potentially have broken, but by Python 1.6, all of these should have\n\
  46 been fixed.  As of Python 1.6, the class-based standard exceptions are\n\
  47 now implemented in C, and are guaranteed to exist in the Python\n\
  48 interpreter.\n\
  49 \n\
  50 Here is a rundown of the class hierarchy.  The classes found here are\n\
  51 inserted into both the exceptions module and the `built-in' module.  It is\n\
  52 recommended that user defined class based exceptions be derived from the\n\
  53 `Exception' class, although this is currently not enforced.\n"
  54         /* keep string pieces "small" */
  55 "\n\
  56 Exception\n\
  57  |\n\
  58  +-- SystemExit\n\
  59  +-- StopIteration\n\
  60  +-- StandardError\n\
  61  |    |\n\
  62  |    +-- KeyboardInterrupt\n\
  63  |    +-- ImportError\n\
  64  |    +-- EnvironmentError\n\
  65  |    |    |\n\
  66  |    |    +-- IOError\n\
  67  |    |    +-- OSError\n\
  68  |    |         |\n\
  69  |    |         +-- WindowsError\n\
  70  |    |         +-- VMSError\n\
  71  |    |\n\
  72  |    +-- EOFError\n\
  73  |    +-- RuntimeError\n\
  74  |    |    |\n\
  75  |    |    +-- NotImplementedError\n\
  76  |    |\n\
  77  |    +-- NameError\n\
  78  |    |    |\n\
  79  |    |    +-- UnboundLocalError\n\
  80  |    |\n\
  81  |    +-- AttributeError\n\
  82  |    +-- SyntaxError\n\
  83  |    |    |\n\
  84  |    |    +-- IndentationError\n\
  85  |    |         |\n\
  86  |    |         +-- TabError\n\
  87  |    |\n\
  88  |    +-- TypeError\n\
  89  |    +-- AssertionError\n\
  90  |    +-- LookupError\n\
  91  |    |    |\n\
  92  |    |    +-- IndexError\n\
  93  |    |    +-- KeyError\n\
  94  |    |\n\
  95  |    +-- ArithmeticError\n\
  96  |    |    |\n\
  97  |    |    +-- OverflowError\n\
  98  |    |    +-- ZeroDivisionError\n\
  99  |    |    +-- FloatingPointError\n\
 100  |    |\n\
 101  |    +-- ValueError\n\
 102  |    |    |\n\
 103  |    |    +-- UnicodeError\n\
 104  |    |        |\n\
 105  |    |        +-- UnicodeEncodeError\n\
 106  |    |        +-- UnicodeDecodeError\n\
 107  |    |        +-- UnicodeTranslateError\n\
 108  |    |\n\
 109  |    +-- ReferenceError\n\
 110  |    +-- SystemError\n\
 111  |    +-- MemoryError\n\
 112  |\n\
 113  +---Warning\n\
 114       |\n\
 115       +-- UserWarning\n\
 116       +-- DeprecationWarning\n\
 117       +-- PendingDeprecationWarning\n\
 118       +-- SyntaxWarning\n\
 119       +-- OverflowWarning\n\
 120       +-- RuntimeWarning\n\
 121       +-- FutureWarning"
 122 );
 123
 124 \f
 125 /* Helper function for populating a dictionary with method wrappers. */
 126 static int
 127 populate_methods(PyObject *klass, PyObject *dict, PyMethodDef *methods)
 128 {
 129     PyObject *module;
 130     int status = -1;
 131
 132     if (!methods)
 133         return 0;
 134
 135     module = PyString_FromString("exceptions");
 136     if (!module)
 137         return 0;
 138     while (methods->ml_name) {
 139         /* get a wrapper for the built-in function */
 140         PyObject *func = PyCFunction_NewEx(methods, NULL, module);
 141         PyObject *meth;
 142
 143         if (!func)
 144             goto status;
 145
 146         /* turn the function into an unbound method */
 147         if (!(meth = PyMethod_New(func, NULL, klass))) {
 148             Py_DECREF(func);
 149             goto status;
 150         }
 151
 152         /* add method to dictionary */
 153         status = PyDict_SetItemString(dict, methods->ml_name, meth);
 154         Py_DECREF(meth);
 155         Py_DECREF(func);
 156
 157         /* stop now if an error occurred, otherwise do the next method */
 158         if (status)
 159             goto status;
 160
 161         methods++;
 162     }
 163     status = 0;
 164  status:
 165     Py_DECREF(module);
 166     return status;
 167 }
 168
 169
 170 \f
 171 /* This function is used to create all subsequent exception classes. */
 172 static int
 173 make_class(PyObject **klass, PyObject *base,
 174            char *name, PyMethodDef *methods,
 175            char *docstr)
 176 {
 177     PyObject *dict = PyDict_New();
 178     PyObject *str = NULL;
 179     int status = -1;
 180
 181     if (!dict)
 182         return -1;
 183
 184     /* If an error occurs from here on, goto finally instead of explicitly
 185      * returning NULL.
 186      */
 187
 188     if (docstr) {
 189         if (!(str = PyString_FromString(docstr)))
 190             goto finally;
 191         if (PyDict_SetItemString(dict, "__doc__", str))
 192             goto finally;
 193     }
 194
 195     if (!(*klass = PyErr_NewException(name, base, dict)))
 196         goto finally;
 197
 198     if (populate_methods(*klass, dict, methods)) {
 199         Py_DECREF(*klass);
 200         *klass = NULL;
 201         goto finally;
 202     }
 203
 204     status = 0;
 205
 206   finally:
 207     Py_XDECREF(dict);
 208     Py_XDECREF(str);
 209     return status;
 210 }
 211
 212
 213 /* Use this for *args signatures, otherwise just use PyArg_ParseTuple() */
 214 static PyObject *
 215 get_self(PyObject *args)
 216 {
 217     PyObject *self = PyTuple_GetItem(args, 0);
 218     if (!self) {
 219         /* Watch out for being called to early in the bootstrapping process */
 220         if (PyExc_TypeError) {
 221             PyErr_SetString(PyExc_TypeError,
 222              "unbound method must be called with instance as first argument");
 223         }
 224         return NULL;
 225     }
 226     return self;
 227 }
 228
 229
 230 \f
 231 /* Notes on bootstrapping the exception classes.
 232  *
 233  * First thing we create is the base class for all exceptions, called
 234  * appropriately enough: Exception.  Creation of this class makes no
 235  * assumptions about the existence of any other exception class -- except
 236  * for TypeError, which can conditionally exist.
 237  *
 238  * Next, StandardError is created (which is quite simple) followed by
 239  * TypeError, because the instantiation of other exceptions can potentially
 240  * throw a TypeError.  Once these exceptions are created, all the others
 241  * can be created in any order.  See the static exctable below for the
 242  * explicit bootstrap order.
 243  *
 244  * All classes after Exception can be created using PyErr_NewException().
 245  */
 246
 247 PyDoc_STRVAR(Exception__doc__, "Common base class for all exceptions.");
 248
 249
 250 static PyObject *
 251 Exception__init__(PyObject *self, PyObject *args)
 252 {
 253     int status;
 254
 255     if (!(self = get_self(args)))
 256         return NULL;
 257
 258     /* set args attribute */
 259     /* XXX size is only a hint */
 260     args = PySequence_GetSlice(args, 1, PySequence_Size(args));
 261     if (!args)
 262         return NULL;
 263     status = PyObject_SetAttrString(self, "args", args);
 264     Py_DECREF(args);
 265     if (status < 0)
 266         return NULL;
 267
 268     Py_INCREF(Py_None);
 269     return Py_None;
 270 }
 271
 272
 273 static PyObject *
 274 Exception__str__(PyObject *self, PyObject *args)
 275 {
 276     PyObject *out;
 277
 278     if (!PyArg_ParseTuple(args, "O:__str__", &self))
 279         return NULL;
 280
 281     args = PyObject_GetAttrString(self, "args");
 282     if (!args)
 283         return NULL;
 284
 285     switch (PySequence_Size(args)) {
 286     case 0:
 287         out = PyString_FromString("");
 288         break;
 289     case 1:
 290     {
 291         PyObject *tmp = PySequence_GetItem(args, 0);
 292         if (tmp) {
 293             out = PyObject_Str(tmp);
 294             Py_DECREF(tmp);
 295         }
 296         else
 297             out = NULL;
 298         break;
 299     }
 300     case -1:
 301         PyErr_Clear();
 302         /* Fall through */
 303     default:
 304         out = PyObject_Str(args);
 305         break;
 306     }
 307
 308     Py_DECREF(args);
 309     return out;
 310 }
 311
 312
 313 static PyObject *
 314 Exception__getitem__(PyObject *self, PyObject *args)
 315 {
 316     PyObject *out;
 317     PyObject *index;
 318
 319     if (!PyArg_ParseTuple(args, "OO:__getitem__", &self, &index))
 320         return NULL;
 321
 322     args = PyObject_GetAttrString(self, "args");
 323     if (!args)
 324         return NULL;
 325
 326     out = PyObject_GetItem(args, index);
 327     Py_DECREF(args);
 328     return out;
 329 }
 330
 331
 332 static PyMethodDef
 333 Exception_methods[] = {
 334     /* methods for the Exception class */
 335     { "__getitem__", Exception__getitem__, METH_VARARGS},
 336     { "__str__",     Exception__str__, METH_VARARGS},
 337     { "__init__",    Exception__init__, METH_VARARGS},
 338     { NULL, NULL }
 339 };
 340
 341
 342 static int
 343 make_Exception(char *modulename)
 344 {
 345     PyObject *dict = PyDict_New();
 346     PyObject *str = NULL;
 347     PyObject *name = NULL;
 348     int status = -1;
 349
 350     if (!dict)
 351         return -1;
 352
 353     /* If an error occurs from here on, goto finally instead of explicitly
 354      * returning NULL.
 355      */
 356
 357     if (!(str = PyString_FromString(modulename)))
 358         goto finally;
 359     if (PyDict_SetItemString(dict, "__module__", str))
 360         goto finally;
 361     Py_DECREF(str);
 362     if (!(str = PyString_FromString(Exception__doc__)))
 363         goto finally;
 364     if (PyDict_SetItemString(dict, "__doc__", str))
 365         goto finally;
 366
 367     if (!(name = PyString_FromString("Exception")))
 368         goto finally;
 369
 370     if (!(PyExc_Exception = PyClass_New(NULL, dict, name)))
 371         goto finally;
 372
 373     /* Now populate the dictionary with the method suite */
 374     if (populate_methods(PyExc_Exception, dict, Exception_methods))
 375         /* Don't need to reclaim PyExc_Exception here because that'll
 376          * happen during interpreter shutdown.
 377          */
 378         goto finally;
 379
 380     status = 0;
 381
 382   finally:
 383     Py_XDECREF(dict);
 384     Py_XDECREF(str);
 385     Py_XDECREF(name);
 386     return status;
 387 }
 388
 389
 390 \f
 391 PyDoc_STRVAR(StandardError__doc__,
 392 "Base class for all standard Python exceptions.");
 393
 394 PyDoc_STRVAR(TypeError__doc__, "Inappropriate argument type.");
 395
 396 PyDoc_STRVAR(StopIteration__doc__, "Signal the end from iterator.next().");
 397
 398
 399 \f
 400 PyDoc_STRVAR(SystemExit__doc__, "Request to exit from the interpreter.");
 401
 402
 403 static PyObject *
 404 SystemExit__init__(PyObject *self, PyObject *args)
 405 {
 406     PyObject *code;
 407     int status;
 408
 409     if (!(self = get_self(args)))
 410         return NULL;
 411
 412     /* Set args attribute. */
 413     if (!(args = PySequence_GetSlice(args, 1, PySequence_Size(args))))
 414         return NULL;
 415
 416     status = PyObject_SetAttrString(self, "args", args);
 417     if (status < 0) {
 418         Py_DECREF(args);
 419         return NULL;
 420     }
 421
 422     /* set code attribute */
 423     switch (PySequence_Size(args)) {
 424     case 0:
 425         Py_INCREF(Py_None);
 426         code = Py_None;
 427         break;
 428     case 1:
 429         code = PySequence_GetItem(args, 0);
 430         break;
 431     case -1:
 432         PyErr_Clear();
 433         /* Fall through */
 434     default:
 435         Py_INCREF(args);
 436         code = args;
 437         break;
 438     }
 439
 440     status = PyObject_SetAttrString(self, "code", code);
 441     Py_DECREF(code);
 442     Py_DECREF(args);
 443     if (status < 0)
 444         return NULL;
 445
 446     Py_INCREF(Py_None);
 447     return Py_None;
 448 }
 449
 450
 451 static PyMethodDef SystemExit_methods[] = {
 452     { "__init__", SystemExit__init__, METH_VARARGS},
 453     {NULL, NULL}
 454 };
 455
 456
 457 \f
 458 PyDoc_STRVAR(KeyboardInterrupt__doc__, "Program interrupted by user.");
 459
 460 PyDoc_STRVAR(ImportError__doc__,
 461 "Import can't find module, or can't find name in module.");
 462
 463
 464 \f
 465 PyDoc_STRVAR(EnvironmentError__doc__, "Base class for I/O related errors.");
 466
 467
 468 static PyObject *
 469 EnvironmentError__init__(PyObject *self, PyObject *args)
 470 {
 471     PyObject *item0 = NULL;
 472     PyObject *item1 = NULL;
 473     PyObject *item2 = NULL;
 474     PyObject *subslice = NULL;
 475     PyObject *rtnval = NULL;
 476
 477     if (!(self = get_self(args)))
 478         return NULL;
 479
 480     if (!(args = PySequence_GetSlice(args, 1, PySequence_Size(args))))
 481         return NULL;
 482
 483     if (PyObject_SetAttrString(self, "args", args) ||
 484         PyObject_SetAttrString(self, "errno", Py_None) ||
 485         PyObject_SetAttrString(self, "strerror", Py_None) ||
 486         PyObject_SetAttrString(self, "filename", Py_None))
 487     {
 488         goto finally;
 489     }
 490
 491     switch (PySequence_Size(args)) {
 492     case 3:
 493         /* Where a function has a single filename, such as open() or some
 494          * of the os module functions, PyErr_SetFromErrnoWithFilename() is
 495          * called, giving a third argument which is the filename.  But, so
 496          * that old code using in-place unpacking doesn't break, e.g.:
 497          *
 498          * except IOError, (errno, strerror):
 499          *
 500          * we hack args so that it only contains two items.  This also
 501          * means we need our own __str__() which prints out the filename
 502          * when it was supplied.
 503          */
 504         item0 = PySequence_GetItem(args, 0);
 505         item1 = PySequence_GetItem(args, 1);
 506         item2 = PySequence_GetItem(args, 2);
 507         if (!item0 || !item1 || !item2)
 508             goto finally;
 509
 510         if (PyObject_SetAttrString(self, "errno", item0) ||
 511             PyObject_SetAttrString(self, "strerror", item1) ||
 512             PyObject_SetAttrString(self, "filename", item2))
 513         {
 514             goto finally;
 515         }
 516
 517         subslice = PySequence_GetSlice(args, 0, 2);
 518         if (!subslice || PyObject_SetAttrString(self, "args", subslice))
 519             goto finally;
 520         break;
 521
 522     case 2:
 523         /* Used when PyErr_SetFromErrno() is called and no filename
 524          * argument is given.
 525          */
 526         item0 = PySequence_GetItem(args, 0);
 527         item1 = PySequence_GetItem(args, 1);
 528         if (!item0 || !item1)
 529             goto finally;
 530
 531         if (PyObject_SetAttrString(self, "errno", item0) ||
 532             PyObject_SetAttrString(self, "strerror", item1))
 533         {
 534             goto finally;
 535         }
 536         break;
 537
 538     case -1:
 539         PyErr_Clear();
 540         break;
 541     }
 542
 543     Py_INCREF(Py_None);
 544     rtnval = Py_None;
 545
 546   finally:
 547     Py_DECREF(args);
 548     Py_XDECREF(item0);
 549     Py_XDECREF(item1);
 550     Py_XDECREF(item2);
 551     Py_XDECREF(subslice);
 552     return rtnval;
 553 }
 554
 555
 556 static PyObject *
 557 EnvironmentError__str__(PyObject *self, PyObject *args)
 558 {
 559     PyObject *originalself = self;
 560     PyObject *filename;
 561     PyObject *serrno;
 562     PyObject *strerror;
 563     PyObject *rtnval = NULL;
 564
 565     if (!PyArg_ParseTuple(args, "O:__str__", &self))
 566         return NULL;
 567
 568     filename = PyObject_GetAttrString(self, "filename");
 569     serrno = PyObject_GetAttrString(self, "errno");
 570     strerror = PyObject_GetAttrString(self, "strerror");
 571     if (!filename || !serrno || !strerror)
 572         goto finally;
 573
 574     if (filename != Py_None) {
 575         PyObject *fmt = PyString_FromString("[Errno %s] %s: %s");
 576         PyObject *repr = PyObject_Repr(filename);
 577         PyObject *tuple = PyTuple_New(3);
 578
 579         if (!fmt || !repr || !tuple) {
 580             Py_XDECREF(fmt);
 581             Py_XDECREF(repr);
 582             Py_XDECREF(tuple);
 583             goto finally;
 584         }
 585
 586         PyTuple_SET_ITEM(tuple, 0, serrno);
 587         PyTuple_SET_ITEM(tuple, 1, strerror);
 588         PyTuple_SET_ITEM(tuple, 2, repr);
 589
 590         rtnval = PyString_Format(fmt, tuple);
 591
 592         Py_DECREF(fmt);
 593         Py_DECREF(tuple);
 594         /* already freed because tuple owned only reference */
 595         serrno = NULL;
 596         strerror = NULL;
 597     }
 598     else if (PyObject_IsTrue(serrno) && PyObject_IsTrue(strerror)) {
 599         PyObject *fmt = PyString_FromString("[Errno %s] %s");
 600         PyObject *tuple = PyTuple_New(2);
 601
 602         if (!fmt || !tuple) {
 603             Py_XDECREF(fmt);
 604             Py_XDECREF(tuple);
 605             goto finally;
 606         }
 607
 608         PyTuple_SET_ITEM(tuple, 0, serrno);
 609         PyTuple_SET_ITEM(tuple, 1, strerror);
 610
 611         rtnval = PyString_Format(fmt, tuple);
 612
 613         Py_DECREF(fmt);
 614         Py_DECREF(tuple);
 615         /* already freed because tuple owned only reference */
 616         serrno = NULL;
 617         strerror = NULL;
 618     }
 619     else
 620         /* The original Python code said:
 621          *
 622          *   return StandardError.__str__(self)
 623          *
 624          * but there is no StandardError__str__() function; we happen to
 625          * know that's just a pass through to Exception__str__().
 626          */
 627         rtnval = Exception__str__(originalself, args);
 628
 629   finally:
 630     Py_XDECREF(filename);
 631     Py_XDECREF(serrno);
 632     Py_XDECREF(strerror);
 633     return rtnval;
 634 }
 635
 636
 637 static
 638 PyMethodDef EnvironmentError_methods[] = {
 639     {"__init__", EnvironmentError__init__, METH_VARARGS},
 640     {"__str__",  EnvironmentError__str__, METH_VARARGS},
 641     {NULL, NULL}
 642 };
 643
 644
 645
 646 \f
 647 PyDoc_STRVAR(IOError__doc__, "I/O operation failed.");
 648
 649 PyDoc_STRVAR(OSError__doc__, "OS system call failed.");
 650
 651 #ifdef MS_WINDOWS
 652 PyDoc_STRVAR(WindowsError__doc__, "MS-Windows OS system call failed.");
 653 #endif /* MS_WINDOWS */
 654
 655 #ifdef __VMS
 656 static char
 657 VMSError__doc__[] = "OpenVMS OS system call failed.";
 658 #endif
 659
 660 PyDoc_STRVAR(EOFError__doc__, "Read beyond end of file.");
 661
 662 PyDoc_STRVAR(RuntimeError__doc__, "Unspecified run-time error.");
 663
 664 PyDoc_STRVAR(NotImplementedError__doc__,
 665 "Method or function hasn't been implemented yet.");
 666
 667 PyDoc_STRVAR(NameError__doc__, "Name not found globally.");
 668
 669 PyDoc_STRVAR(UnboundLocalError__doc__,
 670 "Local name referenced but not bound to a value.");
 671
 672 PyDoc_STRVAR(AttributeError__doc__, "Attribute not found.");
 673
 674
 675 \f
 676 PyDoc_STRVAR(SyntaxError__doc__, "Invalid syntax.");
 677
 678
 679 static int
 680 SyntaxError__classinit__(PyObject *klass)
 681 {
 682     int retval = 0;
 683     PyObject *emptystring = PyString_FromString("");
 684
 685     /* Additional class-creation time initializations */
 686     if (!emptystring ||
 687         PyObject_SetAttrString(klass, "msg", emptystring) ||
 688         PyObject_SetAttrString(klass, "filename", Py_None) ||
 689         PyObject_SetAttrString(klass, "lineno", Py_None) ||
 690         PyObject_SetAttrString(klass, "offset", Py_None) ||
 691         PyObject_SetAttrString(klass, "text", Py_None) ||
 692         PyObject_SetAttrString(klass, "print_file_and_line", Py_None))
 693     {
 694         retval = -1;
 695     }
 696     Py_XDECREF(emptystring);
 697     return retval;
 698 }
 699
 700
 701 static PyObject *
 702 SyntaxError__init__(PyObject *self, PyObject *args)
 703 {
 704     PyObject *rtnval = NULL;
 705     int lenargs;
 706
 707     if (!(self = get_self(args)))
 708         return NULL;
 709
 710     if (!(args = PySequence_GetSlice(args, 1, PySequence_Size(args))))
 711         return NULL;
 712
 713     if (PyObject_SetAttrString(self, "args", args))
 714         goto finally;
 715
 716     lenargs = PySequence_Size(args);
 717     if (lenargs >= 1) {
 718         PyObject *item0 = PySequence_GetItem(args, 0);
 719         int status;
 720
 721         if (!item0)
 722             goto finally;
 723         status = PyObject_SetAttrString(self, "msg", item0);
 724         Py_DECREF(item0);
 725         if (status)
 726             goto finally;
 727     }
 728     if (lenargs == 2) {
 729         PyObject *info = PySequence_GetItem(args, 1);
 730         PyObject *filename = NULL, *lineno = NULL;
 731         PyObject *offset = NULL, *text = NULL;
 732         int status = 1;
 733
 734         if (!info)
 735             goto finally;
 736
 737         filename = PySequence_GetItem(info, 0);
 738         if (filename != NULL) {
 739             lineno = PySequence_GetItem(info, 1);
 740             if (lineno != NULL) {
 741                 offset = PySequence_GetItem(info, 2);
 742                 if (offset != NULL) {
 743                     text = PySequence_GetItem(info, 3);
 744                     if (text != NULL) {
 745                         status =
 746                             PyObject_SetAttrString(self, "filename", filename)
 747                             || PyObject_SetAttrString(self, "lineno", lineno)
 748                             || PyObject_SetAttrString(self, "offset", offset)
 749                             || PyObject_SetAttrString(self, "text", text);
 750                         Py_DECREF(text);
 751                     }
 752                     Py_DECREF(offset);
 753                 }
 754                 Py_DECREF(lineno);
 755             }
 756             Py_DECREF(filename);
 757         }
 758         Py_DECREF(info);
 759
 760         if (status)
 761             goto finally;
 762     }
 763     Py_INCREF(Py_None);
 764     rtnval = Py_None;
 765
 766   finally:
 767     Py_DECREF(args);
 768     return rtnval;
 769 }
 770
 771
 772 /* This is called "my_basename" instead of just "basename" to avoid name
 773    conflicts with glibc; basename is already prototyped if _GNU_SOURCE is
 774    defined, and Python does define that. */
 775 static char *
 776 my_basename(char *name)
 777 {
 778         char *cp = name;
 779         char *result = name;
 780
 781         if (name == NULL)
 782                 return "???";
 783         while (*cp != '\0') {
 784                 if (*cp == SEP)
 785                         result = cp + 1;
 786                 ++cp;
 787         }
 788         return result;
 789 }
 790
 791
 792 static PyObject *
 793 SyntaxError__str__(PyObject *self, PyObject *args)
 794 {
 795     PyObject *msg;
 796     PyObject *str;
 797     PyObject *filename, *lineno, *result;
 798
 799     if (!PyArg_ParseTuple(args, "O:__str__", &self))
 800         return NULL;
 801
 802     if (!(msg = PyObject_GetAttrString(self, "msg")))
 803         return NULL;
 804
 805     str = PyObject_Str(msg);
 806     Py_DECREF(msg);
 807     result = str;
 808
 809     /* XXX -- do all the additional formatting with filename and
 810        lineno here */
 811
 812     if (str != NULL && PyString_Check(str)) {
 813         int have_filename = 0;
 814         int have_lineno = 0;
 815         char *buffer = NULL;
 816
 817         if ((filename = PyObject_GetAttrString(self, "filename")) != NULL)
 818             have_filename = PyString_Check(filename);
 819         else
 820             PyErr_Clear();
 821
 822         if ((lineno = PyObject_GetAttrString(self, "lineno")) != NULL)
 823             have_lineno = PyInt_Check(lineno);
 824         else
 825             PyErr_Clear();
 826
 827         if (have_filename || have_lineno) {
 828             int bufsize = PyString_GET_SIZE(str) + 64;
 829             if (have_filename)
 830                 bufsize += PyString_GET_SIZE(filename);
 831
 832             buffer = PyMem_MALLOC(bufsize);
 833             if (buffer != NULL) {
 834                 if (have_filename && have_lineno)
 835                     PyOS_snprintf(buffer, bufsize, "%s (%s, line %ld)",
 836                                   PyString_AS_STRING(str),
 837                                   my_basename(PyString_AS_STRING(filename)),
 838                                   PyInt_AsLong(lineno));
 839                 else if (have_filename)
 840                     PyOS_snprintf(buffer, bufsize, "%s (%s)",
 841                                   PyString_AS_STRING(str),
 842                                   my_basename(PyString_AS_STRING(filename)));
 843                 else if (have_lineno)
 844                     PyOS_snprintf(buffer, bufsize, "%s (line %ld)",
 845                                   PyString_AS_STRING(str),
 846                                   PyInt_AsLong(lineno));
 847
 848                 result = PyString_FromString(buffer);
 849                 PyMem_FREE(buffer);
 850
 851                 if (result == NULL)
 852                     result = str;
 853                 else
 854                     Py_DECREF(str);
 855             }
 856         }
 857         Py_XDECREF(filename);
 858         Py_XDECREF(lineno);
 859     }
 860     return result;
 861 }
 862
 863
 864 static PyMethodDef SyntaxError_methods[] = {
 865     {"__init__", SyntaxError__init__, METH_VARARGS},
 866     {"__str__",  SyntaxError__str__, METH_VARARGS},
 867     {NULL, NULL}
 868 };
 869
 870
 871 static PyObject *
 872 KeyError__str__(PyObject *self, PyObject *args)
 873 {
 874     PyObject *argsattr;
 875     PyObject *result;
 876
 877     if (!PyArg_ParseTuple(args, "O:__str__", &self))
 878         return NULL;
 879
 880     if (!(argsattr = PyObject_GetAttrString(self, "args")))
 881         return NULL;
 882
 883     /* If args is a tuple of exactly one item, apply repr to args[0].
 884        This is done so that e.g. the exception raised by {}[''] prints
 885          KeyError: ''
 886        rather than the confusing
 887          KeyError
 888        alone.  The downside is that if KeyError is raised with an explanatory
 889        string, that string will be displayed in quotes.  Too bad.
 890        If args is anything else, use the default Exception__str__().
 891     */
 892     if (PyTuple_Check(argsattr) && PyTuple_GET_SIZE(argsattr) == 1) {
 893         PyObject *key = PyTuple_GET_ITEM(argsattr, 0);
 894         result = PyObject_Repr(key);
 895     }
 896     else
 897         result = Exception__str__(self, args);
 898
 899     Py_DECREF(argsattr);
 900     return result;
 901 }
 902
 903 static PyMethodDef KeyError_methods[] = {
 904     {"__str__",  KeyError__str__, METH_VARARGS},
 905     {NULL, NULL}
 906 };
 907
 908
 909 #ifdef Py_USING_UNICODE
 910 static
 911 int get_int(PyObject *exc, const char *name, int *value)
 912 {
 913     PyObject *attr = PyObject_GetAttrString(exc, (char *)name);
 914
 915     if (!attr)
 916         return -1;
 917     if (!PyInt_Check(attr)) {
 918         PyErr_Format(PyExc_TypeError, "%.200s attribute must be int", name);
 919         Py_DECREF(attr);
 920         return -1;
 921     }
 922     *value = PyInt_AS_LONG(attr);
 923     Py_DECREF(attr);
 924     return 0;
 925 }
 926
 927
 928 static
 929 int set_int(PyObject *exc, const char *name, int value)
 930 {
 931     PyObject *obj = PyInt_FromLong(value);
 932     int result;
 933
 934     if (!obj)
 935         return -1;
 936     result = PyObject_SetAttrString(exc, (char *)name, obj);
 937     Py_DECREF(obj);
 938     return result;
 939 }
 940
 941
 942 static
 943 PyObject *get_string(PyObject *exc, const char *name)
 944 {
 945     PyObject *attr = PyObject_GetAttrString(exc, (char *)name);
 946
 947     if (!attr)
 948         return NULL;
 949     if (!PyString_Check(attr)) {
 950         PyErr_Format(PyExc_TypeError, "%.200s attribute must be str", name);
 951         Py_DECREF(attr);
 952         return NULL;
 953     }
 954     return attr;
 955 }
 956
 957
 958 static
 959 int set_string(PyObject *exc, const char *name, const char *value)
 960 {
 961     PyObject *obj = PyString_FromString(value);
 962     int result;
 963
 964     if (!obj)
 965         return -1;
 966     result = PyObject_SetAttrString(exc, (char *)name, obj);
 967     Py_DECREF(obj);
 968     return result;
 969 }
 970
 971
 972 static
 973 PyObject *get_unicode(PyObject *exc, const char *name)
 974 {
 975     PyObject *attr = PyObject_GetAttrString(exc, (char *)name);
 976
 977     if (!attr)
 978         return NULL;
 979     if (!PyUnicode_Check(attr)) {
 980         PyErr_Format(PyExc_TypeError, "%.200s attribute must be unicode", name);
 981         Py_DECREF(attr);
 982         return NULL;
 983     }
 984     return attr;
 985 }
 986
 987 PyObject * PyUnicodeEncodeError_GetEncoding(PyObject *exc)
 988 {
 989     return get_string(exc, "encoding");
 990 }
 991
 992 PyObject * PyUnicodeDecodeError_GetEncoding(PyObject *exc)
 993 {
 994     return get_string(exc, "encoding");
 995 }
 996
 997 PyObject *PyUnicodeEncodeError_GetObject(PyObject *exc)
 998 {
 999     return get_unicode(exc, "object");
1000 }
1001
1002 PyObject *PyUnicodeDecodeError_GetObject(PyObject *exc)
1003 {
1004     return get_string(exc, "object");
1005 }
1006
1007 PyObject *PyUnicodeTranslateError_GetObject(PyObject *exc)
1008 {
1009     return get_unicode(exc, "object");
1010 }
1011
1012 int PyUnicodeEncodeError_GetStart(PyObject *exc, int *start)
1013 {
1014     if (!get_int(exc, "start", start)) {
1015         PyObject *object = PyUnicodeEncodeError_GetObject(exc);
1016         int size;
1017         if (!object)
1018             return -1;
1019         size = PyUnicode_GET_SIZE(object);
1020         if (*start<0)
1021             *start = 0;
1022         if (*start>=size)
1023             *start = size-1;
1024         Py_DECREF(object);
1025         return 0;
1026     }
1027     return -1;
1028 }
1029
1030
1031 int PyUnicodeDecodeError_GetStart(PyObject *exc, int *start)
1032 {
1033     if (!get_int(exc, "start", start)) {
1034         PyObject *object = PyUnicodeDecodeError_GetObject(exc);
1035         int size;
1036         if (!object)
1037             return -1;
1038         size = PyString_GET_SIZE(object);
1039         if (*start<0)
1040             *start = 0;
1041         if (*start>=size)
1042             *start = size-1;
1043         Py_DECREF(object);
1044         return 0;
1045     }
1046     return -1;
1047 }
1048
1049
1050 int PyUnicodeTranslateError_GetStart(PyObject *exc, int *start)
1051 {
1052     return PyUnicodeEncodeError_GetStart(exc, start);
1053 }
1054
1055
1056 int PyUnicodeEncodeError_SetStart(PyObject *exc, int start)
1057 {
1058     return set_int(exc, "start", start);
1059 }
1060
1061
1062 int PyUnicodeDecodeError_SetStart(PyObject *exc, int start)
1063 {
1064     return set_int(exc, "start", start);
1065 }
1066
1067
1068 int PyUnicodeTranslateError_SetStart(PyObject *exc, int start)
1069 {
1070     return set_int(exc, "start", start);
1071 }
1072
1073
1074 int PyUnicodeEncodeError_GetEnd(PyObject *exc, int *end)
1075 {
1076     if (!get_int(exc, "end", end)) {
1077         PyObject *object = PyUnicodeEncodeError_GetObject(exc);
1078         int size;
1079         if (!object)
1080             return -1;
1081         size = PyUnicode_GET_SIZE(object);
1082         if (*end<1)
1083             *end = 1;
1084         if (*end>size)
1085             *end = size;
1086         Py_DECREF(object);
1087         return 0;
1088     }
1089     return -1;
1090 }
1091
1092
1093 int PyUnicodeDecodeError_GetEnd(PyObject *exc, int *end)
1094 {
1095     if (!get_int(exc, "end", end)) {
1096         PyObject *object = PyUnicodeDecodeError_GetObject(exc);
1097         int size;
1098         if (!object)
1099             return -1;
1100         size = PyString_GET_SIZE(object);
1101         if (*end<1)
1102             *end = 1;
1103         if (*end>size)
1104             *end = size;
1105         Py_DECREF(object);
1106         return 0;
1107     }
1108     return -1;
1109 }
1110
1111
1112 int PyUnicodeTranslateError_GetEnd(PyObject *exc, int *start)
1113 {
1114     return PyUnicodeEncodeError_GetEnd(exc, start);
1115 }
1116
1117
1118 int PyUnicodeEncodeError_SetEnd(PyObject *exc, int end)
1119 {
1120     return set_int(exc, "end", end);
1121 }
1122
1123
1124 int PyUnicodeDecodeError_SetEnd(PyObject *exc, int end)
1125 {
1126     return set_int(exc, "end", end);
1127 }
1128
1129
1130 int PyUnicodeTranslateError_SetEnd(PyObject *exc, int end)
1131 {
1132     return set_int(exc, "end", end);
1133 }
1134
1135
1136 PyObject *PyUnicodeEncodeError_GetReason(PyObject *exc)
1137 {
1138     return get_string(exc, "reason");
1139 }
1140
1141
1142 PyObject *PyUnicodeDecodeError_GetReason(PyObject *exc)
1143 {
1144     return get_string(exc, "reason");
1145 }
1146
1147
1148 PyObject *PyUnicodeTranslateError_GetReason(PyObject *exc)
1149 {
1150     return get_string(exc, "reason");
1151 }
1152
1153
1154 int PyUnicodeEncodeError_SetReason(PyObject *exc, const char *reason)
1155 {
1156     return set_string(exc, "reason", reason);
1157 }
1158
1159
1160 int PyUnicodeDecodeError_SetReason(PyObject *exc, const char *reason)
1161 {
1162     return set_string(exc, "reason", reason);
1163 }
1164
1165
1166 int PyUnicodeTranslateError_SetReason(PyObject *exc, const char *reason)
1167 {
1168     return set_string(exc, "reason", reason);
1169 }
1170
1171
1172 static PyObject *
1173 UnicodeError__init__(PyObject *self, PyObject *args, PyTypeObject *objecttype)
1174 {
1175     PyObject *rtnval = NULL;
1176     PyObject *encoding;
1177     PyObject *object;
1178     PyObject *start;
1179     PyObject *end;
1180     PyObject *reason;
1181
1182     if (!(self = get_self(args)))
1183         return NULL;
1184
1185     if (!(args = PySequence_GetSlice(args, 1, PySequence_Size(args))))
1186         return NULL;
1187
1188     if (!PyArg_ParseTuple(args, "O!O!O!O!O!",
1189         &PyString_Type, &encoding,
1190         objecttype, &object,
1191         &PyInt_Type, &start,
1192         &PyInt_Type, &end,
1193         &PyString_Type, &reason))
1194         goto finally;
1195
1196     if (PyObject_SetAttrString(self, "args", args))
1197         goto finally;
1198
1199     if (PyObject_SetAttrString(self, "encoding", encoding))
1200         goto finally;
1201     if (PyObject_SetAttrString(self, "object", object))
1202         goto finally;
1203     if (PyObject_SetAttrString(self, "start", start))
1204         goto finally;
1205     if (PyObject_SetAttrString(self, "end", end))
1206         goto finally;
1207     if (PyObject_SetAttrString(self, "reason", reason))
1208         goto finally;
1209
1210     Py_INCREF(Py_None);
1211     rtnval = Py_None;
1212
1213   finally:
1214     Py_DECREF(args);
1215     return rtnval;
1216 }
1217
1218
1219 static PyObject *
1220 UnicodeEncodeError__init__(PyObject *self, PyObject *args)
1221 {
1222     return UnicodeError__init__(self, args, &PyUnicode_Type);
1223 }
1224
1225 static PyObject *
1226 UnicodeEncodeError__str__(PyObject *self, PyObject *arg)
1227 {
1228     PyObject *encodingObj = NULL;
1229     PyObject *objectObj = NULL;
1230     int start;
1231     int end;
1232     PyObject *reasonObj = NULL;
1233     char buffer[1000];
1234     PyObject *result = NULL;
1235
1236     self = arg;
1237
1238     if (!(encodingObj = PyUnicodeEncodeError_GetEncoding(self)))
1239         goto error;
1240
1241     if (!(objectObj = PyUnicodeEncodeError_GetObject(self)))
1242         goto error;
1243
1244     if (PyUnicodeEncodeError_GetStart(self, &start))
1245         goto error;
1246
1247     if (PyUnicodeEncodeError_GetEnd(self, &end))
1248         goto error;
1249
1250     if (!(reasonObj = PyUnicodeEncodeError_GetReason(self)))
1251         goto error;
1252
1253     if (end==start+1) {
1254         int badchar = (int)PyUnicode_AS_UNICODE(objectObj)[start];
1255         char *format;
1256         if (badchar <= 0xff)
1257            format = "'%.400s' codec can't encode character u'\\x%02x' in position %d: %.400s";
1258         else if (badchar <= 0xffff)
1259            format = "'%.400s' codec can't encode character u'\\u%04x' in position %d: %.400s";
1260         else
1261            format = "'%.400s' codec can't encode character u'\\U%08x' in position %d: %.400s";
1262         PyOS_snprintf(buffer, sizeof(buffer),
1263             format,
1264             PyString_AS_STRING(encodingObj),
1265             badchar,
1266             start,
1267             PyString_AS_STRING(reasonObj)
1268         );
1269     }
1270     else {
1271         PyOS_snprintf(buffer, sizeof(buffer),
1272             "'%.400s' codec can't encode characters in position %d-%d: %.400s",
1273             PyString_AS_STRING(encodingObj),
1274             start,
1275             end-1,
1276             PyString_AS_STRING(reasonObj)
1277         );
1278     }
1279     result = PyString_FromString(buffer);
1280
1281 error:
1282     Py_XDECREF(reasonObj);
1283     Py_XDECREF(objectObj);
1284     Py_XDECREF(encodingObj);
1285     return result;
1286 }
1287
1288 static PyMethodDef UnicodeEncodeError_methods[] = {
1289     {"__init__", UnicodeEncodeError__init__, METH_VARARGS},
1290     {"__str__",  UnicodeEncodeError__str__, METH_O},
1291     {NULL, NULL}
1292 };
1293
1294
1295 PyObject * PyUnicodeEncodeError_Create(
1296         const char *encoding, const Py_UNICODE *object, int length,
1297         int start, int end, const char *reason)
1298 {
1299     return PyObject_CallFunction(PyExc_UnicodeEncodeError, "su#iis",
1300         encoding, object, length, start, end, reason);
1301 }
1302
1303
1304 static PyObject *
1305 UnicodeDecodeError__init__(PyObject *self, PyObject *args)
1306 {
1307     return UnicodeError__init__(self, args, &PyString_Type);
1308 }
1309
1310 static PyObject *
1311 UnicodeDecodeError__str__(PyObject *self, PyObject *arg)
1312 {
1313     PyObject *encodingObj = NULL;
1314     PyObject *objectObj = NULL;
1315     int start;
1316     int end;
1317     PyObject *reasonObj = NULL;
1318     char buffer[1000];
1319     PyObject *result = NULL;
1320
1321     self = arg;
1322
1323     if (!(encodingObj = PyUnicodeDecodeError_GetEncoding(self)))
1324         goto error;
1325
1326     if (!(objectObj = PyUnicodeDecodeError_GetObject(self)))
1327         goto error;
1328
1329     if (PyUnicodeDecodeError_GetStart(self, &start))
1330         goto error;
1331
1332     if (PyUnicodeDecodeError_GetEnd(self, &end))
1333         goto error;
1334
1335     if (!(reasonObj = PyUnicodeDecodeError_GetReason(self)))
1336         goto error;
1337
1338     if (end==start+1) {
1339         PyOS_snprintf(buffer, sizeof(buffer),
1340             "'%.400s' codec can't decode byte 0x%02x in position %d: %.400s",
1341             PyString_AS_STRING(encodingObj),
1342             ((int)PyString_AS_STRING(objectObj)[start])&0xff,
1343             start,
1344             PyString_AS_STRING(reasonObj)
1345         );
1346     }
1347     else {
1348         PyOS_snprintf(buffer, sizeof(buffer),
1349             "'%.400s' codec can't decode bytes in position %d-%d: %.400s",
1350             PyString_AS_STRING(encodingObj),
1351             start,
1352             end-1,
1353             PyString_AS_STRING(reasonObj)
1354         );
1355     }
1356     result = PyString_FromString(buffer);
1357
1358 error:
1359     Py_XDECREF(reasonObj);
1360     Py_XDECREF(objectObj);
1361     Py_XDECREF(encodingObj);
1362     return result;
1363 }
1364
1365 static PyMethodDef UnicodeDecodeError_methods[] = {
1366     {"__init__", UnicodeDecodeError__init__, METH_VARARGS},
1367     {"__str__",  UnicodeDecodeError__str__, METH_O},
1368     {NULL, NULL}
1369 };
1370
1371
1372 PyObject * PyUnicodeDecodeError_Create(
1373         const char *encoding, const char *object, int length,
1374         int start, int end, const char *reason)
1375 {
1376     return PyObject_CallFunction(PyExc_UnicodeDecodeError, "ss#iis",
1377         encoding, object, length, start, end, reason);
1378 }
1379
1380
1381 static PyObject *
1382 UnicodeTranslateError__init__(PyObject *self, PyObject *args)
1383 {
1384     PyObject *rtnval = NULL;
1385     PyObject *object;
1386     PyObject *start;
1387     PyObject *end;
1388     PyObject *reason;
1389
1390     if (!(self = get_self(args)))
1391         return NULL;
1392
1393     if (!(args = PySequence_GetSlice(args, 1, PySequence_Size(args))))
1394         return NULL;
1395
1396     if (!PyArg_ParseTuple(args, "O!O!O!O!",
1397         &PyUnicode_Type, &object,
1398         &PyInt_Type, &start,
1399         &PyInt_Type, &end,
1400         &PyString_Type, &reason))
1401         goto finally;
1402
1403     if (PyObject_SetAttrString(self, "args", args))
1404         goto finally;
1405
1406     if (PyObject_SetAttrString(self, "object", object))
1407         goto finally;
1408     if (PyObject_SetAttrString(self, "start", start))
1409         goto finally;
1410     if (PyObject_SetAttrString(self, "end", end))
1411         goto finally;
1412     if (PyObject_SetAttrString(self, "reason", reason))
1413         goto finally;
1414
1415     Py_INCREF(Py_None);
1416     rtnval = Py_None;
1417
1418   finally:
1419     Py_DECREF(args);
1420     return rtnval;
1421 }
1422
1423
1424 static PyObject *
1425 UnicodeTranslateError__str__(PyObject *self, PyObject *arg)
1426 {
1427     PyObject *objectObj = NULL;
1428     int start;
1429     int end;
1430     PyObject *reasonObj = NULL;
1431     char buffer[1000];
1432     PyObject *result = NULL;
1433
1434     self = arg;
1435
1436     if (!(objectObj = PyUnicodeTranslateError_GetObject(self)))
1437         goto error;
1438
1439     if (PyUnicodeTranslateError_GetStart(self, &start))
1440         goto error;
1441
1442     if (PyUnicodeTranslateError_GetEnd(self, &end))
1443         goto error;
1444
1445     if (!(reasonObj = PyUnicodeTranslateError_GetReason(self)))
1446         goto error;
1447
1448     if (end==start+1) {
1449         int badchar = (int)PyUnicode_AS_UNICODE(objectObj)[start];
1450         char *format;
1451         if (badchar <= 0xff)
1452            format = "can't translate character u'\\x%02x' in position %d: %.400s";
1453         else if (badchar <= 0xffff)
1454            format = "can't translate character u'\\u%04x' in position %d: %.400s";
1455         else
1456            format = "can't translate character u'\\U%08x' in position %d: %.400s";
1457         PyOS_snprintf(buffer, sizeof(buffer),
1458             format,
1459             badchar,
1460             start,
1461             PyString_AS_STRING(reasonObj)
1462         );
1463     }
1464     else {
1465         PyOS_snprintf(buffer, sizeof(buffer),
1466             "can't translate characters in position %d-%d: %.400s",
1467             start,
1468             end-1,
1469             PyString_AS_STRING(reasonObj)
1470         );
1471     }
1472     result = PyString_FromString(buffer);
1473
1474 error:
1475     Py_XDECREF(reasonObj);
1476     Py_XDECREF(objectObj);
1477     return result;
1478 }
1479
1480 static PyMethodDef UnicodeTranslateError_methods[] = {
1481     {"__init__", UnicodeTranslateError__init__, METH_VARARGS},
1482     {"__str__",  UnicodeTranslateError__str__, METH_O},
1483     {NULL, NULL}
1484 };
1485
1486
1487 PyObject * PyUnicodeTranslateError_Create(
1488         const Py_UNICODE *object, int length,
1489         int start, int end, const char *reason)
1490 {
1491     return PyObject_CallFunction(PyExc_UnicodeTranslateError, "u#iis",
1492         object, length, start, end, reason);
1493 }
1494 #endif
1495
1496
1497 \f
1498 /* Exception doc strings */
1499
1500 PyDoc_STRVAR(AssertionError__doc__, "Assertion failed.");
1501
1502 PyDoc_STRVAR(LookupError__doc__, "Base class for lookup errors.");
1503
1504 PyDoc_STRVAR(IndexError__doc__, "Sequence index out of range.");
1505
1506 PyDoc_STRVAR(KeyError__doc__, "Mapping key not found.");
1507
1508 PyDoc_STRVAR(ArithmeticError__doc__, "Base class for arithmetic errors.");
1509
1510 PyDoc_STRVAR(OverflowError__doc__, "Result too large to be represented.");
1511
1512 PyDoc_STRVAR(ZeroDivisionError__doc__,
1513 "Second argument to a division or modulo operation was zero.");
1514
1515 PyDoc_STRVAR(FloatingPointError__doc__, "Floating point operation failed.");
1516
1517 PyDoc_STRVAR(ValueError__doc__,
1518 "Inappropriate argument value (of correct type).");
1519
1520 PyDoc_STRVAR(UnicodeError__doc__, "Unicode related error.");
1521
1522 #ifdef Py_USING_UNICODE
1523 PyDoc_STRVAR(UnicodeEncodeError__doc__, "Unicode encoding error.");
1524
1525 PyDoc_STRVAR(UnicodeDecodeError__doc__, "Unicode decoding error.");
1526
1527 PyDoc_STRVAR(UnicodeTranslateError__doc__, "Unicode translation error.");
1528 #endif
1529
1530 PyDoc_STRVAR(SystemError__doc__,
1531 "Internal error in the Python interpreter.\n\
1532 \n\
1533 Please report this to the Python maintainer, along with the traceback,\n\
1534 the Python version, and the hardware/OS platform and version.");
1535
1536 PyDoc_STRVAR(ReferenceError__doc__,
1537 "Weak ref proxy used after referent went away.");
1538
1539 PyDoc_STRVAR(MemoryError__doc__, "Out of memory.");
1540
1541 PyDoc_STRVAR(IndentationError__doc__, "Improper indentation.");
1542
1543 PyDoc_STRVAR(TabError__doc__, "Improper mixture of spaces and tabs.");
1544
1545 /* Warning category docstrings */
1546
1547 PyDoc_STRVAR(Warning__doc__, "Base class for warning categories.");
1548
1549 PyDoc_STRVAR(UserWarning__doc__,
1550 "Base class for warnings generated by user code.");
1551
1552 PyDoc_STRVAR(DeprecationWarning__doc__,
1553 "Base class for warnings about deprecated features.");
1554
1555 PyDoc_STRVAR(PendingDeprecationWarning__doc__,
1556 "Base class for warnings about features which will be deprecated "
1557 "in the future.");
1558
1559 PyDoc_STRVAR(SyntaxWarning__doc__,
1560 "Base class for warnings about dubious syntax.");
1561
1562 PyDoc_STRVAR(OverflowWarning__doc__,
1563 "Base class for warnings about numeric overflow.");
1564
1565 PyDoc_STRVAR(RuntimeWarning__doc__,
1566 "Base class for warnings about dubious runtime behavior.");
1567
1568 PyDoc_STRVAR(FutureWarning__doc__,
1569 "Base class for warnings about constructs that will change semantically "
1570 "in the future.");
1571
1572
1573 \f
1574 /* module global functions */
1575 static PyMethodDef functions[] = {
1576     /* Sentinel */
1577     {NULL, NULL}
1578 };
1579
1580
1581 \f
1582 /* Global C API defined exceptions */
1583
1584 PyObject *PyExc_Exception;
1585 PyObject *PyExc_StopIteration;
1586 PyObject *PyExc_StandardError;
1587 PyObject *PyExc_ArithmeticError;
1588 PyObject *PyExc_LookupError;
1589
1590 PyObject *PyExc_AssertionError;
1591 PyObject *PyExc_AttributeError;
1592 PyObject *PyExc_EOFError;
1593 PyObject *PyExc_FloatingPointError;
1594 PyObject *PyExc_EnvironmentError;
1595 PyObject *PyExc_IOError;
1596 PyObject *PyExc_OSError;
1597 PyObject *PyExc_ImportError;
1598 PyObject *PyExc_IndexError;
1599 PyObject *PyExc_KeyError;
1600 PyObject *PyExc_KeyboardInterrupt;
1601 PyObject *PyExc_MemoryError;
1602 PyObject *PyExc_NameError;
1603 PyObject *PyExc_OverflowError;
1604 PyObject *PyExc_RuntimeError;
1605 PyObject *PyExc_NotImplementedError;
1606 PyObject *PyExc_SyntaxError;
1607 PyObject *PyExc_IndentationError;
1608 PyObject *PyExc_TabError;
1609 PyObject *PyExc_ReferenceError;
1610 PyObject *PyExc_SystemError;
1611 PyObject *PyExc_SystemExit;
1612 PyObject *PyExc_UnboundLocalError;
1613 PyObject *PyExc_UnicodeError;
1614 PyObject *PyExc_UnicodeEncodeError;
1615 PyObject *PyExc_UnicodeDecodeError;
1616 PyObject *PyExc_UnicodeTranslateError;
1617 PyObject *PyExc_TypeError;
1618 PyObject *PyExc_ValueError;
1619 PyObject *PyExc_ZeroDivisionError;
1620 #ifdef MS_WINDOWS
1621 PyObject *PyExc_WindowsError;
1622 #endif
1623 #ifdef __VMS
1624 PyObject *PyExc_VMSError;
1625 #endif
1626
1627 /* Pre-computed MemoryError instance.  Best to create this as early as
1628  * possibly and not wait until a MemoryError is actually raised!
1629  */
1630 PyObject *PyExc_MemoryErrorInst;
1631
1632 /* Predefined warning categories */
1633 PyObject *PyExc_Warning;
1634 PyObject *PyExc_UserWarning;
1635 PyObject *PyExc_DeprecationWarning;
1636 PyObject *PyExc_PendingDeprecationWarning;
1637 PyObject *PyExc_SyntaxWarning;
1638 PyObject *PyExc_OverflowWarning;
1639 PyObject *PyExc_RuntimeWarning;
1640 PyObject *PyExc_FutureWarning;
1641
1642
1643 \f
1644 /* mapping between exception names and their PyObject ** */
1645 static struct {
1646     char *name;
1647     PyObject **exc;
1648     PyObject **base;                         /* NULL == PyExc_StandardError */
1649     char *docstr;
1650     PyMethodDef *methods;
1651     int (*classinit)(PyObject *);
1652 } exctable[] = {
1653  /*
1654   * The first three classes MUST appear in exactly this order
1655   */
1656  {"Exception", &PyExc_Exception},
1657  {"StopIteration", &PyExc_StopIteration, &PyExc_Exception,
1658   StopIteration__doc__},
1659  {"StandardError", &PyExc_StandardError, &PyExc_Exception,
1660   StandardError__doc__},
1661  {"TypeError", &PyExc_TypeError, 0, TypeError__doc__},
1662  /*
1663   * The rest appear in depth-first order of the hierarchy
1664   */
1665  {"SystemExit", &PyExc_SystemExit, &PyExc_Exception, SystemExit__doc__,
1666   SystemExit_methods},
1667  {"KeyboardInterrupt",  &PyExc_KeyboardInterrupt, 0, KeyboardInterrupt__doc__},
1668  {"ImportError",        &PyExc_ImportError,       0, ImportError__doc__},
1669  {"EnvironmentError",   &PyExc_EnvironmentError,  0, EnvironmentError__doc__,
1670   EnvironmentError_methods},
1671  {"IOError", &PyExc_IOError, &PyExc_EnvironmentError, IOError__doc__},
1672  {"OSError", &PyExc_OSError, &PyExc_EnvironmentError, OSError__doc__},
1673 #ifdef MS_WINDOWS
1674  {"WindowsError", &PyExc_WindowsError, &PyExc_OSError,
1675   WindowsError__doc__},
1676 #endif /* MS_WINDOWS */
1677 #ifdef __VMS
1678  {"VMSError", &PyExc_VMSError, &PyExc_OSError,
1679   VMSError__doc__},
1680 #endif
1681  {"EOFError",     &PyExc_EOFError,     0, EOFError__doc__},
1682  {"RuntimeError", &PyExc_RuntimeError, 0, RuntimeError__doc__},
1683  {"NotImplementedError", &PyExc_NotImplementedError,
1684   &PyExc_RuntimeError, NotImplementedError__doc__},
1685  {"NameError",    &PyExc_NameError,    0, NameError__doc__},
1686  {"UnboundLocalError", &PyExc_UnboundLocalError, &PyExc_NameError,
1687   UnboundLocalError__doc__},
1688  {"AttributeError",     &PyExc_AttributeError, 0, AttributeError__doc__},
1689  {"SyntaxError",        &PyExc_SyntaxError,    0, SyntaxError__doc__,
1690   SyntaxError_methods, SyntaxError__classinit__},
1691  {"IndentationError",   &PyExc_IndentationError, &PyExc_SyntaxError,
1692   IndentationError__doc__},
1693  {"TabError",   &PyExc_TabError, &PyExc_IndentationError,
1694   TabError__doc__},
1695  {"AssertionError",     &PyExc_AssertionError, 0, AssertionError__doc__},
1696  {"LookupError",        &PyExc_LookupError,    0, LookupError__doc__},
1697  {"IndexError",         &PyExc_IndexError,     &PyExc_LookupError,
1698   IndexError__doc__},
1699  {"KeyError",           &PyExc_KeyError,       &PyExc_LookupError,
1700   KeyError__doc__, KeyError_methods},
1701  {"ArithmeticError",    &PyExc_ArithmeticError, 0, ArithmeticError__doc__},
1702  {"OverflowError",      &PyExc_OverflowError,     &PyExc_ArithmeticError,
1703   OverflowError__doc__},
1704  {"ZeroDivisionError",  &PyExc_ZeroDivisionError,  &PyExc_ArithmeticError,
1705   ZeroDivisionError__doc__},
1706  {"FloatingPointError", &PyExc_FloatingPointError, &PyExc_ArithmeticError,
1707   FloatingPointError__doc__},
1708  {"ValueError",   &PyExc_ValueError,  0, ValueError__doc__},
1709  {"UnicodeError", &PyExc_UnicodeError, &PyExc_ValueError, UnicodeError__doc__},
1710 #ifdef Py_USING_UNICODE
1711  {"UnicodeEncodeError", &PyExc_UnicodeEncodeError, &PyExc_UnicodeError,
1712   UnicodeEncodeError__doc__, UnicodeEncodeError_methods},
1713  {"UnicodeDecodeError", &PyExc_UnicodeDecodeError, &PyExc_UnicodeError,
1714   UnicodeDecodeError__doc__, UnicodeDecodeError_methods},
1715  {"UnicodeTranslateError", &PyExc_UnicodeTranslateError, &PyExc_UnicodeError,
1716   UnicodeTranslateError__doc__, UnicodeTranslateError_methods},
1717 #endif
1718  {"ReferenceError",  &PyExc_ReferenceError, 0, ReferenceError__doc__},
1719  {"SystemError",  &PyExc_SystemError, 0, SystemError__doc__},
1720  {"MemoryError",  &PyExc_MemoryError, 0, MemoryError__doc__},
1721  /* Warning categories */
1722  {"Warning", &PyExc_Warning, &PyExc_Exception, Warning__doc__},
1723  {"UserWarning", &PyExc_UserWarning, &PyExc_Warning, UserWarning__doc__},
1724  {"DeprecationWarning", &PyExc_DeprecationWarning, &PyExc_Warning,
1725   DeprecationWarning__doc__},
1726  {"PendingDeprecationWarning", &PyExc_PendingDeprecationWarning, &PyExc_Warning,
1727   PendingDeprecationWarning__doc__},
1728  {"SyntaxWarning", &PyExc_SyntaxWarning, &PyExc_Warning, SyntaxWarning__doc__},
1729  {"OverflowWarning", &PyExc_OverflowWarning, &PyExc_Warning,
1730   OverflowWarning__doc__},
1731  {"RuntimeWarning", &PyExc_RuntimeWarning, &PyExc_Warning,
1732   RuntimeWarning__doc__},
1733  {"FutureWarning", &PyExc_FutureWarning, &PyExc_Warning,
1734   FutureWarning__doc__},
1735  /* Sentinel */
1736  {NULL}
1737 };
1738
1739 \f
1740
1741 void
1742 _PyExc_Init(void)
1743 {
1744     char *modulename = "exceptions";
1745     int modnamesz = strlen(modulename);
1746     int i;
1747     PyObject *me, *mydict, *bltinmod, *bdict, *doc, *args;
1748
1749     me = Py_InitModule(modulename, functions);
1750     if (me == NULL)
1751         goto err;
1752     mydict = PyModule_GetDict(me);
1753     if (mydict == NULL)
1754         goto err;
1755     bltinmod = PyImport_ImportModule("__builtin__");
1756     if (bltinmod == NULL)
1757         goto err;
1758     bdict = PyModule_GetDict(bltinmod);
1759     if (bdict == NULL)
1760         goto err;
1761     doc = PyString_FromString(module__doc__);
1762     if (doc == NULL)
1763         goto err;
1764
1765     i = PyDict_SetItemString(mydict, "__doc__", doc);
1766     Py_DECREF(doc);
1767     if (i < 0) {
1768  err:
1769         Py_FatalError("exceptions bootstrapping error.");
1770         return;
1771     }
1772
1773     /* This is the base class of all exceptions, so make it first. */
1774     if (make_Exception(modulename) ||
1775         PyDict_SetItemString(mydict, "Exception", PyExc_Exception) ||
1776         PyDict_SetItemString(bdict, "Exception", PyExc_Exception))
1777     {
1778         Py_FatalError("Base class `Exception' could not be created.");
1779     }
1780
1781     /* Now we can programmatically create all the remaining exceptions.
1782      * Remember to start the loop at 1 to skip Exceptions.
1783      */
1784     for (i=1; exctable[i].name; i++) {
1785         int status;
1786         char *cname = PyMem_NEW(char, modnamesz+strlen(exctable[i].name)+2);
1787         PyObject *base;
1788
1789         (void)strcpy(cname, modulename);
1790         (void)strcat(cname, ".");
1791         (void)strcat(cname, exctable[i].name);
1792
1793         if (exctable[i].base == 0)
1794             base = PyExc_StandardError;
1795         else
1796             base = *exctable[i].base;
1797
1798         status = make_class(exctable[i].exc, base, cname,
1799                             exctable[i].methods,
1800                             exctable[i].docstr);
1801
1802         PyMem_DEL(cname);
1803
1804         if (status)
1805             Py_FatalError("Standard exception classes could not be created.");
1806
1807         if (exctable[i].classinit) {
1808             status = (*exctable[i].classinit)(*exctable[i].exc);
1809             if (status)
1810                 Py_FatalError("An exception class could not be initialized.");
1811         }
1812
1813         /* Now insert the class into both this module and the __builtin__
1814          * module.
1815          */
1816         if (PyDict_SetItemString(mydict, exctable[i].name, *exctable[i].exc) ||
1817             PyDict_SetItemString(bdict, exctable[i].name, *exctable[i].exc))
1818         {
1819             Py_FatalError("Module dictionary insertion problem.");
1820         }
1821     }
1822
1823     /* Now we need to pre-allocate a MemoryError instance */
1824     args = Py_BuildValue("()");
1825     if (!args ||
1826         !(PyExc_MemoryErrorInst = PyEval_CallObject(PyExc_MemoryError, args)))
1827     {
1828         Py_FatalError("Cannot pre-allocate MemoryError instance\n");
1829     }
1830     Py_DECREF(args);
1831
1832     /* We're done with __builtin__ */
1833     Py_DECREF(bltinmod);
1834 }
1835
1836
1837 void
1838 _PyExc_Fini(void)
1839 {
1840     int i;
1841
1842     Py_XDECREF(PyExc_MemoryErrorInst);
1843     PyExc_MemoryErrorInst = NULL;
1844
1845     for (i=0; exctable[i].name; i++) {
1846         /* clear the class's dictionary, freeing up circular references
1847          * between the class and its methods.
1848          */
1849         PyObject* cdict = PyObject_GetAttrString(*exctable[i].exc, "__dict__");
1850         PyDict_Clear(cdict);
1851         Py_DECREF(cdict);
1852
1853         /* Now decref the exception class */
1854         Py_XDECREF(*exctable[i].exc);
1855         *exctable[i].exc = NULL;
1856     }
1857 }