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

gh-111178: Fix function signatures in tupleobject.c (#124804)

This commit is contained in:
Victor Stinner 2024-10-02 13:37:04 +02:00 committed by GitHub
parent 1d3700f943
commit 595a5631d9
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
1 changed files with 64 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

122
Objects/tupleobject.c
View File

@ -181,8 +181,9 @@ PyTuple_Pack(Py_ssize_t n, ...)
/* Methods */
static void
tupledealloc(PyTupleObject *op)
tuple_dealloc(PyObject *self)
{
PyTupleObject *op = _PyTuple_CAST(self);
if (Py_SIZE(op) == 0) {
/* The empty tuple is statically allocated. */
if (op == &_Py_SINGLETON(tuple_empty)) {
@ -199,7 +200,7 @@ tupledealloc(PyTupleObject *op)
}
PyObject_GC_UnTrack(op);
Py_TRASHCAN_BEGIN(op, tupledealloc)
Py_TRASHCAN_BEGIN(op, tuple_dealloc)
Py_ssize_t i = Py_SIZE(op);
while (--i >= 0) {
@ -214,29 +215,29 @@ tupledealloc(PyTupleObject *op)
}
static PyObject *
tuplerepr(PyTupleObject *v)
tuple_repr(PyObject *self)
{
Py_ssize_t i, n;
_PyUnicodeWriter writer;
n = Py_SIZE(v);
if (n == 0)
PyTupleObject *v = _PyTuple_CAST(self);
Py_ssize_t n = PyTuple_GET_SIZE(v);
if (n == 0) {
return PyUnicode_FromString("()");
}
/* While not mutable, it is still possible to end up with a cycle in a
tuple through an object that stores itself within a tuple (and thus
infinitely asks for the repr of itself). This should only be
possible within a type. */
i = Py_ReprEnter((PyObject *)v);
if (i != 0) {
return i > 0 ? PyUnicode_FromString("(...)") : NULL;
int res = Py_ReprEnter((PyObject *)v);
if (res != 0) {
return res > 0 ? PyUnicode_FromString("(...)") : NULL;
}
_PyUnicodeWriter writer;
_PyUnicodeWriter_Init(&writer);
writer.overallocate = 1;
if (Py_SIZE(v) > 1) {
if (n > 1) {
/* "(" + "1" + ", 2" * (len - 1) + ")" */
writer.min_length = 1 + 1 + (2 + 1) * (Py_SIZE(v) - 1) + 1;
writer.min_length = 1 + 1 + (2 + 1) * (n - 1) + 1;
}
else {
/* "(1,)" */
@ -247,7 +248,7 @@ tuplerepr(PyTupleObject *v)
goto error;
/* Do repr() on each element. */
for (i = 0; i < n; ++i) {
for (Py_ssize_t i = 0; i < n; ++i) {
PyObject *s;
if (i > 0) {
@ -316,13 +317,14 @@ error:
/* Tests have shown that it's not worth to cache the hash value, see
https://bugs.python.org/issue9685 */
static Py_hash_t
tuplehash(PyTupleObject *v)
tuple_hash(PyObject *op)
{
Py_ssize_t i, len = Py_SIZE(v);
PyTupleObject *v = _PyTuple_CAST(op);
Py_ssize_t len = Py_SIZE(v);
PyObject **item = v->ob_item;
Py_uhash_t acc = _PyHASH_XXPRIME_5;
for (i = 0; i < len; i++) {
for (Py_ssize_t i = 0; i < len; i++) {
Py_uhash_t lane = PyObject_Hash(item[i]);
if (lane == (Py_uhash_t)-1) {
return -1;
@ -342,25 +344,27 @@ tuplehash(PyTupleObject *v)
}
static Py_ssize_t
tuplelength(PyTupleObject *a)
tuple_length(PyObject *self)
{
PyTupleObject *a = _PyTuple_CAST(self);
return Py_SIZE(a);
}
static int
tuplecontains(PyTupleObject *a, PyObject *el)
tuple_contains(PyObject *self, PyObject *el)
{
Py_ssize_t i;
int cmp;
for (i = 0, cmp = 0 ; cmp == 0 && i < Py_SIZE(a); ++i)
PyTupleObject *a = _PyTuple_CAST(self);
int cmp = 0;
for (Py_ssize_t i = 0; cmp == 0 && i < Py_SIZE(a); ++i) {
cmp = PyObject_RichCompareBool(PyTuple_GET_ITEM(a, i), el, Py_EQ);
}
return cmp;
}
static PyObject *
tupleitem(PyTupleObject *a, Py_ssize_t i)
tuple_item(PyObject *op, Py_ssize_t i)
{
PyTupleObject *a = _PyTuple_CAST(op);
if (i < 0 || i >= Py_SIZE(a)) {
PyErr_SetString(PyExc_IndexError, "tuple index out of range");
return NULL;
@ -432,7 +436,7 @@ _PyTuple_FromArraySteal(PyObject *const *src, Py_ssize_t n)
}
static PyObject *
tupleslice(PyTupleObject *a, Py_ssize_t ilow,
tuple_slice(PyTupleObject *a, Py_ssize_t ilow,
Py_ssize_t ihigh)
{
if (ilow < 0)
@ -454,16 +458,13 @@ PyTuple_GetSlice(PyObject *op, Py_ssize_t i, Py_ssize_t j)
PyErr_BadInternalCall();
return NULL;
}
return tupleslice((PyTupleObject *)op, i, j);
return tuple_slice((PyTupleObject *)op, i, j);
}
static PyObject *
tupleconcat(PyTupleObject *a, PyObject *bb)
tuple_concat(PyObject *aa, PyObject *bb)
{
Py_ssize_t size;
Py_ssize_t i;
PyObject **src, **dest;
PyTupleObject *np;
PyTupleObject *a = _PyTuple_CAST(aa);
if (Py_SIZE(a) == 0 && PyTuple_CheckExact(bb)) {
return Py_NewRef(bb);
}
@ -479,34 +480,38 @@ tupleconcat(PyTupleObject *a, PyObject *bb)
return Py_NewRef(a);
}
assert((size_t)Py_SIZE(a) + (size_t)Py_SIZE(b) < PY_SSIZE_T_MAX);
size = Py_SIZE(a) + Py_SIZE(b);
Py_ssize_t size = Py_SIZE(a) + Py_SIZE(b);
if (size == 0) {
return tuple_get_empty();
}
np = tuple_alloc(size);
PyTupleObject *np = tuple_alloc(size);
if (np == NULL) {
return NULL;
}
src = a->ob_item;
dest = np->ob_item;
for (i = 0; i < Py_SIZE(a); i++) {
PyObject **src = a->ob_item;
PyObject **dest = np->ob_item;
for (Py_ssize_t i = 0; i < Py_SIZE(a); i++) {
PyObject *v = src[i];
dest[i] = Py_NewRef(v);
}
src = b->ob_item;
dest = np->ob_item + Py_SIZE(a);
for (i = 0; i < Py_SIZE(b); i++) {
for (Py_ssize_t i = 0; i < Py_SIZE(b); i++) {
PyObject *v = src[i];
dest[i] = Py_NewRef(v);
}
_PyObject_GC_TRACK(np);
return (PyObject *)np;
}
static PyObject *
tuplerepeat(PyTupleObject *a, Py_ssize_t n)
tuple_repeat(PyObject *self, Py_ssize_t n)
{
PyTupleObject *a = _PyTuple_CAST(self);
const Py_ssize_t input_size = Py_SIZE(a);
if (input_size == 0 || n == 1) {
if (PyTuple_CheckExact(a)) {
@ -621,17 +626,17 @@ tuple_count(PyTupleObject *self, PyObject *value)
}
static int
tupletraverse(PyTupleObject *o, visitproc visit, void *arg)
tuple_traverse(PyObject *self, visitproc visit, void *arg)
{
Py_ssize_t i;
for (i = Py_SIZE(o); --i >= 0; )
PyTupleObject *o = _PyTuple_CAST(self);
for (Py_ssize_t i = Py_SIZE(o); --i >= 0; ) {
Py_VISIT(o->ob_item[i]);
}
return 0;
}
static PyObject *
tuplerichcompare(PyObject *v, PyObject *w, int op)
tuple_richcompare(PyObject *v, PyObject *w, int op)
{
PyTupleObject *vt, *wt;
Py_ssize_t i;
@ -770,26 +775,27 @@ tuple_subtype_new(PyTypeObject *type, PyObject *iterable)
}
static PySequenceMethods tuple_as_sequence = {
(lenfunc)tuplelength, /* sq_length */
(binaryfunc)tupleconcat, /* sq_concat */
(ssizeargfunc)tuplerepeat, /* sq_repeat */
(ssizeargfunc)tupleitem, /* sq_item */
tuple_length, /* sq_length */
tuple_concat, /* sq_concat */
tuple_repeat, /* sq_repeat */
tuple_item, /* sq_item */
0, /* sq_slice */
0, /* sq_ass_item */
0, /* sq_ass_slice */
(objobjproc)tuplecontains, /* sq_contains */
tuple_contains, /* sq_contains */
};
static PyObject*
tuplesubscript(PyTupleObject* self, PyObject* item)
tuple_subscript(PyObject *op, PyObject* item)
{
PyTupleObject *self = _PyTuple_CAST(op);
if (_PyIndex_Check(item)) {
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return NULL;
if (i < 0)
i += PyTuple_GET_SIZE(self);
return tupleitem(self, i);
return tuple_item(op, i);
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength, i;
@ -843,7 +849,7 @@ static PyObject *
tuple___getnewargs___impl(PyTupleObject *self)
/*[clinic end generated code: output=25e06e3ee56027e2 input=1aeb4b286a21639a]*/
{
return Py_BuildValue("(N)", tupleslice(self, 0, Py_SIZE(self)));
return Py_BuildValue("(N)", tuple_slice(self, 0, Py_SIZE(self)));
}
static PyMethodDef tuple_methods[] = {
@ -855,8 +861,8 @@ static PyMethodDef tuple_methods[] = {
};
static PyMappingMethods tuple_as_mapping = {
(lenfunc)tuplelength,
(binaryfunc)tuplesubscript,
tuple_length,
tuple_subscript,
0
};
@ -867,16 +873,16 @@ PyTypeObject PyTuple_Type = {
"tuple",
sizeof(PyTupleObject) - sizeof(PyObject *),
sizeof(PyObject *),
(destructor)tupledealloc, /* tp_dealloc */
tuple_dealloc, /* tp_dealloc */
0, /* tp_vectorcall_offset */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_as_async */
(reprfunc)tuplerepr, /* tp_repr */
tuple_repr, /* tp_repr */
0, /* tp_as_number */
&tuple_as_sequence, /* tp_as_sequence */
&tuple_as_mapping, /* tp_as_mapping */
(hashfunc)tuplehash, /* tp_hash */
tuple_hash, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
@ -886,9 +892,9 @@ PyTypeObject PyTuple_Type = {
Py_TPFLAGS_BASETYPE | Py_TPFLAGS_TUPLE_SUBCLASS |
_Py_TPFLAGS_MATCH_SELF | Py_TPFLAGS_SEQUENCE, /* tp_flags */
tuple_new__doc__, /* tp_doc */
(traverseproc)tupletraverse, /* tp_traverse */
tuple_traverse, /* tp_traverse */
0, /* tp_clear */
tuplerichcompare, /* tp_richcompare */
tuple_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
tuple_iter, /* tp_iter */
0, /* tp_iternext */