/* 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)) {
}
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) {
}
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,)" */
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) {
/* 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;
}
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;
}
static PyObject *
-tupleslice(PyTupleObject *a, Py_ssize_t ilow,
+tuple_slice(PyTupleObject *a, Py_ssize_t ilow,
Py_ssize_t ihigh)
{
if (ilow < 0)
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);
}
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)) {
}
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;
}
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;
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[] = {
};
static PyMappingMethods tuple_as_mapping = {
- (lenfunc)tuplelength,
- (binaryfunc)tuplesubscript,
+ tuple_length,
+ tuple_subscript,
0
};
"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 */
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 */
projects / thirdparty / Python / cpython.git / commitdiff
