From c8019add6c91e80213273b157ecf2c62891abe73 Mon Sep 17 00:00:00 2001 From: Barry Warsaw Date: Fri, 26 May 2000 19:03:19 +0000 Subject: _exceptions.c is moved to ../Python/exceptions.c --- Modules/_exceptions.c | 994 -------------------------------------------------- 1 file changed, 994 deletions(-) delete mode 100644 Modules/_exceptions.c 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; - } -} -- cgit v0.12