Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

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

Merged
merged 1 commit into from
Oct 2, 2024
+64 −58
Merged

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

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
122 changes: 64 additions & 58 deletions Objects/tupleobject.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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)) {
Expand All @@ -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) {
Expand All @@ -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,)" */
Expand All @@ -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) {
Expand Down Expand Up @@ -316,13 +317,14 @@ tuplerepr(PyTupleObject *v)
/* 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;
Expand All @@ -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;
Expand Down Expand Up @@ -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)
Expand All @@ -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);
}
Expand All @@ -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)) {
Expand Down Expand Up @@ -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;
Expand Down Expand Up @@ -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;
Expand Down Expand Up @@ -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[] = {
Expand All @@ -855,8 +861,8 @@ static PyMethodDef tuple_methods[] = {
};

static PyMappingMethods tuple_as_mapping = {
(lenfunc)tuplelength,
(binaryfunc)tuplesubscript,
tuple_length,
tuple_subscript,
0
};

Expand All @@ -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 */
Expand All @@ -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 */
Expand Down
Loading