_exceptions.c is moved to ../Python/exceptions.c

1 files changed, 0 insertions, 994 deletions

diff --git a/Modules/_exceptions.c b/Modules/_exceptions.c
deleted file mode 100644
index 97e90ea..0000000
--- a/Modules/_exceptions.c
+++ /dev/null
@@ -1,994 +0,0 @@
-/* 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;
-    }
-}