#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_moduleobject.h" // _PyModule_CAST()

#include "pycore_object.h"

#include "pycore_pyerrors.h" // struct _PyErr_SetRaisedException

#include "pycore_tuple.h" // _PyTuple_FromPair

#include "pycore_unicodeobject.h" // _PyUnicode_Equal()

#include "osdefs.h" // SEP

#include "clinic/exceptions.c.h"

static struct _Py_exc_state*

get_exc_state(void)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

return &interp->exc_state;

}

static inline PyBaseExceptionObject *

PyBaseExceptionObject_CAST(PyObject *exc)

{

assert(PyExceptionInstance_Check(exc));

return (PyBaseExceptionObject *)exc;

}

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;

}

static PyObject *

BaseException___reduce___impl(PyBaseExceptionObject *self)

{

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

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

else

return _PyTuple_FromPair((PyObject *)Py_TYPE(self), self->args);

}

static PyObject *

BaseException___setstate___impl(PyBaseExceptionObject *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)) {

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;

}

static PyObject *

BaseException_with_traceback_impl(PyBaseExceptionObject *self, PyObject *tb)

{

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

return NULL;

}

return Py_NewRef(self);

}

static PyObject *

BaseException_add_note_impl(PyBaseExceptionObject *self, PyObject *note)

{

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

};

static PyObject *

BaseException_args_get_impl(PyBaseExceptionObject *self)

{

if (self->args == NULL) {

Py_RETURN_NONE;

}

return Py_NewRef(self->args);

}

static int

BaseException_args_set_impl(PyBaseExceptionObject *self, PyObject *value)

{

PyObject *seq;

seq = PySequence_Tuple(value);

if (!seq)

return -1;

Py_XSETREF(self->args, seq);

return 0;

}

static PyObject *

BaseException___traceback___get_impl(PyBaseExceptionObject *self)

{

if (self->traceback == NULL) {

Py_RETURN_NONE;

}

return Py_NewRef(self->traceback);

}

static int

BaseException___traceback___set_impl(PyBaseExceptionObject *self,

PyObject *value)

{

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;

}

static PyObject *

BaseException___context___get_impl(PyBaseExceptionObject *self)

{

if (self->context == NULL) {

Py_RETURN_NONE;

}

return Py_NewRef(self->context);

}

static int

BaseException___context___set_impl(PyBaseExceptionObject *self,

PyObject *value)

{

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;

}

static PyObject *

BaseException___cause___get_impl(PyBaseExceptionObject *self)

{

if (self->cause == NULL) {

Py_RETURN_NONE;

}

return Py_NewRef(self->cause);

}

static int

BaseException___cause___set_impl(PyBaseExceptionObject *self,

PyObject *value)

{

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;

}

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;

}

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;

}

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;

}

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,

};

PyObject *PyExc_BaseException = (PyObject *)&_PyExc_BaseException;

#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

SimpleExtendsException(PyExc_BaseException, Exception,

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

SimpleExtendsException(PyExc_Exception, TypeError,

"Inappropriate argument type.");

SimpleExtendsException(PyExc_Exception, StopAsyncIteration,

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

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__().");

SimpleExtendsException(PyExc_BaseException, GeneratorExit,

"Request that a generator exit.");

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

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

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 %zd 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,

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

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

return NULL;

}

PyObject *

_PyExc_CreateExceptionGroup(const char *msg_str, PyObject *excs)

{

PyObject *msg = PyUnicode_FromString(msg_str);

if (!msg) {

return NULL;

}

PyObject *args = _PyTuple_FromPairSteal(msg, Py_NewRef(excs));