1 /*

     2  * New exceptions.c written in Iceland by Richard Jones and Georg Brandl.

     3  *

     4  * Thanks go to Tim Peters and Michael Hudson for debugging.

     5  */

     6 

     7 #define PY_SSIZE_T_CLEAN

     8 #include <Python.h>

     9 #include "structmember.h"

    10 #include "osdefs.h"

    11 

    12 #define MAKE_IT_NONE(x) (x) = Py_None; Py_INCREF(Py_None);

    13 #define EXC_MODULE_NAME "exceptions."

    14 

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

    16  * Lib/test/exception_hierarchy.txt

    17  */

    18 

    19 PyDoc_STRVAR(exceptions_doc, "Python's standard exception class hierarchy.\n\

    20 \n\

    21 Exceptions found here are defined both in the exceptions module and the\n\

    22 built-in namespace.  It is recommended that user-defined exceptions\n\

    23 inherit from Exception.  See the documentation for the exception\n\

    24 inheritance hierarchy.\n\

    25 ");

    26 

    27 /*

    28  *    BaseException

    29  */

    30 static PyObject *

    31 BaseException_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

    32 {

    33     PyBaseExceptionObject *self;

    34 

    35     self = (PyBaseExceptionObject *)type->tp_alloc(type, 0);

    36     if (!self)

    37         return NULL;

    38     /* the dict is created on the fly in PyObject_GenericSetAttr */

    39     self->message = self->dict = NULL;

    40 

    41     self->args = PyTuple_New(0);

    42     if (!self->args) {

    43         Py_DECREF(self);

    44         return NULL;

    45     }

    46 

    47     self->message = PyString_FromString("");

    48     if (!self->message) {

    49         Py_DECREF(self);

    50         return NULL;

    51     }

    52 

    53     return (PyObject *)self;

    54 }

    55 

    56 static int

    57 BaseException_init(PyBaseExceptionObject *self, PyObject *args, PyObject *kwds)

    58 {

    59     if (!_PyArg_NoKeywords(Py_TYPE(self)->tp_name, kwds))

    60         return -1;

    61 

    62     Py_DECREF(self->args);

    63     self->args = args;

    64     Py_INCREF(self->args);

    65 

    66     if (PyTuple_GET_SIZE(self->args) == 1) {

    67         Py_CLEAR(self->message);

    68         self->message = PyTuple_GET_ITEM(self->args, 0);

    69         Py_INCREF(self->message);

    70     }

    71     return 0;

    72 }

    73 

    74 static int

    75 BaseException_clear(PyBaseExceptionObject *self)

    76 {

    77     Py_CLEAR(self->dict);

    78     Py_CLEAR(self->args);

    79     Py_CLEAR(self->message);

    80     return 0;

    81 }

    82 

    83 static void

    84 BaseException_dealloc(PyBaseExceptionObject *self)

    85 {

    86     _PyObject_GC_UNTRACK(self);

    87     BaseException_clear(self);

    88     Py_TYPE(self)->tp_free((PyObject *)self);

    89 }

    90 

    91 static int

    92 BaseException_traverse(PyBaseExceptionObject *self, visitproc visit, void *arg)

    93 {

    94     Py_VISIT(self->dict);

    95     Py_VISIT(self->args);

    96     Py_VISIT(self->message);

    97     return 0;

    98 }

    99 

   100 static PyObject *

   101 BaseException_str(PyBaseExceptionObject *self)

   102 {

   103     PyObject *out;

   104 

   105     switch (PyTuple_GET_SIZE(self->args)) {

   106     case 0:

   107         out = PyString_FromString("");

   108         break;

   109     case 1:

   110         out = PyObject_Str(PyTuple_GET_ITEM(self->args, 0));

   111         break;

   112     default:

   113         out = PyObject_Str(self->args);

   114         break;

   115     }

   116 

   117     return out;

   118 }

   119 

   120 #ifdef Py_USING_UNICODE

   121 static PyObject *

   122 BaseException_unicode(PyBaseExceptionObject *self)

   123 {

   124     PyObject *out;

   125 

   126     switch (PyTuple_GET_SIZE(self->args)) {

   127     case 0:

   128         out = PyUnicode_FromString("");

   129         break;

   130     case 1:

   131         out = PyObject_Unicode(PyTuple_GET_ITEM(self->args, 0));

   132         break;

   133     default:

   134         out = PyObject_Unicode(self->args);

   135         break;

   136     }

   137 

   138     return out;

   139 }

   140 #endif

   141 

   142 static PyObject *

   143 BaseException_repr(PyBaseExceptionObject *self)

   144 {

   145     PyObject *repr_suffix;

   146     PyObject *repr;

   147     char *name;

   148     char *dot;

   149 

   150     repr_suffix = PyObject_Repr(self->args);

   151     if (!repr_suffix)

   152         return NULL;

   153 

   154     name = (char *)Py_TYPE(self)->tp_name;

   155     dot = strrchr(name, '.');

   156     if (dot != NULL) name = dot+1;

   157 

   158     repr = PyString_FromString(name);

   159     if (!repr) {

   160         Py_DECREF(repr_suffix);

   161         return NULL;

   162     }

   163 

   164     PyString_ConcatAndDel(&repr, repr_suffix);

   165     return repr;

   166 }

   167 

   168 /* Pickling support */

   169 static PyObject *

   170 BaseException_reduce(PyBaseExceptionObject *self)

   171 {

   172     if (self->args && self->dict)

   173         return PyTuple_Pack(3, Py_TYPE(self), self->args, self->dict);

   174     else

   175         return PyTuple_Pack(2, Py_TYPE(self), self->args);

   176 }

   177 

   178 /*

   179  * Needed for backward compatibility, since exceptions used to store

   180  * all their attributes in the __dict__. Code is taken from cPickle's

   181  * load_build function.

   182  */

   183 static PyObject *

   184 BaseException_setstate(PyObject *self, PyObject *state)

   185 {

   186     PyObject *d_key, *d_value;

   187     Py_ssize_t i = 0;

   188 

   189     if (state != Py_None) {

   190         if (!PyDict_Check(state)) {

   191             PyErr_SetString(PyExc_TypeError, "state is not a dictionary");

   192             return NULL;

   193         }

   194         while (PyDict_Next(state, &i, &d_key, &d_value)) {

   195             if (PyObject_SetAttr(self, d_key, d_value) < 0)

   196                 return NULL;

   197         }

   198     }

   199     Py_RETURN_NONE;

   200 }

   201 

   202 

   203 static PyMethodDef BaseException_methods[] = {

   204    {"__reduce__", (PyCFunction)BaseException_reduce, METH_NOARGS },

   205    {"__setstate__", (PyCFunction)BaseException_setstate, METH_O },

   206 #ifdef Py_USING_UNICODE   

   207    {"__unicode__", (PyCFunction)BaseException_unicode, METH_NOARGS },

   208 #endif

   209    {NULL, NULL, 0, NULL},

   210 };

   211 

   212 

   213 

   214 static PyObject *

   215 BaseException_getitem(PyBaseExceptionObject *self, Py_ssize_t index)

   216 {

   217     if (PyErr_WarnPy3k("__getitem__ not supported for exception "

   218                        "classes in 3.x; use args attribute", 1) < 0)

   219         return NULL;

   220     return PySequence_GetItem(self->args, index);

   221 }

   222 

   223 static PyObject *

   224 BaseException_getslice(PyBaseExceptionObject *self,

   225 			Py_ssize_t start, Py_ssize_t stop)

   226 {

   227     if (PyErr_WarnPy3k("__getslice__ not supported for exception "

   228                        "classes in 3.x; use args attribute", 1) < 0)

   229         return NULL;

   230     return PySequence_GetSlice(self->args, start, stop);

   231 }

   232 

   233 static PySequenceMethods BaseException_as_sequence = {

   234     0,                      /* sq_length; */

   235     0,                      /* sq_concat; */

   236     0,                      /* sq_repeat; */

   237     (ssizeargfunc)BaseException_getitem,  /* sq_item; */

   238     (ssizessizeargfunc)BaseException_getslice,  /* sq_slice; */

   239     0,                      /* sq_ass_item; */

   240     0,                      /* sq_ass_slice; */

   241     0,                      /* sq_contains; */

   242     0,                      /* sq_inplace_concat; */

   243     0                       /* sq_inplace_repeat; */

   244 };

   245 

   246 static PyObject *

   247 BaseException_get_dict(PyBaseExceptionObject *self)

   248 {

   249     if (self->dict == NULL) {

   250         self->dict = PyDict_New();

   251         if (!self->dict)

   252             return NULL;

   253     }

   254     Py_INCREF(self->dict);

   255     return self->dict;

   256 }

   257 

   258 static int

   259 BaseException_set_dict(PyBaseExceptionObject *self, PyObject *val)

   260 {

   261     if (val == NULL) {

   262         PyErr_SetString(PyExc_TypeError, "__dict__ may not be deleted");

   263         return -1;

   264     }

   265     if (!PyDict_Check(val)) {

   266         PyErr_SetString(PyExc_TypeError, "__dict__ must be a dictionary");

   267         return -1;

   268     }

   269     Py_CLEAR(self->dict);

   270     Py_INCREF(val);

   271     self->dict = val;

   272     return 0;

   273 }

   274 

   275 static PyObject *

   276 BaseException_get_args(PyBaseExceptionObject *self)

   277 {

   278     if (self->args == NULL) {

   279         Py_INCREF(Py_None);

   280         return Py_None;

   281     }

   282     Py_INCREF(self->args);

   283     return self->args;

   284 }

   285 

   286 static int

   287 BaseException_set_args(PyBaseExceptionObject *self, PyObject *val)

   288 {

   289     PyObject *seq;

   290     if (val == NULL) {

   291         PyErr_SetString(PyExc_TypeError, "args may not be deleted");

   292         return -1;

   293     }

   294     seq = PySequence_Tuple(val);

   295     if (!seq) return -1;

   296     Py_CLEAR(self->args);

   297     self->args = seq;

   298     return 0;

   299 }

   300 

   301 static PyObject *

   302 BaseException_get_message(PyBaseExceptionObject *self)

   303 {

   304 	int ret;

   305 	ret = PyErr_WarnEx(PyExc_DeprecationWarning,

   306 				"BaseException.message has been deprecated as "

   307 				"of Python 2.6", 1);

   308 	if (ret < 0)

   309 		return NULL;

   310 

   311 	Py_INCREF(self->message);

   312 	return self->message;

   313 }

   314 

   315 static int

   316 BaseException_set_message(PyBaseExceptionObject *self, PyObject *val)

   317 {

   318 	int ret;

   319 	ret = PyErr_WarnEx(PyExc_DeprecationWarning,

   320 				"BaseException.message has been deprecated as "

   321 				"of Python 2.6", 1);

   322 	if (ret < 0)

   323 		return -1;

   324 	Py_INCREF(val);

   325 	Py_DECREF(self->message);

   326 	self->message = val;

   327 	return 0;

   328 }

   329 

   330 static PyGetSetDef BaseException_getset[] = {

   331     {"__dict__", (getter)BaseException_get_dict, (setter)BaseException_set_dict},

   332     {"args", (getter)BaseException_get_args, (setter)BaseException_set_args},

   333     {"message", (getter)BaseException_get_message,

   334 	    (setter)BaseException_set_message},

   335     {NULL},

   336 };

   337 

   338 

   339 static PyTypeObject _PyExc_BaseException = {

   340     PyObject_HEAD_INIT(NULL)

   341     0,                          /*ob_size*/

   342     EXC_MODULE_NAME "BaseException", /*tp_name*/

   343     sizeof(PyBaseExceptionObject), /*tp_basicsize*/

   344     0,                          /*tp_itemsize*/

   345     (destructor)BaseException_dealloc, /*tp_dealloc*/

   346     0,                          /*tp_print*/

   347     0,                          /*tp_getattr*/

   348     0,                          /*tp_setattr*/

   349     0,                          /* tp_compare; */

   350     (reprfunc)BaseException_repr, /*tp_repr*/

   351     0,                          /*tp_as_number*/

   352     &BaseException_as_sequence, /*tp_as_sequence*/

   353     0,                          /*tp_as_mapping*/

   354     0,                          /*tp_hash */

   355     0,                          /*tp_call*/

   356     (reprfunc)BaseException_str,  /*tp_str*/

   357     PyObject_GenericGetAttr,    /*tp_getattro*/

   358     PyObject_GenericSetAttr,    /*tp_setattro*/

   359     0,                          /*tp_as_buffer*/

   360     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC |

   361     	Py_TPFLAGS_BASE_EXC_SUBCLASS,  /*tp_flags*/

   362     PyDoc_STR("Common base class for all exceptions"), /* tp_doc */

   363     (traverseproc)BaseException_traverse, /* tp_traverse */

   364     (inquiry)BaseException_clear, /* tp_clear */

   365     0,                          /* tp_richcompare */

   366     0,                          /* tp_weaklistoffset */

   367     0,                          /* tp_iter */

   368     0,                          /* tp_iternext */

   369     BaseException_methods,      /* tp_methods */

   370     0,                          /* tp_members */

   371     BaseException_getset,       /* tp_getset */

   372     0,                          /* tp_base */

   373     0,                          /* tp_dict */

   374     0,                          /* tp_descr_get */

   375     0,                          /* tp_descr_set */

   376     offsetof(PyBaseExceptionObject, dict), /* tp_dictoffset */

   377     (initproc)BaseException_init, /* tp_init */

   378     0,                          /* tp_alloc */

   379     BaseException_new,          /* tp_new */

   380 };

   381 /* the CPython API expects exceptions to be (PyObject *) - both a hold-over

   382 from the previous implmentation and also allowing Python objects to be used

   383 in the API */

   384 PyObject *PyExc_BaseException = (PyObject *)&_PyExc_BaseException;

   385 

   386 /* note these macros omit the last semicolon so the macro invocation may

   387  * include it and not look strange.

   388  */

   389 #define SimpleExtendsException(EXCBASE, EXCNAME, EXCDOC) \

   390 static PyTypeObject _PyExc_ ## EXCNAME = { \

   391     PyObject_HEAD_INIT(NULL) \

   392     0, \

   393     EXC_MODULE_NAME # EXCNAME, \

   394     sizeof(PyBaseExceptionObject), \

   395     0, (destructor)BaseException_dealloc, 0, 0, 0, 0, 0, 0, 0, \

   396     0, 0, 0, 0, 0, 0, 0, \

   397     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \

   398     PyDoc_STR(EXCDOC), (traverseproc)BaseException_traverse, \

   399     (inquiry)BaseException_clear, 0, 0, 0, 0, 0, 0, 0, &_ ## EXCBASE, \

   400     0, 0, 0, offsetof(PyBaseExceptionObject, dict), \

   401     (initproc)BaseException_init, 0, BaseException_new,\

   402 }; \

   403 PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME

   404 

   405 #define MiddlingExtendsException(EXCBASE, EXCNAME, EXCSTORE, EXCDOC) \

   406 static PyTypeObject _PyExc_ ## EXCNAME = { \

   407     PyObject_HEAD_INIT(NULL) \

   408     0, \

   409     EXC_MODULE_NAME # EXCNAME, \

   410     sizeof(Py ## EXCSTORE ## Object), \

   411     0, (destructor)EXCSTORE ## _dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, \

   412     0, 0, 0, 0, 0, \

   413     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \

   414     PyDoc_STR(EXCDOC), (traverseproc)EXCSTORE ## _traverse, \

   415     (inquiry)EXCSTORE ## _clear, 0, 0, 0, 0, 0, 0, 0, &_ ## EXCBASE, \

   416     0, 0, 0, offsetof(Py ## EXCSTORE ## Object, dict), \

   417     (initproc)EXCSTORE ## _init, 0, BaseException_new,\

   418 }; \

   419 PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME

   420 

   421 #define ComplexExtendsException(EXCBASE, EXCNAME, EXCSTORE, EXCDEALLOC, EXCMETHODS, EXCMEMBERS, EXCSTR, EXCDOC) \

   422 static PyTypeObject _PyExc_ ## EXCNAME = { \

   423     PyObject_HEAD_INIT(NULL) \

   424     0, \

   425     EXC_MODULE_NAME # EXCNAME, \

   426     sizeof(Py ## EXCSTORE ## Object), 0, \

   427     (destructor)EXCSTORE ## _dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \

   428     (reprfunc)EXCSTR, 0, 0, 0, \

   429     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \

   430     PyDoc_STR(EXCDOC), (traverseproc)EXCSTORE ## _traverse, \

   431     (inquiry)EXCSTORE ## _clear, 0, 0, 0, 0, EXCMETHODS, \

   432     EXCMEMBERS, 0, &_ ## EXCBASE, \

   433     0, 0, 0, offsetof(Py ## EXCSTORE ## Object, dict), \

   434     (initproc)EXCSTORE ## _init, 0, BaseException_new,\

   435 }; \

   436 PyObject *PyExc_ ## EXCNAME = (PyObject *)&_PyExc_ ## EXCNAME

   437 

   438 

   439 /*

   440  *    Exception extends BaseException

   441  */

   442 SimpleExtendsException(PyExc_BaseException, Exception,

   443                        "Common base class for all non-exit exceptions.");

   444 

   445 

   446 /*

   447  *    StandardError extends Exception

   448  */

   449 SimpleExtendsException(PyExc_Exception, StandardError,

   450     "Base class for all standard Python exceptions that do not represent\n"

   451     "interpreter exiting.");

   452 

   453 

   454 /*

   455  *    TypeError extends StandardError

   456  */

   457 SimpleExtendsException(PyExc_StandardError, TypeError,

   458                        "Inappropriate argument type.");

   459 

   460 

   461 /*

   462  *    StopIteration extends Exception

   463  */

   464 SimpleExtendsException(PyExc_Exception, StopIteration,

   465                        "Signal the end from iterator.next().");

   466 

   467 

   468 /*

   469  *    GeneratorExit extends BaseException

   470  */

   471 SimpleExtendsException(PyExc_BaseException, GeneratorExit,

   472                        "Request that a generator exit.");

   473 

   474 

   475 /*

   476  *    SystemExit extends BaseException

   477  */

   478 

   479 static int

   480 SystemExit_init(PySystemExitObject *self, PyObject *args, PyObject *kwds)

   481 {

   482     Py_ssize_t size = PyTuple_GET_SIZE(args);

   483 

   484     if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)

   485         return -1;

   486 

   487     if (size == 0)

   488         return 0;

   489     Py_CLEAR(self->code);

   490     if (size == 1)

   491         self->code = PyTuple_GET_ITEM(args, 0);

   492     else if (size > 1)

   493         self->code = args;

   494     Py_INCREF(self->code);

   495     return 0;

   496 }

   497 

   498 static int

   499 SystemExit_clear(PySystemExitObject *self)

   500 {

   501     Py_CLEAR(self->code);

   502     return BaseException_clear((PyBaseExceptionObject *)self);

   503 }

   504 

   505 static void

   506 SystemExit_dealloc(PySystemExitObject *self)

   507 {

   508     _PyObject_GC_UNTRACK(self);

   509     SystemExit_clear(self);

   510     Py_TYPE(self)->tp_free((PyObject *)self);

   511 }

   512 

   513 static int

   514 SystemExit_traverse(PySystemExitObject *self, visitproc visit, void *arg)

   515 {

   516     Py_VISIT(self->code);

   517     return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);

   518 }

   519 

   520 static PyMemberDef SystemExit_members[] = {

   521     {"code", T_OBJECT, offsetof(PySystemExitObject, code), 0,

   522         PyDoc_STR("exception code")},

   523     {NULL}  /* Sentinel */

   524 };

   525 

   526 ComplexExtendsException(PyExc_BaseException, SystemExit, SystemExit,

   527                         SystemExit_dealloc, 0, SystemExit_members, 0,

   528                         "Request to exit from the interpreter.");

   529 

   530 /*

   531  *    KeyboardInterrupt extends BaseException

   532  */

   533 SimpleExtendsException(PyExc_BaseException, KeyboardInterrupt,

   534                        "Program interrupted by user.");

   535 

   536 

   537 /*

   538  *    ImportError extends StandardError

   539  */

   540 SimpleExtendsException(PyExc_StandardError, ImportError,

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

   542 

   543 

   544 /*

   545  *    EnvironmentError extends StandardError

   546  */

   547 

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

   549  * of the os module functions, PyErr_SetFromErrnoWithFilename() is

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

   551  * that old code using in-place unpacking doesn't break, e.g.:

   552  *

   553  * except IOError, (errno, strerror):

   554  *

   555  * we hack args so that it only contains two items.  This also

   556  * means we need our own __str__() which prints out the filename

   557  * when it was supplied.

   558  */

   559 static int

   560 EnvironmentError_init(PyEnvironmentErrorObject *self, PyObject *args,

   561     PyObject *kwds)

   562 {

   563     PyObject *myerrno = NULL, *strerror = NULL, *filename = NULL;

   564     PyObject *subslice = NULL;

   565 

   566     if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)

   567         return -1;

   568 

   569     if (PyTuple_GET_SIZE(args) <= 1 || PyTuple_GET_SIZE(args) > 3) {

   570         return 0;

   571     }

   572 

   573     if (!PyArg_UnpackTuple(args, "EnvironmentError", 2, 3,

   574                            &myerrno, &strerror, &filename)) {

   575         return -1;

   576     }

   577     Py_CLEAR(self->myerrno);       /* replacing */

   578     self->myerrno = myerrno;

   579     Py_INCREF(self->myerrno);

   580 

   581     Py_CLEAR(self->strerror);      /* replacing */

   582     self->strerror = strerror;

   583     Py_INCREF(self->strerror);

   584 

   585     /* self->filename will remain Py_None otherwise */

   586     if (filename != NULL) {

   587         Py_CLEAR(self->filename);      /* replacing */

   588         self->filename = filename;

   589         Py_INCREF(self->filename);

   590 

   591         subslice = PyTuple_GetSlice(args, 0, 2);

   592         if (!subslice)

   593             return -1;

   594 

   595         Py_DECREF(self->args);  /* replacing args */

   596         self->args = subslice;

   597     }

   598     return 0;

   599 }

   600 

   601 static int

   602 EnvironmentError_clear(PyEnvironmentErrorObject *self)

   603 {

   604     Py_CLEAR(self->myerrno);

   605     Py_CLEAR(self->strerror);

   606     Py_CLEAR(self->filename);

   607     return BaseException_clear((PyBaseExceptionObject *)self);

   608 }

   609 

   610 static void

   611 EnvironmentError_dealloc(PyEnvironmentErrorObject *self)

   612 {

   613     _PyObject_GC_UNTRACK(self);

   614     EnvironmentError_clear(self);

   615     Py_TYPE(self)->tp_free((PyObject *)self);

   616 }

   617 

   618 static int

   619 EnvironmentError_traverse(PyEnvironmentErrorObject *self, visitproc visit,

   620         void *arg)

   621 {

   622     Py_VISIT(self->myerrno);

   623     Py_VISIT(self->strerror);

   624     Py_VISIT(self->filename);

   625     return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);

   626 }

   627 

   628 static PyObject *

   629 EnvironmentError_str(PyEnvironmentErrorObject *self)

   630 {

   631     PyObject *rtnval = NULL;

   632 

   633     if (self->filename) {

   634         PyObject *fmt;

   635         PyObject *repr;

   636         PyObject *tuple;

   637 

   638         fmt = PyString_FromString("[Errno %s] %s: %s");

   639         if (!fmt)

   640             return NULL;

   641 

   642         repr = PyObject_Repr(self->filename);

   643         if (!repr) {

   644             Py_DECREF(fmt);

   645             return NULL;

   646         }

   647         tuple = PyTuple_New(3);

   648         if (!tuple) {

   649             Py_DECREF(repr);

   650             Py_DECREF(fmt);

   651             return NULL;

   652         }

   653 

   654         if (self->myerrno) {

   655             Py_INCREF(self->myerrno);

   656             PyTuple_SET_ITEM(tuple, 0, self->myerrno);

   657         }

   658         else {

   659             Py_INCREF(Py_None);

   660             PyTuple_SET_ITEM(tuple, 0, Py_None);

   661         }

   662         if (self->strerror) {

   663             Py_INCREF(self->strerror);

   664             PyTuple_SET_ITEM(tuple, 1, self->strerror);

   665         }

   666         else {

   667             Py_INCREF(Py_None);

   668             PyTuple_SET_ITEM(tuple, 1, Py_None);

   669         }

   670 

   671         PyTuple_SET_ITEM(tuple, 2, repr);

   672 

   673         rtnval = PyString_Format(fmt, tuple);

   674 

   675         Py_DECREF(fmt);

   676         Py_DECREF(tuple);

   677     }

   678     else if (self->myerrno && self->strerror) {

   679         PyObject *fmt;

   680         PyObject *tuple;

   681 

   682         fmt = PyString_FromString("[Errno %s] %s");

   683         if (!fmt)

   684             return NULL;

   685 

   686         tuple = PyTuple_New(2);

   687         if (!tuple) {

   688             Py_DECREF(fmt);

   689             return NULL;

   690         }

   691 

   692         if (self->myerrno) {

   693             Py_INCREF(self->myerrno);

   694             PyTuple_SET_ITEM(tuple, 0, self->myerrno);

   695         }

   696         else {

   697             Py_INCREF(Py_None);

   698             PyTuple_SET_ITEM(tuple, 0, Py_None);

   699         }

   700         if (self->strerror) {

   701             Py_INCREF(self->strerror);

   702             PyTuple_SET_ITEM(tuple, 1, self->strerror);

   703         }

   704         else {

   705             Py_INCREF(Py_None);

   706             PyTuple_SET_ITEM(tuple, 1, Py_None);

   707         }

   708 

   709         rtnval = PyString_Format(fmt, tuple);

   710 

   711         Py_DECREF(fmt);

   712         Py_DECREF(tuple);

   713     }

   714     else

   715         rtnval = BaseException_str((PyBaseExceptionObject *)self);

   716 

   717     return rtnval;

   718 }

   719 

   720 static PyMemberDef EnvironmentError_members[] = {

   721     {"errno", T_OBJECT, offsetof(PyEnvironmentErrorObject, myerrno), 0,

   722         PyDoc_STR("exception errno")},

   723     {"strerror", T_OBJECT, offsetof(PyEnvironmentErrorObject, strerror), 0,

   724         PyDoc_STR("exception strerror")},

   725     {"filename", T_OBJECT, offsetof(PyEnvironmentErrorObject, filename), 0,

   726         PyDoc_STR("exception filename")},

   727     {NULL}  /* Sentinel */

   728 };

   729 

   730 

   731 static PyObject *

   732 EnvironmentError_reduce(PyEnvironmentErrorObject *self)

   733 {

   734     PyObject *args = self->args;

   735     PyObject *res = NULL, *tmp;

   736 

   737     /* self->args is only the first two real arguments if there was a

   738      * file name given to EnvironmentError. */

   739     if (PyTuple_GET_SIZE(args) == 2 && self->filename) {

   740         args = PyTuple_New(3);

   741         if (!args) return NULL;

   742 

   743         tmp = PyTuple_GET_ITEM(self->args, 0);

   744         Py_INCREF(tmp);

   745         PyTuple_SET_ITEM(args, 0, tmp);

   746 

   747         tmp = PyTuple_GET_ITEM(self->args, 1);

   748         Py_INCREF(tmp);

   749         PyTuple_SET_ITEM(args, 1, tmp);

   750 

   751         Py_INCREF(self->filename);

   752         PyTuple_SET_ITEM(args, 2, self->filename);

   753     } else

   754         Py_INCREF(args);

   755 

   756     if (self->dict)

   757         res = PyTuple_Pack(3, Py_TYPE(self), args, self->dict);

   758     else

   759         res = PyTuple_Pack(2, Py_TYPE(self), args);

   760     Py_DECREF(args);

   761     return res;

   762 }

   763 

   764 

   765 static PyMethodDef EnvironmentError_methods[] = {

   766     {"__reduce__", (PyCFunction)EnvironmentError_reduce, METH_NOARGS},

   767     {NULL}

   768 };

   769 

   770 ComplexExtendsException(PyExc_StandardError, EnvironmentError,

   771                         EnvironmentError, EnvironmentError_dealloc,

   772                         EnvironmentError_methods, EnvironmentError_members,

   773                         EnvironmentError_str,

   774                         "Base class for I/O related errors.");

   775 

   776 

   777 /*

   778  *    IOError extends EnvironmentError

   779  */

   780 MiddlingExtendsException(PyExc_EnvironmentError, IOError,

   781                          EnvironmentError, "I/O operation failed.");

   782 

   783 

   784 /*

   785  *    OSError extends EnvironmentError

   786  */

   787 MiddlingExtendsException(PyExc_EnvironmentError, OSError,

   788                          EnvironmentError, "OS system call failed.");

   789 

   790 

   791 /*

   792  *    WindowsError extends OSError

   793  */

   794 #ifdef MS_WINDOWS

   795 #include "errmap.h"

   796 

   797 static int

   798 WindowsError_clear(PyWindowsErrorObject *self)

   799 {

   800     Py_CLEAR(self->myerrno);

   801     Py_CLEAR(self->strerror);

   802     Py_CLEAR(self->filename);

   803     Py_CLEAR(self->winerror);

   804     return BaseException_clear((PyBaseExceptionObject *)self);

   805 }

   806 

   807 static void

   808 WindowsError_dealloc(PyWindowsErrorObject *self)

   809 {

   810     _PyObject_GC_UNTRACK(self);

   811     WindowsError_clear(self);

   812     Py_TYPE(self)->tp_free((PyObject *)self);

   813 }

   814 

   815 static int

   816 WindowsError_traverse(PyWindowsErrorObject *self, visitproc visit, void *arg)

   817 {

   818     Py_VISIT(self->myerrno);

   819     Py_VISIT(self->strerror);

   820     Py_VISIT(self->filename);

   821     Py_VISIT(self->winerror);

   822     return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);

   823 }

   824 

   825 static int

   826 WindowsError_init(PyWindowsErrorObject *self, PyObject *args, PyObject *kwds)

   827 {

   828     PyObject *o_errcode = NULL;

   829     long errcode;

   830     long posix_errno;

   831 

   832     if (EnvironmentError_init((PyEnvironmentErrorObject *)self, args, kwds)

   833             == -1)

   834         return -1;

   835 

   836     if (self->myerrno == NULL)

   837         return 0;

   838 

   839     /* Set errno to the POSIX errno, and winerror to the Win32

   840        error code. */

   841     errcode = PyInt_AsLong(self->myerrno);

   842     if (errcode == -1 && PyErr_Occurred())

   843         return -1;

   844     posix_errno = winerror_to_errno(errcode);

   845 

   846     Py_CLEAR(self->winerror);

   847     self->winerror = self->myerrno;

   848 

   849     o_errcode = PyInt_FromLong(posix_errno);

   850     if (!o_errcode)

   851         return -1;

   852 

   853     self->myerrno = o_errcode;

   854 

   855     return 0;

   856 }

   857 

   858 

   859 static PyObject *

   860 WindowsError_str(PyWindowsErrorObject *self)

   861 {

   862     PyObject *rtnval = NULL;

   863 

   864     if (self->filename) {

   865         PyObject *fmt;

   866         PyObject *repr;

   867         PyObject *tuple;

   868 

   869         fmt = PyString_FromString("[Error %s] %s: %s");

   870         if (!fmt)

   871             return NULL;

   872 

   873         repr = PyObject_Repr(self->filename);

   874         if (!repr) {

   875             Py_DECREF(fmt);

   876             return NULL;

   877         }

   878         tuple = PyTuple_New(3);

   879         if (!tuple) {

   880             Py_DECREF(repr);

   881             Py_DECREF(fmt);

   882             return NULL;

   883         }

   884 

   885         if (self->winerror) {

   886             Py_INCREF(self->winerror);

   887             PyTuple_SET_ITEM(tuple, 0, self->winerror);

   888         }

   889         else {

   890             Py_INCREF(Py_None);

   891             PyTuple_SET_ITEM(tuple, 0, Py_None);

   892         }

   893         if (self->strerror) {

   894             Py_INCREF(self->strerror);

   895             PyTuple_SET_ITEM(tuple, 1, self->strerror);

   896         }

   897         else {

   898             Py_INCREF(Py_None);

   899             PyTuple_SET_ITEM(tuple, 1, Py_None);

   900         }

   901 

   902         PyTuple_SET_ITEM(tuple, 2, repr);

   903 

   904         rtnval = PyString_Format(fmt, tuple);

   905 

   906         Py_DECREF(fmt);

   907         Py_DECREF(tuple);

   908     }

   909     else if (self->winerror && self->strerror) {

   910         PyObject *fmt;

   911         PyObject *tuple;

   912 

   913         fmt = PyString_FromString("[Error %s] %s");

   914         if (!fmt)

   915             return NULL;

   916 

   917         tuple = PyTuple_New(2);

   918         if (!tuple) {

   919             Py_DECREF(fmt);

   920             return NULL;

   921         }

   922 

   923         if (self->winerror) {

   924             Py_INCREF(self->winerror);

   925             PyTuple_SET_ITEM(tuple, 0, self->winerror);

   926         }

   927         else {

   928             Py_INCREF(Py_None);

   929             PyTuple_SET_ITEM(tuple, 0, Py_None);

   930         }

   931         if (self->strerror) {

   932             Py_INCREF(self->strerror);

   933             PyTuple_SET_ITEM(tuple, 1, self->strerror);

   934         }

   935         else {

   936             Py_INCREF(Py_None);

   937             PyTuple_SET_ITEM(tuple, 1, Py_None);

   938         }

   939 

   940         rtnval = PyString_Format(fmt, tuple);

   941 

   942         Py_DECREF(fmt);

   943         Py_DECREF(tuple);

   944     }

   945     else

   946         rtnval = EnvironmentError_str((PyEnvironmentErrorObject *)self);

   947 

   948     return rtnval;

   949 }

   950 

   951 static PyMemberDef WindowsError_members[] = {

   952     {"errno", T_OBJECT, offsetof(PyWindowsErrorObject, myerrno), 0,

   953         PyDoc_STR("POSIX exception code")},

   954     {"strerror", T_OBJECT, offsetof(PyWindowsErrorObject, strerror), 0,

   955         PyDoc_STR("exception strerror")},

   956     {"filename", T_OBJECT, offsetof(PyWindowsErrorObject, filename), 0,

   957         PyDoc_STR("exception filename")},

   958     {"winerror", T_OBJECT, offsetof(PyWindowsErrorObject, winerror), 0,

   959         PyDoc_STR("Win32 exception code")},

   960     {NULL}  /* Sentinel */

   961 };

   962 

   963 ComplexExtendsException(PyExc_OSError, WindowsError, WindowsError,

   964                         WindowsError_dealloc, 0, WindowsError_members,

   965                         WindowsError_str, "MS-Windows OS system call failed.");

   966 

   967 #endif /* MS_WINDOWS */

   968 

   969 

   970 /*

   971  *    VMSError extends OSError (I think)

   972  */

   973 #ifdef __VMS

   974 MiddlingExtendsException(PyExc_OSError, VMSError, EnvironmentError,

   975                          "OpenVMS OS system call failed.");

   976 #endif

   977 

   978 

   979 /*

   980  *    EOFError extends StandardError

   981  */

   982 SimpleExtendsException(PyExc_StandardError, EOFError,

   983                        "Read beyond end of file.");

   984 

   985 

   986 /*

   987  *    RuntimeError extends StandardError

   988  */

   989 SimpleExtendsException(PyExc_StandardError, RuntimeError,

   990                        "Unspecified run-time error.");

   991 

   992 

   993 /*

   994  *    NotImplementedError extends RuntimeError

   995  */

   996 SimpleExtendsException(PyExc_RuntimeError, NotImplementedError,

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

   998 

   999 /*

  1000  *    NameError extends StandardError

  1001  */

  1002 SimpleExtendsException(PyExc_StandardError, NameError,

  1003                        "Name not found globally.");

  1004 

  1005 /*

  1006  *    UnboundLocalError extends NameError

  1007  */

  1008 SimpleExtendsException(PyExc_NameError, UnboundLocalError,

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

  1010 

  1011 /*

  1012  *    AttributeError extends StandardError

  1013  */

  1014 SimpleExtendsException(PyExc_StandardError, AttributeError,

  1015                        "Attribute not found.");

  1016 

  1017 

  1018 /*

  1019  *    SyntaxError extends StandardError

  1020  */

  1021 

  1022 static int

  1023 SyntaxError_init(PySyntaxErrorObject *self, PyObject *args, PyObject *kwds)

  1024 {

  1025     PyObject *info = NULL;

  1026     Py_ssize_t lenargs = PyTuple_GET_SIZE(args);

  1027 

  1028     if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)

  1029         return -1;

  1030 

  1031     if (lenargs >= 1) {

  1032         Py_CLEAR(self->msg);

  1033         self->msg = PyTuple_GET_ITEM(args, 0);

  1034         Py_INCREF(self->msg);

  1035     }

  1036     if (lenargs == 2) {

  1037         info = PyTuple_GET_ITEM(args, 1);

  1038         info = PySequence_Tuple(info);

  1039         if (!info) return -1;

  1040 

  1041         if (PyTuple_GET_SIZE(info) != 4) {

  1042             /* not a very good error message, but it's what Python 2.4 gives */

  1043             PyErr_SetString(PyExc_IndexError, "tuple index out of range");

  1044             Py_DECREF(info);

  1045             return -1;

  1046         }

  1047 

  1048         Py_CLEAR(self->filename);

  1049         self->filename = PyTuple_GET_ITEM(info, 0);

  1050         Py_INCREF(self->filename);

  1051 

  1052         Py_CLEAR(self->lineno);

  1053         self->lineno = PyTuple_GET_ITEM(info, 1);

  1054         Py_INCREF(self->lineno);

  1055 

  1056         Py_CLEAR(self->offset);

  1057         self->offset = PyTuple_GET_ITEM(info, 2);

  1058         Py_INCREF(self->offset);

  1059 

  1060         Py_CLEAR(self->text);

  1061         self->text = PyTuple_GET_ITEM(info, 3);

  1062         Py_INCREF(self->text);

  1063 

  1064         Py_DECREF(info);

  1065     }

  1066     return 0;

  1067 }

  1068 

  1069 static int

  1070 SyntaxError_clear(PySyntaxErrorObject *self)

  1071 {

  1072     Py_CLEAR(self->msg);

  1073     Py_CLEAR(self->filename);

  1074     Py_CLEAR(self->lineno);

  1075     Py_CLEAR(self->offset);

  1076     Py_CLEAR(self->text);

  1077     Py_CLEAR(self->print_file_and_line);

  1078     return BaseException_clear((PyBaseExceptionObject *)self);

  1079 }

  1080 

  1081 static void

  1082 SyntaxError_dealloc(PySyntaxErrorObject *self)

  1083 {

  1084     _PyObject_GC_UNTRACK(self);

  1085     SyntaxError_clear(self);

  1086     Py_TYPE(self)->tp_free((PyObject *)self);

  1087 }

  1088 

  1089 static int

  1090 SyntaxError_traverse(PySyntaxErrorObject *self, visitproc visit, void *arg)

  1091 {

  1092     Py_VISIT(self->msg);

  1093     Py_VISIT(self->filename);

  1094     Py_VISIT(self->lineno);

  1095     Py_VISIT(self->offset);

  1096     Py_VISIT(self->text);

  1097     Py_VISIT(self->print_file_and_line);

  1098     return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);

  1099 }

  1100 

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

  1102    conflicts with glibc; basename is already prototyped if _GNU_SOURCE is

  1103    defined, and Python does define that. */

  1104 static char *

  1105 my_basename(char *name)

  1106 {

  1107     char *cp = name;

  1108     char *result = name;

  1109 

  1110     if (name == NULL)

  1111         return "???";

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

  1113         if (*cp == SEP)

  1114             result = cp + 1;

  1115         ++cp;

  1116     }

  1117     return result;

  1118 }

  1119 

  1120 

  1121 static PyObject *

  1122 SyntaxError_str(PySyntaxErrorObject *self)

  1123 {

  1124     PyObject *str;

  1125     PyObject *result;

  1126     int have_filename = 0;

  1127     int have_lineno = 0;

  1128     char *buffer = NULL;

  1129     Py_ssize_t bufsize;

  1130 

  1131     if (self->msg)

  1132         str = PyObject_Str(self->msg);

  1133     else

  1134         str = PyObject_Str(Py_None);

  1135     if (!str) return NULL;