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         return NULL;
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         PyOS_snprintf(buffer, sizeof(buffer),
1255             "'%.400s' codec can't encode character '\\u%x' in position %d: %.400s",
1256             PyString_AS_STRING(encodingObj),
1257             (int)PyUnicode_AS_UNICODE(objectObj)[start],
1258             start,
1259             PyString_AS_STRING(reasonObj)
1260         );
1261     }
1262     else {
1263         PyOS_snprintf(buffer, sizeof(buffer),
1264             "'%.400s' codec can't encode characters in position %d-%d: %.400s",
1265             PyString_AS_STRING(encodingObj),
1266             start,
1267             end-1,
1268             PyString_AS_STRING(reasonObj)
1269         );
1270     }
1271     result = PyString_FromString(buffer);
1272
1273 error:
1274     Py_XDECREF(reasonObj);
1275     Py_XDECREF(objectObj);
1276     Py_XDECREF(encodingObj);
1277     return result;
1278 }
1279
1280 static PyMethodDef UnicodeEncodeError_methods[] = {
1281     {"__init__", UnicodeEncodeError__init__, METH_VARARGS},
1282     {"__str__",  UnicodeEncodeError__str__, METH_O},
1283     {NULL, NULL}
1284 };
1285
1286
1287 PyObject * PyUnicodeEncodeError_Create(
1288         const char *encoding, const Py_UNICODE *object, int length,
1289         int start, int end, const char *reason)
1290 {
1291     return PyObject_CallFunction(PyExc_UnicodeEncodeError, "su#iis",
1292         encoding, object, length, start, end, reason);
1293 }
1294
1295
1296 static PyObject *
1297 UnicodeDecodeError__init__(PyObject *self, PyObject *args)
1298 {
1299     return UnicodeError__init__(self, args, &PyString_Type);
1300 }
1301
1302 static PyObject *
1303 UnicodeDecodeError__str__(PyObject *self, PyObject *arg)
1304 {
1305     PyObject *encodingObj = NULL;
1306     PyObject *objectObj = NULL;
1307     int start;
1308     int end;
1309     PyObject *reasonObj = NULL;
1310     char buffer[1000];
1311     PyObject *result = NULL;
1312
1313     self = arg;
1314
1315     if (!(encodingObj = PyUnicodeDecodeError_GetEncoding(self)))
1316         goto error;
1317
1318     if (!(objectObj = PyUnicodeDecodeError_GetObject(self)))
1319         goto error;
1320
1321     if (PyUnicodeDecodeError_GetStart(self, &start))
1322         goto error;
1323
1324     if (PyUnicodeDecodeError_GetEnd(self, &end))
1325         goto error;
1326
1327     if (!(reasonObj = PyUnicodeDecodeError_GetReason(self)))
1328         goto error;
1329
1330     if (end==start+1) {
1331         PyOS_snprintf(buffer, sizeof(buffer),
1332             "'%.400s' codec can't decode byte 0x%x in position %d: %.400s",
1333             PyString_AS_STRING(encodingObj),
1334             ((int)PyString_AS_STRING(objectObj)[start])&0xff,
1335             start,
1336             PyString_AS_STRING(reasonObj)
1337         );
1338     }
1339     else {
1340         PyOS_snprintf(buffer, sizeof(buffer),
1341             "'%.400s' codec can't decode bytes in position %d-%d: %.400s",
1342             PyString_AS_STRING(encodingObj),
1343             start,
1344             end-1,
1345             PyString_AS_STRING(reasonObj)
1346         );
1347     }
1348     result = PyString_FromString(buffer);
1349
1350 error:
1351     Py_XDECREF(reasonObj);
1352     Py_XDECREF(objectObj);
1353     Py_XDECREF(encodingObj);
1354     return result;
1355 }
1356
1357 static PyMethodDef UnicodeDecodeError_methods[] = {
1358     {"__init__", UnicodeDecodeError__init__, METH_VARARGS},
1359     {"__str__",  UnicodeDecodeError__str__, METH_O},
1360     {NULL, NULL}
1361 };
1362
1363
1364 PyObject * PyUnicodeDecodeError_Create(
1365         const char *encoding, const char *object, int length,
1366         int start, int end, const char *reason)
1367 {
1368     return PyObject_CallFunction(PyExc_UnicodeDecodeError, "ss#iis",
1369         encoding, object, length, start, end, reason);
1370 }
1371
1372
1373 static PyObject *
1374 UnicodeTranslateError__init__(PyObject *self, PyObject *args)
1375 {
1376     PyObject *rtnval = NULL;
1377     PyObject *object;
1378     PyObject *start;
1379     PyObject *end;
1380     PyObject *reason;
1381
1382     if (!(self = get_self(args)))
1383         return NULL;
1384
1385     if (!(args = PySequence_GetSlice(args, 1, PySequence_Size(args))))
1386         return NULL;
1387
1388     if (!PyArg_ParseTuple(args, "O!O!O!O!",
1389         &PyUnicode_Type, &object,
1390         &PyInt_Type, &start,
1391         &PyInt_Type, &end,
1392         &PyString_Type, &reason))
1393         goto finally;
1394
1395     if (PyObject_SetAttrString(self, "args", args))
1396         goto finally;
1397
1398     if (PyObject_SetAttrString(self, "object", object))
1399         goto finally;
1400     if (PyObject_SetAttrString(self, "start", start))
1401         goto finally;
1402     if (PyObject_SetAttrString(self, "end", end))
1403         goto finally;
1404     if (PyObject_SetAttrString(self, "reason", reason))
1405         goto finally;
1406
1407     Py_INCREF(Py_None);
1408     rtnval = Py_None;
1409
1410   finally:
1411     Py_DECREF(args);
1412     return rtnval;
1413 }
1414
1415
1416 static PyObject *
1417 UnicodeTranslateError__str__(PyObject *self, PyObject *arg)
1418 {
1419     PyObject *objectObj = NULL;
1420     int start;
1421     int end;
1422     PyObject *reasonObj = NULL;
1423     char buffer[1000];
1424     PyObject *result = NULL;
1425
1426     self = arg;
1427
1428     if (!(objectObj = PyUnicodeTranslateError_GetObject(self)))
1429         goto error;
1430
1431     if (PyUnicodeTranslateError_GetStart(self, &start))
1432         goto error;
1433
1434     if (PyUnicodeTranslateError_GetEnd(self, &end))
1435         goto error;
1436
1437     if (!(reasonObj = PyUnicodeTranslateError_GetReason(self)))
1438         goto error;
1439
1440     if (end==start+1) {
1441         PyOS_snprintf(buffer, sizeof(buffer),
1442             "can't translate character '\\u%x' in position %d: %.400s",
1443             (int)PyUnicode_AS_UNICODE(objectObj)[start],
1444             start,
1445             PyString_AS_STRING(reasonObj)
1446         );
1447     }
1448     else {
1449         PyOS_snprintf(buffer, sizeof(buffer),
1450             "can't translate characters in position %d-%d: %.400s",
1451             start,
1452             end-1,
1453             PyString_AS_STRING(reasonObj)
1454         );
1455     }
1456     result = PyString_FromString(buffer);
1457
1458 error:
1459     Py_XDECREF(reasonObj);
1460     Py_XDECREF(objectObj);
1461     return result;
1462 }
1463
1464 static PyMethodDef UnicodeTranslateError_methods[] = {
1465     {"__init__", UnicodeTranslateError__init__, METH_VARARGS},
1466     {"__str__",  UnicodeTranslateError__str__, METH_O},
1467     {NULL, NULL}
1468 };
1469
1470
1471 PyObject * PyUnicodeTranslateError_Create(
1472         const Py_UNICODE *object, int length,
1473         int start, int end, const char *reason)
1474 {
1475     return PyObject_CallFunction(PyExc_UnicodeTranslateError, "u#iis",
1476         object, length, start, end, reason);
1477 }
1478 #endif
1479
1480
1481 \f
1482 /* Exception doc strings */
1483
1484 PyDoc_STRVAR(AssertionError__doc__, "Assertion failed.");
1485
1486 PyDoc_STRVAR(LookupError__doc__, "Base class for lookup errors.");
1487
1488 PyDoc_STRVAR(IndexError__doc__, "Sequence index out of range.");
1489
1490 PyDoc_STRVAR(KeyError__doc__, "Mapping key not found.");
1491
1492 PyDoc_STRVAR(ArithmeticError__doc__, "Base class for arithmetic errors.");
1493
1494 PyDoc_STRVAR(OverflowError__doc__, "Result too large to be represented.");
1495
1496 PyDoc_STRVAR(ZeroDivisionError__doc__,
1497 "Second argument to a division or modulo operation was zero.");
1498
1499 PyDoc_STRVAR(FloatingPointError__doc__, "Floating point operation failed.");
1500
1501 PyDoc_STRVAR(ValueError__doc__,
1502 "Inappropriate argument value (of correct type).");
1503
1504 PyDoc_STRVAR(UnicodeError__doc__, "Unicode related error.");
1505
1506 #ifdef Py_USING_UNICODE
1507 PyDoc_STRVAR(UnicodeEncodeError__doc__, "Unicode encoding error.");
1508
1509 PyDoc_STRVAR(UnicodeDecodeError__doc__, "Unicode decoding error.");
1510
1511 PyDoc_STRVAR(UnicodeTranslateError__doc__, "Unicode translation error.");
1512 #endif
1513
1514 PyDoc_STRVAR(SystemError__doc__,
1515 "Internal error in the Python interpreter.\n\
1516 \n\
1517 Please report this to the Python maintainer, along with the traceback,\n\
1518 the Python version, and the hardware/OS platform and version.");
1519
1520 PyDoc_STRVAR(ReferenceError__doc__,
1521 "Weak ref proxy used after referent went away.");
1522
1523 PyDoc_STRVAR(MemoryError__doc__, "Out of memory.");
1524
1525 PyDoc_STRVAR(IndentationError__doc__, "Improper indentation.");
1526
1527 PyDoc_STRVAR(TabError__doc__, "Improper mixture of spaces and tabs.");
1528
1529 /* Warning category docstrings */
1530
1531 PyDoc_STRVAR(Warning__doc__, "Base class for warning categories.");
1532
1533 PyDoc_STRVAR(UserWarning__doc__,
1534 "Base class for warnings generated by user code.");
1535
1536 PyDoc_STRVAR(DeprecationWarning__doc__,
1537 "Base class for warnings about deprecated features.");
1538
1539 PyDoc_STRVAR(PendingDeprecationWarning__doc__,
1540 "Base class for warnings about features which will be deprecated "
1541 "in the future.");
1542
1543 PyDoc_STRVAR(SyntaxWarning__doc__,
1544 "Base class for warnings about dubious syntax.");
1545
1546 PyDoc_STRVAR(OverflowWarning__doc__,
1547 "Base class for warnings about numeric overflow.");
1548
1549 PyDoc_STRVAR(RuntimeWarning__doc__,
1550 "Base class for warnings about dubious runtime behavior.");
1551
1552 PyDoc_STRVAR(FutureWarning__doc__,
1553 "Base class for warnings about constructs that will change semantically "
1554 "in the future.");
1555
1556
1557 \f
1558 /* module global functions */
1559 static PyMethodDef functions[] = {
1560     /* Sentinel */
1561     {NULL, NULL}
1562 };
1563
1564
1565 \f
1566 /* Global C API defined exceptions */
1567
1568 PyObject *PyExc_Exception;
1569 PyObject *PyExc_StopIteration;
1570 PyObject *PyExc_StandardError;
1571 PyObject *PyExc_ArithmeticError;
1572 PyObject *PyExc_LookupError;
1573
1574 PyObject *PyExc_AssertionError;
1575 PyObject *PyExc_AttributeError;
1576 PyObject *PyExc_EOFError;
1577 PyObject *PyExc_FloatingPointError;
1578 PyObject *PyExc_EnvironmentError;
1579 PyObject *PyExc_IOError;
1580 PyObject *PyExc_OSError;
1581 PyObject *PyExc_ImportError;
1582 PyObject *PyExc_IndexError;
1583 PyObject *PyExc_KeyError;
1584 PyObject *PyExc_KeyboardInterrupt;
1585 PyObject *PyExc_MemoryError;
1586 PyObject *PyExc_NameError;
1587 PyObject *PyExc_OverflowError;
1588 PyObject *PyExc_RuntimeError;
1589 PyObject *PyExc_NotImplementedError;
1590 PyObject *PyExc_SyntaxError;
1591 PyObject *PyExc_IndentationError;
1592 PyObject *PyExc_TabError;
1593 PyObject *PyExc_ReferenceError;
1594 PyObject *PyExc_SystemError;
1595 PyObject *PyExc_SystemExit;
1596 PyObject *PyExc_UnboundLocalError;
1597 PyObject *PyExc_UnicodeError;
1598 PyObject *PyExc_UnicodeEncodeError;
1599 PyObject *PyExc_UnicodeDecodeError;
1600 PyObject *PyExc_UnicodeTranslateError;
1601 PyObject *PyExc_TypeError;
1602 PyObject *PyExc_ValueError;
1603 PyObject *PyExc_ZeroDivisionError;
1604 #ifdef MS_WINDOWS
1605 PyObject *PyExc_WindowsError;
1606 #endif
1607 #ifdef __VMS
1608 PyObject *PyExc_VMSError;
1609 #endif
1610
1611 /* Pre-computed MemoryError instance.  Best to create this as early as
1612  * possibly and not wait until a MemoryError is actually raised!
1613  */
1614 PyObject *PyExc_MemoryErrorInst;
1615
1616 /* Predefined warning categories */
1617 PyObject *PyExc_Warning;
1618 PyObject *PyExc_UserWarning;
1619 PyObject *PyExc_DeprecationWarning;
1620 PyObject *PyExc_PendingDeprecationWarning;
1621 PyObject *PyExc_SyntaxWarning;
1622 PyObject *PyExc_OverflowWarning;
1623 PyObject *PyExc_RuntimeWarning;
1624 PyObject *PyExc_FutureWarning;
1625
1626
1627 \f
1628 /* mapping between exception names and their PyObject ** */
1629 static struct {
1630     char *name;
1631     PyObject **exc;
1632     PyObject **base;                         /* NULL == PyExc_StandardError */
1633     char *docstr;
1634     PyMethodDef *methods;
1635     int (*classinit)(PyObject *);
1636 } exctable[] = {
1637  /*
1638   * The first three classes MUST appear in exactly this order
1639   */
1640  {"Exception", &PyExc_Exception},
1641  {"StopIteration", &PyExc_StopIteration, &PyExc_Exception,
1642   StopIteration__doc__},
1643  {"StandardError", &PyExc_StandardError, &PyExc_Exception,
1644   StandardError__doc__},
1645  {"TypeError", &PyExc_TypeError, 0, TypeError__doc__},
1646  /*
1647   * The rest appear in depth-first order of the hierarchy
1648   */
1649  {"SystemExit", &PyExc_SystemExit, &PyExc_Exception, SystemExit__doc__,
1650   SystemExit_methods},
1651  {"KeyboardInterrupt",  &PyExc_KeyboardInterrupt, 0, KeyboardInterrupt__doc__},
1652  {"ImportError",        &PyExc_ImportError,       0, ImportError__doc__},
1653  {"EnvironmentError",   &PyExc_EnvironmentError,  0, EnvironmentError__doc__,
1654   EnvironmentError_methods},
1655  {"IOError", &PyExc_IOError, &PyExc_EnvironmentError, IOError__doc__},
1656  {"OSError", &PyExc_OSError, &PyExc_EnvironmentError, OSError__doc__},
1657 #ifdef MS_WINDOWS
1658  {"WindowsError", &PyExc_WindowsError, &PyExc_OSError,
1659   WindowsError__doc__},
1660 #endif /* MS_WINDOWS */
1661 #ifdef __VMS
1662  {"VMSError", &PyExc_VMSError, &PyExc_OSError,
1663   VMSError__doc__},
1664 #endif
1665  {"EOFError",     &PyExc_EOFError,     0, EOFError__doc__},
1666  {"RuntimeError", &PyExc_RuntimeError, 0, RuntimeError__doc__},
1667  {"NotImplementedError", &PyExc_NotImplementedError,
1668   &PyExc_RuntimeError, NotImplementedError__doc__},
1669  {"NameError",    &PyExc_NameError,    0, NameError__doc__},
1670  {"UnboundLocalError", &PyExc_UnboundLocalError, &PyExc_NameError,
1671   UnboundLocalError__doc__},
1672  {"AttributeError",     &PyExc_AttributeError, 0, AttributeError__doc__},
1673  {"SyntaxError",        &PyExc_SyntaxError,    0, SyntaxError__doc__,
1674   SyntaxError_methods, SyntaxError__classinit__},
1675  {"IndentationError",   &PyExc_IndentationError, &PyExc_SyntaxError,
1676   IndentationError__doc__},
1677  {"TabError",   &PyExc_TabError, &PyExc_IndentationError,
1678   TabError__doc__},
1679  {"AssertionError",     &PyExc_AssertionError, 0, AssertionError__doc__},
1680  {"LookupError",        &PyExc_LookupError,    0, LookupError__doc__},
1681  {"IndexError",         &PyExc_IndexError,     &PyExc_LookupError,
1682   IndexError__doc__},
1683  {"KeyError",           &PyExc_KeyError,       &PyExc_LookupError,
1684   KeyError__doc__, KeyError_methods},
1685  {"ArithmeticError",    &PyExc_ArithmeticError, 0, ArithmeticError__doc__},
1686  {"OverflowError",      &PyExc_OverflowError,     &PyExc_ArithmeticError,
1687   OverflowError__doc__},
1688  {"ZeroDivisionError",  &PyExc_ZeroDivisionError,  &PyExc_ArithmeticError,
1689   ZeroDivisionError__doc__},
1690  {"FloatingPointError", &PyExc_FloatingPointError, &PyExc_ArithmeticError,
1691   FloatingPointError__doc__},
1692  {"ValueError",   &PyExc_ValueError,  0, ValueError__doc__},
1693  {"UnicodeError", &PyExc_UnicodeError, &PyExc_ValueError, UnicodeError__doc__},
1694 #ifdef Py_USING_UNICODE
1695  {"UnicodeEncodeError", &PyExc_UnicodeEncodeError, &PyExc_UnicodeError,
1696   UnicodeEncodeError__doc__, UnicodeEncodeError_methods},
1697  {"UnicodeDecodeError", &PyExc_UnicodeDecodeError, &PyExc_UnicodeError,
1698   UnicodeDecodeError__doc__, UnicodeDecodeError_methods},
1699  {"UnicodeTranslateError", &PyExc_UnicodeTranslateError, &PyExc_UnicodeError,
1700   UnicodeTranslateError__doc__, UnicodeTranslateError_methods},
1701 #endif
1702  {"ReferenceError",  &PyExc_ReferenceError, 0, ReferenceError__doc__},
1703  {"SystemError",  &PyExc_SystemError, 0, SystemError__doc__},
1704  {"MemoryError",  &PyExc_MemoryError, 0, MemoryError__doc__},
1705  /* Warning categories */
1706  {"Warning", &PyExc_Warning, &PyExc_Exception, Warning__doc__},
1707  {"UserWarning", &PyExc_UserWarning, &PyExc_Warning, UserWarning__doc__},
1708  {"DeprecationWarning", &PyExc_DeprecationWarning, &PyExc_Warning,
1709   DeprecationWarning__doc__},
1710  {"PendingDeprecationWarning", &PyExc_PendingDeprecationWarning, &PyExc_Warning,
1711   PendingDeprecationWarning__doc__},
1712  {"SyntaxWarning", &PyExc_SyntaxWarning, &PyExc_Warning, SyntaxWarning__doc__},
1713  {"OverflowWarning", &PyExc_OverflowWarning, &PyExc_Warning,
1714   OverflowWarning__doc__},
1715  {"RuntimeWarning", &PyExc_RuntimeWarning, &PyExc_Warning,
1716   RuntimeWarning__doc__},
1717  {"FutureWarning", &PyExc_FutureWarning, &PyExc_Warning,
1718   FutureWarning__doc__},
1719  /* Sentinel */
1720  {NULL}
1721 };
1722
1723 \f
1724
1725 void
1726 _PyExc_Init(void)
1727 {
1728     char *modulename = "exceptions";
1729     int modnamesz = strlen(modulename);
1730     int i;
1731     PyObject *me, *mydict, *bltinmod, *bdict, *doc, *args;
1732
1733     me = Py_InitModule(modulename, functions);
1734     if (me == NULL)
1735         goto err;
1736     mydict = PyModule_GetDict(me);
1737     if (mydict == NULL)
1738         goto err;
1739     bltinmod = PyImport_ImportModule("__builtin__");
1740     if (bltinmod == NULL)
1741         goto err;
1742     bdict = PyModule_GetDict(bltinmod);
1743     if (bdict == NULL)
1744         goto err;
1745     doc = PyString_FromString(module__doc__);
1746     if (doc == NULL)
1747         goto err;
1748
1749     i = PyDict_SetItemString(mydict, "__doc__", doc);
1750     Py_DECREF(doc);
1751     if (i < 0) {
1752  err:
1753         Py_FatalError("exceptions bootstrapping error.");
1754         return;
1755     }
1756
1757     /* This is the base class of all exceptions, so make it first. */
1758     if (make_Exception(modulename) ||
1759         PyDict_SetItemString(mydict, "Exception", PyExc_Exception) ||
1760         PyDict_SetItemString(bdict, "Exception", PyExc_Exception))
1761     {
1762         Py_FatalError("Base class `Exception' could not be created.");
1763     }
1764
1765     /* Now we can programmatically create all the remaining exceptions.
1766      * Remember to start the loop at 1 to skip Exceptions.
1767      */
1768     for (i=1; exctable[i].name; i++) {
1769         int status;
1770         char *cname = PyMem_NEW(char, modnamesz+strlen(exctable[i].name)+2);
1771         PyObject *base;
1772
1773         (void)strcpy(cname, modulename);
1774         (void)strcat(cname, ".");
1775         (void)strcat(cname, exctable[i].name);
1776
1777         if (exctable[i].base == 0)
1778             base = PyExc_StandardError;
1779         else
1780             base = *exctable[i].base;
1781
1782         status = make_class(exctable[i].exc, base, cname,
1783                             exctable[i].methods,
1784                             exctable[i].docstr);
1785
1786         PyMem_DEL(cname);
1787
1788         if (status)
1789             Py_FatalError("Standard exception classes could not be created.");
1790
1791         if (exctable[i].classinit) {
1792             status = (*exctable[i].classinit)(*exctable[i].exc);
1793             if (status)
1794                 Py_FatalError("An exception class could not be initialized.");
1795         }
1796
1797         /* Now insert the class into both this module and the __builtin__
1798          * module.
1799          */
1800         if (PyDict_SetItemString(mydict, exctable[i].name, *exctable[i].exc) ||
1801             PyDict_SetItemString(bdict, exctable[i].name, *exctable[i].exc))
1802         {
1803             Py_FatalError("Module dictionary insertion problem.");
1804         }
1805     }
1806
1807     /* Now we need to pre-allocate a MemoryError instance */
1808     args = Py_BuildValue("()");
1809     if (!args ||
1810         !(PyExc_MemoryErrorInst = PyEval_CallObject(PyExc_MemoryError, args)))
1811     {
1812         Py_FatalError("Cannot pre-allocate MemoryError instance\n");
1813     }
1814     Py_DECREF(args);
1815
1816     /* We're done with __builtin__ */
1817     Py_DECREF(bltinmod);
1818 }
1819
1820
1821 void
1822 _PyExc_Fini(void)
1823 {
1824     int i;
1825
1826     Py_XDECREF(PyExc_MemoryErrorInst);
1827     PyExc_MemoryErrorInst = NULL;
1828
1829     for (i=0; exctable[i].name; i++) {
1830         /* clear the class's dictionary, freeing up circular references
1831          * between the class and its methods.
1832          */
1833         PyObject* cdict = PyObject_GetAttrString(*exctable[i].exc, "__dict__");
1834         PyDict_Clear(cdict);
1835         Py_DECREF(cdict);
1836
1837         /* Now decref the exception class */
1838         Py_XDECREF(*exctable[i].exc);
1839         *exctable[i].exc = NULL;
1840     }
1841 }