Built-in class-based standard exceptions. Written by Fredrik Lundh.

Modified, proofread, and integrated for Python 1.6 by Barry Warsaw.

Modules/_exceptions.c

+/* This module provides the suite of standard class-based exceptions for
+ * Python's builtin module.  This is a complete C implementation of what,
+ * in Python 1.5.2 was contained in the exceptions.py module.  The problem
+ * there was that if exceptions.py could not be imported for some reason,
+ * the entire interpreter would abort.
+ *
+ * By moving the exceptions into C and statically linking, we can guarantee
+ * that the standard exceptions will always be available.
+ *
+ * history:
+ * 98-08-19    fl   created (for pyexe)
+ * 00-02-08    fl   updated for 1.5.2
+ * 26-May-2000 baw  vetted for Python 1.6
+ *
+ * written by Fredrik Lundh
+ * modifications, additions, cleanups, and proofreading by Barry Warsaw
+ *
+ * Copyright (c) 1998-2000 by Secret Labs AB.  All rights reserved.
+ */
+
+#include "Python.h"
+
+static char
+module__doc__[] = 
+"Class based built-in exception hierarchy.\n\
+\n\
+Before Python 1.5, the standard built-in exceptions were all simple\n\
+string objects.  In Python 1.5, the standard exceptions were converted\n\
+to classes and a simple hierarchy was created.  String-based standard\n\
+exceptions were optional, or used as a fallback if some problem\n\
+occurred while importing the exception module.  With Python 1.6,\n\
+optional string-based standard exceptions were removed (along with the\n\
+-X flag).\n\
+\n\
+The class exceptions were implemented in such a way as to be almost\n\
+completely backward compatible.  Some tricky uses of IOError could\n\
+potentially have broken, but by Python 1.6, all of these should have\n\
+been fixed.  As of Python 1.6, the class-based standard exceptions are\n\
+now implemented in C, and are guaranteed to exist in the Python\n\
+interpreter.\n\
+\n\
+Here is a rundown of the class hierarchy.  The classes found here are\n\
+inserted into the builtin module so that they are always available.\n\
+\n\
+Exception\n\
+ |\n\
+ +-- SystemExit\n\
+ +-- StandardError\n\
+      |\n\
+      +-- KeyboardInterrupt\n\
+      +-- ImportError\n\
+      +-- EnvironmentError\n\
+      |    |\n\
+      |    +-- IOError\n\
+      |    +-- OSError\n\
+      |         |\n\
+      |         +-- WindowsError\n\
+      |\n\
+      +-- EOFError\n\
+      +-- RuntimeError\n\
+      |    |\n\
+      |    +-- NotImplementedError\n\
+      |\n\
+      +-- NameError\n\
+      |    |\n\
+      |    +-- UnboundLocalError\n\
+      |\n\
+      +-- AttributeError\n\
+      +-- SyntaxError\n\
+      +-- TypeError\n\
+      +-- AssertionError\n\
+      +-- LookupError\n\
+      |    |\n\
+      |    +-- IndexError\n\
+      |    +-- KeyError\n\
+      |\n\
+      +-- ArithmeticError\n\
+      |    |\n\
+      |    +-- OverflowError\n\
+      |    +-- ZeroDivisionError\n\
+      |    +-- FloatingPointError\n\
+      |\n\
+      +-- ValueError\n\
+      |    |\n\
+      |    +-- UnicodeError\n\
+      |\n\
+      +-- SystemError\n\
+      +-- MemoryError";
+
+static char* class_modulename = "exceptions";
+
+
+
+/* Helper function for populating a dictionary with method wrappers. */
+static int
+populate_methods(PyObject* klass, PyObject* dict, PyMethodDef* methods) 
+{
+    if (!methods)
+	return 0;
+
+    while (methods->ml_name) {
+	/* get a wrapper for the built-in function */
+	PyObject* func = PyCFunction_New(methods, NULL);
+	PyObject* meth;
+	int status;
+
+	if (!func)
+	    return -1;
+
+	/* turn the function into an unbound method */
+	if (!(meth = PyMethod_New(func, NULL, klass))) {
+	    Py_DECREF(func);
+	    return -1;
+	}
+	
+	/* add method to dictionary */
+	status = PyDict_SetItemString(dict, methods->ml_name, meth);
+	Py_DECREF(meth);
+	Py_DECREF(func);
+
+	/* stop now if an error occurred, otherwise do the next method */
+	if (status)
+	    return status;
+
+	methods++;
+    }
+    return 0;
+}
+
+	
+
+/* This function is used to create all subsequent exception classes. */
+static int
+make_class(PyObject** klass, PyObject* base,
+	   char* name, PyMethodDef* methods,
+	   char* docstr)
+{
+    PyObject* dict = PyDict_New();
+    PyObject* str = NULL;
+    int status = -1;
+
+    if (!dict)
+	return -1;
+
+    /* If an error occurs from here on, goto finally instead of explicitly
+     * returning NULL.
+     */
+
+    if (docstr) {
+	if (!(str = PyString_FromString(docstr)))
+	    goto finally;
+	if (PyDict_SetItemString(dict, "__doc__", str))
+	    goto finally;
+    }
+
+    if (!(*klass = PyErr_NewException(name, base, dict)))
+	goto finally;
+
+    if (populate_methods(*klass, dict, methods)) {
+	Py_DECREF(*klass);
+	*klass = NULL;
+    }
+
+    status = 0;
+
+  finally:
+    Py_XDECREF(dict);
+    Py_XDECREF(str);
+    return status;
+}
+
+
+/* Use this for *args signatures, otherwise just use PyArg_ParseTuple() */
+static PyObject* get_self(PyObject* args)
+{
+    PyObject* self = PyTuple_GetItem(args, 0);
+    if (!self) {
+	/* Watch out for being called to early in the bootstapping process */
+	if (PyExc_TypeError) {
+	    PyErr_SetString(PyExc_TypeError,
+	     "unbound method must be called with class instance 1st argument");
+	}
+        return NULL;
+    }
+    return self;
+}
+
+
+
+/* Notes on bootstrapping the exception classes.
+ *
+ * First thing we create is the base class for all exceptions, called
+ * appropriately enough: Exception.  Creation of this class makes no
+ * assumptions about the existance of any other exception class -- except
+ * for TypeError, which can conditionally exist.
+ *
+ * Next, StandardError is created (which is quite simple) followed by
+ * TypeError, because the instantiation of other exceptions can potentially
+ * throw a TypeError.  Once these exceptions are created, all the others
+ * can be created in any order.  See the static exctable below for the
+ * explicit bootstrap order.
+ *
+ * All classes after Exception can be created using PyErr_NewException().
+ */
+
+static char
+Exception__doc__[] = "Common base class for all exceptions.";
+
+
+static PyObject*
+Exception__init__(PyObject* self, PyObject* args)
+{
+    int status;
+
+    if (!(self = get_self(args)))
+	return NULL;
+
+    /* set args attribute */
+    args = PySequence_GetSlice(args, 1, PySequence_Length(args));
+    if (!args)
+        return NULL;
+    status = PyObject_SetAttrString(self, "args", args);
+    Py_DECREF(args);
+    if (status < 0)
+        return NULL;
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+
+static PyObject*
+Exception__str__(PyObject* self, PyObject* args)
+{
+    PyObject* out;
+    PyObject* tmp;
+
+    if (!PyArg_ParseTuple(args, "O", &self))
+        return NULL;
+
+    args = PyObject_GetAttrString(self, "args");
+    if (!args)
+        return NULL;
+
+    switch (PySequence_Length(args)) {
+    case 0:
+        out = PyString_FromString("");
+        break;
+    case 1:
+	if (!(tmp = PySequence_GetItem(args, 0)))
+	    out = NULL;
+	else
+	    out = PyObject_Str(tmp);
+	break;
+    default:
+        out = PyObject_Str(args);
+        break;
+    }
+
+    Py_DECREF(args);
+    return out;
+}
+
+
+static PyObject*
+Exception__getitem__(PyObject* self, PyObject* args)
+{
+    PyObject* out;
+    PyObject* index;
+
+    if (!PyArg_ParseTuple(args, "OO", &self, &index))
+        return NULL;
+
+    args = PyObject_GetAttrString(self, "args");
+    if (!args)
+        return NULL;
+
+    out = PyObject_GetItem(args, index);
+    Py_DECREF(args);
+    return out;
+}
+
+
+static PyMethodDef
+Exception_methods[] = {
+    /* methods for the Exception class */
+    { "__getitem__", Exception__getitem__, 1},
+    { "__str__",     Exception__str__, 1},
+    { "__init__",    Exception__init__, 1},
+    { NULL, NULL }
+};
+
+
+static int
+make_Exception() 
+{
+    PyObject* dict = PyDict_New();
+    PyObject* str = NULL;
+    PyObject* name = NULL;
+    int status = -1;
+
+    if (!dict)
+	return -1;
+
+    /* If an error occurs from here on, goto finally instead of explicitly
+     * returning NULL.
+     */
+
+    if (!(str = PyString_FromString(class_modulename)))
+	goto finally;
+    if (PyDict_SetItemString(dict, "__module__", str))
+	goto finally;
+    Py_DECREF(str);
+    if (!(str = PyString_FromString(Exception__doc__)))
+	goto finally;
+    if (PyDict_SetItemString(dict, "__doc__", str))
+	goto finally;
+
+    if (!(name = PyString_FromString("Exception")))
+	goto finally;
+    
+    if (!(PyExc_Exception = PyClass_New(NULL, dict, name)))
+	goto finally;
+
+    /* Now populate the dictionary with the method suite */
+    if (populate_methods(PyExc_Exception, dict, Exception_methods))
+	/* Don't need to reclaim PyExc_Exception here because that'll
+	 * happen during interpreter shutdown.
+	 */
+	goto finally;
+
+    status = 0;
+
+  finally:
+    Py_XDECREF(dict);
+    Py_XDECREF(str);
+    Py_XDECREF(name);
+    return status;
+}
+
+
+
+static char
+StandardError__doc__[] = "Base class for all standard Python exceptions.";
+
+static char
+TypeError__doc__[] = "Inappropriate argument type.";
+
+
+
+static char
+SystemExit__doc__[] = "Request to exit from the interpreter.";
+
+
+static PyObject*
+SystemExit__init__(PyObject* self, PyObject* args)
+{
+    PyObject* code;
+    int status;
+
+    if (!(self = get_self(args)))
+	return NULL;
+
+    /* Set args attribute. */
+    if (!(args = PySequence_GetSlice(args, 1, PySequence_Length(args))))
+        return NULL;
+    
+    status = PyObject_SetAttrString(self, "args", args);
+    if (status < 0) {
+	Py_DECREF(args);
+        return NULL;
+    }
+
+    /* set code attribute */
+    switch (PySequence_Length(args)) {
+    case 0:
+        Py_INCREF(Py_None);
+        code = Py_None;
+        break;
+    case 1:
+        code = PySequence_GetItem(args, 0);
+        break;
+    default:
+        Py_INCREF(args);
+        code = args;
+        break;
+    }
+
+    status = PyObject_SetAttrString(self, "code", code);
+    Py_DECREF(code);
+    Py_DECREF(args);
+    if (status < 0)
+        return NULL;
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+
+PyMethodDef SystemExit_methods[] = {
+    { "__init__", SystemExit__init__, 1},
+    {NULL, NULL}
+};
+
+
+
+static char
+KeyboardInterrupt__doc__[] = "Program interrupted by user.";
+
+static char
+ImportError__doc__[] =
+"Import can't find module, or can't find name in module.";
+
+
+
+static char
+EnvironmentError__doc__[] = "Base class for I/O related errors.";
+
+
+static PyObject*
+EnvironmentError__init__(PyObject* self, PyObject* args) 
+{
+    PyObject* item0 = NULL;
+    PyObject* item1 = NULL;
+    PyObject* item2 = NULL;
+    PyObject* subslice = NULL;
+    PyObject* rtnval = NULL;
+
+    if (!(self = get_self(args)))
+	return NULL;
+
+    if (!(args = PySequence_GetSlice(args, 1, PySequence_Length(args))))
+	return NULL;
+
+    if (PyObject_SetAttrString(self, "args", args) ||
+	PyObject_SetAttrString(self, "errno", Py_None) ||
+	PyObject_SetAttrString(self, "strerror", Py_None) ||
+	PyObject_SetAttrString(self, "filename", Py_None))
+    {
+	goto finally;
+    }
+
+    switch (PySequence_Length(args)) {
+    case 3:
+	/* open() errors give third argument which is the filename.  But so
+	 * common in-place unpacking doesn't break, e.g.:
+	 * 
+	 * except IOError, (errno, strerror):
+	 * 
+	 * we hack args so that it only contains two items.  This also
+	 * means we need our own __str__() which prints out the filename
+	 * when it was supplied.
+	 */
+	item0 = PySequence_GetItem(args, 0);
+	item1 = PySequence_GetItem(args, 1);
+	item2 = PySequence_GetItem(args, 2);
+	if (!item0 || !item1 || !item2)
+	    goto finally;
+	
+	if (PyObject_SetAttrString(self, "errno", item0) ||
+	    PyObject_SetAttrString(self, "strerror", item1) ||
+	    PyObject_SetAttrString(self, "filename", item2))
+	{
+	    goto finally;
+	}
+
+	subslice = PySequence_GetSlice(args, 0, 2);
+	if (!subslice || PyObject_SetAttrString(self, "args", subslice))
+	    goto finally;
+
+    case 2:
+	/* common case: PyErr_SetFromErrno() */
+	item0 = PySequence_GetItem(args, 0);
+	item1 = PySequence_GetItem(args, 1);
+	if (!item0 || !item1)
+	    goto finally;
+	
+	if (PyObject_SetAttrString(self, "errno", item0) ||
+	    PyObject_SetAttrString(self, "strerror", item1))
+	{
+	    goto finally;
+	}
+    }
+
+    Py_INCREF(Py_None);
+    rtnval = Py_None;
+
+  finally:
+    Py_DECREF(args);
+    Py_XDECREF(item0);
+    Py_XDECREF(item1);
+    Py_XDECREF(item2);
+    Py_XDECREF(subslice);
+    return rtnval;
+}
+
+
+static PyObject*
+EnvironmentError__str__(PyObject* self, PyObject* args) 
+{
+    PyObject* originalself = self;
+    PyObject* filename;
+    PyObject* serrno;
+    PyObject* strerror;
+    PyObject* rtnval = NULL;
+
+    if (!PyArg_ParseTuple(args, "O", &self))
+	return NULL;
+    
+    filename = PyObject_GetAttrString(self, "filename");
+    serrno = PyObject_GetAttrString(self, "errno");
+    strerror = PyObject_GetAttrString(self, "strerror");
+    if (!filename || !serrno || !strerror)
+	goto finally;
+
+    if (filename != Py_None) {
+	PyObject* fmt = PyString_FromString("[Errno %s] %s: %s");
+	PyObject* repr = PyObject_Repr(filename);
+	PyObject* tuple = PyTuple_New(3);
+
+	if (!fmt || !repr || !tuple) {
+	    Py_XDECREF(fmt);
+	    Py_XDECREF(repr);
+	    Py_XDECREF(tuple);
+	    goto finally;
+	}
+
+	PyTuple_SET_ITEM(tuple, 0, serrno);
+	PyTuple_SET_ITEM(tuple, 1, strerror);
+	PyTuple_SET_ITEM(tuple, 2, repr);
+	Py_INCREF(serrno);
+	Py_INCREF(strerror);
+
+	rtnval = PyString_Format(fmt, tuple);
+
+	Py_DECREF(fmt);
+	Py_DECREF(repr);
+	Py_DECREF(tuple);
+    }
+    else if (PyObject_IsTrue(serrno) && PyObject_IsTrue(strerror)) {
+	PyObject* fmt = PyString_FromString("[Errno %s] %s");
+	PyObject* tuple = PyTuple_New(2);
+
+	if (!fmt || !tuple) {
+	    Py_XDECREF(fmt);
+	    Py_XDECREF(tuple);
+	    goto finally;
+	}
+
+	PyTuple_SET_ITEM(tuple, 0, serrno);
+	PyTuple_SET_ITEM(tuple, 1, strerror);
+	Py_INCREF(serrno);
+	Py_INCREF(strerror);
+	
+	rtnval = PyString_Format(fmt, tuple);
+
+	Py_DECREF(fmt);
+	Py_DECREF(tuple);
+    }
+    else
+	/* The original Python code said:
+	 *
+	 *   return StandardError.__str__(self)
+	 *
+	 * but there is no StandardError__str__() function; we happen to
+	 * know that's just a pass through to Exception__str__().
+	 */
+	rtnval = Exception__str__(originalself, args);
+
+  finally:
+    Py_XDECREF(filename);
+    Py_XDECREF(serrno);
+    Py_XDECREF(strerror);
+    return rtnval;
+}
+
+
+static
+PyMethodDef EnvironmentError_methods[] = {
+    {"__init__", EnvironmentError__init__, 1},
+    {"__str__",  EnvironmentError__str__, 1},
+    {NULL, NULL}
+};
+
+
+
+
+static char
+IOError__doc__[] = "I/O operation failed.";
+
+static char
+OSError__doc__[] = "OS system call failed.";
+
+#ifdef MS_WINDOWS
+static char
+WindowsError__doc__[] = "MS-Windows OS system call failed.";
+#endif /* MS_WINDOWS */
+
+static char
+EOFError__doc__[] = "Read beyond end of file.";
+
+static char
+RuntimeError__doc__[] = "Unspecified run-time error.";
+
+static char
+NotImplementedError__doc__[] =
+"Method or function hasn't been implemented yet.";
+
+static char
+NameError__doc__[] = "Name not found globally.";
+
+static char
+UnboundLocalError__doc__[] =
+"Local name referenced but not bound to a value.";
+
+static char
+AttributeError__doc__[] = "Attribute not found.";
+
+
+
+static char
+SyntaxError__doc__[] = "Invalid syntax.";
+
+
+static int
+SyntaxError__classinit__(PyObject* klass)
+{
+    PyObject* emptystring = PyString_FromString("");
+
+    /* Additional class-creation time initializations */
+    if (!emptystring ||
+	PyObject_SetAttrString(klass, "msg", emptystring) ||
+	PyObject_SetAttrString(klass, "filename", Py_None) ||
+	PyObject_SetAttrString(klass, "lineno", Py_None) ||
+	PyObject_SetAttrString(klass, "offset", Py_None) ||
+	PyObject_SetAttrString(klass, "text", Py_None))
+    {
+	Py_XDECREF(emptystring);
+	return -1;
+    }
+    Py_DECREF(emptystring);
+    return 0;
+}
+
+
+static PyObject*
+SyntaxError__init__(PyObject* self, PyObject* args)
+{
+    PyObject* rtnval = NULL;
+    int lenargs;
+
+    if (!(self = get_self(args)))
+	return NULL;
+
+    if (!(args = PySequence_GetSlice(args, 1, PySequence_Length(args))))
+	return NULL;
+
+    if (PyObject_SetAttrString(self, "args", args))
+	goto finally;
+
+    lenargs = PySequence_Length(args);
+    if (lenargs >= 1) {
+	PyObject* item0 = PySequence_GetItem(args, 0);
+	int status;
+
+	if (!item0)
+	    goto finally;
+	status = PyObject_SetAttrString(self, "msg", item0);
+	Py_DECREF(item0);
+	if (status)
+	    goto finally;
+    }
+    if (lenargs == 2) {
+	PyObject* info = PySequence_GetItem(args, 1);
+	PyObject *filename, *lineno, *offset, *text;
+	int status = 1;
+
+	if (!info)
+	    goto finally;
+
+	filename = PySequence_GetItem(info, 0);
+	lineno = PySequence_GetItem(info, 1);
+	offset = PySequence_GetItem(info, 2);
+	text = PySequence_GetItem(info, 3);
+
+	Py_DECREF(info);
+
+	if (filename && lineno && offset && text) {
+	    status = PyObject_SetAttrString(self, "filename", filename) ||
+		PyObject_SetAttrString(self, "lineno", lineno) ||
+		PyObject_SetAttrString(self, "offset", offset) ||
+		PyObject_SetAttrString(self, "text", text);
+	}
+	Py_XDECREF(filename);
+	Py_XDECREF(lineno);
+	Py_XDECREF(offset);
+	Py_XDECREF(text);
+
+	if (status)
+	    goto finally;
+    }
+    Py_INCREF(Py_None);
+    rtnval = Py_None;
+
+  finally:
+    Py_DECREF(args);
+    return rtnval;
+}
+
+
+static PyObject*
+SyntaxError__str__(PyObject* self, PyObject* args)
+{
+    PyObject* msg;
+    PyObject* str;
+
+    if (!PyArg_ParseTuple(args, "O", &self))
+	return NULL;
+
+    if (!(msg = PyObject_GetAttrString(self, "msg")))
+	return NULL;
+    
+    str = PyObject_Str(msg);
+    Py_DECREF(msg);
+    return str;
+}
+
+
+PyMethodDef SyntaxError_methods[] = {
+    {"__init__", SyntaxError__init__, 1},
+    {"__str__",  SyntaxError__str__,},
+    {NULL, NULL}
+};
+
+
+
+static char
+AssertionError__doc__[] = "Assertion failed.";
+
+static char
+LookupError__doc__[] = "Base class for lookup errors.";
+
+static char
+IndexError__doc__[] = "Sequence index out of range.";
+
+static char
+KeyError__doc__[] = "Mapping key not found.";
+
+static char
+ArithmeticError__doc__[] = "Base class for arithmetic errors.";
+
+static char
+OverflowError__doc__[] = "Result too large to be represented.";
+
+static char
+ZeroDivisionError__doc__[] =
+"Second argument to a division or modulo operation was zero.";
+
+static char
+FloatingPointError__doc__[] = "Floating point operation failed.";
+
+static char
+ValueError__doc__[] = "Inappropriate argument value (of correct type).";
+
+static char
+UnicodeError__doc__[] = "Unicode related error.";
+
+static char
+SystemError__doc__[] = "Internal error in the Python interpreter.\n\
+\n\
+Please report this to the Python maintainer, along with the traceback,\n\
+the Python version, and the hardware/OS platform and version.";
+
+static char
+MemoryError__doc__[] = "Out of memory.";
+
+
+
+/* module global functions */
+static PyMethodDef functions[] = {
+    /* Sentinel */
+    {NULL, NULL}
+};
+
+
+
+/* Global C API defined exceptions */
+
+PyObject *PyExc_Exception;
+PyObject *PyExc_StandardError;
+PyObject *PyExc_ArithmeticError;
+PyObject *PyExc_LookupError;
+
+PyObject *PyExc_AssertionError;
+PyObject *PyExc_AttributeError;
+PyObject *PyExc_EOFError;
+PyObject *PyExc_FloatingPointError;
+PyObject *PyExc_EnvironmentError;
+PyObject *PyExc_IOError;
+PyObject *PyExc_OSError;
+PyObject *PyExc_ImportError;
+PyObject *PyExc_IndexError;
+PyObject *PyExc_KeyError;
+PyObject *PyExc_KeyboardInterrupt;
+PyObject *PyExc_MemoryError;
+PyObject *PyExc_NameError;
+PyObject *PyExc_OverflowError;
+PyObject *PyExc_RuntimeError;
+PyObject *PyExc_NotImplementedError;
+PyObject *PyExc_SyntaxError;
+PyObject *PyExc_SystemError;
+PyObject *PyExc_SystemExit;
+PyObject *PyExc_UnboundLocalError;
+PyObject *PyExc_UnicodeError;
+PyObject *PyExc_TypeError;
+PyObject *PyExc_ValueError;
+PyObject *PyExc_ZeroDivisionError;
+#ifdef MS_WINDOWS
+PyObject *PyExc_WindowsError;
+#endif
+
+/* Pre-computed MemoryError instance.  Best to create this as early as
+ * possibly and not wait until a MemoryError is actually raised!
+ */
+PyObject *PyExc_MemoryErrorInst;
+
+
+
+/* mapping between exception names and their PyObject** */
+static struct
+{
+    char* name;
+    PyObject** exc;
+    PyObject** base;			     /* NULL == PyExc_StandardError */
+    char* docstr;
+    PyMethodDef* methods;
+    int (*classinit)(PyObject*);
+}
+exctable[] = {
+ /*
+  * The first three classes MUST appear in exactly this order
+  */
+ {"Exception", &PyExc_Exception},
+ {"StandardError", &PyExc_StandardError, &PyExc_Exception,
+  StandardError__doc__},
+ {"TypeError", &PyExc_TypeError, 0, TypeError__doc__},
+ /*
+  * The rest appear in depth-first order of the hierarchy
+  */
+ {"SystemExit", &PyExc_SystemExit, &PyExc_Exception, SystemExit__doc__,
+  SystemExit_methods},
+ {"KeyboardInterrupt",  &PyExc_KeyboardInterrupt, 0, KeyboardInterrupt__doc__},
+ {"ImportError",        &PyExc_ImportError,       0, ImportError__doc__},
+ {"EnvironmentError",   &PyExc_EnvironmentError,  0, EnvironmentError__doc__,
+  EnvironmentError_methods},
+ {"IOError", &PyExc_IOError, &PyExc_EnvironmentError, IOError__doc__},
+ {"OSError", &PyExc_OSError, &PyExc_EnvironmentError, OSError__doc__},
+#ifdef MS_WINDOWS
+ {"WindowsError", &PyExc_WindowsError, &PyExc_EnvironmentError,
+  WindowsError__doc__},
+#endif /* MS_WINDOWS */
+ {"EOFError",     &PyExc_EOFError,     0, EOFError__doc__},
+ {"RuntimeError", &PyExc_RuntimeError, 0, RuntimeError__doc__},
+ {"NotImplementedError", &PyExc_NotImplementedError,
+  &PyExc_RuntimeError, NotImplementedError__doc__},
+ {"NameError",    &PyExc_NameError,    0, NameError__doc__},
+ {"UnboundLocalError", &PyExc_UnboundLocalError, &PyExc_NameError,
+  UnboundLocalError__doc__},
+ {"AttributeError",     &PyExc_AttributeError, 0, AttributeError__doc__},
+ {"SyntaxError",        &PyExc_SyntaxError,    0, SyntaxError__doc__,
+  SyntaxError_methods, SyntaxError__classinit__},
+ {"AssertionError",     &PyExc_AssertionError, 0, AssertionError__doc__},
+ {"LookupError",        &PyExc_LookupError,    0, LookupError__doc__},
+ {"IndexError",         &PyExc_IndexError,     &PyExc_LookupError,
+  IndexError__doc__},
+ {"KeyError",           &PyExc_KeyError,       &PyExc_LookupError,
+  KeyError__doc__},
+ {"ArithmeticError",    &PyExc_ArithmeticError, 0, ArithmeticError__doc__},
+ {"OverflowError",      &PyExc_OverflowError,     &PyExc_ArithmeticError,
+  OverflowError__doc__},
+ {"ZeroDivisionError",  &PyExc_ZeroDivisionError,  &PyExc_ArithmeticError,
+  ZeroDivisionError__doc__},
+ {"FloatingPointError", &PyExc_FloatingPointError, &PyExc_ArithmeticError,
+  FloatingPointError__doc__},
+ {"ValueError",   &PyExc_ValueError,  0, ValueError__doc__},
+ {"UnicodeError", &PyExc_UnicodeError, &PyExc_ValueError, UnicodeError__doc__},
+ {"SystemError",  &PyExc_SystemError, 0, SystemError__doc__},
+ {"MemoryError",  &PyExc_MemoryError, 0, MemoryError__doc__},
+ /* Sentinel */
+ {NULL}
+};
+
+
+
+void
+#ifdef WIN32
+__declspec(dllexport)
+#endif /* WIN32 */
+init_exceptions()
+{
+    int i;
+    int modnamesz = strlen(class_modulename);
+
+    PyObject* me = Py_InitModule("_exceptions", functions);
+    PyObject* mydict = PyModule_GetDict(me);
+    PyObject* bltinmod = PyImport_ImportModule("__builtin__");
+    PyObject* bdict = PyModule_GetDict(bltinmod);
+    PyObject* doc = PyString_FromString(module__doc__);
+    PyObject* args;
+
+    PyDict_SetItemString(mydict, "__doc__", doc);
+    if (PyErr_Occurred())
+	Py_FatalError("_exceptions bootstrapping error.");
+
+    /* This is the base class of all exceptions, so make it first. */
+    if (make_Exception() ||
+	PyDict_SetItemString(mydict, "Exception", PyExc_Exception) ||
+	PyDict_SetItemString(bdict, "Exception", PyExc_Exception))
+    {
+	Py_FatalError("Base class `Exception' could not be created.");
+    }
+    
+    /* Now we can programmatically create all the remaining exceptions.
+     * Remember to start the loop at 1 to skip Exceptions.
+     */
+    for (i=1; exctable[i].name; i++) {
+	int status;
+	char* cname = PyMem_NEW(char, modnamesz+strlen(exctable[i].name)+2);
+	PyObject* base;
+
+	(void)strcpy(cname, class_modulename);
+	(void)strcat(cname, ".");
+	(void)strcat(cname, exctable[i].name);
+
+	if (exctable[i].base == 0)
+	    base = PyExc_StandardError;
+	else
+	    base = *exctable[i].base;
+
+	status = make_class(exctable[i].exc, base, cname,
+			    exctable[i].methods,
+			    exctable[i].docstr);
+
+	PyMem_DEL(cname);
+
+	if (status)
+	    Py_FatalError("Standard exception classes could not be created.");
+
+	if (exctable[i].classinit) {
+	    status = (*exctable[i].classinit)(*exctable[i].exc);
+	    if (status)
+		Py_FatalError("An exception class could not be initialized.");
+	}
+
+	/* Now insert the class into both this module and the __builtin__
+	 * module.
+	 */
+	if (PyDict_SetItemString(mydict, exctable[i].name, *exctable[i].exc) ||
+	    PyDict_SetItemString(bdict, exctable[i].name, *exctable[i].exc))
+	{
+	    Py_FatalError("Module dictionary insertion problem.");
+	}
+    }
+
+    /* Now we need to pre-allocate a MemoryError instance */
+    args = Py_BuildValue("()");
+    if (!args ||
+	!(PyExc_MemoryErrorInst = PyEval_CallObject(PyExc_MemoryError, args)))
+    {
+	Py_FatalError("Cannot pre-allocate MemoryError instance\n");
+    }
+    Py_DECREF(args);
+
+    /* We're done with __builtin__ */
+    Py_DECREF(bltinmod);
+}
+
+
+void
+#ifdef WIN32
+__declspec(dllexport)
+#endif /* WIN32 */
+fini_exceptions()
+{
+    int i;
+
+    Py_XDECREF(PyExc_MemoryErrorInst);
+    PyExc_MemoryErrorInst = NULL;
+
+    for (i=0; exctable[i].name; i++) {
+	Py_XDECREF(*exctable[i].exc);
+	*exctable[i].exc = NULL;
+    }
+}