cpython/Objects/exceptions.c at main · python/cpython

4652 lines (4036 loc) · 132 KB

B94A

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

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

#include <Python.h>

#include <stdbool.h>

#include "pycore_abstract.h" // _PyObject_RealIsSubclass()

#include "pycore_ceval.h" // _Py_EnterRecursiveCall

#include "pycore_exceptions.h" // struct _Py_exc_state

#include "pycore_initconfig.h"

#include "pycore_modsupport.h" // _PyArg_NoKeywords()

#include "pycore_object.h"

#include "pycore_pyerrors.h" // struct _PyErr_SetRaisedException

#include "osdefs.h" // SEP

#include "clinic/exceptions.c.h"

/*[clinic input]

class BaseException "PyBaseExceptionObject *" "&PyExc_BaseException"

class BaseExceptionGroup "PyBaseExceptionGroupObject *" "&PyExc_BaseExceptionGroup"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=b7c45e78cff8edc3]*/

static struct _Py_exc_state*

get_exc_state(void)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

return &interp->exc_state;

}

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

* Lib/test/exception_hierarchy.txt

static inline PyBaseExceptionObject *

PyBaseExceptionObject_CAST(PyObject *exc)

{

assert(PyExceptionInstance_Check(exc));

return (PyBaseExceptionObject *)exc;

}

* 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->notes = NULL;

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

self->suppress_context = 0;

if (args) {

self->args = Py_NewRef(args);

return (PyObject *)self;

}

self->args = PyTuple_New(0);

if (!self->args) {

Py_DECREF(self);

return NULL;

}

return (PyObject *)self;

}

static int

BaseException_init(PyObject *op, PyObject *args, PyObject *kwds)

{

PyBaseExceptionObject *self = PyBaseExceptionObject_CAST(op);

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

return -1;

Py_XSETREF(self->args, Py_NewRef(args));

return 0;

}

static PyObject *

BaseException_vectorcall(PyObject *type_obj, PyObject * const*args,

size_t nargsf, PyObject *kwnames)

{

PyTypeObject *type = _PyType_CAST(type_obj);

if (!_PyArg_NoKwnames(type->tp_name, kwnames)) {

return NULL;

}

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->notes = NULL;

self->traceback = NULL;

self->cause = NULL;

self->context = NULL;

self->suppress_context = 0;

self->args = PyTuple_FromArray(args, PyVectorcall_NARGS(nargsf));

if (!self->args) {

Py_DECREF(self);

return NULL;

}

return (PyObject *)self;

}

static int

BaseException_clear(PyObject *op)

{

PyBaseExceptionObject *self = PyBaseExceptionObject_CAST(op);

Py_CLEAR(self->dict);

Py_CLEAR(self->args);

Py_CLEAR(self->notes);

Py_CLEAR(self->traceback);

Py_CLEAR(self->cause);

Py_CLEAR(self->context);

return 0;

}

static void

BaseException_dealloc(PyObject *op)

{

PyBaseExceptionObject *self = PyBaseExceptionObject_CAST(op);

PyObject_GC_UnTrack(self);

// bpo-44348: The trashcan mechanism prevents stack overflow when deleting

// long chains of exceptions. For example, exceptions can be chained

// through the __context__ attributes or the __traceback__ attribute.

(void)BaseException_clear(op);

Py_TYPE(self)->tp_free(self);

}

static int

BaseException_traverse(PyObject *op, visitproc visit, void *arg)

{

PyBaseExceptionObject *self = PyBaseExceptionObject_CAST(op);

Py_VISIT(self->dict);

Py_VISIT(self->args);

Py_VISIT(self->notes);

Py_VISIT(self->traceback);

Py_VISIT(self->cause);

Py_VISIT(self->context);

return 0;

}

static PyObject *

BaseException_str(PyObject *op)

{

PyBaseExceptionObject *self = PyBaseExceptionObject_CAST(op);

PyObject *res;

Py_BEGIN_CRITICAL_SECTION(self);

switch (PyTuple_GET_SIZE(self->args)) {

case 0:

res = Py_GetConstant(Py_CONSTANT_EMPTY_STR);

break;

case 1:

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

break;

default:

res = PyObject_Str(self->args);

break;

}

Py_END_CRITICAL_SECTION();

return res;

}

static PyObject *

BaseException_repr(PyObject *op)

{

PyBaseExceptionObject *self = PyBaseExceptionObject_CAST(op);

PyObject *res;

Py_BEGIN_CRITICAL_SECTION(self);

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

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

res = PyUnicode_FromFormat("%s(%R)", name,

PyTuple_GET_ITEM(self->args, 0));

}

else {

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

}

Py_END_CRITICAL_SECTION();

return res;

}

/* Pickling support */

/*[clinic input]

@critical_section

BaseException.__reduce__

[clinic start generated code]*/

static PyObject *

BaseException___reduce___impl(PyBaseExceptionObject *self)

/*[clinic end generated code: output=af87c1247ef98748 input=283be5a10d9c964f]*/

{

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.

/*[clinic input]

@critical_section

BaseException.__setstate__

state: object

[clinic start generated code]*/

static PyObject *

BaseException___setstate___impl(PyBaseExceptionObject *self, PyObject *state)

/*[clinic end generated code: output=f3834889950453ab input=5524b61cfe9b9856]*/

{

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

Py_INCREF(d_key);

Py_INCREF(d_value);

int res = PyObject_SetAttr((PyObject *)self, d_key, d_value);

Py_DECREF(d_value);

Py_DECREF(d_key);

if (res < 0) {

return NULL;

}

Py_RETURN_NONE;

}

/*[clinic input]

@critical_section

BaseException.with_traceback

tb: object

Set self.__traceback__ to tb and return self.

[clinic start generated code]*/

static PyObject *

BaseException_with_traceback_impl(PyBaseExceptionObject *self, PyObject *tb)

/*[clinic end generated code: output=81e92f2387927f10 input=b5fb64d834717e36]*/

{

if (BaseException___traceback___set_impl(self, tb) < 0){

return NULL;

}

return Py_NewRef(self);

}

/*[clinic input]

@critical_section

BaseException.add_note

note: object(subclass_of="&PyUnicode_Type")

Add a note to the exception

[clinic start generated code]*/

static PyObject *

BaseException_add_note_impl(PyBaseExceptionObject *self, PyObject *note)

/*[clinic end generated code: output=fb7cbcba611c187b input=e60a6b6e9596acaf]*/

{

PyObject *notes;

if (PyObject_GetOptionalAttr((PyObject *)self, &_Py_ID(__notes__), &notes) < 0) {

return NULL;

}

if (notes == NULL) {

notes = PyList_New(0);

if (notes == NULL) {

return NULL;

}

if (PyObject_SetAttr((PyObject *)self, &_Py_ID(__notes__), notes) < 0) {

Py_DECREF(notes);

return NULL;

}

else if (!PyList_Check(notes)) {

Py_DECREF(notes);

PyErr_SetString(PyExc_TypeError, "Cannot add note: __notes__ is not a list");

return NULL;

}

if (PyList_Append(notes, note) < 0) {

Py_DECREF(notes);

return NULL;

}

Py_DECREF(notes);

Py_RETURN_NONE;

}

static PyMethodDef BaseException_methods[] = {

BASEEXCEPTION___REDUCE___METHODDEF

BASEEXCEPTION___SETSTATE___METHODDEF

BASEEXCEPTION_WITH_TRACEBACK_METHODDEF

BASEEXCEPTION_ADD_NOTE_METHODDEF

{NULL, NULL, 0, NULL},

};

/*[clinic input]

@critical_section

@getter

BaseException.args

[clinic start generated code]*/

static PyObject *

BaseException_args_get_impl(PyBaseExceptionObject *self)

/*[clinic end generated code: output=e02e34e35cf4d677 input=64282386e4d7822d]*/

{

if (self->args == NULL) {

Py_RETURN_NONE;

}

return Py_NewRef(self->args);

}

/*[clinic input]

@critical_section

@setter

BaseException.args

[clinic start generated code]*/

static int

BaseException_args_set_impl(PyBaseExceptionObject *self, PyObject *value)

/*[clinic end generated code: output=331137e11d8f9e80 input=2400047ea5970a84]*/

{

PyObject *seq;

if (value == NULL) {

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

return -1;

}

seq = PySequence_Tuple(value);

if (!seq)

return -1;

Py_XSETREF(self->args, seq);

return 0;

}

/*[clinic input]

@critical_section

@getter

BaseException.__traceback__

[clinic start generated code]*/

static PyObject *

BaseException___traceback___get_impl(PyBaseExceptionObject *self)

/*[clinic end generated code: output=17cf874a52339398 input=a2277f0de62170cf]*/

{

if (self->traceback == NULL) {

Py_RETURN_NONE;

}

return Py_NewRef(self->traceback);

}

/*[clinic input]

@critical_section

@setter

BaseException.__traceback__

[clinic start generated code]*/

static int

BaseException___traceback___set_impl(PyBaseExceptionObject *self,

PyObject *value)

/*[clinic end generated code: output=a82c86d9f29f48f0 input=12676035676badad]*/

{

if (value == NULL) {

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

return -1;

}

if (PyTraceBack_Check(value)) {

Py_XSETREF(self->traceback, Py_NewRef(value));

}

else if (value == Py_None) {

Py_CLEAR(self->traceback);

}

else {

PyErr_SetString(PyExc_TypeError,

"__traceback__ must be a traceback or None");

return -1;

}

return 0;

}

/*[clinic input]

@critical_section

@getter

BaseException.__context__

[clinic start generated code]*/

static PyObject *

BaseException___context___get_impl(PyBaseExceptionObject *self)

/*[clinic end generated code: output=6ec5d296ce8d1c93 input=b2d22687937e66ab]*/

{

if (self->context == NULL) {

Py_RETURN_NONE;

}

return Py_NewRef(self->context);

}

/*[clinic input]

@critical_section

@setter

BaseException.__context__

[clinic start generated code]*/

static int

BaseException___context___set_impl(PyBaseExceptionObject *self,

PyObject *value)

/*[clinic end generated code: output=b4cb52dcca1da3bd input=c0971adf47fa1858]*/

{

if (value == NULL) {

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

return -1;

} else if (value == Py_None) {

value = NULL;

} else if (!PyExceptionInstance_Check(value)) {

PyErr_SetString(PyExc_TypeError, "exception context must be None "

"or derive from BaseException");

return -1;

} else {

Py_INCREF(value);

}

Py_XSETREF(self->context, value);

return 0;

}

/*[clinic input]

@critical_section

@getter

BaseException.__cause__

[clinic start generated code]*/

static PyObject *

BaseException___cause___get_impl(PyBaseExceptionObject *self)

/*[clinic end generated code: output=987f6c4d8a0bdbab input=40e0eac427b6e602]*/

{

if (self->cause == NULL) {

Py_RETURN_NONE;

}

return Py_NewRef(self->cause);

}

/*[clinic input]

@critical_section

@setter

BaseException.__cause__

[clinic start generated code]*/

static int

BaseException___cause___set_impl(PyBaseExceptionObject *self,

PyObject *value)

/*[clinic end generated code: output=6161315398aaf541 input=e1b403c0bde3f62a]*/

{

if (value == NULL) {

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

return -1;

} else if (value == Py_None) {

value = NULL;

} else if (!PyExceptionInstance_Check(value)) {

PyErr_SetString(PyExc_TypeError, "exception cause must be None "

"or derive from BaseException");

return -1;

} else {

/* PyException_SetCause steals this reference */

Py_INCREF(value);

}

PyException_SetCause((PyObject *)self, value);

return 0;

}

static PyGetSetDef BaseException_getset[] = {

{"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict},

BASEEXCEPTION_ARGS_GETSETDEF

BASEEXCEPTION___TRACEBACK___GETSETDEF

BASEEXCEPTION___CONTEXT___GETSETDEF

BASEEXCEPTION___CAUSE___GETSETDEF

{NULL},

};

PyObject *

PyException_GetTraceback(PyObject *self)

{

PyObject *traceback;

Py_BEGIN_CRITICAL_SECTION(self);

traceback = Py_XNewRef(PyBaseExceptionObject_CAST(self)->traceback);

Py_END_CRITICAL_SECTION();

return traceback;

}

int

PyException_SetTraceback(PyObject *self, PyObject *tb)

{

int res;

Py_BEGIN_CRITICAL_SECTION(self);

res = BaseException___traceback___set_impl(PyBaseExceptionObject_CAST(self), tb);

Py_END_CRITICAL_SECTION();

return res;

}

PyObject *

PyException_GetCause(PyObject *self)

{

PyObject *cause;

Py_BEGIN_CRITICAL_SECTION(self);

cause = Py_XNewRef(PyBaseExceptionObject_CAST(self)->cause);

Py_END_CRITICAL_SECTION();

return cause;

}

/* Steals a reference to cause */

void

PyException_SetCause(PyObject *self, PyObject *cause)

{

Py_BEGIN_CRITICAL_SECTION(self);

PyBaseExceptionObject *base_self = PyBaseExceptionObject_CAST(self);

base_self->suppress_context = 1;

Py_XSETREF(base_self->cause, cause);

Py_END_CRITICAL_SECTION();

}

PyObject *

PyException_GetContext(PyObject *self)

{

PyObject *context;

Py_BEGIN_CRITICAL_SECTION(self);

context = Py_XNewRef(PyBaseExceptionObject_CAST(self)->context);

Py_END_CRITICAL_SECTION();

return context;

}

/* Steals a reference to context */

void

PyException_SetContext(PyObject *self, PyObject *context)

{

Py_BEGIN_CRITICAL_SECTION(self);

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

Py_END_CRITICAL_SECTION();

}

PyObject *

PyException_GetArgs(PyObject *self)

{

PyObject *args;

Py_BEGIN_CRITICAL_SECTION(self);

args = Py_NewRef(PyBaseExceptionObject_CAST(self)->args);

Py_END_CRITICAL_SECTION();

return args;

}

void

PyException_SetArgs(PyObject *self, PyObject *args)

{

Py_BEGIN_CRITICAL_SECTION(self);

Py_INCREF(args);

Py_XSETREF(PyBaseExceptionObject_CAST(self)->args, args);

Py_END_CRITICAL_SECTION();

}

const char *

PyExceptionClass_Name(PyObject *ob)

{

assert(PyExceptionClass_Check(ob));

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

}

static struct PyMemberDef BaseException_members[] = {

{"__suppress_context__", Py_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*/

BaseException_dealloc, /*tp_dealloc*/

0, /*tp_vectorcall_offset*/

0, /*tp_getattr*/

0, /*tp_setattr*/

0, /*tp_as_async*/

BaseException_repr, /*tp_repr*/

0, /*tp_as_number*/

0, /*tp_as_sequence*/

0, /*tp_as_mapping*/

0, /*tp_hash */

0, /*tp_call*/

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

BaseException_traverse, /* tp_traverse */

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

BaseException_init, /* tp_init */

0, /* tp_alloc */

BaseException_new, /* tp_new */

.tp_vectorcall = BaseException_vectorcall,

};

/* 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, 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), BaseException_traverse, \

BaseException_clear, 0, 0, 0, 0, 0, 0, 0, &_ ## EXCBASE, \

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

BaseException_init, 0, BaseException_new,\

}; \

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

#define MiddlingExtendsExceptionEx(EXCBASE, EXCNAME, PYEXCNAME, EXCSTORE, EXCDOC) \

PyTypeObject _PyExc_ ## EXCNAME = { \

PyVarObject_HEAD_INIT(NULL, 0) \

# PYEXCNAME, \

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

0, 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), EXCSTORE ## _traverse, \

EXCSTORE ## _clear, 0, 0, 0, 0, 0, 0, 0, &_ ## EXCBASE, \

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

EXCSTORE ## _init, 0, 0, \

};

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

static MiddlingExtendsExceptionEx( \

EXCBASE, EXCNAME, EXCNAME, EXCSTORE, EXCDOC); \

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

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

EXCMETHODS, EXCMEMBERS, EXCGETSET, \

EXCSTR, EXCREPR, EXCDOC) \

static PyTypeObject _PyExc_ ## EXCNAME = { \

PyVarObject_HEAD_INIT(NULL, 0) \

# EXCNAME, \

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

EXCSTORE ## _dealloc, 0, 0, 0, 0, EXCREPR, 0, 0, 0, 0, 0, \

EXCSTR, 0, 0, 0, \

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, \

PyDoc_STR(EXCDOC), EXCSTORE ## _traverse, \

EXCSTORE ## _clear, 0, 0, 0, 0, EXCMETHODS, \

EXCMEMBERS, EXCGETSET, &_ ## EXCBASE, \

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

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", _Py_T_OBJECT, offsetof(PyStopIterationObject, value), 0,

PyDoc_STR("generator return value")},

{NULL} /* Sentinel */

};

static inline PyStopIterationObject *

PyStopIterationObject_CAST(PyObject *self)

{

assert(PyObject_TypeCheck(self, (PyTypeObject *)PyExc_StopIteration));

return (PyStopIterationObject *)self;

}

static int

StopIteration_init(PyObject *op, PyObject *args, PyObject *kwds)

{

Py_ssize_t size = PyTuple_GET_SIZE(args);

PyObject *value;

if (BaseException_init(op, args, kwds) == -1)

return -1;

PyStopIterationObject *self = PyStopIterationObject_CAST(op);

Py_CLEAR(self->value);

if (size > 0)

value = PyTuple_GET_ITEM(args, 0);

else

value = Py_None;

self->value = Py_NewRef(value);

return 0;

}

static int

StopIteration_clear(PyObject *op)

{

PyStopIterationObject *self = PyStopIterationObject_CAST(op);

Py_CLEAR(self->value);

return BaseException_clear(op);

}

static void

StopIteration_dealloc(PyObject *self)

{

PyObject_GC_UnTrack(self);

(void)StopIteration_clear(self);

Py_TYPE(self)->tp_free(self);

}

static int

StopIteration_traverse(PyObject *op, visitproc visit, void *arg)

{

PyStopIterationObject *self = PyStopIterationObject_CAST(op);

Py_VISIT(self->value);

return BaseException_traverse(op, visit, arg);

}

ComplexExtendsException(PyExc_Exception, StopIteration, StopIteration,

0, 0, StopIteration_members, 0, 0, 0,

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

* GeneratorExit extends BaseException

SimpleExtendsException(PyExc_BaseException, GeneratorExit,

"Request that a generator exit.");

* SystemExit extends BaseException

static inline PySystemExitObject *

PySystemExitObject_CAST(PyObject *self)

{

assert(PyObject_TypeCheck(self, (PyTypeObject *)PyExc_SystemExit));

return (PySystemExitObject *)self;

}

static int

SystemExit_init(PyObject *op, PyObject *args, PyObject *kwds)

{

Py_ssize_t size = PyTuple_GET_SIZE(args);

if (BaseException_init(op, args, kwds) == -1)

return -1;

PySystemExitObject *self = PySystemExitObject_CAST(op);

if (size == 0)

return 0;

if (size == 1) {

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

}

else { /* size > 1 */

Py_XSETREF(self->code, Py_NewRef(args));

}

return 0;

}

static int

SystemExit_clear(PyObject *op)

{

PySystemExitObject *self = PySystemExitObject_CAST(op);

Py_CLEAR(self->code);

return BaseException_clear(op);

}

static void

SystemExit_dealloc(PyObject *self)

{

_PyObject_GC_UNTRACK(self);

(void)SystemExit_clear(self);

Py_TYPE(self)->tp_free(self);

}

static int

SystemExit_traverse(PyObject *op, visitproc visit, void *arg)

{

PySystemExitObject *self = PySystemExitObject_CAST(op);

Py_VISIT(self->code);

return BaseException_traverse(op, visit, arg);

}

static PyMemberDef SystemExit_members[] = {

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

PyDoc_STR("exception code")},

{NULL} /* Sentinel */

};

ComplexExtendsException(PyExc_BaseException, SystemExit, SystemExit,

0, 0, SystemExit_members, 0, 0, 0,

"Request to exit from the interpreter.");

* BaseExceptionGroup extends BaseException

* ExceptionGroup extends BaseExceptionGroup and Exception

static inline PyBaseExceptionGroupObject*

PyBaseExceptionGroupObject_CAST(PyObject *exc)

{

assert(_PyBaseExceptionGroup_Check(exc));

return (PyBaseExceptionGroupObject *)exc;

}

static PyObject *

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

{

struct _Py_exc_state *state = get_exc_state();

PyTypeObject *PyExc_ExceptionGroup =

(PyTypeObject*)state->PyExc_ExceptionGroup;

PyObject *message = NULL;

PyObject *exceptions = NULL;

PyObject *exceptions_str = NULL;

if (!PyArg_ParseTuple(args,

"UO:BaseExceptionGroup.__new__",

&message,

&exceptions)) {

return NULL;

}

if (!PySequence_Check(exceptions)) {

PyErr_SetString(

PyExc_TypeError,

"second argument (exceptions) must be a sequence");

return NULL;

}

/* Save initial exceptions sequence as a string in case sequence is mutated */

if (!PyList_Check(exceptions) && !PyTuple_Check(exceptions)) {

exceptions_str = PyObject_Repr(exceptions);

if (exceptions_str == NULL) {

/* We don't hold a reference to exceptions, so clear it before

* attempting a decref in the cleanup.

exceptions = NULL;

goto error;

}

exceptions = PySequence_Tuple(exceptions);

if (!exceptions) {

goto error;

}

/* We are now holding a ref to the exceptions tuple */

Py_ssize_t numexcs = PyTuple_GET_SIZE(exceptions);

if (numexcs == 0) {

PyErr_SetString(

PyExc_ValueError,

"second argument (exceptions) must be a non-empty sequence");

goto error;

}

bool nested_base_exceptions = false;

for (Py_ssize_t i = 0; i < numexcs; i++) {

PyObject *exc = PyTuple_GET_ITEM(exceptions, i);

if (!exc) {

goto error;

}

if (!PyExceptionInstance_Check(exc)) {

PyErr_Format(

PyExc_ValueError,

"Item %d of second argument (exceptions) is not an exception",

i);

goto error;

}

int is_nonbase_exception = PyObject_IsInstance(exc, PyExc_Exception);

if (is_nonbase_exception < 0) {

goto error;

}

else if (is_nonbase_exception == 0) {

nested_base_exceptions = true;

}

PyTypeObject *cls = type;

if (cls == PyExc_ExceptionGroup) {

if (nested_base_exceptions) {

PyErr_SetString(PyExc_TypeError,

"Cannot nest BaseExceptions in an ExceptionGroup");

goto error;

}

else if (cls == (PyTypeObject*)PyExc_BaseExceptionGroup) {

if (!nested_base_exceptions) {

/* All nested exceptions are Exception subclasses,

* wrap them in an ExceptionGroup

cls = PyExc_ExceptionGroup;

}

else {

/* user-defined subclass */

if (nested_base_exceptions) {

int nonbase = PyObject_IsSubclass((PyObject*)cls, PyExc_Exception);

if (nonbase == -1) {

goto error;

}

else if (nonbase == 1) {

PyErr_Format(PyExc_TypeError,

"Cannot nest BaseExceptions in '%.200s'",

cls->tp_name);

goto error;

}

if (!cls) {

/* Don't crash during interpreter shutdown

* (PyExc_ExceptionGroup may have been cleared)

cls = (PyTypeObject*)PyExc_BaseExceptionGroup;

}

PyBaseExceptionGroupObject *self =

PyBaseExceptionGroupObject_CAST(BaseException_new(cls, args, kwds));

if (!self) {

goto error;

}

self->msg = Py_NewRef(message);

self->excs = exceptions;

self->excs_str = exceptions_str;

return (PyObject*)self;

error:

Py_XDECREF(exceptions);

Py_XDECREF(exceptions_str);

View remainder of file in raw view

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

FilesExpand file tree

exceptions.c

Latest commit

History

exceptions.c

File metadata and controls