Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

gh-111178: Fix function signatures in _threadmodule.c (#124964)

This commit is contained in:
Victor Stinner 2024-10-04 12:50:01 +02:00 committed by GitHub
parent ac9648243d
commit ddccd546a0
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
1 changed files with 70 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

119
Modules/_threadmodule.c
View File

@ -599,8 +599,9 @@ PyThreadHandleObject_traverse(PyThreadHandleObject *self, visitproc visit,
} }
static void static void
PyThreadHandleObject_dealloc(PyThreadHandleObject *self) PyThreadHandleObject_dealloc(PyObject *op)
{ {
PyThreadHandleObject *self = (PyThreadHandleObject*)op;
PyObject_GC_UnTrack(self); PyObject_GC_UnTrack(self);
PyTypeObject *tp = Py_TYPE(self); PyTypeObject *tp = Py_TYPE(self);
ThreadHandle_decref(self->handle); ThreadHandle_decref(self->handle);
@ -609,23 +610,26 @@ PyThreadHandleObject_dealloc(PyThreadHandleObject *self)
} }
static PyObject * static PyObject *
PyThreadHandleObject_repr(PyThreadHandleObject *self) PyThreadHandleObject_repr(PyObject *op)
{ {
PyThreadHandleObject *self = (PyThreadHandleObject*)op;
PyThread_ident_t ident = ThreadHandle_ident(self->handle); PyThread_ident_t ident = ThreadHandle_ident(self->handle);
return PyUnicode_FromFormat("<%s object: ident=%" PY_FORMAT_THREAD_IDENT_T ">", return PyUnicode_FromFormat("<%s object: ident=%" PY_FORMAT_THREAD_IDENT_T ">",
Py_TYPE(self)->tp_name, ident); Py_TYPE(self)->tp_name, ident);
} }
static PyObject * static PyObject *
PyThreadHandleObject_get_ident(PyThreadHandleObject *self, PyThreadHandleObject_get_ident(PyObject *op, void *Py_UNUSED(ignored))
PyObject *Py_UNUSED(ignored))
{ {
PyThreadHandleObject *self = (PyThreadHandleObject*)op;
return PyLong_FromUnsignedLongLong(ThreadHandle_ident(self->handle)); return PyLong_FromUnsignedLongLong(ThreadHandle_ident(self->handle));
} }
static PyObject * static PyObject *
PyThreadHandleObject_join(PyThreadHandleObject *self, PyObject *args) PyThreadHandleObject_join(PyObject *op, PyObject *args)
{ {
PyThreadHandleObject *self = (PyThreadHandleObject*)op;
PyObject *timeout_obj = NULL; PyObject *timeout_obj = NULL;
if (!PyArg_ParseTuple(args, "|O:join", &timeout_obj)) { if (!PyArg_ParseTuple(args, "|O:join", &timeout_obj)) {
return NULL; return NULL;
@ -646,9 +650,9 @@ PyThreadHandleObject_join(PyThreadHandleObject *self, PyObject *args)
} }
static PyObject * static PyObject *
PyThreadHandleObject_is_done(PyThreadHandleObject *self, PyThreadHandleObject_is_done(PyObject *op, PyObject *Py_UNUSED(ignored))
PyObject *Py_UNUSED(ignored))
{ {
PyThreadHandleObject *self = (PyThreadHandleObject*)op;
if (_PyEvent_IsSet(&self->handle->thread_is_exiting)) { if (_PyEvent_IsSet(&self->handle->thread_is_exiting)) {
Py_RETURN_TRUE; Py_RETURN_TRUE;
} }
@ -658,9 +662,9 @@ PyThreadHandleObject_is_done(PyThreadHandleObject *self,
} }
static PyObject * static PyObject *
PyThreadHandleObject_set_done(PyThreadHandleObject *self, PyThreadHandleObject_set_done(PyObject *op, PyObject *Py_UNUSED(ignored))
PyObject *Py_UNUSED(ignored))
{ {
PyThreadHandleObject *self = (PyThreadHandleObject*)op;
if (ThreadHandle_set_done(self->handle) < 0) { if (ThreadHandle_set_done(self->handle) < 0) {
return NULL; return NULL;
} }
@ -668,20 +672,20 @@ PyThreadHandleObject_set_done(PyThreadHandleObject *self,
} }
static PyGetSetDef ThreadHandle_getsetlist[] = { static PyGetSetDef ThreadHandle_getsetlist[] = {
{"ident", (getter)PyThreadHandleObject_get_ident, NULL, NULL}, {"ident", PyThreadHandleObject_get_ident, NULL, NULL},
{0}, {0},
}; };
static PyMethodDef ThreadHandle_methods[] = { static PyMethodDef ThreadHandle_methods[] = {
{"join", (PyCFunction)PyThreadHandleObject_join, METH_VARARGS, NULL}, {"join", PyThreadHandleObject_join, METH_VARARGS, NULL},
{"_set_done", (PyCFunction)PyThreadHandleObject_set_done, METH_NOARGS, NULL}, {"_set_done", PyThreadHandleObject_set_done, METH_NOARGS, NULL},
{"is_done", (PyCFunction)PyThreadHandleObject_is_done, METH_NOARGS, NULL}, {"is_done", PyThreadHandleObject_is_done, METH_NOARGS, NULL},
{0, 0} {0, 0}
}; };
static PyType_Slot ThreadHandle_Type_slots[] = { static PyType_Slot ThreadHandle_Type_slots[] = {
{Py_tp_dealloc, (destructor)PyThreadHandleObject_dealloc}, {Py_tp_dealloc, PyThreadHandleObject_dealloc},
{Py_tp_repr, (reprfunc)PyThreadHandleObject_repr}, {Py_tp_repr, PyThreadHandleObject_repr},
{Py_tp_getset, ThreadHandle_getsetlist}, {Py_tp_getset, ThreadHandle_getsetlist},
{Py_tp_traverse, PyThreadHandleObject_traverse}, {Py_tp_traverse, PyThreadHandleObject_traverse},
{Py_tp_methods, ThreadHandle_methods}, {Py_tp_methods, ThreadHandle_methods},
@ -707,15 +711,16 @@ typedef struct {
} lockobject; } lockobject;
static int static int
lock_traverse(lockobject *self, visitproc visit, void *arg) lock_traverse(PyObject *self, visitproc visit, void *arg)
{ {
Py_VISIT(Py_TYPE(self)); Py_VISIT(Py_TYPE(self));
return 0; return 0;
} }
static void static void
lock_dealloc(lockobject *self) lock_dealloc(PyObject *op)
{ {
lockobject *self = (lockobject*)op;
PyObject_GC_UnTrack(self); PyObject_GC_UnTrack(self);
if (self->in_weakreflist != NULL) { if (self->in_weakreflist != NULL) {
PyObject_ClearWeakRefs((PyObject *) self); PyObject_ClearWeakRefs((PyObject *) self);
@ -784,11 +789,14 @@ lock_acquire_parse_args(PyObject *args, PyObject *kwds,
} }
static PyObject * static PyObject *
lock_PyThread_acquire_lock(lockobject *self, PyObject *args, PyObject *kwds) lock_PyThread_acquire_lock(PyObject *op, PyObject *args, PyObject *kwds)
{ {
lockobject *self = (lockobject*)op;
PyTime_t timeout; PyTime_t timeout;
if (lock_acquire_parse_args(args, kwds, &timeout) < 0) if (lock_acquire_parse_args(args, kwds, &timeout) < 0) {
return NULL; return NULL;
}
PyLockStatus r = acquire_timed(self->lock_lock, timeout); PyLockStatus r = acquire_timed(self->lock_lock, timeout);
if (r == PY_LOCK_INTR) { if (r == PY_LOCK_INTR) {
@ -824,8 +832,9 @@ PyDoc_STRVAR(enter_doc,
Lock the lock."); Lock the lock.");
static PyObject * static PyObject *
lock_PyThread_release_lock(lockobject *self, PyObject *Py_UNUSED(ignored)) lock_PyThread_release_lock(PyObject *op, PyObject *Py_UNUSED(ignored))
{ {
lockobject *self = (lockobject*)op;
/* Sanity check: the lock must be locked */ /* Sanity check: the lock must be locked */
if (!self->locked) { if (!self->locked) {
PyErr_SetString(ThreadError, "release unlocked lock"); PyErr_SetString(ThreadError, "release unlocked lock");
@ -858,8 +867,9 @@ PyDoc_STRVAR(lock_exit_doc,
Release the lock."); Release the lock.");
static PyObject * static PyObject *
lock_locked_lock(lockobject *self, PyObject *Py_UNUSED(ignored)) lock_locked_lock(PyObject *op, PyObject *Py_UNUSED(ignored))
{ {
lockobject *self = (lockobject*)op;
return PyBool_FromLong((long)self->locked); return PyBool_FromLong((long)self->locked);
} }
@ -876,16 +886,18 @@ PyDoc_STRVAR(locked_lock_doc,
An obsolete synonym of locked()."); An obsolete synonym of locked().");
static PyObject * static PyObject *
lock_repr(lockobject *self) lock_repr(PyObject *op)
{ {
lockobject *self = (lockobject*)op;
return PyUnicode_FromFormat("<%s %s object at %p>", return PyUnicode_FromFormat("<%s %s object at %p>",
self->locked ? "locked" : "unlocked", Py_TYPE(self)->tp_name, self); self->locked ? "locked" : "unlocked", Py_TYPE(self)->tp_name, self);
} }
#ifdef HAVE_FORK #ifdef HAVE_FORK
static PyObject * static PyObject *
lock__at_fork_reinit(lockobject *self, PyObject *Py_UNUSED(args)) lock__at_fork_reinit(PyObject *op, PyObject *Py_UNUSED(args))
{ {
lockobject *self = (lockobject*)op;
if (_PyThread_at_fork_reinit(&self->lock_lock) < 0) { if (_PyThread_at_fork_reinit(&self->lock_lock) < 0) {
PyErr_SetString(ThreadError, "failed to reinitialize lock at fork"); PyErr_SetString(ThreadError, "failed to reinitialize lock at fork");
return NULL; return NULL;
@ -924,20 +936,20 @@ static PyMethodDef lock_methods[] = {
METH_VARARGS | METH_KEYWORDS, acquire_lock_doc}, METH_VARARGS | METH_KEYWORDS, acquire_lock_doc},
{"acquire", _PyCFunction_CAST(lock_PyThread_acquire_lock), {"acquire", _PyCFunction_CAST(lock_PyThread_acquire_lock),
METH_VARARGS | METH_KEYWORDS, acquire_doc}, METH_VARARGS | METH_KEYWORDS, acquire_doc},
{"release_lock", (PyCFunction)lock_PyThread_release_lock, {"release_lock", lock_PyThread_release_lock,
METH_NOARGS, release_lock_doc}, METH_NOARGS, release_lock_doc},
{"release", (PyCFunction)lock_PyThread_release_lock, {"release", lock_PyThread_release_lock,
METH_NOARGS, release_doc}, METH_NOARGS, release_doc},
{"locked_lock", (PyCFunction)lock_locked_lock, {"locked_lock", lock_locked_lock,
METH_NOARGS, locked_lock_doc}, METH_NOARGS, locked_lock_doc},
{"locked", (PyCFunction)lock_locked_lock, {"locked", lock_locked_lock,
METH_NOARGS, locked_doc}, METH_NOARGS, locked_doc},
{"__enter__", _PyCFunction_CAST(lock_PyThread_acquire_lock), {"__enter__", _PyCFunction_CAST(lock_PyThread_acquire_lock),
METH_VARARGS | METH_KEYWORDS, enter_doc}, METH_VARARGS | METH_KEYWORDS, enter_doc},
{"__exit__", (PyCFunction)lock_PyThread_release_lock, {"__exit__", lock_PyThread_release_lock,
METH_VARARGS, lock_exit_doc}, METH_VARARGS, lock_exit_doc},
#ifdef HAVE_FORK #ifdef HAVE_FORK
{"_at_fork_reinit", (PyCFunction)lock__at_fork_reinit, {"_at_fork_reinit", lock__at_fork_reinit,
METH_NOARGS, NULL}, METH_NOARGS, NULL},
#endif #endif
{NULL, NULL} /* sentinel */ {NULL, NULL} /* sentinel */
@ -964,8 +976,8 @@ static PyMemberDef lock_type_members[] = {
}; };
static PyType_Slot lock_type_slots[] = { static PyType_Slot lock_type_slots[] = {
{Py_tp_dealloc, (destructor)lock_dealloc}, {Py_tp_dealloc, lock_dealloc},
{Py_tp_repr, (reprfunc)lock_repr}, {Py_tp_repr, lock_repr},
{Py_tp_doc, (void *)lock_doc}, {Py_tp_doc, (void *)lock_doc},
{Py_tp_methods, lock_methods}, {Py_tp_methods, lock_methods},
{Py_tp_traverse, lock_traverse}, {Py_tp_traverse, lock_traverse},
@ -1001,8 +1013,9 @@ rlock_traverse(rlockobject *self, visitproc visit, void *arg)
static void static void
rlock_dealloc(rlockobject *self) rlock_dealloc(PyObject *op)
{ {
rlockobject *self = (rlockobject*)op;
PyObject_GC_UnTrack(self); PyObject_GC_UnTrack(self);
if (self->in_weakreflist != NULL) if (self->in_weakreflist != NULL)
PyObject_ClearWeakRefs((PyObject *) self); PyObject_ClearWeakRefs((PyObject *) self);
@ -1029,8 +1042,9 @@ rlock_is_owned_by(rlockobject *self, PyThread_ident_t tid)
} }
static PyObject * static PyObject *
rlock_acquire(rlockobject *self, PyObject *args, PyObject *kwds) rlock_acquire(PyObject *op, PyObject *args, PyObject *kwds)
{ {
rlockobject *self = (rlockobject*)op;
PyTime_t timeout; PyTime_t timeout;
PyThread_ident_t tid; PyThread_ident_t tid;
PyLockStatus r = PY_LOCK_ACQUIRED; PyLockStatus r = PY_LOCK_ACQUIRED;
@ -1086,8 +1100,9 @@ PyDoc_STRVAR(rlock_enter_doc,
Lock the lock."); Lock the lock.");
static PyObject * static PyObject *
rlock_release(rlockobject *self, PyObject *Py_UNUSED(ignored)) rlock_release(PyObject *op, PyObject *Py_UNUSED(ignored))
{ {
rlockobject *self = (rlockobject*)op;
PyThread_ident_t tid = PyThread_get_thread_ident_ex(); PyThread_ident_t tid = PyThread_get_thread_ident_ex();
if (!rlock_is_owned_by(self, tid)) { if (!rlock_is_owned_by(self, tid)) {
@ -1122,8 +1137,9 @@ PyDoc_STRVAR(rlock_exit_doc,
Release the lock."); Release the lock.");
static PyObject * static PyObject *
rlock_acquire_restore(rlockobject *self, PyObject *args) rlock_acquire_restore(PyObject *op, PyObject *args)
{ {
rlockobject *self = (rlockobject*)op;
PyThread_ident_t owner; PyThread_ident_t owner;
unsigned long count; unsigned long count;
int r = 1; int r = 1;
@ -1154,8 +1170,9 @@ PyDoc_STRVAR(rlock_acquire_restore_doc,
For internal use by `threading.Condition`."); For internal use by `threading.Condition`.");
static PyObject * static PyObject *
rlock_release_save(rlockobject *self, PyObject *Py_UNUSED(ignored)) rlock_release_save(PyObject *op, PyObject *Py_UNUSED(ignored))
{ {
rlockobject *self = (rlockobject*)op;
PyThread_ident_t owner; PyThread_ident_t owner;
unsigned long count; unsigned long count;
@ -1180,8 +1197,9 @@ PyDoc_STRVAR(rlock_release_save_doc,
For internal use by `threading.Condition`."); For internal use by `threading.Condition`.");
static PyObject * static PyObject *
rlock_recursion_count(rlockobject *self, PyObject *Py_UNUSED(ignored)) rlock_recursion_count(PyObject *op, PyObject *Py_UNUSED(ignored))
{ {
rlockobject *self = (rlockobject*)op;
PyThread_ident_t tid = PyThread_get_thread_ident_ex(); PyThread_ident_t tid = PyThread_get_thread_ident_ex();
PyThread_ident_t owner = PyThread_ident_t owner =
_Py_atomic_load_ullong_relaxed(&self->rlock_owner); _Py_atomic_load_ullong_relaxed(&self->rlock_owner);
@ -1195,8 +1213,9 @@ PyDoc_STRVAR(rlock_recursion_count_doc,
For internal use by reentrancy checks."); For internal use by reentrancy checks.");
static PyObject * static PyObject *
rlock_is_owned(rlockobject *self, PyObject *Py_UNUSED(ignored)) rlock_is_owned(PyObject *op, PyObject *Py_UNUSED(ignored))
{ {
rlockobject *self = (rlockobject*)op;
PyThread_ident_t tid = PyThread_get_thread_ident_ex(); PyThread_ident_t tid = PyThread_get_thread_ident_ex();
if (rlock_is_owned_by(self, tid)) { if (rlock_is_owned_by(self, tid)) {
@ -1232,8 +1251,9 @@ rlock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
} }
static PyObject * static PyObject *
rlock_repr(rlockobject *self) rlock_repr(PyObject *op)
{ {
rlockobject *self = (rlockobject*)op;
PyThread_ident_t owner = PyThread_ident_t owner =
_Py_atomic_load_ullong_relaxed(&self->rlock_owner); _Py_atomic_load_ullong_relaxed(&self->rlock_owner);
return PyUnicode_FromFormat( return PyUnicode_FromFormat(
@ -1264,19 +1284,19 @@ rlock__at_fork_reinit(rlockobject *self, PyObject *Py_UNUSED(args))
static PyMethodDef rlock_methods[] = { static PyMethodDef rlock_methods[] = {
{"acquire", _PyCFunction_CAST(rlock_acquire), {"acquire", _PyCFunction_CAST(rlock_acquire),
METH_VARARGS | METH_KEYWORDS, rlock_acquire_doc}, METH_VARARGS | METH_KEYWORDS, rlock_acquire_doc},
{"release", (PyCFunction)rlock_release, {"release", rlock_release,
METH_NOARGS, rlock_release_doc}, METH_NOARGS, rlock_release_doc},
{"_is_owned", (PyCFunction)rlock_is_owned, {"_is_owned", rlock_is_owned,
METH_NOARGS, rlock_is_owned_doc}, METH_NOARGS, rlock_is_owned_doc},
{"_acquire_restore", (PyCFunction)rlock_acquire_restore, {"_acquire_restore", rlock_acquire_restore,
METH_VARARGS, rlock_acquire_restore_doc}, METH_VARARGS, rlock_acquire_restore_doc},
{"_release_save", (PyCFunction)rlock_release_save, {"_release_save", rlock_release_save,
METH_NOARGS, rlock_release_save_doc}, METH_NOARGS, rlock_release_save_doc},
{"_recursion_count", (PyCFunction)rlock_recursion_count, {"_recursion_count", rlock_recursion_count,
METH_NOARGS, rlock_recursion_count_doc}, METH_NOARGS, rlock_recursion_count_doc},
{"__enter__", _PyCFunction_CAST(rlock_acquire), {"__enter__", _PyCFunction_CAST(rlock_acquire),
METH_VARARGS | METH_KEYWORDS, rlock_enter_doc}, METH_VARARGS | METH_KEYWORDS, rlock_enter_doc},
{"__exit__", (PyCFunction)rlock_release, {"__exit__", rlock_release,
METH_VARARGS, rlock_exit_doc}, METH_VARARGS, rlock_exit_doc},
#ifdef HAVE_FORK #ifdef HAVE_FORK
{"_at_fork_reinit", (PyCFunction)rlock__at_fork_reinit, {"_at_fork_reinit", (PyCFunction)rlock__at_fork_reinit,
@ -1292,8 +1312,8 @@ static PyMemberDef rlock_type_members[] = {
}; };
static PyType_Slot rlock_type_slots[] = { static PyType_Slot rlock_type_slots[] = {
{Py_tp_dealloc, (destructor)rlock_dealloc}, {Py_tp_dealloc, rlock_dealloc},
{Py_tp_repr, (reprfunc)rlock_repr}, {Py_tp_repr, rlock_repr},
{Py_tp_methods, rlock_methods}, {Py_tp_methods, rlock_methods},
{Py_tp_alloc, PyType_GenericAlloc}, {Py_tp_alloc, PyType_GenericAlloc},
{Py_tp_new, rlock_new}, {Py_tp_new, rlock_new},
@ -1392,8 +1412,9 @@ typedef struct {
} localdummyobject; } localdummyobject;
static void static void
localdummy_dealloc(localdummyobject *self) localdummy_dealloc(PyObject *op)
{ {
localdummyobject *self = (localdummyobject*)op;
if (self->weakreflist != NULL) if (self->weakreflist != NULL)
PyObject_ClearWeakRefs((PyObject *) self); PyObject_ClearWeakRefs((PyObject *) self);
PyTypeObject *tp = Py_TYPE(self); PyTypeObject *tp = Py_TYPE(self);
@ -1407,7 +1428,7 @@ static PyMemberDef local_dummy_type_members[] = {
}; };
static PyType_Slot local_dummy_type_slots[] = { static PyType_Slot local_dummy_type_slots[] = {
{Py_tp_dealloc, (destructor)localdummy_dealloc}, {Py_tp_dealloc, localdummy_dealloc},
{Py_tp_doc, "Thread-local dummy"}, {Py_tp_doc, "Thread-local dummy"},
{Py_tp_members, local_dummy_type_members}, {Py_tp_members, local_dummy_type_members},
{0, 0} {0, 0}