/* 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"

#include "osdefs.h"

/* Caution: MS Visual C++ 6 errors if a single string literal exceeds

* 2Kb. So the module docstring has been broken roughly in half, using

* compile-time literal concatenation.

*/

/* NOTE: If the exception class hierarchy changes, don't forget to update

* Doc/lib/libexcs.tex!

*/

PyDoc_STRVAR(module__doc__,

"Python's standard exception class hierarchy.\n\

\n\

Before Python 1.5, the standard exceptions were all simple string objects.\n\

In Python 1.5, the standard exceptions were converted to classes organized\n\

into a relatively flat hierarchy. String-based standard exceptions were\n\

optional, or used as a fallback if some problem occurred while importing\n\

the exception module. With Python 1.6, optional string-based standard\n\

exceptions were removed (along with the -X command line 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 both the exceptions module and the `built-in' module. It is\n\

recommended that user defined class based exceptions be derived from the\n\

`Exception' class, although this is currently not enforced.\n"

/* keep string pieces "small" */

"\n\

Exception\n\

|\n\

+-- SystemExit\n\

+-- StopIteration\n\

+-- GeneratorExit\n\

+-- StandardError\n\

| |\n\

| +-- KeyboardInterrupt\n\

| +-- ImportError\n\

| +-- EnvironmentError\n\

| | |\n\

| | +-- IOError\n\

| | +-- OSError\n\

| | |\n\

| | +-- WindowsError\n\

| | +-- VMSError\n\

| |\n\

| +-- EOFError\n\

| +-- RuntimeError\n\

| | |\n\

| | +-- NotImplementedError\n\

| |\n\

| +-- NameError\n\

| | |\n\

| | +-- UnboundLocalError\n\

| |\n\

| +-- AttributeError\n\

| +-- SyntaxError\n\

| | |\n\

| | +-- IndentationError\n\

| | |\n\

| | +-- TabError\n\

| |\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\

| | +-- UnicodeEncodeError\n\

| | +-- UnicodeDecodeError\n\

| | +-- UnicodeTranslateError\n\

| |\n\

| +-- ReferenceError\n\

| +-- SystemError\n\

| +-- MemoryError\n\

|\n\

+---Warning\n\

|\n\

+-- UserWarning\n\

+-- DeprecationWarning\n\

+-- PendingDeprecationWarning\n\

+-- SyntaxWarning\n\

+-- OverflowWarning\n\

+-- RuntimeWarning\n\

+-- FutureWarning"

);



/* Helper function for populating a dictionary with method wrappers. */

static int

populate_methods(PyObject *klass, PyObject *dict, PyMethodDef *methods)

{

PyObject *module;

int status = -1;

if (!methods)

return 0;

module = PyString_FromString("exceptions");

if (!module)

return 0;

while (methods->ml_name) {

/* get a wrapper for the built-in function */

PyObject *func = PyCFunction_NewEx(methods, NULL, module);

PyObject *meth;

if (!func)

goto status;

/* turn the function into an unbound method */

if (!(meth = PyMethod_New(func, NULL, klass))) {

Py_DECREF(func);

goto status;

}

/* 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)

goto status;

methods++;

}

status = 0;

status:

Py_DECREF(module);

return status;

}



/* 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;

goto finally;

}

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 bootstrapping process */

if (PyExc_TypeError) {

PyErr_SetString(PyExc_TypeError,

"unbound method must be called with instance as first 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 existence 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().

*/

PyDoc_STRVAR(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 */

/* XXX size is only a hint */

args = PySequence_GetSlice(args, 1, PySequence_Size(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;

if (!PyArg_ParseTuple(args, "O:__str__", &self))

return NULL;

args = PyObject_GetAttrString(self, "args");

if (!args)

return NULL;

switch (PySequence_Size(args)) {

case 0:

out = PyString_FromString("");

break;

case 1:

{

PyObject *tmp = PySequence_GetItem(args, 0);

if (tmp) {

out = PyObject_Str(tmp);

Py_DECREF(tmp);

}

else

out = NULL;

break;

}

case -1:

PyErr_Clear();

/* Fall through */

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:__getitem__", &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__, METH_VARARGS},

{ "__str__", Exception__str__, METH_VARARGS},

{ "__init__", Exception__init__, METH_VARARGS},

{ NULL, NULL }

};

static int

make_Exception(char *modulename)

{

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(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;

}



PyDoc_STRVAR(StandardError__doc__,

"Base class for all standard Python exceptions.");

PyDoc_STRVAR(TypeError__doc__, "Inappropriate argument type.");

PyDoc_STRVAR(StopIteration__doc__, "Signal the end from iterator.next().");

PyDoc_STRVAR(GeneratorExit__doc__, "Request that a generator exit.");



PyDoc_STRVAR(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_Size(args))))

return NULL;

status = PyObject_SetAttrString(self, "args", args);

if (status < 0) {

Py_DECREF(args);

return NULL;

}

/* set code attribute */

switch (PySequence_Size(args)) {

case 0:

Py_INCREF(Py_None);

code = Py_None;

break;

case 1:

code = PySequence_GetItem(args, 0);

break;

case -1:

PyErr_Clear();

/* Fall through */

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;

}

static PyMethodDef SystemExit_methods[] = {

{ "__init__", SystemExit__init__, METH_VARARGS},

{NULL, NULL}

};



PyDoc_STRVAR(KeyboardInterrupt__doc__, "Program interrupted by user.");

PyDoc_STRVAR(ImportError__doc__,

"Import can't find module, or can't find name in module.");



PyDoc_STRVAR(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_Size(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_Size(args)) {

case 3:

/* Where a function has a single filename, such as open() or some

* of the os module functions, PyErr_SetFromErrnoWithFilename() is

* called, giving a third argument which is the filename. But, so

* that old code using 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;

break;

case 2:

/* Used when PyErr_SetFromErrno() is called and no filename

* argument is given.

*/

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;

}

break;

case -1:

PyErr_Clear();

break;

}

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:__str__", &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);

rtnval = PyString_Format(fmt, tuple);

Py_DECREF(fmt);

Py_DECREF(tuple);

/* already freed because tuple owned only reference */

serrno = NULL;

strerror = NULL;

}

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);

rtnval = PyString_Format(fmt, tuple);

Py_DECREF(fmt);

Py_DECREF(tuple);

/* already freed because tuple owned only reference */

serrno = NULL;

strerror = NULL;

}

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__, METH_VARARGS},

{"__str__", EnvironmentError__str__, METH_VARARGS},

{NULL, NULL}

};



PyDoc_STRVAR(IOError__doc__, "I/O operation failed.");

PyDoc_STRVAR(OSError__doc__, "OS system call failed.");

#ifdef MS_WINDOWS

PyDoc_STRVAR(WindowsError__doc__, "MS-Windows OS system call failed.");

#endif /* MS_WINDOWS */

#ifdef __VMS

static char

VMSError__doc__[] = "OpenVMS OS system call failed.";

#endif

PyDoc_STRVAR(EOFError__doc__, "Read beyond end of file.");

PyDoc_STRVAR(RuntimeError__doc__, "Unspecified run-time error.");

PyDoc_STRVAR(NotImplementedError__doc__,

"Method or function hasn't been implemented yet.");

PyDoc_STRVAR(NameError__doc__, "Name not found globally.");

PyDoc_STRVAR(UnboundLocalError__doc__,

"Local name referenced but not bound to a value.");

PyDoc_STRVAR(AttributeError__doc__, "Attribute not found.");



PyDoc_STRVAR(SyntaxError__doc__, "Invalid syntax.");

static int

SyntaxError__classinit__(PyObject *klass)

{

int retval = 0;

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) ||

PyObject_SetAttrString(klass, "print_file_and_line", Py_None))

{

retval = -1;

}

Py_XDECREF(emptystring);

return retval;

}

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_Size(args))))

return NULL;

if (PyObject_SetAttrString(self, "args", args))

goto finally;

lenargs = PySequence_Size(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 = NULL, *lineno = NULL;

PyObject *offset = NULL, *text = NULL;

int status = 1;

if (!info)

goto finally;

filename = PySequence_GetItem(info, 0);

if (filename != NULL) {

lineno = PySequence_GetItem(info, 1);

if (lineno != NULL) {

offset = PySequence_GetItem(info, 2);

if (offset != NULL) {

text = PySequence_GetItem(info, 3);

if (text != NULL) {

status =

PyObject_SetAttrString(self, "filename", filename)

|| PyObject_SetAttrString(self, "lineno", lineno)

|| PyObject_SetAttrString(self, "offset", offset)

|| PyObject_SetAttrString(self, "text", text);

Py_DECREF(text);

}

Py_DECREF(offset);

}

Py_DECREF(lineno);

}

Py_DECREF(filename);

}

Py_DECREF(info);

if (status)

goto finally;

}

Py_INCREF(Py_None);

rtnval = Py_None;

finally:

Py_DECREF(args);

return rtnval;

}

/* This is called "my_basename" instead of just "basename" to avoid name

conflicts with glibc; basename is already prototyped if _GNU_SOURCE is

defined, and Python does define that. */

static char *

my_basename(char *name)

{

char *cp = name;

char *result = name;

if (name == NULL)

return "???";

while (*cp != '\0') {

if (*cp == SEP)

result = cp + 1;

++cp;

}

return result;

}

static PyObject *

SyntaxError__str__(PyObject *self, PyObject *args)

{

PyObject *msg;

PyObject *str;

PyObject *filename, *lineno, *result;

if (!PyArg_ParseTuple(args, "O:__str__", &self))

return NULL;

if (!(msg = PyObject_GetAttrString(self, "msg")))

return NULL;

str = PyObject_Str(msg);

Py_DECREF(msg);

result = str;

/* XXX -- do all the additional formatting with filename and

lineno here */

if (str != NULL && PyString_Check(str)) {

int have_filename = 0;

int have_lineno = 0;

char *buffer = NULL;

if ((filename = PyObject_GetAttrString(self, "filename")) != NULL)

have_filename = PyString_Check(filename);

else

PyErr_Clear();

if ((lineno = PyObject_GetAttrString(self, "lineno")) != NULL)

have_lineno = PyInt_Check(lineno);

else

PyErr_Clear();

if (have_filename || have_lineno) {

int bufsize = PyString_GET_SIZE(str) + 64;

if (have_filename)

bufsize += PyString_GET_SIZE(filename);

buffer = PyMem_MALLOC(bufsize);

if (buffer != NULL) {

if (have_filename && have_lineno)

PyOS_snprintf(buffer, bufsize, "%s (%s, line %ld)",

PyString_AS_STRING(str),

my_basename(PyString_AS_STRING(filename)),

PyInt_AsLong(lineno));

else if (have_filename)

PyOS_snprintf(buffer, bufsize, "%s (%s)",

PyString_AS_STRING(str),

my_basename(PyString_AS_STRING(filename)));

else if (have_lineno)

PyOS_snprintf(buffer, bufsize, "%s (line %ld)",

PyString_AS_STRING(str),

PyInt_AsLong(lineno));

result = PyString_FromString(buffer);

PyMem_FREE(buffer);

if (result == NULL)

result = str;

else

Py_DECREF(str);

}

}

Py_XDECREF(filename);

Py_XDECREF(lineno);

}

return result;

}

static PyMethodDef SyntaxError_methods[] = {

{"__init__", SyntaxError__init__, METH_VARARGS},

{"__str__", SyntaxError__str__, METH_VARARGS},

{NULL, NULL}

};

static PyObject *

KeyError__str__(PyObject *self, PyObject *args)

{

PyObject *argsattr;

PyObject *result;

if (!PyArg_ParseTuple(args, "O:__str__", &self))

return NULL;

if (!(argsattr = PyObject_GetAttrString(self, "args")))

return NULL;

/* If args is a tuple of exactly one item, apply repr to args[0].

This is done so that e.g. the exception raised by {}[''] prints

KeyError: ''

rather than the confusing

KeyError

alone. The downside is that if KeyError is raised with an explanatory

string, that string will be displayed in quotes. Too bad.

If args is anything else, use the default Exception__str__().

*/

if (PyTuple_Check(argsattr) && PyTuple_GET_SIZE(argsattr) == 1) {

PyObject *key = PyTuple_GET_ITEM(argsattr, 0);

result = PyObject_Repr(key);

}

else

result = Exception__str__(self, args);

Py_DECREF(argsattr);

return result;

}

static PyMethodDef KeyError_methods[] = {

{"__str__", KeyError__str__, METH_VARARGS},

{NULL, NULL}

};

#ifdef Py_USING_UNICODE

static

int get_int(PyObject *exc, const char *name, int *value)

{

PyObject *attr = PyObject_GetAttrString(exc, (char *)name);

if (!attr)

return -1;

if (!PyInt_Check(attr)) {

PyErr_Format(PyExc_TypeError, "%.200s attribute must be int", name);

Py_DECREF(attr);

return -1;

}

*value = PyInt_AS_LONG(attr);

Py_DECREF(attr);

return 0;

}

static

int set_int(PyObject *exc, const char *name, int value)

{

PyObject *obj = PyInt_FromLong(value);

int result;

if (!obj)

return -1;

result = PyObject_SetAttrString(exc, (char *)name, obj);

Py_DECREF(obj);

return result;

}

static

PyObject *get_string(PyObject *exc, const char *name)

{

PyObject *attr = PyObject_GetAttrString(exc, (char *)name);

if (!attr)

return NULL;

if (!PyString_Check(attr)) {

PyErr_Format(PyExc_TypeError, "%.200s attribute must be str", name);

Py_DECREF(attr);

return NULL;

}

return attr;

}

static

int set_string(PyObject *exc, const char *name, const char *value)

{

PyObject *obj = PyString_FromString(value);

int result;

if (!obj)

return -1;

result = PyObject_SetAttrString(exc, (char *)name, obj);

Py_DECREF(obj);

return result;

}

static

PyObject *get_unicode(PyObject *exc, const char *name)

{

PyObject *attr = PyObject_GetAttrString(exc, (char *)name);

if (!attr)

return NULL;

if (!PyUnicode_Check(attr)) {

PyErr_Format(PyExc_TypeError, "%.200s attribute must be unicode", name);

Py_DECREF(attr);

return NULL;

}

return attr;

}

PyObject * PyUnicodeEncodeError_GetEncoding(PyObject *exc)

{

return get_string(exc, "encoding");

}

PyObject * PyUnicodeDecodeError_GetEncoding(PyObject *exc)

{

return get_string(exc, "encoding");

}

PyObject *PyUnicodeEncodeError_GetObject(PyObject *exc)

{