/*

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

*

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

*/

#define PY_SSIZE_T_CLEAN

#include <Python.h>

#include "pycore_initconfig.h"

#include "pycore_object.h"

#include "structmember.h" // PyMemberDef

#include "osdefs.h" // SEP

/* Compatibility aliases */

PyObject *PyExc_EnvironmentError = NULL;

PyObject *PyExc_IOError = NULL;

#ifdef MS_WINDOWS

PyObject *PyExc_WindowsError = NULL;

#endif

/* The dict map from errno codes to OSError subclasses */

static PyObject *errnomap = NULL;

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

* Lib/test/exception_hierarchy.txt

*/

/*

* BaseException

*/

static PyObject *

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

{

PyBaseExceptionObject *self;

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

if (!self)

return NULL;

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

self->dict = NULL;

self->traceback = self->cause = self->context = NULL;

self->suppress_context = 0;

if (args) {

self->args = args;

Py_INCREF(args);

return (PyObject *)self;

}

self->args = PyTuple_New(0);

if (!self->args) {

Py_DECREF(self);

return NULL;

}

return (PyObject *)self;

}

static int

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

{

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

return -1;

Py_INCREF(args);

Py_XSETREF(self->args, args);

return 0;

}

static int

BaseException_clear(PyBaseExceptionObject *self)

{

Py_CLEAR(self->dict);

Py_CLEAR(self->args);

Py_CLEAR(self->traceback);

Py_CLEAR(self->cause);

Py_CLEAR(self->context);

return 0;

}

static void

BaseException_dealloc(PyBaseExceptionObject *self)

{

_PyObject_GC_UNTRACK(self);

BaseException_clear(self);

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

}

static int

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

{

Py_VISIT(self->dict);

Py_VISIT(self->args);

Py_VISIT(self->traceback);

Py_VISIT(self->cause);

Py_VISIT(self->context);

return 0;

}

static PyObject *

BaseException_str(PyBaseExceptionObject *self)

{

switch (PyTuple_GET_SIZE(self->args)) {

case 0:

return PyUnicode_FromString("");

case 1:

return PyObject_Str(PyTuple_GET_ITEM(self->args, 0));

default:

return PyObject_Str(self->args);

}

}

static PyObject *

BaseException_repr(PyBaseExceptionObject *self)

{

const char *name = _PyType_Name(Py_TYPE(self));

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

return PyUnicode_FromFormat("%s(%R)", name,

PyTuple_GET_ITEM(self->args, 0));

else

return PyUnicode_FromFormat("%s%R", name, self->args);

}

/* Pickling support */

static PyObject *

BaseException_reduce(PyBaseExceptionObject *self, PyObject *Py_UNUSED(ignored))

{

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

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

else

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

}

/*

* Needed for backward compatibility, since exceptions used to store

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

* load_build function.

*/

static PyObject *

BaseException_setstate(PyObject *self, PyObject *state)

{

PyObject *d_key, *d_value;

Py_ssize_t i = 0;

if (state != Py_None) {

if (!PyDict_Check(state)) {

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

return NULL;

}

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

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

return NULL;

}

}

Py_RETURN_NONE;

}

static PyObject *

BaseException_with_traceback(PyObject *self, PyObject *tb) {

if (PyException_SetTraceback(self, tb))

return NULL;

Py_INCREF(self);

return self;

}

PyDoc_STRVAR(with_traceback_doc,

"Exception.with_traceback(tb) --\n\

set self.__traceback__ to tb and return self.");

static PyMethodDef BaseException_methods[] = {

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

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

{"with_traceback", (PyCFunction)BaseException_with_traceback, METH_O,

with_traceback_doc},

{NULL, NULL, 0, NULL},

};

static PyObject *

BaseException_get_args(PyBaseExceptionObject *self, void *Py_UNUSED(ignored))

{

if (self->args == NULL) {

Py_RETURN_NONE;

}

Py_INCREF(self->args);

return self->args;

}

static int

BaseException_set_args(PyBaseExceptionObject *self, PyObject *val, void *Py_UNUSED(ignored))

{

PyObject *seq;

if (val == NULL) {

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

return -1;

}

seq = PySequence_Tuple(val);

if (!seq)

return -1;

Py_XSETREF(self->args, seq);

return 0;

}

static PyObject *

BaseException_get_tb(PyBaseExceptionObject *self, void *Py_UNUSED(ignored))

{

if (self->traceback == NULL) {

Py_RETURN_NONE;

}

Py_INCREF(self->traceback);

return self->traceback;

}

static int

BaseException_set_tb(PyBaseExceptionObject *self, PyObject *tb, void *Py_UNUSED(ignored))

{

if (tb == NULL) {

PyErr_SetString(PyExc_TypeError, "__traceback__ may not be deleted");

return -1;

}

else if (!(tb == Py_None || PyTraceBack_Check(tb))) {

PyErr_SetString(PyExc_TypeError,

"__traceback__ must be a traceback or None");

return -1;

}

Py_INCREF(tb);

Py_XSETREF(self->traceback, tb);

return 0;

}

static PyObject *

BaseException_get_context(PyObject *self, void *Py_UNUSED(ignored))

{

PyObject *res = PyException_GetContext(self);

if (res)

return res; /* new reference already returned above */

Py_RETURN_NONE;

}

static int

BaseException_set_context(PyObject *self, PyObject *arg, void *Py_UNUSED(ignored))

{

if (arg == NULL) {

PyErr_SetString(PyExc_TypeError, "__context__ may not be deleted");

return -1;

} else if (arg == Py_None) {

arg = NULL;

} else if (!PyExceptionInstance_Check(arg)) {

PyErr_SetString(PyExc_TypeError, "exception context must be None "

"or derive from BaseException");

return -1;

} else {

/* PyException_SetContext steals this reference */

Py_INCREF(arg);

}

PyException_SetContext(self, arg);

return 0;

}

static PyObject *

BaseException_get_cause(PyObject *self, void *Py_UNUSED(ignored))

{

PyObject *res = PyException_GetCause(self);

if (res)

return res; /* new reference already returned above */

Py_RETURN_NONE;

}

static int

BaseException_set_cause(PyObject *self, PyObject *arg, void *Py_UNUSED(ignored))

{

if (arg == NULL) {

PyErr_SetString(PyExc_TypeError, "__cause__ may not be deleted");

return -1;

} else if (arg == Py_None) {

arg = NULL;

} else if (!PyExceptionInstance_Check(arg)) {

PyErr_SetString(PyExc_TypeError, "exception cause must be None "

"or derive from BaseException");

return -1;

} else {

/* PyException_SetCause steals this reference */

Py_INCREF(arg);

}

PyException_SetCause(self, arg);

return 0;

}

static PyGetSetDef BaseException_getset[] = {

{"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict},

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

{"__traceback__", (getter)BaseException_get_tb, (setter)BaseException_set_tb},

{"__context__", BaseException_get_context,

BaseException_set_context, PyDoc_STR("exception context")},

{"__cause__", BaseException_get_cause,

BaseException_set_cause, PyDoc_STR("exception cause")},

{NULL},

};

static inline PyBaseExceptionObject*

_PyBaseExceptionObject_cast(PyObject *exc)

{

assert(PyExceptionInstance_Check(exc));

return (PyBaseExceptionObject *)exc;

}

PyObject *

PyException_GetTraceback(PyObject *self)

{

PyBaseExceptionObject *base_self = _PyBaseExceptionObject_cast(self);

Py_XINCREF(base_self->traceback);

return base_self->traceback;

}

int

PyException_SetTraceback(PyObject *self, PyObject *tb)

{

return BaseException_set_tb(_PyBaseExceptionObject_cast(self), tb, NULL);

}

PyObject *

PyException_GetCause(PyObject *self)

{

PyObject *cause = _PyBaseExceptionObject_cast(self)->cause;

Py_XINCREF(cause);

return cause;

}

/* Steals a reference to cause */

void

PyException_SetCause(PyObject *self, PyObject *cause)

{

PyBaseExceptionObject *base_self = _PyBaseExceptionObject_cast(self);

base_self->suppress_context = 1;

Py_XSETREF(base_self->cause, cause);

}

PyObject *

PyException_GetContext(PyObject *self)

{

PyObject *context = _PyBaseExceptionObject_cast(self)->context;

Py_XINCREF(context);

return context;

}

/* Steals a reference to context */

void

PyException_SetContext(PyObject *self, PyObject *context)

{

Py_XSETREF(_PyBaseExceptionObject_cast(self)->context, context);

}

#undef PyExceptionClass_Name

const char *

PyExceptionClass_Name(PyObject *ob)

{

assert(PyExceptionClass_Check(ob));

return ((PyTypeObject*)ob)->tp_name;

}

static struct PyMemberDef BaseException_members[] = {

{"__suppress_context__", T_BOOL,

offsetof(PyBaseExceptionObject, suppress_context)},

{NULL}

};

static PyTypeObject _PyExc_BaseException = {

PyVarObject_HEAD_INIT(NULL, 0)

"BaseException", /*tp_name*/

sizeof(PyBaseExceptionObject), /*tp_basicsize*/

0, /*tp_itemsize*/

(destructor)BaseException_dealloc, /*tp_dealloc*/

0, /*tp_vectorcall_offset*/

0, /*tp_getattr*/

0, /*tp_setattr*/

0, /*tp_as_async*/

(reprfunc)BaseException_repr, /*tp_repr*/

0, /*tp_as_number*/

0, /*tp_as_sequence*/

0, /*tp_as_mapping*/

0, /*tp_hash */

0, /*tp_call*/

(reprfunc)BaseException_str, /*tp_str*/

PyObject_GenericGetAttr, /*tp_getattro*/

PyObject_GenericSetAttr, /*tp_setattro*/

0, /*tp_as_buffer*/

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC |

Py_TPFLAGS_BASE_EXC_SUBCLASS, /*tp_flags*/

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

(traverseproc)BaseException_traverse, /* tp_traverse */

(inquiry)BaseException_clear, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

BaseException_methods, /* tp_methods */

BaseException_members, /* tp_members */

BaseException_getset, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

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

(initproc)BaseException_init, /* tp_init */

0, /* tp_alloc */

BaseException_new, /* tp_new */

};

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

from the previous implementation and also allowing Python objects to be used

in the API */

PyObject *PyExc_BaseException = (PyObject *)&_PyExc_BaseException;

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

* include it and not look strange.

*/

#define SimpleExtendsException(EXCBASE, EXCNAME, EXCDOC) \

static PyTypeObject _PyExc_ ## EXCNAME = { \

PyVarObject_HEAD_INIT(NULL, 0) \

# EXCNAME, \

sizeof(PyBaseExceptionObject), \

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

0, 0, 0, 0, 0, 0, 0, \

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \

PyDoc_STR(EXCDOC), (traverseproc)BaseException_traverse, \

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

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

(initproc)BaseException_init, 0, BaseException_new,\

}; \

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

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

static PyTypeObject _PyExc_ ## EXCNAME = { \

PyVarObject_HEAD_INIT(NULL, 0) \

# EXCNAME, \

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

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

0, 0, 0, 0, 0, \

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \

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

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

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

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

}; \

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

#define ComplexExtendsException(EXCBASE, EXCNAME, EXCSTORE, EXCNEW, \

EXCMETHODS, EXCMEMBERS, EXCGETSET, \

EXCSTR, EXCDOC) \

static PyTypeObject _PyExc_ ## EXCNAME = { \

PyVarObject_HEAD_INIT(NULL, 0) \

# EXCNAME, \

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

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

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

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \

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

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

EXCMEMBERS, EXCGETSET, &_ ## EXCBASE, \

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

(initproc)EXCSTORE ## _init, 0, EXCNEW,\

}; \

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

/*

* Exception extends BaseException

*/

SimpleExtendsException(PyExc_BaseException, Exception,

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

/*

* TypeError extends Exception

*/

SimpleExtendsException(PyExc_Exception, TypeError,

"Inappropriate argument type.");

/*

* StopAsyncIteration extends Exception

*/

SimpleExtendsException(PyExc_Exception, StopAsyncIteration,

"Signal the end from iterator.__anext__().");

/*

* StopIteration extends Exception

*/

static PyMemberDef StopIteration_members[] = {

{"value", T_OBJECT, offsetof(PyStopIterationObject, value), 0,

PyDoc_STR("generator return value")},

{NULL} /* Sentinel */

};

static int

StopIteration_init(PyStopIterationObject *self, PyObject *args, PyObject *kwds)

{

Py_ssize_t size = PyTuple_GET_SIZE(args);

PyObject *value;

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

return -1;

Py_CLEAR(self->value);

if (size > 0)

value = PyTuple_GET_ITEM(args, 0);

else

value = Py_None;

Py_INCREF(value);

self->value = value;

return 0;

}

static int

StopIteration_clear(PyStopIterationObject *self)

{

Py_CLEAR(self->value);

return BaseException_clear((PyBaseExceptionObject *)self);

}

static void

StopIteration_dealloc(PyStopIterationObject *self)

{

_PyObject_GC_UNTRACK(self);

StopIteration_clear(self);

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

}

static int

StopIteration_traverse(PyStopIterationObject *self, visitproc visit, void *arg)

{

Py_VISIT(self->value);

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

}

ComplexExtendsException(

PyExc_Exception, /* base */

StopIteration, /* name */

StopIteration, /* prefix for *_init, etc */

0, /* new */

0, /* methods */

StopIteration_members, /* members */

0, /* getset */

0, /* str */

"Signal the end from iterator.__next__()."

);

/*

* GeneratorExit extends BaseException

*/

SimpleExtendsException(PyExc_BaseException, GeneratorExit,

"Request that a generator exit.");

/*

* SystemExit extends BaseException

*/

static int

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

{

Py_ssize_t size = PyTuple_GET_SIZE(args);

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

return -1;

if (size == 0)

return 0;

if (size == 1) {

Py_INCREF(PyTuple_GET_ITEM(args, 0));

Py_XSETREF(self->code, PyTuple_GET_ITEM(args, 0));

}

else { /* size > 1 */

Py_INCREF(args);

Py_XSETREF(self->code, args);

}

return 0;

}

static int

SystemExit_clear(PySystemExitObject *self)

{

Py_CLEAR(self->code);

return BaseException_clear((PyBaseExceptionObject *)self);

}

static void

SystemExit_dealloc(PySystemExitObject *self)

{

_PyObject_GC_UNTRACK(self);

SystemExit_clear(self);

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

}

static int

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

{

Py_VISIT(self->code);

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

}

static PyMemberDef SystemExit_members[] = {

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

PyDoc_STR("exception code")},

{NULL} /* Sentinel */

};

ComplexExtendsException(PyExc_BaseException, SystemExit, SystemExit,

0, 0, SystemExit_members, 0, 0,

"Request to exit from the interpreter.");

/*

* KeyboardInterrupt extends BaseException

*/

SimpleExtendsException(PyExc_BaseException, KeyboardInterrupt,

"Program interrupted by user.");

/*

* ImportError extends Exception

*/

static int

ImportError_init(PyImportErrorObject *self, PyObject *args, PyObject *kwds)

{

static char *kwlist[] = {"name", "path", 0};

PyObject *empty_tuple;

PyObject *msg = NULL;

PyObject *name = NULL;

PyObject *path = NULL;

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

return -1;

empty_tuple = PyTuple_New(0);

if (!empty_tuple)

return -1;

if (!PyArg_ParseTupleAndKeywords(empty_tuple, kwds, "|$OO:ImportError", kwlist,

&name, &path)) {

Py_DECREF(empty_tuple);

return -1;

}

Py_DECREF(empty_tuple);

Py_XINCREF(name);

Py_XSETREF(self->name, name);

Py_XINCREF(path);

Py_XSETREF(self->path, path);

if (PyTuple_GET_SIZE(args) == 1) {

msg = PyTuple_GET_ITEM(args, 0);

Py_INCREF(msg);

}

Py_XSETREF(self->msg, msg);

return 0;

}

static int

ImportError_clear(PyImportErrorObject *self)

{

Py_CLEAR(self->msg);

Py_CLEAR(self->name);

Py_CLEAR(self->path);

return BaseException_clear((PyBaseExceptionObject *)self);

}

static void

ImportError_dealloc(PyImportErrorObject *self)

{

_PyObject_GC_UNTRACK(self);

ImportError_clear(self);

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

}

static int

ImportError_traverse(PyImportErrorObject *self, visitproc visit, void *arg)

{

Py_VISIT(self->msg);

Py_VISIT(self->name);

Py_VISIT(self->path);

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

}

static PyObject *

ImportError_str(PyImportErrorObject *self)

{

if (self->msg && PyUnicode_CheckExact(self->msg)) {

Py_INCREF(self->msg);

return self->msg;

}

else {

return BaseException_str((PyBaseExceptionObject *)self);

}

}

static PyObject *

ImportError_getstate(PyImportErrorObject *self)

{

PyObject *dict = ((PyBaseExceptionObject *)self)->dict;

if (self->name || self->path) {

_Py_IDENTIFIER(name);

_Py_IDENTIFIER(path);

dict = dict ? PyDict_Copy(dict) : PyDict_New();

if (dict == NULL)

return NULL;

if (self->name && _PyDict_SetItemId(dict, &PyId_name, self->name) < 0) {

Py_DECREF(dict);

return NULL;

}

if (self->path && _PyDict_SetItemId(dict, &PyId_path, self->path) < 0) {

Py_DECREF(dict);

return NULL;

}

return dict;

}

else if (dict) {

Py_INCREF(dict);

return dict;

}

else {

Py_RETURN_NONE;

}

}

/* Pickling support */

static PyObject *

ImportError_reduce(PyImportErrorObject *self, PyObject *Py_UNUSED(ignored))

{

PyObject *res;

PyObject *args;

PyObject *state = ImportError_getstate(self);

if (state == NULL)

return NULL;

args = ((PyBaseExceptionObject *)self)->args;

if (state == Py_None)

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

else

res = PyTuple_Pack(3, Py_TYPE(self), args, state);

Py_DECREF(state);

return res;

}

static PyMemberDef ImportError_members[] = {

{"msg", T_OBJECT, offsetof(PyImportErrorObject, msg), 0,

PyDoc_STR("exception message")},

{"name", T_OBJECT, offsetof(PyImportErrorObject, name), 0,

PyDoc_STR("module name")},

{"path", T_OBJECT, offsetof(PyImportErrorObject, path), 0,

PyDoc_STR("module path")},

{NULL} /* Sentinel */

};

static PyMethodDef ImportError_methods[] = {

{"__reduce__", (PyCFunction)ImportError_reduce, METH_NOARGS},

{NULL}

};

ComplexExtendsException(PyExc_Exception, ImportError,

ImportError, 0 /* new */,

ImportError_methods, ImportError_members,

0 /* getset */, ImportError_str,

"Import can't find module, or can't find name in "

"module.");

/*

* ModuleNotFoundError extends ImportError

*/

MiddlingExtendsException(PyExc_ImportError, ModuleNotFoundError, ImportError,

"Module not found.");

/*

* OSError extends Exception

*/

#ifdef MS_WINDOWS

#include "errmap.h"

#endif

/* 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 OSError, (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.

*

* (If a function has two filenames, such as rename(), symlink(),

* or copy(), PyErr_SetFromErrnoWithFilenameObjects() is called,

* which allows passing in a second filename.)

*/

/* This function doesn't cleanup on error, the caller should */

static int

oserror_parse_args(PyObject **p_args,

PyObject **myerrno, PyObject **strerror,

PyObject **filename, PyObject **filename2

#ifdef MS_WINDOWS

, PyObject **winerror

#endif

)

{

Py_ssize_t nargs;

PyObject *args = *p_args;

#ifndef MS_WINDOWS

/*

* ignored on non-Windows platforms,

* but parsed so OSError has a consistent signature

*/

PyObject *_winerror = NULL;

PyObject **winerror = &_winerror;

#endif /* MS_WINDOWS */

nargs = PyTuple_GET_SIZE(args);

if (nargs >= 2 && nargs <= 5) {

if (!PyArg_UnpackTuple(args, "OSError", 2, 5,

myerrno, strerror,

filename, winerror, filename2))

return -1;

#ifdef MS_WINDOWS

if (*winerror && PyLong_Check(*winerror)) {

long errcode, winerrcode;

PyObject *newargs;

Py_ssize_t i;

winerrcode = PyLong_AsLong(*winerror);

if (winerrcode == -1 && PyErr_Occurred())

return -1;

/* Set errno to the corresponding POSIX errno (overriding

first argument). Windows Socket error codes (>= 10000)

have the same value as their POSIX counterparts.

*/

if (winerrcode < 10000)

errcode = winerror_to_errno(winerrcode);

else

errcode = winerrcode;

*myerrno = PyLong_FromLong(errcode);

if (!*myerrno)

return -1;

newargs = PyTuple_New(nargs);

if (!newargs)

return -1;

PyTuple_SET_ITEM(newargs, 0, *myerrno);

for (i = 1; i < nargs; i++) {

PyObject *val = PyTuple_GET_ITEM(args, i);

Py_INCREF(val);

PyTuple_SET_ITEM(newargs, i, val);

}

Py_DECREF(args);

args = *p_args = newargs;

}

#endif /* MS_WINDOWS */

}

return 0;

}

static int

oserror_init(PyOSErrorObject *self, PyObject **p_args,

PyObject *myerrno, PyObject *strerror,

PyObject *filename, PyObject *filename2

#ifdef MS_WINDOWS

, PyObject *winerror

#endif

)

{

PyObject *args = *p_args;

Py_ssize_t nargs = PyTuple_GET_SIZE(args);

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

if (filename && filename != Py_None) {

if (Py_IS_TYPE(self, (PyTypeObject *) PyExc_BlockingIOError) &&

PyNumber_Check(filename)) {

/* BlockingIOError's 3rd argument can be the number of

* characters written.

*/

self->written = PyNumber_AsSsize_t(filename, PyExc_ValueError);

if (self->written == -1 && PyErr_Occurred())

return -1;

}

else {

Py_INCREF(filename);

self->filename = filename;

if (filename2 && filename2 != Py_None) {

Py_INCREF(filename2);

self->filename2 = filename2;

}

if (nargs >= 2 && nargs <= 5) {

/* filename, filename2, and winerror are removed from the args tuple

(for compatibility purposes, see test_exceptions.py) */

PyObject *subslice = PyTuple_GetSlice(args, 0, 2);

if (!subslice)

return -1;

Py_DECREF(args); /* replacing args */

*p_args = args = subslice;

}

}

}

Py_XINCREF(myerrno);

self->myerrno = myerrno;

Py_XINCREF(strerror);

self->strerror = strerror;

#ifdef MS_WINDOWS

Py_XINCREF(winerror);

self->winerror = winerror;

#endif

/* Steals the reference to args */

Py_XSETREF(self->args, args);

*p_args = args = NULL;

return 0;

}

static PyObject *

OSError_new(PyTypeObject *type, PyObject *args, PyObject *kwds);

static int

OSError_init(PyOSErrorObject *self, PyObject *args, PyObject *kwds);

static int

oserror_use_init(PyTypeObject *type)

{

/* When __init__ is defined in an OSError subclass, we want any

extraneous argument to __new__ to be ignored. The only reasonable

solution, given __new__ takes a variable number of arguments,

is to defer arg parsing and initialization to __init__.

But when __new__ is overridden as well, it should call our __new__

with the right arguments.

(see http://bugs.python.org/issue12555#msg148829 )

*/

if (type->tp_init != (initproc) OSError_init &&

type->tp_new == (newfunc) OSError_new) {

assert((PyObject *) type != PyExc_OSError);

return 1;

}

return 0;

}

static PyObject *

OSError_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

PyOSErrorObject *self = NULL;

PyObject *myerrno = NULL, *strerror = NULL;

PyObject *filename = NULL, *filename2 = NULL;

#ifdef MS_WINDOWS

PyObject *winerror = NULL;

#endif

Py_INCREF(args);

if (!oserror_use_init(type)) {

if (!_PyArg_NoKeywords(type->tp_name, kwds))

goto error;

if (oserror_parse_args(&args, &myerrno, &strerror,

&filename, &filename2

#ifdef MS_WINDOWS

, &winerror

#endif

))

goto error;

if (myerrno && PyLong_Check(myerrno) &&

errnomap && (PyObject *) type == PyExc_OSError) {

PyObject *newtype;

newtype = PyDict_GetItemWithError(errnomap, myerrno);

if (newtype) {

assert(PyType_Check(newtype));

type = (PyTypeObject *) newtype;

}

else if (PyErr_Occurred())

goto error;

}

}