mirror of https://github.com/python/cpython
Built-in class-based standard exceptions. Written by Fredrik Lundh.
Modified, proofread, and integrated for Python 1.6 by Barry Warsaw.
This commit is contained in:
Barry Warsaw
parent
992cb8ab53
commit
8415edb433
|
|
@ -0,0 +1,994 @@
|
|||
/* 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;
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue