git/typthon
1
0
Fork 0
mirror of https://github.com/johndoe6345789/typthon.git synced 2026-04-24 13:45:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix exception objects and more Py_ patterns

Browse Source 
- Fixed all exception object types: Py*ErrorObject → Ty*ErrorObject
- Fixed Py*ExceptionObject → Ty*ExceptionObject
- Fixed Py*GroupObject, PyStopIterationObject, PySystemExitObject
- Fixed Py_ASNATIVEBYTES_* → Ty_ASNATIVEBYTES_*
- Fixed Py_SAFE_DOWNCAST → Ty_SAFE_DOWNCAST

Build is progressing through more files.

Co-authored-by: johndoe6345789 <224850594+johndoe6345789@users.noreply.github.com>
This commit is contained in:
copilot-swe-agent[bot]
2025-12-29 18:34:50 +00:00
parent 0b5cf5416d
commit 210fb1519d
15 changed files with 181 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
Include/cpython/pyerrors.h
View File

@@ -18,7 +18,7 @@ typedef struct {
PyException_HEAD PyException_HEAD
TyObject *msg; TyObject *msg;
TyObject *excs; TyObject *excs;
} PyBaseExceptionGroupObject; } TyBaseExceptionGroupObject;
typedef struct { typedef struct {
PyException_HEAD PyException_HEAD
@@ -31,7 +31,7 @@ typedef struct {
TyObject *text; TyObject *text;
TyObject *print_file_and_line; TyObject *print_file_and_line;
TyObject *metadata; TyObject *metadata;
} PySyntaxErrorObject; } TySyntaxErrorObject;
typedef struct { typedef struct {
PyException_HEAD PyException_HEAD
@@ -39,7 +39,7 @@ typedef struct {
TyObject *name; TyObject *name;
TyObject *path; TyObject *path;
TyObject *name_from; TyObject *name_from;
} PyImportErrorObject; } TyImportErrorObject;
typedef struct { typedef struct {
PyException_HEAD PyException_HEAD
@@ -48,12 +48,12 @@ typedef struct {
Ty_ssize_t start; Ty_ssize_t start;
Ty_ssize_t end; Ty_ssize_t end;
TyObject *reason; TyObject *reason;
} PyUnicodeErrorObject; } TyUnicodeErrorObject;
typedef struct { typedef struct {
PyException_HEAD PyException_HEAD
TyObject *code; TyObject *code;
} PySystemExitObject; } TySystemExitObject;
typedef struct { typedef struct {
PyException_HEAD PyException_HEAD
@@ -65,28 +65,28 @@ typedef struct {
TyObject *winerror; TyObject *winerror;
#endif #endif
Ty_ssize_t written; /* only for BlockingIOError, -1 otherwise */ Ty_ssize_t written; /* only for BlockingIOError, -1 otherwise */
} PyOSErrorObject; } TyOSErrorObject;
typedef struct { typedef struct {
PyException_HEAD PyException_HEAD
TyObject *value; TyObject *value;
} PyStopIterationObject; } TyStopIterationObject;
typedef struct { typedef struct {
PyException_HEAD PyException_HEAD
TyObject *name; TyObject *name;
} PyNameErrorObject; } TyNameErrorObject;
typedef struct { typedef struct {
PyException_HEAD PyException_HEAD
TyObject *obj; TyObject *obj;
TyObject *name; TyObject *name;
} PyAttributeErrorObject; } TyAttributeErrorObject;
/* Compatibility typedefs */ /* Compatibility typedefs */
typedef PyOSErrorObject PyEnvironmentErrorObject; typedef TyOSErrorObject PyEnvironmentErrorObject;
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
typedef PyOSErrorObject PyWindowsErrorObject; typedef TyOSErrorObject PyWindowsErrorObject;
#endif #endif
/* Context manipulation (PEP 3134) */ /* Context manipulation (PEP 3134) */

4
Modules/_io/bufferedio.c
View File

@@ -765,7 +765,7 @@ _buffered_check_blocking_error(void)
TyErr_SetRaisedException(exc); TyErr_SetRaisedException(exc);
return NULL; return NULL;
} }
PyOSErrorObject *err = (PyOSErrorObject *)exc; TyOSErrorObject *err = (TyOSErrorObject *)exc;
/* TODO: sanity check (err->written >= 0) */ /* TODO: sanity check (err->written >= 0) */
TyErr_SetRaisedException(exc); TyErr_SetRaisedException(exc);
return &err->written; return &err->written;
@@ -873,7 +873,7 @@ _PyIO_trap_eintr(void)
return 0; return 0;
} }
TyObject *exc = TyErr_GetRaisedException(); TyObject *exc = TyErr_GetRaisedException();
PyOSErrorObject *env_err = (PyOSErrorObject *)exc; TyOSErrorObject *env_err = (TyOSErrorObject *)exc;
assert(env_err != NULL); assert(env_err != NULL);
if (env_err->myerrno != NULL) { if (env_err->myerrno != NULL) {
assert(EINTR > 0 && EINTR < INT_MAX); assert(EINTR > 0 && EINTR < INT_MAX);

8
Modules/_ssl.c
View File

@@ -452,7 +452,7 @@ TyDoc_STRVAR(SSLEOFError_doc,
static TyObject * static TyObject *
SSLError_str(TyObject *op) SSLError_str(TyObject *op)
{ {
PyOSErrorObject *self = (PyOSErrorObject*)op; TyOSErrorObject *self = (TyOSErrorObject*)op;
if (self->strerror != NULL && TyUnicode_Check(self->strerror)) { if (self->strerror != NULL && TyUnicode_Check(self->strerror)) {
return Ty_NewRef(self->strerror); return Ty_NewRef(self->strerror);
} }
@@ -468,7 +468,7 @@ static TyType_Slot sslerror_type_slots[] = {
static TyType_Spec sslerror_type_spec = { static TyType_Spec sslerror_type_spec = {
.name = "ssl.SSLError", .name = "ssl.SSLError",
.basicsize = sizeof(PyOSErrorObject), .basicsize = sizeof(TyOSErrorObject),
.flags = (Ty_TPFLAGS_DEFAULT | Ty_TPFLAGS_BASETYPE | Ty_TPFLAGS_IMMUTABLETYPE), .flags = (Ty_TPFLAGS_DEFAULT | Ty_TPFLAGS_BASETYPE | Ty_TPFLAGS_IMMUTABLETYPE),
.slots = sslerror_type_slots .slots = sslerror_type_slots
}; };
@@ -916,7 +916,7 @@ newPySSLSocket(PySSLContext *sslctx, PySocketSockObject *sock,
#endif #endif
SSL_set_app_data(self->ssl, self); SSL_set_app_data(self->ssl, self);
if (sock) { if (sock) {
SSL_set_fd(self->ssl, Py_SAFE_DOWNCAST(sock->sock_fd, SOCKET_T, int)); SSL_set_fd(self->ssl, Ty_SAFE_DOWNCAST(sock->sock_fd, SOCKET_T, int));
} else { } else {
/* BIOs are reference counted and SSL_set_bio borrows our reference. /* BIOs are reference counted and SSL_set_bio borrows our reference.
* To prevent a double free in memory_bio_dealloc() we need to take an * To prevent a double free in memory_bio_dealloc() we need to take an
@@ -2429,7 +2429,7 @@ PySSL_select(PySocketSockObject *s, int writing, TyTime_t timeout)
/* Wait until the socket becomes ready */ /* Wait until the socket becomes ready */
PySSL_BEGIN_ALLOW_THREADS PySSL_BEGIN_ALLOW_THREADS
nfds = Py_SAFE_DOWNCAST(s->sock_fd+1, SOCKET_T, int); nfds = Ty_SAFE_DOWNCAST(s->sock_fd+1, SOCKET_T, int);
if (writing) if (writing)
rc = select(nfds, NULL, &fds, NULL, &tv); rc = select(nfds, NULL, &fds, NULL, &tv);
else else

4
Modules/posixmodule.c
View File

@@ -5196,7 +5196,7 @@ os__getvolumepathname_impl(TyObject *module, path_t *path)
Ty_BEGIN_ALLOW_THREADS Ty_BEGIN_ALLOW_THREADS
ret = GetVolumePathNameW(path->wide, mountpath, ret = GetVolumePathNameW(path->wide, mountpath,
Py_SAFE_DOWNCAST(buflen, size_t, DWORD)); Ty_SAFE_DOWNCAST(buflen, size_t, DWORD));
Ty_END_ALLOW_THREADS Ty_END_ALLOW_THREADS
if (!ret) { if (!ret) {
@@ -8306,7 +8306,7 @@ convert_sched_param(TyObject *module, TyObject *param, struct sched_param *res)
TyErr_SetString(TyExc_OverflowError, "sched_priority out of range"); TyErr_SetString(TyExc_OverflowError, "sched_priority out of range");
return 0; return 0;
} }
res->sched_priority = Py_SAFE_DOWNCAST(priority, long, int); res->sched_priority = Ty_SAFE_DOWNCAST(priority, long, int);
return 1; return 1;
} }
#endif /* defined(HAVE_SCHED_SETPARAM) || defined(HAVE_SCHED_SETSCHEDULER) || defined(POSIX_SPAWN_SETSCHEDULER) || defined(POSIX_SPAWN_SETSCHEDPARAM) */ #endif /* defined(HAVE_SCHED_SETPARAM) || defined(HAVE_SCHED_SETSCHEDULER) || defined(POSIX_SPAWN_SETSCHEDULER) || defined(POSIX_SPAWN_SETSCHEDPARAM) */

12
Modules/socketmodule.c
View File

@@ -614,10 +614,10 @@ static int \
_TyLong_##NAME##_Converter(TyObject *obj, void *ptr) \ _TyLong_##NAME##_Converter(TyObject *obj, void *ptr) \
{ \ { \
Ty_ssize_t bytes = TyLong_AsNativeBytes(obj, ptr, sizeof(TYPE), \ Ty_ssize_t bytes = TyLong_AsNativeBytes(obj, ptr, sizeof(TYPE), \
Py_ASNATIVEBYTES_NATIVE_ENDIAN | \ Ty_ASNATIVEBYTES_NATIVE_ENDIAN | \
Py_ASNATIVEBYTES_ALLOW_INDEX | \ Ty_ASNATIVEBYTES_ALLOW_INDEX | \
Py_ASNATIVEBYTES_REJECT_NEGATIVE | \ Ty_ASNATIVEBYTES_REJECT_NEGATIVE | \
Py_ASNATIVEBYTES_UNSIGNED_BUFFER); \ Ty_ASNATIVEBYTES_UNSIGNED_BUFFER); \
if (bytes < 0) { \ if (bytes < 0) { \
return 0; \ return 0; \
} \ } \
@@ -921,10 +921,10 @@ internal_select(PySocketSockObject *s, int writing, TyTime_t interval,
/* See if the socket is ready */ /* See if the socket is ready */
Ty_BEGIN_ALLOW_THREADS; Ty_BEGIN_ALLOW_THREADS;
if (writing) if (writing)
n = select(Py_SAFE_DOWNCAST(get_sock_fd(s)+1, SOCKET_T, int), n = select(Ty_SAFE_DOWNCAST(get_sock_fd(s)+1, SOCKET_T, int),
NULL, &fds, &efds, tvp); NULL, &fds, &efds, tvp);
else else
n = select(Py_SAFE_DOWNCAST(get_sock_fd(s)+1, SOCKET_T, int), n = select(Ty_SAFE_DOWNCAST(get_sock_fd(s)+1, SOCKET_T, int),
&fds, NULL, &efds, tvp); &fds, NULL, &efds, tvp);
Ty_END_ALLOW_THREADS; Ty_END_ALLOW_THREADS;
#endif #endif

12
Objects/clinic/exceptions.c.h generated
View File

@@ -318,7 +318,7 @@ TyDoc_STRVAR(BaseExceptionGroup_derive__doc__,
{"derive", (PyCFunction)BaseExceptionGroup_derive, METH_O, BaseExceptionGroup_derive__doc__}, {"derive", (PyCFunction)BaseExceptionGroup_derive, METH_O, BaseExceptionGroup_derive__doc__},
static TyObject * static TyObject *
BaseExceptionGroup_derive_impl(PyBaseExceptionGroupObject *self, BaseExceptionGroup_derive_impl(TyBaseExceptionGroupObject *self,
TyObject *excs); TyObject *excs);
static TyObject * static TyObject *
@@ -327,7 +327,7 @@ BaseExceptionGroup_derive(TyObject *self, TyObject *excs)
TyObject *return_value = NULL; TyObject *return_value = NULL;
Ty_BEGIN_CRITICAL_SECTION(self); Ty_BEGIN_CRITICAL_SECTION(self);
return_value = BaseExceptionGroup_derive_impl((PyBaseExceptionGroupObject *)self, excs); return_value = BaseExceptionGroup_derive_impl((TyBaseExceptionGroupObject *)self, excs);
Ty_END_CRITICAL_SECTION(); Ty_END_CRITICAL_SECTION();
return return_value; return return_value;
@@ -342,7 +342,7 @@ TyDoc_STRVAR(BaseExceptionGroup_split__doc__,
{"split", (PyCFunction)BaseExceptionGroup_split, METH_O, BaseExceptionGroup_split__doc__}, {"split", (PyCFunction)BaseExceptionGroup_split, METH_O, BaseExceptionGroup_split__doc__},
static TyObject * static TyObject *
BaseExceptionGroup_split_impl(PyBaseExceptionGroupObject *self, BaseExceptionGroup_split_impl(TyBaseExceptionGroupObject *self,
TyObject *matcher_value); TyObject *matcher_value);
static TyObject * static TyObject *
@@ -351,7 +351,7 @@ BaseExceptionGroup_split(TyObject *self, TyObject *matcher_value)
TyObject *return_value = NULL; TyObject *return_value = NULL;
Ty_BEGIN_CRITICAL_SECTION(self); Ty_BEGIN_CRITICAL_SECTION(self);
return_value = BaseExceptionGroup_split_impl((PyBaseExceptionGroupObject *)self, matcher_value); return_value = BaseExceptionGroup_split_impl((TyBaseExceptionGroupObject *)self, matcher_value);
Ty_END_CRITICAL_SECTION(); Ty_END_CRITICAL_SECTION();
return return_value; return return_value;
@@ -366,7 +366,7 @@ TyDoc_STRVAR(BaseExceptionGroup_subgroup__doc__,
{"subgroup", (PyCFunction)BaseExceptionGroup_subgroup, METH_O, BaseExceptionGroup_subgroup__doc__}, {"subgroup", (PyCFunction)BaseExceptionGroup_subgroup, METH_O, BaseExceptionGroup_subgroup__doc__},
static TyObject * static TyObject *
BaseExceptionGroup_subgroup_impl(PyBaseExceptionGroupObject *self, BaseExceptionGroup_subgroup_impl(TyBaseExceptionGroupObject *self,
TyObject *matcher_value); TyObject *matcher_value);
static TyObject * static TyObject *
@@ -375,7 +375,7 @@ BaseExceptionGroup_subgroup(TyObject *self, TyObject *matcher_value)
TyObject *return_value = NULL; TyObject *return_value = NULL;
Ty_BEGIN_CRITICAL_SECTION(self); Ty_BEGIN_CRITICAL_SECTION(self);
return_value = BaseExceptionGroup_subgroup_impl((PyBaseExceptionGroupObject *)self, matcher_value); return_value = BaseExceptionGroup_subgroup_impl((TyBaseExceptionGroupObject *)self, matcher_value);
Ty_END_CRITICAL_SECTION(); Ty_END_CRITICAL_SECTION();
return return_value; return return_value;

254
Objects/exceptions.c
View File

@@ -21,7 +21,7 @@
/*[clinic input] /*[clinic input]
class BaseException "TyBaseExceptionObject *" "&TyExc_BaseException" class BaseException "TyBaseExceptionObject *" "&TyExc_BaseException"
class BaseExceptionGroup "PyBaseExceptionGroupObject *" "&TyExc_BaseExceptionGroup" class BaseExceptionGroup "TyBaseExceptionGroupObject *" "&TyExc_BaseExceptionGroup"
[clinic start generated code]*/ [clinic start generated code]*/
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=b7c45e78cff8edc3]*/ /*[clinic end generated code: output=da39a3ee5e6b4b0d input=b7c45e78cff8edc3]*/
@@ -738,16 +738,16 @@ SimpleExtendsException(TyExc_Exception, StopAsyncIteration,
*/ */
static TyMemberDef StopIteration_members[] = { static TyMemberDef StopIteration_members[] = {
{"value", _Ty_T_OBJECT, offsetof(PyStopIterationObject, value), 0, {"value", _Ty_T_OBJECT, offsetof(TyStopIterationObject, value), 0,
TyDoc_STR("generator return value")}, TyDoc_STR("generator return value")},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
static inline PyStopIterationObject * static inline TyStopIterationObject *
PyStopIterationObject_CAST(TyObject *self) PyStopIterationObject_CAST(TyObject *self)
{ {
assert(PyObject_TypeCheck(self, (TyTypeObject *)TyExc_StopIteration)); assert(PyObject_TypeCheck(self, (TyTypeObject *)TyExc_StopIteration));
return (PyStopIterationObject *)self; return (TyStopIterationObject *)self;
} }
static int static int
@@ -758,7 +758,7 @@ StopIteration_init(TyObject *op, TyObject *args, TyObject *kwds)
if (BaseException_init(op, args, kwds) == -1) if (BaseException_init(op, args, kwds) == -1)
return -1; return -1;
PyStopIterationObject *self = PyStopIterationObject_CAST(op); TyStopIterationObject *self = PyStopIterationObject_CAST(op);
Ty_CLEAR(self->value); Ty_CLEAR(self->value);
if (size > 0) if (size > 0)
value = TyTuple_GET_ITEM(args, 0); value = TyTuple_GET_ITEM(args, 0);
@@ -771,7 +771,7 @@ StopIteration_init(TyObject *op, TyObject *args, TyObject *kwds)
static int static int
StopIteration_clear(TyObject *op) StopIteration_clear(TyObject *op)
{ {
PyStopIterationObject *self = PyStopIterationObject_CAST(op); TyStopIterationObject *self = PyStopIterationObject_CAST(op);
Ty_CLEAR(self->value); Ty_CLEAR(self->value);
return BaseException_clear(op); return BaseException_clear(op);
} }
@@ -787,7 +787,7 @@ StopIteration_dealloc(TyObject *self)
static int static int
StopIteration_traverse(TyObject *op, visitproc visit, void *arg) StopIteration_traverse(TyObject *op, visitproc visit, void *arg)
{ {
PyStopIterationObject *self = PyStopIterationObject_CAST(op); TyStopIterationObject *self = PyStopIterationObject_CAST(op);
Ty_VISIT(self->value); Ty_VISIT(self->value);
return BaseException_traverse(op, visit, arg); return BaseException_traverse(op, visit, arg);
} }
@@ -808,11 +808,11 @@ SimpleExtendsException(TyExc_BaseException, GeneratorExit,
* SystemExit extends BaseException * SystemExit extends BaseException
*/ */
static inline PySystemExitObject * static inline TySystemExitObject *
PySystemExitObject_CAST(TyObject *self) PySystemExitObject_CAST(TyObject *self)
{ {
assert(PyObject_TypeCheck(self, (TyTypeObject *)TyExc_SystemExit)); assert(PyObject_TypeCheck(self, (TyTypeObject *)TyExc_SystemExit));
return (PySystemExitObject *)self; return (TySystemExitObject *)self;
} }
static int static int
@@ -823,7 +823,7 @@ SystemExit_init(TyObject *op, TyObject *args, TyObject *kwds)
if (BaseException_init(op, args, kwds) == -1) if (BaseException_init(op, args, kwds) == -1)
return -1; return -1;
PySystemExitObject *self = PySystemExitObject_CAST(op); TySystemExitObject *self = PySystemExitObject_CAST(op);
if (size == 0) if (size == 0)
return 0; return 0;
if (size == 1) { if (size == 1) {
@@ -838,7 +838,7 @@ SystemExit_init(TyObject *op, TyObject *args, TyObject *kwds)
static int static int
SystemExit_clear(TyObject *op) SystemExit_clear(TyObject *op)
{ {
PySystemExitObject *self = PySystemExitObject_CAST(op); TySystemExitObject *self = PySystemExitObject_CAST(op);
Ty_CLEAR(self->code); Ty_CLEAR(self->code);
return BaseException_clear(op); return BaseException_clear(op);
} }
@@ -854,13 +854,13 @@ SystemExit_dealloc(TyObject *self)
static int static int
SystemExit_traverse(TyObject *op, visitproc visit, void *arg) SystemExit_traverse(TyObject *op, visitproc visit, void *arg)
{ {
PySystemExitObject *self = PySystemExitObject_CAST(op); TySystemExitObject *self = PySystemExitObject_CAST(op);
Ty_VISIT(self->code); Ty_VISIT(self->code);
return BaseException_traverse(op, visit, arg); return BaseException_traverse(op, visit, arg);
} }
static TyMemberDef SystemExit_members[] = { static TyMemberDef SystemExit_members[] = {
{"code", _Ty_T_OBJECT, offsetof(PySystemExitObject, code), 0, {"code", _Ty_T_OBJECT, offsetof(TySystemExitObject, code), 0,
TyDoc_STR("exception code")}, TyDoc_STR("exception code")},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
@@ -875,11 +875,11 @@ ComplexExtendsException(TyExc_BaseException, SystemExit, SystemExit,
*/ */
static inline PyBaseExceptionGroupObject* static inline TyBaseExceptionGroupObject*
PyBaseExceptionGroupObject_CAST(TyObject *exc) PyBaseExceptionGroupObject_CAST(TyObject *exc)
{ {
assert(_PyBaseExceptionGroup_Check(exc)); assert(_PyBaseExceptionGroup_Check(exc));
return (PyBaseExceptionGroupObject *)exc; return (TyBaseExceptionGroupObject *)exc;
} }
static TyObject * static TyObject *
@@ -981,7 +981,7 @@ BaseExceptionGroup_new(TyTypeObject *type, TyObject *args, TyObject *kwds)
*/ */
cls = (TyTypeObject*)TyExc_BaseExceptionGroup; cls = (TyTypeObject*)TyExc_BaseExceptionGroup;
} }
PyBaseExceptionGroupObject *self = TyBaseExceptionGroupObject *self =
PyBaseExceptionGroupObject_CAST(BaseException_new(cls, args, kwds)); PyBaseExceptionGroupObject_CAST(BaseException_new(cls, args, kwds));
if (!self) { if (!self) {
goto error; goto error;
@@ -1027,7 +1027,7 @@ BaseExceptionGroup_init(TyObject *self, TyObject *args, TyObject *kwds)
static int static int
BaseExceptionGroup_clear(TyObject *op) BaseExceptionGroup_clear(TyObject *op)
{ {
PyBaseExceptionGroupObject *self = PyBaseExceptionGroupObject_CAST(op); TyBaseExceptionGroupObject *self = PyBaseExceptionGroupObject_CAST(op);
Ty_CLEAR(self->msg); Ty_CLEAR(self->msg);
Ty_CLEAR(self->excs); Ty_CLEAR(self->excs);
return BaseException_clear(op); return BaseException_clear(op);
@@ -1044,7 +1044,7 @@ BaseExceptionGroup_dealloc(TyObject *self)
static int static int
BaseExceptionGroup_traverse(TyObject *op, visitproc visit, void *arg) BaseExceptionGroup_traverse(TyObject *op, visitproc visit, void *arg)
{ {
PyBaseExceptionGroupObject *self = PyBaseExceptionGroupObject_CAST(op); TyBaseExceptionGroupObject *self = PyBaseExceptionGroupObject_CAST(op);
Ty_VISIT(self->msg); Ty_VISIT(self->msg);
Ty_VISIT(self->excs); Ty_VISIT(self->excs);
return BaseException_traverse(op, visit, arg); return BaseException_traverse(op, visit, arg);
@@ -1053,7 +1053,7 @@ BaseExceptionGroup_traverse(TyObject *op, visitproc visit, void *arg)
static TyObject * static TyObject *
BaseExceptionGroup_str(TyObject *op) BaseExceptionGroup_str(TyObject *op)
{ {
PyBaseExceptionGroupObject *self = PyBaseExceptionGroupObject_CAST(op); TyBaseExceptionGroupObject *self = PyBaseExceptionGroupObject_CAST(op);
assert(self->msg); assert(self->msg);
assert(TyUnicode_Check(self->msg)); assert(TyUnicode_Check(self->msg));
@@ -1072,7 +1072,7 @@ BaseExceptionGroup.derive
[clinic start generated code]*/ [clinic start generated code]*/
static TyObject * static TyObject *
BaseExceptionGroup_derive_impl(PyBaseExceptionGroupObject *self, BaseExceptionGroup_derive_impl(TyBaseExceptionGroupObject *self,
TyObject *excs) TyObject *excs)
/*[clinic end generated code: output=4307564218dfbf06 input=f72009d38e98cec1]*/ /*[clinic end generated code: output=4307564218dfbf06 input=f72009d38e98cec1]*/
{ {
@@ -1088,7 +1088,7 @@ BaseExceptionGroup_derive_impl(PyBaseExceptionGroupObject *self,
static int static int
exceptiongroup_subset( exceptiongroup_subset(
PyBaseExceptionGroupObject *_orig, TyObject *excs, TyObject **result) TyBaseExceptionGroupObject *_orig, TyObject *excs, TyObject **result)
{ {
/* Sets *result to an ExceptionGroup wrapping excs with metadata from /* Sets *result to an ExceptionGroup wrapping excs with metadata from
* _orig. If excs is empty, sets *result to NULL. * _orig. If excs is empty, sets *result to NULL.
@@ -1288,7 +1288,7 @@ exceptiongroup_split_recursive(TyObject *exc,
/* Partial match */ /* Partial match */
PyBaseExceptionGroupObject *eg = PyBaseExceptionGroupObject_CAST(exc); TyBaseExceptionGroupObject *eg = PyBaseExceptionGroupObject_CAST(exc);
assert(TyTuple_CheckExact(eg->excs)); assert(TyTuple_CheckExact(eg->excs));
Ty_ssize_t num_excs = TyTuple_Size(eg->excs); Ty_ssize_t num_excs = TyTuple_Size(eg->excs);
if (num_excs < 0) { if (num_excs < 0) {
@@ -1376,7 +1376,7 @@ BaseExceptionGroup.split
[clinic start generated code]*/ [clinic start generated code]*/
static TyObject * static TyObject *
BaseExceptionGroup_split_impl(PyBaseExceptionGroupObject *self, BaseExceptionGroup_split_impl(TyBaseExceptionGroupObject *self,
TyObject *matcher_value) TyObject *matcher_value)
/*[clinic end generated code: output=d74db579da4df6e2 input=0c5cfbfed57e0052]*/ /*[clinic end generated code: output=d74db579da4df6e2 input=0c5cfbfed57e0052]*/
{ {
@@ -1411,7 +1411,7 @@ BaseExceptionGroup.subgroup
[clinic start generated code]*/ [clinic start generated code]*/
static TyObject * static TyObject *
BaseExceptionGroup_subgroup_impl(PyBaseExceptionGroupObject *self, BaseExceptionGroup_subgroup_impl(TyBaseExceptionGroupObject *self,
TyObject *matcher_value) TyObject *matcher_value)
/*[clinic end generated code: output=07dbec8f77d4dd8e input=988ffdd755a151ce]*/ /*[clinic end generated code: output=07dbec8f77d4dd8e input=988ffdd755a151ce]*/
{ {
@@ -1457,7 +1457,7 @@ collect_exception_group_leaf_ids(TyObject *exc, TyObject *leaf_ids)
Ty_DECREF(exc_id); Ty_DECREF(exc_id);
return res; return res;
} }
PyBaseExceptionGroupObject *eg = PyBaseExceptionGroupObject_CAST(exc); TyBaseExceptionGroupObject *eg = PyBaseExceptionGroupObject_CAST(exc);
Ty_ssize_t num_excs = TyTuple_GET_SIZE(eg->excs); Ty_ssize_t num_excs = TyTuple_GET_SIZE(eg->excs);
/* recursive calls */ /* recursive calls */
for (Ty_ssize_t i = 0; i < num_excs; i++) { for (Ty_ssize_t i = 0; i < num_excs; i++) {
@@ -1679,9 +1679,9 @@ PyUnstable_Exc_PrepReraiseStar(TyObject *orig, TyObject *excs)
} }
static TyMemberDef BaseExceptionGroup_members[] = { static TyMemberDef BaseExceptionGroup_members[] = {
{"message", _Ty_T_OBJECT, offsetof(PyBaseExceptionGroupObject, msg), Py_READONLY, {"message", _Ty_T_OBJECT, offsetof(TyBaseExceptionGroupObject, msg), Py_READONLY,
TyDoc_STR("exception message")}, TyDoc_STR("exception message")},
{"exceptions", _Ty_T_OBJECT, offsetof(PyBaseExceptionGroupObject, excs), Py_READONLY, {"exceptions", _Ty_T_OBJECT, offsetof(TyBaseExceptionGroupObject, excs), Py_READONLY,
TyDoc_STR("nested exceptions")}, TyDoc_STR("nested exceptions")},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
@@ -1733,11 +1733,11 @@ SimpleExtendsException(TyExc_BaseException, KeyboardInterrupt,
* ImportError extends Exception * ImportError extends Exception
*/ */
static inline PyImportErrorObject * static inline TyImportErrorObject *
PyImportErrorObject_CAST(TyObject *self) PyImportErrorObject_CAST(TyObject *self)
{ {
assert(PyObject_TypeCheck(self, (TyTypeObject *)TyExc_ImportError)); assert(PyObject_TypeCheck(self, (TyTypeObject *)TyExc_ImportError));
return (PyImportErrorObject *)self; return (TyImportErrorObject *)self;
} }
static int static int
@@ -1753,7 +1753,7 @@ ImportError_init(TyObject *op, TyObject *args, TyObject *kwds)
if (BaseException_init(op, args, NULL) == -1) if (BaseException_init(op, args, NULL) == -1)
return -1; return -1;
PyImportErrorObject *self = PyImportErrorObject_CAST(op); TyImportErrorObject *self = PyImportErrorObject_CAST(op);
empty_tuple = TyTuple_New(0); empty_tuple = TyTuple_New(0);
if (!empty_tuple) if (!empty_tuple)
return -1; return -1;
@@ -1779,7 +1779,7 @@ ImportError_init(TyObject *op, TyObject *args, TyObject *kwds)
static int static int
ImportError_clear(TyObject *op) ImportError_clear(TyObject *op)
{ {
PyImportErrorObject *self = PyImportErrorObject_CAST(op); TyImportErrorObject *self = PyImportErrorObject_CAST(op);
Ty_CLEAR(self->msg); Ty_CLEAR(self->msg);
Ty_CLEAR(self->name); Ty_CLEAR(self->name);
Ty_CLEAR(self->path); Ty_CLEAR(self->path);
@@ -1798,7 +1798,7 @@ ImportError_dealloc(TyObject *self)
static int static int
ImportError_traverse(TyObject *op, visitproc visit, void *arg) ImportError_traverse(TyObject *op, visitproc visit, void *arg)
{ {
PyImportErrorObject *self = PyImportErrorObject_CAST(op); TyImportErrorObject *self = PyImportErrorObject_CAST(op);
Ty_VISIT(self->msg); Ty_VISIT(self->msg);
Ty_VISIT(self->name); Ty_VISIT(self->name);
Ty_VISIT(self->path); Ty_VISIT(self->path);
@@ -1809,7 +1809,7 @@ ImportError_traverse(TyObject *op, visitproc visit, void *arg)
static TyObject * static TyObject *
ImportError_str(TyObject *op) ImportError_str(TyObject *op)
{ {
PyImportErrorObject *self = PyImportErrorObject_CAST(op); TyImportErrorObject *self = PyImportErrorObject_CAST(op);
if (self->msg && TyUnicode_CheckExact(self->msg)) { if (self->msg && TyUnicode_CheckExact(self->msg)) {
return Ty_NewRef(self->msg); return Ty_NewRef(self->msg);
} }
@@ -1819,7 +1819,7 @@ ImportError_str(TyObject *op)
static TyObject * static TyObject *
ImportError_getstate(TyObject *op) ImportError_getstate(TyObject *op)
{ {
PyImportErrorObject *self = PyImportErrorObject_CAST(op); TyImportErrorObject *self = PyImportErrorObject_CAST(op);
TyObject *dict = self->dict; TyObject *dict = self->dict;
if (self->name || self->path || self->name_from) { if (self->name || self->path || self->name_from) {
dict = dict ? TyDict_Copy(dict) : TyDict_New(); dict = dict ? TyDict_Copy(dict) : TyDict_New();
@@ -1865,13 +1865,13 @@ ImportError_reduce(TyObject *self, TyObject *Py_UNUSED(ignored))
} }
static TyMemberDef ImportError_members[] = { static TyMemberDef ImportError_members[] = {
{"msg", _Ty_T_OBJECT, offsetof(PyImportErrorObject, msg), 0, {"msg", _Ty_T_OBJECT, offsetof(TyImportErrorObject, msg), 0,
TyDoc_STR("exception message")}, TyDoc_STR("exception message")},
{"name", _Ty_T_OBJECT, offsetof(PyImportErrorObject, name), 0, {"name", _Ty_T_OBJECT, offsetof(TyImportErrorObject, name), 0,
TyDoc_STR("module name")}, TyDoc_STR("module name")},
{"path", _Ty_T_OBJECT, offsetof(PyImportErrorObject, path), 0, {"path", _Ty_T_OBJECT, offsetof(TyImportErrorObject, path), 0,
TyDoc_STR("module path")}, TyDoc_STR("module path")},
{"name_from", _Ty_T_OBJECT, offsetof(PyImportErrorObject, name_from), 0, {"name_from", _Ty_T_OBJECT, offsetof(TyImportErrorObject, name_from), 0,
TyDoc_STR("name imported from module")}, TyDoc_STR("name imported from module")},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
@@ -1899,11 +1899,11 @@ MiddlingExtendsException(TyExc_ImportError, ModuleNotFoundError, ImportError,
* OSError extends Exception * OSError extends Exception
*/ */
static inline PyOSErrorObject * static inline TyOSErrorObject *
PyOSErrorObject_CAST(TyObject *self) PyOSErrorObject_CAST(TyObject *self)
{ {
assert(PyObject_TypeCheck(self, (TyTypeObject *)TyExc_OSError)); assert(PyObject_TypeCheck(self, (TyTypeObject *)TyExc_OSError));
return (PyOSErrorObject *)self; return (TyOSErrorObject *)self;
} }
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
@@ -1985,7 +1985,7 @@ oserror_parse_args(TyObject **p_args,
} }
static int static int
oserror_init(PyOSErrorObject *self, TyObject **p_args, oserror_init(TyOSErrorObject *self, TyObject **p_args,
TyObject *myerrno, TyObject *strerror, TyObject *myerrno, TyObject *strerror,
TyObject *filename, TyObject *filename2 TyObject *filename, TyObject *filename2
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
@@ -2067,7 +2067,7 @@ oserror_use_init(TyTypeObject *type)
static TyObject * static TyObject *
OSError_new(TyTypeObject *type, TyObject *args, TyObject *kwds) OSError_new(TyTypeObject *type, TyObject *args, TyObject *kwds)
{ {
PyOSErrorObject *self = NULL; TyOSErrorObject *self = NULL;
TyObject *myerrno = NULL, *strerror = NULL; TyObject *myerrno = NULL, *strerror = NULL;
TyObject *filename = NULL, *filename2 = NULL; TyObject *filename = NULL, *filename2 = NULL;
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
@@ -2101,7 +2101,7 @@ OSError_new(TyTypeObject *type, TyObject *args, TyObject *kwds)
} }
} }
self = (PyOSErrorObject *) type->tp_alloc(type, 0); self = (TyOSErrorObject *) type->tp_alloc(type, 0);
if (!self) if (!self)
goto error; goto error;
@@ -2135,7 +2135,7 @@ error:
static int static int
OSError_init(TyObject *op, TyObject *args, TyObject *kwds) OSError_init(TyObject *op, TyObject *args, TyObject *kwds)
{ {
PyOSErrorObject *self = PyOSErrorObject_CAST(op); TyOSErrorObject *self = PyOSErrorObject_CAST(op);
TyObject *myerrno = NULL, *strerror = NULL; TyObject *myerrno = NULL, *strerror = NULL;
TyObject *filename = NULL, *filename2 = NULL; TyObject *filename = NULL, *filename2 = NULL;
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
@@ -2174,7 +2174,7 @@ error:
static int static int
OSError_clear(TyObject *op) OSError_clear(TyObject *op)
{ {
PyOSErrorObject *self = PyOSErrorObject_CAST(op); TyOSErrorObject *self = PyOSErrorObject_CAST(op);
Ty_CLEAR(self->myerrno); Ty_CLEAR(self->myerrno);
Ty_CLEAR(self->strerror); Ty_CLEAR(self->strerror);
Ty_CLEAR(self->filename); Ty_CLEAR(self->filename);
@@ -2196,7 +2196,7 @@ OSError_dealloc(TyObject *self)
static int static int
OSError_traverse(TyObject *op, visitproc visit, void *arg) OSError_traverse(TyObject *op, visitproc visit, void *arg)
{ {
PyOSErrorObject *self = PyOSErrorObject_CAST(op); TyOSErrorObject *self = PyOSErrorObject_CAST(op);
Ty_VISIT(self->myerrno); Ty_VISIT(self->myerrno);
Ty_VISIT(self->strerror); Ty_VISIT(self->strerror);
Ty_VISIT(self->filename); Ty_VISIT(self->filename);
@@ -2210,7 +2210,7 @@ OSError_traverse(TyObject *op, visitproc visit, void *arg)
static TyObject * static TyObject *
OSError_str(TyObject *op) OSError_str(TyObject *op)
{ {
PyOSErrorObject *self = PyOSErrorObject_CAST(op); TyOSErrorObject *self = PyOSErrorObject_CAST(op);
#define OR_NONE(x) ((x)?(x):Ty_None) #define OR_NONE(x) ((x)?(x):Ty_None)
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
/* If available, winerror has the priority over myerrno */ /* If available, winerror has the priority over myerrno */
@@ -2256,7 +2256,7 @@ OSError_str(TyObject *op)
static TyObject * static TyObject *
OSError_reduce(TyObject *op, TyObject *Py_UNUSED(ignored)) OSError_reduce(TyObject *op, TyObject *Py_UNUSED(ignored))
{ {
PyOSErrorObject *self = PyOSErrorObject_CAST(op); TyOSErrorObject *self = PyOSErrorObject_CAST(op);
TyObject *args = self->args; TyObject *args = self->args;
TyObject *res = NULL; TyObject *res = NULL;
@@ -2297,7 +2297,7 @@ OSError_reduce(TyObject *op, TyObject *Py_UNUSED(ignored))
static TyObject * static TyObject *
OSError_written_get(TyObject *op, void *context) OSError_written_get(TyObject *op, void *context)
{ {
PyOSErrorObject *self = PyOSErrorObject_CAST(op); TyOSErrorObject *self = PyOSErrorObject_CAST(op);
if (self->written == -1) { if (self->written == -1) {
TyErr_SetString(TyExc_AttributeError, "characters_written"); TyErr_SetString(TyExc_AttributeError, "characters_written");
return NULL; return NULL;
@@ -2308,7 +2308,7 @@ OSError_written_get(TyObject *op, void *context)
static int static int
OSError_written_set(TyObject *op, TyObject *arg, void *context) OSError_written_set(TyObject *op, TyObject *arg, void *context)
{ {
PyOSErrorObject *self = PyOSErrorObject_CAST(op); TyOSErrorObject *self = PyOSErrorObject_CAST(op);
if (arg == NULL) { if (arg == NULL) {
if (self->written == -1) { if (self->written == -1) {
TyErr_SetString(TyExc_AttributeError, "characters_written"); TyErr_SetString(TyExc_AttributeError, "characters_written");
@@ -2326,16 +2326,16 @@ OSError_written_set(TyObject *op, TyObject *arg, void *context)
} }
static TyMemberDef OSError_members[] = { static TyMemberDef OSError_members[] = {
{"errno", _Ty_T_OBJECT, offsetof(PyOSErrorObject, myerrno), 0, {"errno", _Ty_T_OBJECT, offsetof(TyOSErrorObject, myerrno), 0,
TyDoc_STR("POSIX exception code")}, TyDoc_STR("POSIX exception code")},
{"strerror", _Ty_T_OBJECT, offsetof(PyOSErrorObject, strerror), 0, {"strerror", _Ty_T_OBJECT, offsetof(TyOSErrorObject, strerror), 0,
TyDoc_STR("exception strerror")}, TyDoc_STR("exception strerror")},
{"filename", _Ty_T_OBJECT, offsetof(PyOSErrorObject, filename), 0, {"filename", _Ty_T_OBJECT, offsetof(TyOSErrorObject, filename), 0,
TyDoc_STR("exception filename")}, TyDoc_STR("exception filename")},
{"filename2", _Ty_T_OBJECT, offsetof(PyOSErrorObject, filename2), 0, {"filename2", _Ty_T_OBJECT, offsetof(TyOSErrorObject, filename2), 0,
TyDoc_STR("second exception filename")}, TyDoc_STR("second exception filename")},
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
{"winerror", _Ty_T_OBJECT, offsetof(PyOSErrorObject, winerror), 0, {"winerror", _Ty_T_OBJECT, offsetof(TyOSErrorObject, winerror), 0,
TyDoc_STR("Win32 exception code")}, TyDoc_STR("Win32 exception code")},
#endif #endif
{NULL} /* Sentinel */ {NULL} /* Sentinel */
@@ -2427,11 +2427,11 @@ SimpleExtendsException(TyExc_RuntimeError, NotImplementedError,
* NameError extends Exception * NameError extends Exception
*/ */
static inline PyNameErrorObject * static inline TyNameErrorObject *
PyNameErrorObject_CAST(TyObject *self) PyNameErrorObject_CAST(TyObject *self)
{ {
assert(PyObject_TypeCheck(self, (TyTypeObject *)TyExc_NameError)); assert(PyObject_TypeCheck(self, (TyTypeObject *)TyExc_NameError));
return (PyNameErrorObject *)self; return (TyNameErrorObject *)self;
} }
static int static int
@@ -2455,7 +2455,7 @@ NameError_init(TyObject *op, TyObject *args, TyObject *kwds)
} }
Ty_DECREF(empty_tuple); Ty_DECREF(empty_tuple);
PyNameErrorObject *self = PyNameErrorObject_CAST(op); TyNameErrorObject *self = PyNameErrorObject_CAST(op);
Ty_XSETREF(self->name, Ty_XNewRef(name)); Ty_XSETREF(self->name, Ty_XNewRef(name));
return 0; return 0;
@@ -2464,7 +2464,7 @@ NameError_init(TyObject *op, TyObject *args, TyObject *kwds)
static int static int
NameError_clear(TyObject *op) NameError_clear(TyObject *op)
{ {
PyNameErrorObject *self = PyNameErrorObject_CAST(op); TyNameErrorObject *self = PyNameErrorObject_CAST(op);
Ty_CLEAR(self->name); Ty_CLEAR(self->name);
return BaseException_clear(op); return BaseException_clear(op);
} }
@@ -2480,13 +2480,13 @@ NameError_dealloc(TyObject *self)
static int static int
NameError_traverse(TyObject *op, visitproc visit, void *arg) NameError_traverse(TyObject *op, visitproc visit, void *arg)
{ {
PyNameErrorObject *self = PyNameErrorObject_CAST(op); TyNameErrorObject *self = PyNameErrorObject_CAST(op);
Ty_VISIT(self->name); Ty_VISIT(self->name);
return BaseException_traverse(op, visit, arg); return BaseException_traverse(op, visit, arg);
} }
static TyMemberDef NameError_members[] = { static TyMemberDef NameError_members[] = {
{"name", _Ty_T_OBJECT, offsetof(PyNameErrorObject, name), 0, TyDoc_STR("name")}, {"name", _Ty_T_OBJECT, offsetof(TyNameErrorObject, name), 0, TyDoc_STR("name")},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
@@ -2510,11 +2510,11 @@ MiddlingExtendsException(TyExc_NameError, UnboundLocalError, NameError,
* AttributeError extends Exception * AttributeError extends Exception
*/ */
static inline PyAttributeErrorObject * static inline TyAttributeErrorObject *
PyAttributeErrorObject_CAST(TyObject *self) PyAttributeErrorObject_CAST(TyObject *self)
{ {
assert(PyObject_TypeCheck(self, (TyTypeObject *)TyExc_AttributeError)); assert(PyObject_TypeCheck(self, (TyTypeObject *)TyExc_AttributeError));
return (PyAttributeErrorObject *)self; return (TyAttributeErrorObject *)self;
} }
static int static int
@@ -2539,7 +2539,7 @@ AttributeError_init(TyObject *op, TyObject *args, TyObject *kwds)
} }
Ty_DECREF(empty_tuple); Ty_DECREF(empty_tuple);
PyAttributeErrorObject *self = PyAttributeErrorObject_CAST(op); TyAttributeErrorObject *self = PyAttributeErrorObject_CAST(op);
Ty_XSETREF(self->name, Ty_XNewRef(name)); Ty_XSETREF(self->name, Ty_XNewRef(name));
Ty_XSETREF(self->obj, Ty_XNewRef(obj)); Ty_XSETREF(self->obj, Ty_XNewRef(obj));
@@ -2549,7 +2549,7 @@ AttributeError_init(TyObject *op, TyObject *args, TyObject *kwds)
static int static int
AttributeError_clear(TyObject *op) AttributeError_clear(TyObject *op)
{ {
PyAttributeErrorObject *self = PyAttributeErrorObject_CAST(op); TyAttributeErrorObject *self = PyAttributeErrorObject_CAST(op);
Ty_CLEAR(self->obj); Ty_CLEAR(self->obj);
Ty_CLEAR(self->name); Ty_CLEAR(self->name);
return BaseException_clear(op); return BaseException_clear(op);
@@ -2566,7 +2566,7 @@ AttributeError_dealloc(TyObject *self)
static int static int
AttributeError_traverse(TyObject *op, visitproc visit, void *arg) AttributeError_traverse(TyObject *op, visitproc visit, void *arg)
{ {
PyAttributeErrorObject *self = PyAttributeErrorObject_CAST(op); TyAttributeErrorObject *self = PyAttributeErrorObject_CAST(op);
Ty_VISIT(self->obj); Ty_VISIT(self->obj);
Ty_VISIT(self->name); Ty_VISIT(self->name);
return BaseException_traverse(op, visit, arg); return BaseException_traverse(op, visit, arg);
@@ -2576,7 +2576,7 @@ AttributeError_traverse(TyObject *op, visitproc visit, void *arg)
static TyObject * static TyObject *
AttributeError_getstate(TyObject *op, TyObject *Py_UNUSED(ignored)) AttributeError_getstate(TyObject *op, TyObject *Py_UNUSED(ignored))
{ {
PyAttributeErrorObject *self = PyAttributeErrorObject_CAST(op); TyAttributeErrorObject *self = PyAttributeErrorObject_CAST(op);
TyObject *dict = self->dict; TyObject *dict = self->dict;
if (self->name || self->args) { if (self->name || self->args) {
dict = dict ? TyDict_Copy(dict) : TyDict_New(); dict = dict ? TyDict_Copy(dict) : TyDict_New();
@@ -2610,15 +2610,15 @@ AttributeError_reduce(TyObject *op, TyObject *Py_UNUSED(ignored))
return NULL; return NULL;
} }
PyAttributeErrorObject *self = PyAttributeErrorObject_CAST(op); TyAttributeErrorObject *self = PyAttributeErrorObject_CAST(op);
TyObject *return_value = TyTuple_Pack(3, Ty_TYPE(self), self->args, state); TyObject *return_value = TyTuple_Pack(3, Ty_TYPE(self), self->args, state);
Ty_DECREF(state); Ty_DECREF(state);
return return_value; return return_value;
} }
static TyMemberDef AttributeError_members[] = { static TyMemberDef AttributeError_members[] = {
{"name", _Ty_T_OBJECT, offsetof(PyAttributeErrorObject, name), 0, TyDoc_STR("attribute name")}, {"name", _Ty_T_OBJECT, offsetof(TyAttributeErrorObject, name), 0, TyDoc_STR("attribute name")},
{"obj", _Ty_T_OBJECT, offsetof(PyAttributeErrorObject, obj), 0, TyDoc_STR("object")}, {"obj", _Ty_T_OBJECT, offsetof(TyAttributeErrorObject, obj), 0, TyDoc_STR("object")},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
@@ -2637,11 +2637,11 @@ ComplexExtendsException(TyExc_Exception, AttributeError,
* SyntaxError extends Exception * SyntaxError extends Exception
*/ */
static inline PySyntaxErrorObject * static inline TySyntaxErrorObject *
PySyntaxErrorObject_CAST(TyObject *self) PySyntaxErrorObject_CAST(TyObject *self)
{ {
assert(PyObject_TypeCheck(self, (TyTypeObject *)TyExc_SyntaxError)); assert(PyObject_TypeCheck(self, (TyTypeObject *)TyExc_SyntaxError));
return (PySyntaxErrorObject *)self; return (TySyntaxErrorObject *)self;
} }
static int static int
@@ -2653,7 +2653,7 @@ SyntaxError_init(TyObject *op, TyObject *args, TyObject *kwds)
if (BaseException_init(op, args, kwds) == -1) if (BaseException_init(op, args, kwds) == -1)
return -1; return -1;
PySyntaxErrorObject *self = PySyntaxErrorObject_CAST(op); TySyntaxErrorObject *self = PySyntaxErrorObject_CAST(op);
if (lenargs >= 1) { if (lenargs >= 1) {
Ty_XSETREF(self->msg, Ty_NewRef(TyTuple_GET_ITEM(args, 0))); Ty_XSETREF(self->msg, Ty_NewRef(TyTuple_GET_ITEM(args, 0)));
} }
@@ -2694,7 +2694,7 @@ SyntaxError_init(TyObject *op, TyObject *args, TyObject *kwds)
static int static int
SyntaxError_clear(TyObject *op) SyntaxError_clear(TyObject *op)
{ {
PySyntaxErrorObject *self = PySyntaxErrorObject_CAST(op); TySyntaxErrorObject *self = PySyntaxErrorObject_CAST(op);
Ty_CLEAR(self->msg); Ty_CLEAR(self->msg);
Ty_CLEAR(self->filename); Ty_CLEAR(self->filename);
Ty_CLEAR(self->lineno); Ty_CLEAR(self->lineno);
@@ -2718,7 +2718,7 @@ SyntaxError_dealloc(TyObject *self)
static int static int
SyntaxError_traverse(TyObject *op, visitproc visit, void *arg) SyntaxError_traverse(TyObject *op, visitproc visit, void *arg)
{ {
PySyntaxErrorObject *self = PySyntaxErrorObject_CAST(op); TySyntaxErrorObject *self = PySyntaxErrorObject_CAST(op);
Ty_VISIT(self->msg); Ty_VISIT(self->msg);
Ty_VISIT(self->filename); Ty_VISIT(self->filename);
Ty_VISIT(self->lineno); Ty_VISIT(self->lineno);
@@ -2762,7 +2762,7 @@ my_basename(TyObject *name)
static TyObject * static TyObject *
SyntaxError_str(TyObject *op) SyntaxError_str(TyObject *op)
{ {
PySyntaxErrorObject *self = PySyntaxErrorObject_CAST(op); TySyntaxErrorObject *self = PySyntaxErrorObject_CAST(op);
int have_lineno = 0; int have_lineno = 0;
TyObject *filename; TyObject *filename;
TyObject *result; TyObject *result;
@@ -2806,24 +2806,24 @@ SyntaxError_str(TyObject *op)
} }
static TyMemberDef SyntaxError_members[] = { static TyMemberDef SyntaxError_members[] = {
{"msg", _Ty_T_OBJECT, offsetof(PySyntaxErrorObject, msg), 0, {"msg", _Ty_T_OBJECT, offsetof(TySyntaxErrorObject, msg), 0,
TyDoc_STR("exception msg")}, TyDoc_STR("exception msg")},
{"filename", _Ty_T_OBJECT, offsetof(PySyntaxErrorObject, filename), 0, {"filename", _Ty_T_OBJECT, offsetof(TySyntaxErrorObject, filename), 0,
TyDoc_STR("exception filename")}, TyDoc_STR("exception filename")},
{"lineno", _Ty_T_OBJECT, offsetof(PySyntaxErrorObject, lineno), 0, {"lineno", _Ty_T_OBJECT, offsetof(TySyntaxErrorObject, lineno), 0,
TyDoc_STR("exception lineno")}, TyDoc_STR("exception lineno")},
{"offset", _Ty_T_OBJECT, offsetof(PySyntaxErrorObject, offset), 0, {"offset", _Ty_T_OBJECT, offsetof(TySyntaxErrorObject, offset), 0,
TyDoc_STR("exception offset")}, TyDoc_STR("exception offset")},
{"text", _Ty_T_OBJECT, offsetof(PySyntaxErrorObject, text), 0, {"text", _Ty_T_OBJECT, offsetof(TySyntaxErrorObject, text), 0,
TyDoc_STR("exception text")}, TyDoc_STR("exception text")},
{"end_lineno", _Ty_T_OBJECT, offsetof(PySyntaxErrorObject, end_lineno), 0, {"end_lineno", _Ty_T_OBJECT, offsetof(TySyntaxErrorObject, end_lineno), 0,
TyDoc_STR("exception end lineno")}, TyDoc_STR("exception end lineno")},
{"end_offset", _Ty_T_OBJECT, offsetof(PySyntaxErrorObject, end_offset), 0, {"end_offset", _Ty_T_OBJECT, offsetof(TySyntaxErrorObject, end_offset), 0,
TyDoc_STR("exception end offset")}, TyDoc_STR("exception end offset")},
{"print_file_and_line", _Ty_T_OBJECT, {"print_file_and_line", _Ty_T_OBJECT,
offsetof(PySyntaxErrorObject, print_file_and_line), 0, offsetof(TySyntaxErrorObject, print_file_and_line), 0,
TyDoc_STR("exception print_file_and_line")}, TyDoc_STR("exception print_file_and_line")},
{"_metadata", _Ty_T_OBJECT, offsetof(PySyntaxErrorObject, metadata), 0, {"_metadata", _Ty_T_OBJECT, offsetof(TySyntaxErrorObject, metadata), 0,
TyDoc_STR("exception private metadata")}, TyDoc_STR("exception private metadata")},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
@@ -2956,7 +2956,7 @@ as_unicode_error_attribute(TyObject *attr, const char *name, int as_bytes)
#define PyUnicodeError_Check(PTR) \ #define PyUnicodeError_Check(PTR) \
PyObject_TypeCheck((PTR), (TyTypeObject *)TyExc_UnicodeError) PyObject_TypeCheck((PTR), (TyTypeObject *)TyExc_UnicodeError)
#define PyUnicodeError_CAST(PTR) \ #define PyUnicodeError_CAST(PTR) \
(assert(PyUnicodeError_Check(PTR)), ((PyUnicodeErrorObject *)(PTR))) (assert(PyUnicodeError_Check(PTR)), ((TyUnicodeErrorObject *)(PTR)))
/* class names to use when reporting errors */ /* class names to use when reporting errors */
@@ -2992,10 +2992,10 @@ check_unicode_error_type(TyObject *self, const char *expect_type)
} }
// --- PyUnicodeEncodeObject: internal helpers -------------------------------- // --- TyUnicodeEncodeObject: internal helpers --------------------------------
// //
// In the helpers below, the caller is responsible to ensure that 'self' // In the helpers below, the caller is responsible to ensure that 'self'
// is a PyUnicodeErrorObject, although this is verified on DEBUG builds // is a TyUnicodeErrorObject, although this is verified on DEBUG builds
// through PyUnicodeError_CAST(). // through PyUnicodeError_CAST().
/* /*
@@ -3005,7 +3005,7 @@ static inline TyObject *
unicode_error_get_encoding_impl(TyObject *self) unicode_error_get_encoding_impl(TyObject *self)
{ {
assert(self != NULL); assert(self != NULL);
PyUnicodeErrorObject *exc = PyUnicodeError_CAST(self); TyUnicodeErrorObject *exc = PyUnicodeError_CAST(self);
return as_unicode_error_attribute(exc->encoding, "encoding", false); return as_unicode_error_attribute(exc->encoding, "encoding", false);
} }
@@ -3018,7 +3018,7 @@ static inline TyObject *
unicode_error_get_object_impl(TyObject *self, int as_bytes) unicode_error_get_object_impl(TyObject *self, int as_bytes)
{ {
assert(self != NULL); assert(self != NULL);
PyUnicodeErrorObject *exc = PyUnicodeError_CAST(self); TyUnicodeErrorObject *exc = PyUnicodeError_CAST(self);
return as_unicode_error_attribute(exc->object, "object", as_bytes); return as_unicode_error_attribute(exc->object, "object", as_bytes);
} }
@@ -3030,7 +3030,7 @@ static inline TyObject *
unicode_error_get_reason_impl(TyObject *self) unicode_error_get_reason_impl(TyObject *self)
{ {
assert(self != NULL); assert(self != NULL);
PyUnicodeErrorObject *exc = PyUnicodeError_CAST(self); TyUnicodeErrorObject *exc = PyUnicodeError_CAST(self);
return as_unicode_error_attribute(exc->reason, "reason", false); return as_unicode_error_attribute(exc->reason, "reason", false);
} }
@@ -3048,7 +3048,7 @@ unicode_error_set_reason_impl(TyObject *self, const char *reason)
if (value == NULL) { if (value == NULL) {
return -1; return -1;
} }
PyUnicodeErrorObject *exc = PyUnicodeError_CAST(self); TyUnicodeErrorObject *exc = PyUnicodeError_CAST(self);
Ty_XSETREF(exc->reason, value); Ty_XSETREF(exc->reason, value);
return 0; return 0;
} }
@@ -3063,7 +3063,7 @@ static inline int
unicode_error_set_start_impl(TyObject *self, Ty_ssize_t start) unicode_error_set_start_impl(TyObject *self, Ty_ssize_t start)
{ {
assert(self != NULL); assert(self != NULL);
PyUnicodeErrorObject *exc = PyUnicodeError_CAST(self); TyUnicodeErrorObject *exc = PyUnicodeError_CAST(self);
exc->start = start; exc->start = start;
return 0; return 0;
} }
@@ -3078,12 +3078,12 @@ static inline int
unicode_error_set_end_impl(TyObject *self, Ty_ssize_t end) unicode_error_set_end_impl(TyObject *self, Ty_ssize_t end)
{ {
assert(self != NULL); assert(self != NULL);
PyUnicodeErrorObject *exc = PyUnicodeError_CAST(self); TyUnicodeErrorObject *exc = PyUnicodeError_CAST(self);
exc->end = end; exc->end = end;
return 0; return 0;
} }
// --- PyUnicodeEncodeObject: internal getters -------------------------------- // --- TyUnicodeEncodeObject: internal getters --------------------------------
/* /*
* Adjust the (inclusive) 'start' value of a UnicodeError object. * Adjust the (inclusive) 'start' value of a UnicodeError object.
@@ -3151,7 +3151,7 @@ unicode_error_adjust_end(Ty_ssize_t end, Ty_ssize_t objlen)
#define PyUnicodeError_Check(PTR) \ #define PyUnicodeError_Check(PTR) \
PyObject_TypeCheck((PTR), (TyTypeObject *)TyExc_UnicodeError) PyObject_TypeCheck((PTR), (TyTypeObject *)TyExc_UnicodeError)
#define PyUnicodeErrorObject_CAST(op) \ #define PyUnicodeErrorObject_CAST(op) \
(assert(PyUnicodeError_Check(op)), ((PyUnicodeErrorObject *)(op))) (assert(PyUnicodeError_Check(op)), ((TyUnicodeErrorObject *)(op)))
/* Assert some properties of the adjusted 'end' value. */ /* Assert some properties of the adjusted 'end' value. */
#ifndef NDEBUG #ifndef NDEBUG
@@ -3209,7 +3209,7 @@ assert_adjusted_unicode_error_len(Ty_ssize_t ranlen, Ty_ssize_t objlen)
/* /*
* Get various common parameters of a UnicodeError object. * Get various common parameters of a UnicodeError object.
* *
* The caller is responsible to ensure that 'self' is a PyUnicodeErrorObject, * The caller is responsible to ensure that 'self' is a TyUnicodeErrorObject,
* although this condition is verified by this function on DEBUG builds. * although this condition is verified by this function on DEBUG builds.
* *
* Return 0 on success and -1 on failure. * Return 0 on success and -1 on failure.
@@ -3242,7 +3242,7 @@ _PyUnicodeError_GetParams(TyObject *self,
{ {
assert(self != NULL); assert(self != NULL);
assert(as_bytes == 0 || as_bytes == 1); assert(as_bytes == 0 || as_bytes == 1);
PyUnicodeErrorObject *exc = PyUnicodeError_CAST(self); TyUnicodeErrorObject *exc = PyUnicodeError_CAST(self);
TyObject *r = as_unicode_error_attribute(exc->object, "object", as_bytes); TyObject *r = as_unicode_error_attribute(exc->object, "object", as_bytes);
if (r == NULL) { if (r == NULL) {
return -1; return -1;
@@ -3286,7 +3286,7 @@ _PyUnicodeError_GetParams(TyObject *self,
} }
// --- PyUnicodeEncodeObject: 'encoding' getters ------------------------------ // --- TyUnicodeEncodeObject: 'encoding' getters ------------------------------
// Note: PyUnicodeTranslateError does not have an 'encoding' attribute. // Note: PyUnicodeTranslateError does not have an 'encoding' attribute.
TyObject * TyObject *
@@ -3305,7 +3305,7 @@ PyUnicodeDecodeError_GetEncoding(TyObject *self)
} }
// --- PyUnicodeEncodeObject: 'object' getters -------------------------------- // --- TyUnicodeEncodeObject: 'object' getters --------------------------------
TyObject * TyObject *
PyUnicodeEncodeError_GetObject(TyObject *self) PyUnicodeEncodeError_GetObject(TyObject *self)
@@ -3331,12 +3331,12 @@ PyUnicodeTranslateError_GetObject(TyObject *self)
} }
// --- PyUnicodeEncodeObject: 'start' getters --------------------------------- // --- TyUnicodeEncodeObject: 'start' getters ---------------------------------
/* /*
* Specialization of _PyUnicodeError_GetParams() for the 'start' attribute. * Specialization of _PyUnicodeError_GetParams() for the 'start' attribute.
* *
* The caller is responsible to ensure that 'self' is a PyUnicodeErrorObject, * The caller is responsible to ensure that 'self' is a TyUnicodeErrorObject,
* although this condition is verified by this function on DEBUG builds. * although this condition is verified by this function on DEBUG builds.
*/ */
static inline int static inline int
@@ -3373,7 +3373,7 @@ PyUnicodeTranslateError_GetStart(TyObject *self, Ty_ssize_t *start)
} }
// --- PyUnicodeEncodeObject: 'start' setters --------------------------------- // --- TyUnicodeEncodeObject: 'start' setters ---------------------------------
int int
PyUnicodeEncodeError_SetStart(TyObject *self, Ty_ssize_t start) PyUnicodeEncodeError_SetStart(TyObject *self, Ty_ssize_t start)
@@ -3399,12 +3399,12 @@ PyUnicodeTranslateError_SetStart(TyObject *self, Ty_ssize_t start)
} }
// --- PyUnicodeEncodeObject: 'end' getters ----------------------------------- // --- TyUnicodeEncodeObject: 'end' getters -----------------------------------
/* /*
* Specialization of _PyUnicodeError_GetParams() for the 'end' attribute. * Specialization of _PyUnicodeError_GetParams() for the 'end' attribute.
* *
* The caller is responsible to ensure that 'self' is a PyUnicodeErrorObject, * The caller is responsible to ensure that 'self' is a TyUnicodeErrorObject,
* although this condition is verified by this function on DEBUG builds. * although this condition is verified by this function on DEBUG builds.
*/ */
static inline int static inline int
@@ -3441,7 +3441,7 @@ PyUnicodeTranslateError_GetEnd(TyObject *self, Ty_ssize_t *end)
} }
// --- PyUnicodeEncodeObject: 'end' setters ----------------------------------- // --- TyUnicodeEncodeObject: 'end' setters -----------------------------------
int int
PyUnicodeEncodeError_SetEnd(TyObject *self, Ty_ssize_t end) PyUnicodeEncodeError_SetEnd(TyObject *self, Ty_ssize_t end)
@@ -3467,7 +3467,7 @@ PyUnicodeTranslateError_SetEnd(TyObject *self, Ty_ssize_t end)
} }
// --- PyUnicodeEncodeObject: 'reason' getters -------------------------------- // --- TyUnicodeEncodeObject: 'reason' getters --------------------------------
TyObject * TyObject *
PyUnicodeEncodeError_GetReason(TyObject *self) PyUnicodeEncodeError_GetReason(TyObject *self)
@@ -3493,7 +3493,7 @@ PyUnicodeTranslateError_GetReason(TyObject *self)
} }
// --- PyUnicodeEncodeObject: 'reason' setters -------------------------------- // --- TyUnicodeEncodeObject: 'reason' setters --------------------------------
int int
PyUnicodeEncodeError_SetReason(TyObject *self, const char *reason) PyUnicodeEncodeError_SetReason(TyObject *self, const char *reason)
@@ -3522,7 +3522,7 @@ PyUnicodeTranslateError_SetReason(TyObject *self, const char *reason)
static int static int
UnicodeError_clear(TyObject *self) UnicodeError_clear(TyObject *self)
{ {
PyUnicodeErrorObject *exc = PyUnicodeErrorObject_CAST(self); TyUnicodeErrorObject *exc = PyUnicodeErrorObject_CAST(self);
Ty_CLEAR(exc->encoding); Ty_CLEAR(exc->encoding);
Ty_CLEAR(exc->object); Ty_CLEAR(exc->object);
Ty_CLEAR(exc->reason); Ty_CLEAR(exc->reason);
@@ -3541,7 +3541,7 @@ UnicodeError_dealloc(TyObject *self)
static int static int
UnicodeError_traverse(TyObject *self, visitproc visit, void *arg) UnicodeError_traverse(TyObject *self, visitproc visit, void *arg)
{ {
PyUnicodeErrorObject *exc = PyUnicodeErrorObject_CAST(self); TyUnicodeErrorObject *exc = PyUnicodeErrorObject_CAST(self);
Ty_VISIT(exc->encoding); Ty_VISIT(exc->encoding);
Ty_VISIT(exc->object); Ty_VISIT(exc->object);
Ty_VISIT(exc->reason); Ty_VISIT(exc->reason);
@@ -3549,15 +3549,15 @@ UnicodeError_traverse(TyObject *self, visitproc visit, void *arg)
} }
static TyMemberDef UnicodeError_members[] = { static TyMemberDef UnicodeError_members[] = {
{"encoding", _Ty_T_OBJECT, offsetof(PyUnicodeErrorObject, encoding), 0, {"encoding", _Ty_T_OBJECT, offsetof(TyUnicodeErrorObject, encoding), 0,
TyDoc_STR("exception encoding")}, TyDoc_STR("exception encoding")},
{"object", _Ty_T_OBJECT, offsetof(PyUnicodeErrorObject, object), 0, {"object", _Ty_T_OBJECT, offsetof(TyUnicodeErrorObject, object), 0,
TyDoc_STR("exception object")}, TyDoc_STR("exception object")},
{"start", Ty_T_PYSSIZET, offsetof(PyUnicodeErrorObject, start), 0, {"start", Ty_T_PYSSIZET, offsetof(TyUnicodeErrorObject, start), 0,
TyDoc_STR("exception start")}, TyDoc_STR("exception start")},
{"end", Ty_T_PYSSIZET, offsetof(PyUnicodeErrorObject, end), 0, {"end", Ty_T_PYSSIZET, offsetof(TyUnicodeErrorObject, end), 0,
TyDoc_STR("exception end")}, TyDoc_STR("exception end")},
{"reason", _Ty_T_OBJECT, offsetof(PyUnicodeErrorObject, reason), 0, {"reason", _Ty_T_OBJECT, offsetof(TyUnicodeErrorObject, reason), 0,
TyDoc_STR("exception reason")}, TyDoc_STR("exception reason")},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
@@ -3583,7 +3583,7 @@ UnicodeEncodeError_init(TyObject *self, TyObject *args, TyObject *kwds)
return -1; return -1;
} }
PyUnicodeErrorObject *exc = PyUnicodeErrorObject_CAST(self); TyUnicodeErrorObject *exc = PyUnicodeErrorObject_CAST(self);
Ty_XSETREF(exc->encoding, Ty_NewRef(encoding)); Ty_XSETREF(exc->encoding, Ty_NewRef(encoding));
Ty_XSETREF(exc->object, Ty_NewRef(object)); Ty_XSETREF(exc->object, Ty_NewRef(object));
exc->start = start; exc->start = start;
@@ -3595,7 +3595,7 @@ UnicodeEncodeError_init(TyObject *self, TyObject *args, TyObject *kwds)
static TyObject * static TyObject *
UnicodeEncodeError_str(TyObject *self) UnicodeEncodeError_str(TyObject *self)
{ {
PyUnicodeErrorObject *exc = PyUnicodeErrorObject_CAST(self); TyUnicodeErrorObject *exc = PyUnicodeErrorObject_CAST(self);
TyObject *result = NULL; TyObject *result = NULL;
TyObject *reason_str = NULL; TyObject *reason_str = NULL;
TyObject *encoding_str = NULL; TyObject *encoding_str = NULL;
@@ -3658,13 +3658,13 @@ done:
static TyTypeObject _TyExc_UnicodeEncodeError = { static TyTypeObject _TyExc_UnicodeEncodeError = {
TyVarObject_HEAD_INIT(NULL, 0) TyVarObject_HEAD_INIT(NULL, 0)
"UnicodeEncodeError", "UnicodeEncodeError",
sizeof(PyUnicodeErrorObject), 0, sizeof(TyUnicodeErrorObject), 0,
UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
UnicodeEncodeError_str, 0, 0, 0, UnicodeEncodeError_str, 0, 0, 0,
Ty_TPFLAGS_DEFAULT | Ty_TPFLAGS_BASETYPE | Ty_TPFLAGS_HAVE_GC, Ty_TPFLAGS_DEFAULT | Ty_TPFLAGS_BASETYPE | Ty_TPFLAGS_HAVE_GC,
TyDoc_STR("Unicode encoding error."), UnicodeError_traverse, TyDoc_STR("Unicode encoding error."), UnicodeError_traverse,
UnicodeError_clear, 0, 0, 0, 0, 0, UnicodeError_members, UnicodeError_clear, 0, 0, 0, 0, 0, UnicodeError_members,
0, &_TyExc_UnicodeError, 0, 0, 0, offsetof(PyUnicodeErrorObject, dict), 0, &_TyExc_UnicodeError, 0, 0, 0, offsetof(TyUnicodeErrorObject, dict),
UnicodeEncodeError_init, 0, BaseException_new, UnicodeEncodeError_init, 0, BaseException_new,
}; };
TyObject *TyExc_UnicodeEncodeError = (TyObject *)&_TyExc_UnicodeEncodeError; TyObject *TyExc_UnicodeEncodeError = (TyObject *)&_TyExc_UnicodeEncodeError;
@@ -3706,7 +3706,7 @@ UnicodeDecodeError_init(TyObject *self, TyObject *args, TyObject *kwds)
} }
} }
PyUnicodeErrorObject *exc = PyUnicodeErrorObject_CAST(self); TyUnicodeErrorObject *exc = PyUnicodeErrorObject_CAST(self);
Ty_XSETREF(exc->encoding, Ty_NewRef(encoding)); Ty_XSETREF(exc->encoding, Ty_NewRef(encoding));
Ty_XSETREF(exc->object, object /* already a strong reference */); Ty_XSETREF(exc->object, object /* already a strong reference */);
exc->start = start; exc->start = start;
@@ -3718,7 +3718,7 @@ UnicodeDecodeError_init(TyObject *self, TyObject *args, TyObject *kwds)
static TyObject * static TyObject *
UnicodeDecodeError_str(TyObject *self) UnicodeDecodeError_str(TyObject *self)
{ {
PyUnicodeErrorObject *exc = PyUnicodeErrorObject_CAST(self); TyUnicodeErrorObject *exc = PyUnicodeErrorObject_CAST(self);
TyObject *result = NULL; TyObject *result = NULL;
TyObject *reason_str = NULL; TyObject *reason_str = NULL;
TyObject *encoding_str = NULL; TyObject *encoding_str = NULL;
@@ -3771,13 +3771,13 @@ done:
static TyTypeObject _TyExc_UnicodeDecodeError = { static TyTypeObject _TyExc_UnicodeDecodeError = {
TyVarObject_HEAD_INIT(NULL, 0) TyVarObject_HEAD_INIT(NULL, 0)
"UnicodeDecodeError", "UnicodeDecodeError",
sizeof(PyUnicodeErrorObject), 0, sizeof(TyUnicodeErrorObject), 0,
UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
UnicodeDecodeError_str, 0, 0, 0, UnicodeDecodeError_str, 0, 0, 0,
Ty_TPFLAGS_DEFAULT | Ty_TPFLAGS_BASETYPE | Ty_TPFLAGS_HAVE_GC, Ty_TPFLAGS_DEFAULT | Ty_TPFLAGS_BASETYPE | Ty_TPFLAGS_HAVE_GC,
TyDoc_STR("Unicode decoding error."), UnicodeError_traverse, TyDoc_STR("Unicode decoding error."), UnicodeError_traverse,
UnicodeError_clear, 0, 0, 0, 0, 0, UnicodeError_members, UnicodeError_clear, 0, 0, 0, 0, 0, UnicodeError_members,
0, &_TyExc_UnicodeError, 0, 0, 0, offsetof(PyUnicodeErrorObject, dict), 0, &_TyExc_UnicodeError, 0, 0, 0, offsetof(TyUnicodeErrorObject, dict),
UnicodeDecodeError_init, 0, BaseException_new, UnicodeDecodeError_init, 0, BaseException_new,
}; };
TyObject *TyExc_UnicodeDecodeError = (TyObject *)&_TyExc_UnicodeDecodeError; TyObject *TyExc_UnicodeDecodeError = (TyObject *)&_TyExc_UnicodeDecodeError;
@@ -3810,7 +3810,7 @@ UnicodeTranslateError_init(TyObject *self, TyObject *args, TyObject *kwds)
return -1; return -1;
} }
PyUnicodeErrorObject *exc = PyUnicodeErrorObject_CAST(self); TyUnicodeErrorObject *exc = PyUnicodeErrorObject_CAST(self);
Ty_XSETREF(exc->object, Ty_NewRef(object)); Ty_XSETREF(exc->object, Ty_NewRef(object));
exc->start = start; exc->start = start;
exc->end = end; exc->end = end;
@@ -3822,7 +3822,7 @@ UnicodeTranslateError_init(TyObject *self, TyObject *args, TyObject *kwds)
static TyObject * static TyObject *
UnicodeTranslateError_str(TyObject *self) UnicodeTranslateError_str(TyObject *self)
{ {
PyUnicodeErrorObject *exc = PyUnicodeErrorObject_CAST(self); TyUnicodeErrorObject *exc = PyUnicodeErrorObject_CAST(self);
TyObject *result = NULL; TyObject *result = NULL;
TyObject *reason_str = NULL; TyObject *reason_str = NULL;
@@ -3877,13 +3877,13 @@ done:
static TyTypeObject _TyExc_UnicodeTranslateError = { static TyTypeObject _TyExc_UnicodeTranslateError = {
TyVarObject_HEAD_INIT(NULL, 0) TyVarObject_HEAD_INIT(NULL, 0)
"UnicodeTranslateError", "UnicodeTranslateError",
sizeof(PyUnicodeErrorObject), 0, sizeof(TyUnicodeErrorObject), 0,
UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, UnicodeError_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
UnicodeTranslateError_str, 0, 0, 0, UnicodeTranslateError_str, 0, 0, 0,
Ty_TPFLAGS_DEFAULT | Ty_TPFLAGS_BASETYPE | Ty_TPFLAGS_HAVE_GC, Ty_TPFLAGS_DEFAULT | Ty_TPFLAGS_BASETYPE | Ty_TPFLAGS_HAVE_GC,
TyDoc_STR("Unicode translation error."), UnicodeError_traverse, TyDoc_STR("Unicode translation error."), UnicodeError_traverse,
UnicodeError_clear, 0, 0, 0, 0, 0, UnicodeError_members, UnicodeError_clear, 0, 0, 0, 0, 0, UnicodeError_members,
0, &_TyExc_UnicodeError, 0, 0, 0, offsetof(PyUnicodeErrorObject, dict), 0, &_TyExc_UnicodeError, 0, 0, 0, offsetof(TyUnicodeErrorObject, dict),
UnicodeTranslateError_init, 0, BaseException_new, UnicodeTranslateError_init, 0, BaseException_new,
}; };
TyObject *TyExc_UnicodeTranslateError = (TyObject *)&_TyExc_UnicodeTranslateError; TyObject *TyExc_UnicodeTranslateError = (TyObject *)&_TyExc_UnicodeTranslateError;

2
Objects/genobject.c
View File

@@ -680,7 +680,7 @@ _TyGen_FetchStopIterationValue(TyObject **pvalue)
TyObject *value = NULL; TyObject *value = NULL;
if (TyErr_ExceptionMatches(TyExc_StopIteration)) { if (TyErr_ExceptionMatches(TyExc_StopIteration)) {
TyObject *exc = TyErr_GetRaisedException(); TyObject *exc = TyErr_GetRaisedException();
value = Ty_NewRef(((PyStopIterationObject *)exc)->value); value = Ty_NewRef(((TyStopIterationObject *)exc)->value);
Ty_DECREF(exc); Ty_DECREF(exc);
} else if (TyErr_Occurred()) { } else if (TyErr_Occurred()) {
return -1; return -1;

32
Objects/longobject.c
View File

@@ -294,7 +294,7 @@ _TyLong_FromLarge(stwodigits ival)
_TyLong_SetSignAndDigitCount(v, sign, ndigits); _TyLong_SetSignAndDigitCount(v, sign, ndigits);
t = abs_ival; t = abs_ival;
while (t) { while (t) {
*p++ = Py_SAFE_DOWNCAST( *p++ = Ty_SAFE_DOWNCAST(
t & TyLong_MASK, twodigits, digit); t & TyLong_MASK, twodigits, digit);
t >>= TyLong_SHIFT; t >>= TyLong_SHIFT;
} }
@@ -1218,7 +1218,7 @@ TyLong_AsNativeBytes(TyObject* vv, void* buffer, Ty_ssize_t n, int flags)
if (TyLong_Check(vv)) { if (TyLong_Check(vv)) {
v = (PyLongObject *)vv; v = (PyLongObject *)vv;
} }
else if (flags != -1 && (flags & Py_ASNATIVEBYTES_ALLOW_INDEX)) { else if (flags != -1 && (flags & Ty_ASNATIVEBYTES_ALLOW_INDEX)) {
v = (PyLongObject *)_PyNumber_Index(vv); v = (PyLongObject *)_PyNumber_Index(vv);
if (v == NULL) { if (v == NULL) {
return -1; return -1;
@@ -1230,7 +1230,7 @@ TyLong_AsNativeBytes(TyObject* vv, void* buffer, Ty_ssize_t n, int flags)
return -1; return -1;
} }
if ((flags != -1 && (flags & Py_ASNATIVEBYTES_REJECT_NEGATIVE)) if ((flags != -1 && (flags & Ty_ASNATIVEBYTES_REJECT_NEGATIVE))
&& _TyLong_IsNegative(v)) { && _TyLong_IsNegative(v)) {
TyErr_SetString(TyExc_ValueError, "Cannot convert negative int"); TyErr_SetString(TyExc_ValueError, "Cannot convert negative int");
if (do_decref) { if (do_decref) {
@@ -1277,7 +1277,7 @@ TyLong_AsNativeBytes(TyObject* vv, void* buffer, Ty_ssize_t n, int flags)
/* Positive values with the MSB set do not require an /* Positive values with the MSB set do not require an
* additional bit when the caller's intent is to treat them * additional bit when the caller's intent is to treat them
* as unsigned. */ * as unsigned. */
if (flags == -1 || (flags & Py_ASNATIVEBYTES_UNSIGNED_BUFFER)) { if (flags == -1 || (flags & Ty_ASNATIVEBYTES_UNSIGNED_BUFFER)) {
res = n; res = n;
} else { } else {
res = n + 1; res = n + 1;
@@ -1361,7 +1361,7 @@ TyLong_AsNativeBytes(TyObject* vv, void* buffer, Ty_ssize_t n, int flags)
* as unsigned. */ * as unsigned. */
unsigned char *b = (unsigned char *)buffer; unsigned char *b = (unsigned char *)buffer;
if (b[little_endian ? n - 1 : 0] & 0x80) { if (b[little_endian ? n - 1 : 0] & 0x80) {
if (flags == -1 || (flags & Py_ASNATIVEBYTES_UNSIGNED_BUFFER)) { if (flags == -1 || (flags & Ty_ASNATIVEBYTES_UNSIGNED_BUFFER)) {
res = n; res = n;
} else { } else {
res = n + 1; res = n + 1;
@@ -1396,7 +1396,7 @@ TyLong_FromNativeBytes(const void* buffer, size_t n, int flags)
(const unsigned char *)buffer, (const unsigned char *)buffer,
n, n,
little_endian, little_endian,
(flags == -1 || !(flags & Py_ASNATIVEBYTES_UNSIGNED_BUFFER)) ? 1 : 0 (flags == -1 || !(flags & Ty_ASNATIVEBYTES_UNSIGNED_BUFFER)) ? 1 : 0
); );
} }
@@ -1733,10 +1733,10 @@ int \
_TyLong_##NAME##_Converter(TyObject *obj, void *ptr) \ _TyLong_##NAME##_Converter(TyObject *obj, void *ptr) \
{ \ { \
Ty_ssize_t bytes = TyLong_AsNativeBytes(obj, ptr, sizeof(TYPE), \ Ty_ssize_t bytes = TyLong_AsNativeBytes(obj, ptr, sizeof(TYPE), \
Py_ASNATIVEBYTES_NATIVE_ENDIAN | \ Ty_ASNATIVEBYTES_NATIVE_ENDIAN | \
Py_ASNATIVEBYTES_ALLOW_INDEX | \ Ty_ASNATIVEBYTES_ALLOW_INDEX | \
Py_ASNATIVEBYTES_REJECT_NEGATIVE | \ Ty_ASNATIVEBYTES_REJECT_NEGATIVE | \
Py_ASNATIVEBYTES_UNSIGNED_BUFFER); \ Ty_ASNATIVEBYTES_UNSIGNED_BUFFER); \
if (bytes < 0) { \ if (bytes < 0) { \
return 0; \ return 0; \
} \ } \
@@ -6698,8 +6698,8 @@ TyObject* TyLong_FromUInt64(uint64_t value)
#define LONG_TO_INT(obj, value, type_name) \ #define LONG_TO_INT(obj, value, type_name) \
do { \ do { \
int flags = (Py_ASNATIVEBYTES_NATIVE_ENDIAN \ int flags = (Ty_ASNATIVEBYTES_NATIVE_ENDIAN \
| Py_ASNATIVEBYTES_ALLOW_INDEX); \ | Ty_ASNATIVEBYTES_ALLOW_INDEX); \
Ty_ssize_t bytes = TyLong_AsNativeBytes(obj, value, sizeof(*value), flags); \ Ty_ssize_t bytes = TyLong_AsNativeBytes(obj, value, sizeof(*value), flags); \
if (bytes < 0) { \ if (bytes < 0) { \
return -1; \ return -1; \
@@ -6724,10 +6724,10 @@ int TyLong_AsInt64(TyObject *obj, int64_t *value)
#define LONG_TO_UINT(obj, value, type_name) \ #define LONG_TO_UINT(obj, value, type_name) \
do { \ do { \
int flags = (Py_ASNATIVEBYTES_NATIVE_ENDIAN \ int flags = (Ty_ASNATIVEBYTES_NATIVE_ENDIAN \
| Py_ASNATIVEBYTES_UNSIGNED_BUFFER \ | Ty_ASNATIVEBYTES_UNSIGNED_BUFFER \
| Py_ASNATIVEBYTES_REJECT_NEGATIVE \ | Ty_ASNATIVEBYTES_REJECT_NEGATIVE \
| Py_ASNATIVEBYTES_ALLOW_INDEX); \ | Ty_ASNATIVEBYTES_ALLOW_INDEX); \
Ty_ssize_t bytes = TyLong_AsNativeBytes(obj, value, sizeof(*value), flags); \ Ty_ssize_t bytes = TyLong_AsNativeBytes(obj, value, sizeof(*value), flags); \
if (bytes < 0) { \ if (bytes < 0) { \
return -1; \ return -1; \

2
Objects/object.c
View File

@@ -1268,7 +1268,7 @@ _TyObject_SetAttributeErrorContext(TyObject* v, TyObject* name)
if (!TyErr_GivenExceptionMatches(exc, TyExc_AttributeError)) { if (!TyErr_GivenExceptionMatches(exc, TyExc_AttributeError)) {
goto restore; goto restore;
} }
PyAttributeErrorObject* the_exc = (PyAttributeErrorObject*) exc; TyAttributeErrorObject* the_exc = (TyAttributeErrorObject*) exc;
// Check if this exception was already augmented // Check if this exception was already augmented
if (the_exc->name || the_exc->obj) { if (the_exc->name || the_exc->obj) {
goto restore; goto restore;

2
Parser/action_helpers.c
View File

@@ -1467,7 +1467,7 @@ _get_interpolation_conversion(Parser *p, Token *debug, ResultTokenWithMetadata *
expr_ty conversion_expr = (expr_ty) conversion->result; expr_ty conversion_expr = (expr_ty) conversion->result;
assert(conversion_expr->kind == Name_kind); assert(conversion_expr->kind == Name_kind);
Ty_UCS4 first = TyUnicode_READ_CHAR(conversion_expr->v.Name.id, 0); Ty_UCS4 first = TyUnicode_READ_CHAR(conversion_expr->v.Name.id, 0);
return Py_SAFE_DOWNCAST(first, Ty_UCS4, int); return Ty_SAFE_DOWNCAST(first, Ty_UCS4, int);
} }
else if (debug && !format) { else if (debug && !format) {
/* If no conversion is specified, use !r for debug expressions */ /* If no conversion is specified, use !r for debug expressions */

2
Parser/pegen.c
View File

@@ -936,7 +936,7 @@ _TyPegen_set_syntax_error_metadata(Parser *p) {
TyErr_Clear(); TyErr_Clear();
return; return;
} }
PySyntaxErrorObject *syntax_error = (PySyntaxErrorObject *)exc; TySyntaxErrorObject *syntax_error = (TySyntaxErrorObject *)exc;
Ty_XDECREF(syntax_error->metadata); Ty_XDECREF(syntax_error->metadata);
syntax_error->metadata = metadata; syntax_error->metadata = metadata;

2
Python/bytecodes.c
View File

@@ -1465,7 +1465,7 @@ dummy_func(
int matches = TyErr_GivenExceptionMatches(exc_value, TyExc_StopIteration); int matches = TyErr_GivenExceptionMatches(exc_value, TyExc_StopIteration);
if (matches) { if (matches) {
value = PyStackRef_FromPyObjectNew(((PyStopIterationObject *)exc_value)->value); value = PyStackRef_FromPyObjectNew(((TyStopIterationObject *)exc_value)->value);
DECREF_INPUTS(); DECREF_INPUTS();
none = PyStackRef_None; none = PyStackRef_None;
} }

2
Python/ceval.c
View File

@@ -3328,7 +3328,7 @@ _TyEval_FormatExcCheckArg(TyThreadState *tstate, TyObject *exc,
// Include the name in the NameError exceptions to offer suggestions later. // Include the name in the NameError exceptions to offer suggestions later.
TyObject *exc = TyErr_GetRaisedException(); TyObject *exc = TyErr_GetRaisedException();
if (TyErr_GivenExceptionMatches(exc, TyExc_NameError)) { if (TyErr_GivenExceptionMatches(exc, TyExc_NameError)) {
if (((PyNameErrorObject*)exc)->name == NULL) { if (((TyNameErrorObject*)exc)->name == NULL) {
// We do not care if this fails because we are going to restore the // We do not care if this fails because we are going to restore the
// NameError anyway. // NameError anyway.
(void)PyObject_SetAttr(exc, &_Ty_ID(name), obj); (void)PyObject_SetAttr(exc, &_Ty_ID(name), obj);

2
Python/generated_cases.c.h generated
View File

@@ -4683,7 +4683,7 @@
int matches = TyErr_GivenExceptionMatches(exc_value, TyExc_StopIteration); int matches = TyErr_GivenExceptionMatches(exc_value, TyExc_StopIteration);
stack_pointer = _TyFrame_GetStackPointer(frame); stack_pointer = _TyFrame_GetStackPointer(frame);
if (matches) { if (matches) {
value = PyStackRef_FromPyObjectNew(((PyStopIterationObject *)exc_value)->value); value = PyStackRef_FromPyObjectNew(((TyStopIterationObject *)exc_value)->value);
_TyFrame_SetStackPointer(frame, stack_pointer); _TyFrame_SetStackPointer(frame, stack_pointer);
_PyStackRef tmp = sub_iter; _PyStackRef tmp = sub_iter;
sub_iter = value; sub_iter = value;