mirror of
https://github.com/johndoe6345789/typthon.git
synced 2026-04-24 13:45:05 +00:00
42e2356c88
Fixed several macros and constants that should not have been renamed: - _Py_CAST, _Py_NULL, _Py_RVALUE (internal utility macros) - Py_UNUSED (unused parameter macro) - Py_EQ, Py_NE, Py_LT, Py_LE, Py_GT, Py_GE (comparison constants) - Py_RETURN_* macros (NONE, TRUE, FALSE, NOTIMPLEMENTED, RICHCOMPARE) - Py_READONLY, Py_ULL, Py_CONTEXT_SWITCHED - TyGC_Head in generated clinic files Build is still in progress with some remaining issues to resolve. Co-authored-by: johndoe6345789 <224850594+johndoe6345789@users.noreply.github.com>
596 lines
16 KiB
C
596 lines
16 KiB
C
// clinic/exceptions.c.h uses internal pycore_modsupport.h API
|
|
#define PYTESTCAPI_NEED_INTERNAL_API
|
|
|
|
#include "parts.h"
|
|
#include "util.h"
|
|
|
|
#include "clinic/exceptions.c.h"
|
|
|
|
|
|
/*[clinic input]
|
|
module _testcapi
|
|
[clinic start generated code]*/
|
|
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=6361033e795369fc]*/
|
|
|
|
/*[clinic input]
|
|
_testcapi.err_set_raised
|
|
exception as exc: object
|
|
/
|
|
[clinic start generated code]*/
|
|
|
|
static TyObject *
|
|
_testcapi_err_set_raised(TyObject *module, TyObject *exc)
|
|
/*[clinic end generated code: output=0a0c7743961fcae5 input=c5f7331864a94df9]*/
|
|
{
|
|
Ty_INCREF(exc);
|
|
TyErr_SetRaisedException(exc);
|
|
assert(TyErr_Occurred());
|
|
return NULL;
|
|
}
|
|
|
|
static TyObject *
|
|
err_restore(TyObject *self, TyObject *args) {
|
|
TyObject *type = NULL, *value = NULL, *traceback = NULL;
|
|
switch(TyTuple_Size(args)) {
|
|
case 3:
|
|
traceback = TyTuple_GetItem(args, 2);
|
|
Ty_INCREF(traceback);
|
|
_Ty_FALLTHROUGH;
|
|
case 2:
|
|
value = TyTuple_GetItem(args, 1);
|
|
Ty_INCREF(value);
|
|
_Ty_FALLTHROUGH;
|
|
case 1:
|
|
type = TyTuple_GetItem(args, 0);
|
|
Ty_INCREF(type);
|
|
break;
|
|
default:
|
|
TyErr_SetString(TyExc_TypeError,
|
|
"wrong number of arguments");
|
|
return NULL;
|
|
}
|
|
TyErr_Restore(type, value, traceback);
|
|
assert(TyErr_Occurred());
|
|
return NULL;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_testcapi.exception_print
|
|
exception as exc: object
|
|
legacy: bool = False
|
|
/
|
|
|
|
To test the format of exceptions as printed out.
|
|
[clinic start generated code]*/
|
|
|
|
static TyObject *
|
|
_testcapi_exception_print_impl(TyObject *module, TyObject *exc, int legacy)
|
|
/*[clinic end generated code: output=3f04fe0c18412ae0 input=c76f42cb94136dbf]*/
|
|
{
|
|
if (legacy) {
|
|
TyObject *tb = NULL;
|
|
if (PyExceptionInstance_Check(exc)) {
|
|
tb = PyException_GetTraceback(exc);
|
|
}
|
|
TyErr_Display((TyObject *) Ty_TYPE(exc), exc, tb);
|
|
Ty_XDECREF(tb);
|
|
}
|
|
else {
|
|
TyErr_DisplayException(exc);
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_testcapi.make_exception_with_doc
|
|
name: str
|
|
doc: str = NULL
|
|
base: object = NULL
|
|
dict: object = NULL
|
|
|
|
Test TyErr_NewExceptionWithDoc (also exercise TyErr_NewException). Run via Lib/test/test_exceptions.py
|
|
[clinic start generated code]*/
|
|
|
|
static TyObject *
|
|
_testcapi_make_exception_with_doc_impl(TyObject *module, const char *name,
|
|
const char *doc, TyObject *base,
|
|
TyObject *dict)
|
|
/*[clinic end generated code: output=439f0d963c1ce2c4 input=23a73013f8a8795a]*/
|
|
{
|
|
return TyErr_NewExceptionWithDoc(name, doc, base, dict);
|
|
}
|
|
|
|
/*[clinic input]
|
|
_testcapi.exc_set_object
|
|
exception as exc: object
|
|
obj: object
|
|
/
|
|
[clinic start generated code]*/
|
|
|
|
static TyObject *
|
|
_testcapi_exc_set_object_impl(TyObject *module, TyObject *exc, TyObject *obj)
|
|
/*[clinic end generated code: output=34c8c7c83e5c8463 input=fc530aafb1b0a360]*/
|
|
{
|
|
TyErr_SetObject(exc, obj);
|
|
return NULL;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_testcapi.exc_set_object_fetch = _testcapi.exc_set_object
|
|
[clinic start generated code]*/
|
|
|
|
static TyObject *
|
|
_testcapi_exc_set_object_fetch_impl(TyObject *module, TyObject *exc,
|
|
TyObject *obj)
|
|
/*[clinic end generated code: output=7a5ff5f6d3cf687f input=77ec686f1f95fa38]*/
|
|
{
|
|
TyObject *type = UNINITIALIZED_PTR;
|
|
TyObject *value = UNINITIALIZED_PTR;
|
|
TyObject *tb = UNINITIALIZED_PTR;
|
|
|
|
TyErr_SetObject(exc, obj);
|
|
TyErr_Fetch(&type, &value, &tb);
|
|
assert(type != UNINITIALIZED_PTR);
|
|
assert(value != UNINITIALIZED_PTR);
|
|
assert(tb != UNINITIALIZED_PTR);
|
|
Ty_XDECREF(type);
|
|
Ty_XDECREF(tb);
|
|
return value;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_testcapi.err_setstring
|
|
exc: object
|
|
value: str(zeroes=True, accept={robuffer, str, NoneType})
|
|
/
|
|
[clinic start generated code]*/
|
|
|
|
static TyObject *
|
|
_testcapi_err_setstring_impl(TyObject *module, TyObject *exc,
|
|
const char *value, Ty_ssize_t value_length)
|
|
/*[clinic end generated code: output=fba8705e5703dd3f input=e8a95fad66d9004b]*/
|
|
{
|
|
NULLABLE(exc);
|
|
TyErr_SetString(exc, value);
|
|
return NULL;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_testcapi.err_setfromerrnowithfilename
|
|
error: int
|
|
exc: object
|
|
value: str(zeroes=True, accept={robuffer, str, NoneType})
|
|
/
|
|
[clinic start generated code]*/
|
|
|
|
static TyObject *
|
|
_testcapi_err_setfromerrnowithfilename_impl(TyObject *module, int error,
|
|
TyObject *exc, const char *value,
|
|
Ty_ssize_t value_length)
|
|
/*[clinic end generated code: output=d02df5749a01850e input=ff7c384234bf097f]*/
|
|
{
|
|
NULLABLE(exc);
|
|
errno = error;
|
|
TyErr_SetFromErrnoWithFilename(exc, value);
|
|
return NULL;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_testcapi.raise_exception
|
|
exception as exc: object
|
|
num_args: int
|
|
/
|
|
[clinic start generated code]*/
|
|
|
|
static TyObject *
|
|
_testcapi_raise_exception_impl(TyObject *module, TyObject *exc, int num_args)
|
|
/*[clinic end generated code: output=eb0a9c5d69e0542d input=83d6262c3829d088]*/
|
|
{
|
|
TyObject *exc_args = TyTuple_New(num_args);
|
|
if (exc_args == NULL) {
|
|
return NULL;
|
|
}
|
|
for (int i = 0; i < num_args; ++i) {
|
|
TyObject *v = TyLong_FromLong(i);
|
|
if (v == NULL) {
|
|
Ty_DECREF(exc_args);
|
|
return NULL;
|
|
}
|
|
TyTuple_SET_ITEM(exc_args, i, v);
|
|
}
|
|
TyErr_SetObject(exc, exc_args);
|
|
Ty_DECREF(exc_args);
|
|
return NULL;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_testcapi.raise_memoryerror
|
|
[clinic start generated code]*/
|
|
|
|
static TyObject *
|
|
_testcapi_raise_memoryerror_impl(TyObject *module)
|
|
/*[clinic end generated code: output=dd057803fb0131e6 input=6ca521bd07fb73cb]*/
|
|
{
|
|
return TyErr_NoMemory();
|
|
}
|
|
|
|
/*[clinic input]
|
|
_testcapi.fatal_error
|
|
message: str(accept={robuffer})
|
|
release_gil: bool = False
|
|
/
|
|
[clinic start generated code]*/
|
|
|
|
static TyObject *
|
|
_testcapi_fatal_error_impl(TyObject *module, const char *message,
|
|
int release_gil)
|
|
/*[clinic end generated code: output=9c3237116e6a03e8 input=1be357a2ccb04c8c]*/
|
|
{
|
|
if (release_gil) {
|
|
Ty_BEGIN_ALLOW_THREADS
|
|
Ty_FatalError(message);
|
|
Ty_END_ALLOW_THREADS
|
|
}
|
|
else {
|
|
Ty_FatalError(message);
|
|
}
|
|
// Ty_FatalError() does not return, but exits the process.
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_testcapi.set_exc_info
|
|
new_type: object
|
|
new_value: object
|
|
new_tb: object
|
|
/
|
|
[clinic start generated code]*/
|
|
|
|
static TyObject *
|
|
_testcapi_set_exc_info_impl(TyObject *module, TyObject *new_type,
|
|
TyObject *new_value, TyObject *new_tb)
|
|
/*[clinic end generated code: output=b55fa35dec31300e input=ea9f19e0f55fe5b3]*/
|
|
{
|
|
TyObject *type = UNINITIALIZED_PTR, *value = UNINITIALIZED_PTR, *tb = UNINITIALIZED_PTR;
|
|
TyErr_GetExcInfo(&type, &value, &tb);
|
|
|
|
Ty_INCREF(new_type);
|
|
Ty_INCREF(new_value);
|
|
Ty_INCREF(new_tb);
|
|
TyErr_SetExcInfo(new_type, new_value, new_tb);
|
|
|
|
TyObject *orig_exc = TyTuple_Pack(3,
|
|
type ? type : Ty_None,
|
|
value ? value : Ty_None,
|
|
tb ? tb : Ty_None);
|
|
Ty_XDECREF(type);
|
|
Ty_XDECREF(value);
|
|
Ty_XDECREF(tb);
|
|
return orig_exc;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_testcapi.set_exception
|
|
new_exc: object
|
|
/
|
|
[clinic start generated code]*/
|
|
|
|
static TyObject *
|
|
_testcapi_set_exception(TyObject *module, TyObject *new_exc)
|
|
/*[clinic end generated code: output=8b969b35d029e96d input=c89d4ca966c69738]*/
|
|
{
|
|
TyObject *exc = TyErr_GetHandledException();
|
|
assert(PyExceptionInstance_Check(exc) || exc == NULL);
|
|
TyErr_SetHandledException(new_exc);
|
|
return exc;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_testcapi.traceback_print
|
|
traceback: object
|
|
file: object
|
|
/
|
|
To test the format of tracebacks as printed out.
|
|
[clinic start generated code]*/
|
|
|
|
static TyObject *
|
|
_testcapi_traceback_print_impl(TyObject *module, TyObject *traceback,
|
|
TyObject *file)
|
|
/*[clinic end generated code: output=17074ecf9d95cf30 input=9423f2857b008ca8]*/
|
|
{
|
|
if (PyTraceBack_Print(traceback, file) < 0) {
|
|
return NULL;
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static TyObject *
|
|
err_writeunraisable(TyObject *Py_UNUSED(module), TyObject *args)
|
|
{
|
|
TyObject *exc, *obj;
|
|
if (!TyArg_ParseTuple(args, "OO", &exc, &obj)) {
|
|
return NULL;
|
|
}
|
|
NULLABLE(exc);
|
|
NULLABLE(obj);
|
|
if (exc) {
|
|
TyErr_SetRaisedException(Ty_NewRef(exc));
|
|
}
|
|
TyErr_WriteUnraisable(obj);
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static TyObject *
|
|
err_formatunraisable(TyObject *Py_UNUSED(module), TyObject *args)
|
|
{
|
|
TyObject *exc;
|
|
const char *fmt;
|
|
Ty_ssize_t fmtlen;
|
|
TyObject *objs[10] = {NULL};
|
|
|
|
if (!TyArg_ParseTuple(args, "Oz#|OOOOOOOOOO", &exc, &fmt, &fmtlen,
|
|
&objs[0], &objs[1], &objs[2], &objs[3], &objs[4],
|
|
&objs[5], &objs[6], &objs[7], &objs[8], &objs[9]))
|
|
{
|
|
return NULL;
|
|
}
|
|
NULLABLE(exc);
|
|
if (exc) {
|
|
TyErr_SetRaisedException(Ty_NewRef(exc));
|
|
}
|
|
TyErr_FormatUnraisable(fmt,
|
|
objs[0], objs[1], objs[2], objs[3], objs[4],
|
|
objs[5], objs[6], objs[7], objs[8], objs[9]);
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_testcapi.unstable_exc_prep_reraise_star
|
|
orig: object
|
|
excs: object
|
|
/
|
|
To test PyUnstable_Exc_PrepReraiseStar.
|
|
[clinic start generated code]*/
|
|
|
|
static TyObject *
|
|
_testcapi_unstable_exc_prep_reraise_star_impl(TyObject *module,
|
|
TyObject *orig, TyObject *excs)
|
|
/*[clinic end generated code: output=850cf008e0563c77 input=27fbcda2203eb301]*/
|
|
{
|
|
return PyUnstable_Exc_PrepReraiseStar(orig, excs);
|
|
}
|
|
|
|
/* Test PyUnicodeEncodeError_GetStart */
|
|
static TyObject *
|
|
unicode_encode_get_start(TyObject *Py_UNUSED(module), TyObject *arg)
|
|
{
|
|
Ty_ssize_t start;
|
|
if (PyUnicodeEncodeError_GetStart(arg, &start) < 0) {
|
|
return NULL;
|
|
}
|
|
RETURN_SIZE(start);
|
|
}
|
|
|
|
/* Test PyUnicodeDecodeError_GetStart */
|
|
static TyObject *
|
|
unicode_decode_get_start(TyObject *Py_UNUSED(module), TyObject *arg)
|
|
{
|
|
Ty_ssize_t start;
|
|
if (PyUnicodeDecodeError_GetStart(arg, &start) < 0) {
|
|
return NULL;
|
|
}
|
|
RETURN_SIZE(start);
|
|
}
|
|
|
|
/* Test PyUnicodeTranslateError_GetStart */
|
|
static TyObject *
|
|
unicode_translate_get_start(TyObject *Py_UNUSED(module), TyObject *arg)
|
|
{
|
|
Ty_ssize_t start;
|
|
if (PyUnicodeTranslateError_GetStart(arg, &start) < 0) {
|
|
return NULL;
|
|
}
|
|
RETURN_SIZE(start);
|
|
}
|
|
|
|
/* Test PyUnicodeEncodeError_SetStart */
|
|
static TyObject *
|
|
unicode_encode_set_start(TyObject *Py_UNUSED(module), TyObject *args)
|
|
{
|
|
TyObject *exc;
|
|
Ty_ssize_t start;
|
|
if (TyArg_ParseTuple(args, "On", &exc, &start) < 0) {
|
|
return NULL;
|
|
}
|
|
if (PyUnicodeEncodeError_SetStart(exc, start) < 0) {
|
|
return NULL;
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/* Test PyUnicodeDecodeError_SetStart */
|
|
static TyObject *
|
|
unicode_decode_set_start(TyObject *Py_UNUSED(module), TyObject *args)
|
|
{
|
|
TyObject *exc;
|
|
Ty_ssize_t start;
|
|
if (TyArg_ParseTuple(args, "On", &exc, &start) < 0) {
|
|
return NULL;
|
|
}
|
|
if (PyUnicodeDecodeError_SetStart(exc, start) < 0) {
|
|
return NULL;
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/* Test PyUnicodeTranslateError_SetStart */
|
|
static TyObject *
|
|
unicode_translate_set_start(TyObject *Py_UNUSED(module), TyObject *args)
|
|
{
|
|
TyObject *exc;
|
|
Ty_ssize_t start;
|
|
if (TyArg_ParseTuple(args, "On", &exc, &start) < 0) {
|
|
return NULL;
|
|
}
|
|
if (PyUnicodeTranslateError_SetStart(exc, start) < 0) {
|
|
return NULL;
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/* Test PyUnicodeEncodeError_GetEnd */
|
|
static TyObject *
|
|
unicode_encode_get_end(TyObject *Py_UNUSED(module), TyObject *arg)
|
|
{
|
|
Ty_ssize_t end;
|
|
if (PyUnicodeEncodeError_GetEnd(arg, &end) < 0) {
|
|
return NULL;
|
|
}
|
|
RETURN_SIZE(end);
|
|
}
|
|
|
|
/* Test PyUnicodeDecodeError_GetEnd */
|
|
static TyObject *
|
|
unicode_decode_get_end(TyObject *Py_UNUSED(module), TyObject *arg)
|
|
{
|
|
Ty_ssize_t end;
|
|
if (PyUnicodeDecodeError_GetEnd(arg, &end) < 0) {
|
|
return NULL;
|
|
}
|
|
RETURN_SIZE(end);
|
|
}
|
|
|
|
/* Test PyUnicodeTranslateError_GetEnd */
|
|
static TyObject *
|
|
unicode_translate_get_end(TyObject *Py_UNUSED(module), TyObject *arg)
|
|
{
|
|
Ty_ssize_t end;
|
|
if (PyUnicodeTranslateError_GetEnd(arg, &end) < 0) {
|
|
return NULL;
|
|
}
|
|
RETURN_SIZE(end);
|
|
}
|
|
|
|
/* Test PyUnicodeEncodeError_SetEnd */
|
|
static TyObject *
|
|
unicode_encode_set_end(TyObject *Py_UNUSED(module), TyObject *args)
|
|
{
|
|
TyObject *exc;
|
|
Ty_ssize_t end;
|
|
if (TyArg_ParseTuple(args, "On", &exc, &end) < 0) {
|
|
return NULL;
|
|
}
|
|
if (PyUnicodeEncodeError_SetEnd(exc, end) < 0) {
|
|
return NULL;
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/* Test PyUnicodeDecodeError_SetEnd */
|
|
static TyObject *
|
|
unicode_decode_set_end(TyObject *Py_UNUSED(module), TyObject *args)
|
|
{
|
|
TyObject *exc;
|
|
Ty_ssize_t end;
|
|
if (TyArg_ParseTuple(args, "On", &exc, &end) < 0) {
|
|
return NULL;
|
|
}
|
|
if (PyUnicodeDecodeError_SetEnd(exc, end) < 0) {
|
|
return NULL;
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/* Test PyUnicodeTranslateError_SetEnd */
|
|
static TyObject *
|
|
unicode_translate_set_end(TyObject *Py_UNUSED(module), TyObject *args)
|
|
{
|
|
TyObject *exc;
|
|
Ty_ssize_t end;
|
|
if (TyArg_ParseTuple(args, "On", &exc, &end) < 0) {
|
|
return NULL;
|
|
}
|
|
if (PyUnicodeTranslateError_SetEnd(exc, end) < 0) {
|
|
return NULL;
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/*
|
|
* Define the PyRecurdingInfinitelyError_Type
|
|
*/
|
|
|
|
static TyTypeObject PyRecursingInfinitelyError_Type;
|
|
|
|
static int
|
|
recurse_infinitely_error_init(TyObject *self, TyObject *args, TyObject *kwds)
|
|
{
|
|
TyObject *type = (TyObject *)&PyRecursingInfinitelyError_Type;
|
|
|
|
/* Instantiating this exception starts infinite recursion. */
|
|
Ty_INCREF(type);
|
|
TyErr_SetObject(type, NULL);
|
|
return -1;
|
|
}
|
|
|
|
static TyTypeObject PyRecursingInfinitelyError_Type = {
|
|
.tp_name = "RecursingInfinitelyError",
|
|
.tp_basicsize = sizeof(PyBaseExceptionObject),
|
|
.tp_flags = Ty_TPFLAGS_DEFAULT | Ty_TPFLAGS_BASETYPE,
|
|
.tp_doc = PyDoc_STR("Instantiating this exception starts infinite recursion."),
|
|
.tp_init = recurse_infinitely_error_init,
|
|
};
|
|
|
|
static TyMethodDef test_methods[] = {
|
|
{"err_restore", err_restore, METH_VARARGS},
|
|
{"err_writeunraisable", err_writeunraisable, METH_VARARGS},
|
|
{"err_formatunraisable", err_formatunraisable, METH_VARARGS},
|
|
_TESTCAPI_ERR_SET_RAISED_METHODDEF
|
|
_TESTCAPI_EXCEPTION_PRINT_METHODDEF
|
|
_TESTCAPI_FATAL_ERROR_METHODDEF
|
|
_TESTCAPI_MAKE_EXCEPTION_WITH_DOC_METHODDEF
|
|
_TESTCAPI_EXC_SET_OBJECT_METHODDEF
|
|
_TESTCAPI_EXC_SET_OBJECT_FETCH_METHODDEF
|
|
_TESTCAPI_ERR_SETSTRING_METHODDEF
|
|
_TESTCAPI_ERR_SETFROMERRNOWITHFILENAME_METHODDEF
|
|
_TESTCAPI_RAISE_EXCEPTION_METHODDEF
|
|
_TESTCAPI_RAISE_MEMORYERROR_METHODDEF
|
|
_TESTCAPI_SET_EXC_INFO_METHODDEF
|
|
_TESTCAPI_SET_EXCEPTION_METHODDEF
|
|
_TESTCAPI_TRACEBACK_PRINT_METHODDEF
|
|
_TESTCAPI_UNSTABLE_EXC_PREP_RERAISE_STAR_METHODDEF
|
|
{"unicode_encode_get_start", unicode_encode_get_start, METH_O},
|
|
{"unicode_decode_get_start", unicode_decode_get_start, METH_O},
|
|
{"unicode_translate_get_start", unicode_translate_get_start, METH_O},
|
|
{"unicode_encode_set_start", unicode_encode_set_start, METH_VARARGS},
|
|
{"unicode_decode_set_start", unicode_decode_set_start, METH_VARARGS},
|
|
{"unicode_translate_set_start", unicode_translate_set_start, METH_VARARGS},
|
|
{"unicode_encode_get_end", unicode_encode_get_end, METH_O},
|
|
{"unicode_decode_get_end", unicode_decode_get_end, METH_O},
|
|
{"unicode_translate_get_end", unicode_translate_get_end, METH_O},
|
|
{"unicode_encode_set_end", unicode_encode_set_end, METH_VARARGS},
|
|
{"unicode_decode_set_end", unicode_decode_set_end, METH_VARARGS},
|
|
{"unicode_translate_set_end", unicode_translate_set_end, METH_VARARGS},
|
|
{NULL},
|
|
};
|
|
|
|
int
|
|
_PyTestCapi_Init_Exceptions(TyObject *mod)
|
|
{
|
|
PyRecursingInfinitelyError_Type.tp_base = (TyTypeObject *)TyExc_Exception;
|
|
if (TyType_Ready(&PyRecursingInfinitelyError_Type) < 0) {
|
|
return -1;
|
|
}
|
|
if (TyModule_AddObjectRef(mod, "RecursingInfinitelyError",
|
|
(TyObject *)&PyRecursingInfinitelyError_Type) < 0)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if (TyModule_AddFunctions(mod, test_methods) < 0) {
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|