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

4
Modules/_io/bufferedio.c
View File

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

8
Modules/_ssl.c
View File

@@ -452,7 +452,7 @@ TyDoc_STRVAR(SSLEOFError_doc,
static TyObject *
SSLError_str(TyObject *op)
{
PyOSErrorObject *self = (PyOSErrorObject*)op;
TyOSErrorObject *self = (TyOSErrorObject*)op;
if (self->strerror != NULL && TyUnicode_Check(self->strerror)) {
return Ty_NewRef(self->strerror);
}
@@ -468,7 +468,7 @@ static TyType_Slot sslerror_type_slots[] = {
static TyType_Spec sslerror_type_spec = {
.name = "ssl.SSLError",
.basicsize = sizeof(PyOSErrorObject),
.basicsize = sizeof(TyOSErrorObject),
.flags = (Ty_TPFLAGS_DEFAULT | Ty_TPFLAGS_BASETYPE | Ty_TPFLAGS_IMMUTABLETYPE),
.slots = sslerror_type_slots
};
@@ -916,7 +916,7 @@ newPySSLSocket(PySSLContext *sslctx, PySocketSockObject *sock,
#endif
SSL_set_app_data(self->ssl, self);
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 {
/* 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
@@ -2429,7 +2429,7 @@ PySSL_select(PySocketSockObject *s, int writing, TyTime_t timeout)
/* Wait until the socket becomes ready */
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)
rc = select(nfds, NULL, &fds, NULL, &tv);
else

4
Modules/posixmodule.c
View File

@@ -5196,7 +5196,7 @@ os__getvolumepathname_impl(TyObject *module, path_t *path)
Ty_BEGIN_ALLOW_THREADS
ret = GetVolumePathNameW(path->wide, mountpath,
Py_SAFE_DOWNCAST(buflen, size_t, DWORD));
Ty_SAFE_DOWNCAST(buflen, size_t, DWORD));
Ty_END_ALLOW_THREADS
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");
return 0;
}
res->sched_priority = Py_SAFE_DOWNCAST(priority, long, int);
res->sched_priority = Ty_SAFE_DOWNCAST(priority, long, int);
return 1;
}
#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) \
{ \
Ty_ssize_t bytes = TyLong_AsNativeBytes(obj, ptr, sizeof(TYPE), \
Py_ASNATIVEBYTES_NATIVE_ENDIAN | \
Py_ASNATIVEBYTES_ALLOW_INDEX | \
Py_ASNATIVEBYTES_REJECT_NEGATIVE | \
Py_ASNATIVEBYTES_UNSIGNED_BUFFER); \
Ty_ASNATIVEBYTES_NATIVE_ENDIAN | \
Ty_ASNATIVEBYTES_ALLOW_INDEX | \
Ty_ASNATIVEBYTES_REJECT_NEGATIVE | \
Ty_ASNATIVEBYTES_UNSIGNED_BUFFER); \
if (bytes < 0) { \
return 0; \
} \
@@ -921,10 +921,10 @@ internal_select(PySocketSockObject *s, int writing, TyTime_t interval,
/* See if the socket is ready */
Ty_BEGIN_ALLOW_THREADS;
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);
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);
Ty_END_ALLOW_THREADS;
#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__},
static TyObject *
BaseExceptionGroup_derive_impl(PyBaseExceptionGroupObject *self,
BaseExceptionGroup_derive_impl(TyBaseExceptionGroupObject *self,
TyObject *excs);
static TyObject *
@@ -327,7 +327,7 @@ BaseExceptionGroup_derive(TyObject *self, TyObject *excs)
TyObject *return_value = NULL;
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();
return return_value;
@@ -342,7 +342,7 @@ TyDoc_STRVAR(BaseExceptionGroup_split__doc__,
{"split", (PyCFunction)BaseExceptionGroup_split, METH_O, BaseExceptionGroup_split__doc__},
static TyObject *
BaseExceptionGroup_split_impl(PyBaseExceptionGroupObject *self,
BaseExceptionGroup_split_impl(TyBaseExceptionGroupObject *self,
TyObject *matcher_value);
static TyObject *
@@ -351,7 +351,7 @@ BaseExceptionGroup_split(TyObject *self, TyObject *matcher_value)
TyObject *return_value = NULL;
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();
return return_value;
@@ -366,7 +366,7 @@ TyDoc_STRVAR(BaseExceptionGroup_subgroup__doc__,
{"subgroup", (PyCFunction)BaseExceptionGroup_subgroup, METH_O, BaseExceptionGroup_subgroup__doc__},
static TyObject *
BaseExceptionGroup_subgroup_impl(PyBaseExceptionGroupObject *self,
BaseExceptionGroup_subgroup_impl(TyBaseExceptionGroupObject *self,
TyObject *matcher_value);
static TyObject *
@@ -375,7 +375,7 @@ BaseExceptionGroup_subgroup(TyObject *self, TyObject *matcher_value)
TyObject *return_value = NULL;
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();
return return_value;

254
Objects/exceptions.c
View File

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

2
Objects/genobject.c
View File

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

32
Objects/longobject.c
View File

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

2
Objects/object.c
View File

@@ -1268,7 +1268,7 @@ _TyObject_SetAttributeErrorContext(TyObject* v, TyObject* name)
if (!TyErr_GivenExceptionMatches(exc, TyExc_AttributeError)) {
goto restore;
}
PyAttributeErrorObject* the_exc = (PyAttributeErrorObject*) exc;
TyAttributeErrorObject* the_exc = (TyAttributeErrorObject*) exc;
// Check if this exception was already augmented
if (the_exc->name || the_exc->obj) {
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;
assert(conversion_expr->kind == Name_kind);
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) {
/* 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();
return;
}
PySyntaxErrorObject *syntax_error = (PySyntaxErrorObject *)exc;
TySyntaxErrorObject *syntax_error = (TySyntaxErrorObject *)exc;
Ty_XDECREF(syntax_error->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);
if (matches) {
value = PyStackRef_FromPyObjectNew(((PyStopIterationObject *)exc_value)->value);
value = PyStackRef_FromPyObjectNew(((TyStopIterationObject *)exc_value)->value);
DECREF_INPUTS();
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.
TyObject *exc = TyErr_GetRaisedException();
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
// NameError anyway.
(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);
stack_pointer = _TyFrame_GetStackPointer(frame);
if (matches) {
value = PyStackRef_FromPyObjectNew(((PyStopIterationObject *)exc_value)->value);
value = PyStackRef_FromPyObjectNew(((TyStopIterationObject *)exc_value)->value);
_TyFrame_SetStackPointer(frame, stack_pointer);
_PyStackRef tmp = sub_iter;
sub_iter = value;