2 /* Tuple object implementation */
6 /* Speed optimization to avoid frequent malloc/free of small tuples */
7 #ifndef PyTuple_MAXSAVESIZE
8 #define PyTuple_MAXSAVESIZE 20 /* Largest tuple to save on free list */
10 #ifndef PyTuple_MAXFREELIST
11 #define PyTuple_MAXFREELIST 2000 /* Maximum number of tuples of each size to save */
14 #if PyTuple_MAXSAVESIZE > 0
15 /* Entries 1 up to PyTuple_MAXSAVESIZE are free lists, entry 0 is the empty
16 tuple () of which at most one instance will be allocated.
18 static PyTupleObject *free_list[PyTuple_MAXSAVESIZE];
19 static int numfree[PyTuple_MAXSAVESIZE];
22 Py_ssize_t fast_tuple_allocs;
23 Py_ssize_t tuple_zero_allocs;
26 /* Debug statistic to count GC tracking of tuples.
27 Please note that tuples are only untracked when considered by the GC, and
28 many of them will be dead before. Therefore, a tracking rate close to 100%
29 does not necessarily prove that the heuristic is inefficient.
31 #ifdef SHOW_TRACK_COUNT
32 static Py_ssize_t count_untracked = 0;
33 static Py_ssize_t count_tracked = 0;
38 fprintf(stderr, "Tuples created: %" PY_FORMAT_SIZE_T "d\n",
39 count_tracked + count_untracked);
40 fprintf(stderr, "Tuples tracked by the GC: %" PY_FORMAT_SIZE_T
41 "d\n", count_tracked);
42 fprintf(stderr, "%.2f%% tuple tracking rate\n\n",
43 (100.0*count_tracked/(count_untracked+count_tracked)));
49 PyTuple_New(register Py_ssize_t size)
51 register PyTupleObject *op;
54 PyErr_BadInternalCall();
57 #if PyTuple_MAXSAVESIZE > 0
58 if (size == 0 && free_list[0]) {
64 return (PyObject *) op;
66 if (size < PyTuple_MAXSAVESIZE && (op = free_list[size]) != NULL) {
67 free_list[size] = (PyTupleObject *) op->ob_item[0];
72 /* Inline PyObject_InitVar */
75 Py_TYPE(op) = &PyTuple_Type;
77 _Py_NewReference((PyObject *)op);
82 Py_ssize_t nbytes = size * sizeof(PyObject *);
83 /* Check for overflow */
84 if (nbytes / sizeof(PyObject *) != (size_t)size ||
85 (nbytes > PY_SSIZE_T_MAX - sizeof(PyTupleObject) - sizeof(PyObject *)))
87 return PyErr_NoMemory();
90 op = PyObject_GC_NewVar(PyTupleObject, &PyTuple_Type, size);
94 for (i=0; i < size; i++)
95 op->ob_item[i] = NULL;
96 #if PyTuple_MAXSAVESIZE > 0
100 Py_INCREF(op); /* extra INCREF so that this is never freed */
103 #ifdef SHOW_TRACK_COUNT
106 _PyObject_GC_TRACK(op);
107 return (PyObject *) op;
111 PyTuple_Size(register PyObject *op)
113 if (!PyTuple_Check(op)) {
114 PyErr_BadInternalCall();
122 PyTuple_GetItem(register PyObject *op, register Py_ssize_t i)
124 if (!PyTuple_Check(op)) {
125 PyErr_BadInternalCall();
128 if (i < 0 || i >= Py_SIZE(op)) {
129 PyErr_SetString(PyExc_IndexError, "tuple index out of range");
132 return ((PyTupleObject *)op) -> ob_item[i];
136 PyTuple_SetItem(register PyObject *op, register Py_ssize_t i, PyObject *newitem)
138 register PyObject *olditem;
139 register PyObject **p;
140 if (!PyTuple_Check(op) || op->ob_refcnt != 1) {
142 PyErr_BadInternalCall();
145 if (i < 0 || i >= Py_SIZE(op)) {
147 PyErr_SetString(PyExc_IndexError,
148 "tuple assignment index out of range");
151 p = ((PyTupleObject *)op) -> ob_item + i;
159 _PyTuple_MaybeUntrack(PyObject *op)
164 if (!PyTuple_CheckExact(op) || !_PyObject_GC_IS_TRACKED(op))
166 t = (PyTupleObject *) op;
168 for (i = 0; i < n; i++) {
169 PyObject *elt = PyTuple_GET_ITEM(t, i);
170 /* Tuple with NULL elements aren't
171 fully constructed, don't untrack
174 _PyObject_GC_MAY_BE_TRACKED(elt))
177 #ifdef SHOW_TRACK_COUNT
181 _PyObject_GC_UNTRACK(op);
185 PyTuple_Pack(Py_ssize_t n, ...)
194 result = PyTuple_New(n);
197 items = ((PyTupleObject *)result)->ob_item;
198 for (i = 0; i < n; i++) {
199 o = va_arg(vargs, PyObject *);
211 tupledealloc(register PyTupleObject *op)
213 register Py_ssize_t i;
214 register Py_ssize_t len = Py_SIZE(op);
215 PyObject_GC_UnTrack(op);
216 Py_TRASHCAN_SAFE_BEGIN(op)
220 Py_XDECREF(op->ob_item[i]);
221 #if PyTuple_MAXSAVESIZE > 0
222 if (len < PyTuple_MAXSAVESIZE &&
223 numfree[len] < PyTuple_MAXFREELIST &&
224 Py_TYPE(op) == &PyTuple_Type)
226 op->ob_item[0] = (PyObject *) free_list[len];
229 goto done; /* return */
233 Py_TYPE(op)->tp_free((PyObject *)op);
235 Py_TRASHCAN_SAFE_END(op)
239 tupleprint(PyTupleObject *op, FILE *fp, int flags)
242 Py_BEGIN_ALLOW_THREADS
245 for (i = 0; i < Py_SIZE(op); i++) {
247 Py_BEGIN_ALLOW_THREADS
251 if (PyObject_Print(op->ob_item[i], fp, 0) != 0)
255 Py_BEGIN_ALLOW_THREADS
264 tuplerepr(PyTupleObject *v)
268 PyObject *pieces, *result = NULL;
272 return PyString_FromString("()");
274 /* While not mutable, it is still possible to end up with a cycle in a
275 tuple through an object that stores itself within a tuple (and thus
276 infinitely asks for the repr of itself). This should only be
277 possible within a type. */
278 i = Py_ReprEnter((PyObject *)v);
280 return i > 0 ? PyString_FromString("(...)") : NULL;
283 pieces = PyTuple_New(n);
287 /* Do repr() on each element. */
288 for (i = 0; i < n; ++i) {
289 if (Py_EnterRecursiveCall(" while getting the repr of a tuple"))
291 s = PyObject_Repr(v->ob_item[i]);
292 Py_LeaveRecursiveCall();
295 PyTuple_SET_ITEM(pieces, i, s);
298 /* Add "()" decorations to the first and last items. */
300 s = PyString_FromString("(");
303 temp = PyTuple_GET_ITEM(pieces, 0);
304 PyString_ConcatAndDel(&s, temp);
305 PyTuple_SET_ITEM(pieces, 0, s);
309 s = PyString_FromString(n == 1 ? ",)" : ")");
312 temp = PyTuple_GET_ITEM(pieces, n-1);
313 PyString_ConcatAndDel(&temp, s);
314 PyTuple_SET_ITEM(pieces, n-1, temp);
318 /* Paste them all together with ", " between. */
319 s = PyString_FromString(", ");
322 result = _PyString_Join(s, pieces);
327 Py_ReprLeave((PyObject *)v);
331 /* The addend 82520, was selected from the range(0, 1000000) for
332 generating the greatest number of prime multipliers for tuples
335 1082527, 1165049, 1082531, 1165057, 1247581, 1330103, 1082533,
336 1330111, 1412633, 1165069, 1247599, 1495177, 1577699
340 tuplehash(PyTupleObject *v)
343 register Py_ssize_t len = Py_SIZE(v);
344 register PyObject **p;
345 long mult = 1000003L;
349 y = PyObject_Hash(*p++);
353 /* the cast might truncate len; that doesn't change hash stability */
354 mult += (long)(82520L + len + len);
363 tuplelength(PyTupleObject *a)
369 tuplecontains(PyTupleObject *a, PyObject *el)
374 for (i = 0, cmp = 0 ; cmp == 0 && i < Py_SIZE(a); ++i)
375 cmp = PyObject_RichCompareBool(el, PyTuple_GET_ITEM(a, i),
381 tupleitem(register PyTupleObject *a, register Py_ssize_t i)
383 if (i < 0 || i >= Py_SIZE(a)) {
384 PyErr_SetString(PyExc_IndexError, "tuple index out of range");
387 Py_INCREF(a->ob_item[i]);
388 return a->ob_item[i];
392 tupleslice(register PyTupleObject *a, register Py_ssize_t ilow,
393 register Py_ssize_t ihigh)
395 register PyTupleObject *np;
396 PyObject **src, **dest;
397 register Py_ssize_t i;
401 if (ihigh > Py_SIZE(a))
405 if (ilow == 0 && ihigh == Py_SIZE(a) && PyTuple_CheckExact(a)) {
407 return (PyObject *)a;
410 np = (PyTupleObject *)PyTuple_New(len);
413 src = a->ob_item + ilow;
415 for (i = 0; i < len; i++) {
416 PyObject *v = src[i];
420 return (PyObject *)np;
424 PyTuple_GetSlice(PyObject *op, Py_ssize_t i, Py_ssize_t j)
426 if (op == NULL || !PyTuple_Check(op)) {
427 PyErr_BadInternalCall();
430 return tupleslice((PyTupleObject *)op, i, j);
434 tupleconcat(register PyTupleObject *a, register PyObject *bb)
436 register Py_ssize_t size;
437 register Py_ssize_t i;
438 PyObject **src, **dest;
440 if (!PyTuple_Check(bb)) {
441 PyErr_Format(PyExc_TypeError,
442 "can only concatenate tuple (not \"%.200s\") to tuple",
443 Py_TYPE(bb)->tp_name);
446 #define b ((PyTupleObject *)bb)
447 size = Py_SIZE(a) + Py_SIZE(b);
449 return PyErr_NoMemory();
450 np = (PyTupleObject *) PyTuple_New(size);
456 for (i = 0; i < Py_SIZE(a); i++) {
457 PyObject *v = src[i];
462 dest = np->ob_item + Py_SIZE(a);
463 for (i = 0; i < Py_SIZE(b); i++) {
464 PyObject *v = src[i];
468 return (PyObject *)np;
473 tuplerepeat(PyTupleObject *a, Py_ssize_t n)
478 PyObject **p, **items;
481 if (Py_SIZE(a) == 0 || n == 1) {
482 if (PyTuple_CheckExact(a)) {
483 /* Since tuples are immutable, we can return a shared
486 return (PyObject *)a;
489 return PyTuple_New(0);
491 size = Py_SIZE(a) * n;
492 if (size/Py_SIZE(a) != n)
493 return PyErr_NoMemory();
494 np = (PyTupleObject *) PyTuple_New(size);
499 for (i = 0; i < n; i++) {
500 for (j = 0; j < Py_SIZE(a); j++) {
506 return (PyObject *) np;
510 tupleindex(PyTupleObject *self, PyObject *args)
512 Py_ssize_t i, start=0, stop=Py_SIZE(self);
515 if (!PyArg_ParseTuple(args, "O|O&O&:index", &v,
516 _PyEval_SliceIndex, &start,
517 _PyEval_SliceIndex, &stop))
520 start += Py_SIZE(self);
525 stop += Py_SIZE(self);
529 for (i = start; i < stop && i < Py_SIZE(self); i++) {
530 int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
532 return PyInt_FromSsize_t(i);
536 PyErr_SetString(PyExc_ValueError, "tuple.index(x): x not in tuple");
541 tuplecount(PyTupleObject *self, PyObject *v)
543 Py_ssize_t count = 0;
546 for (i = 0; i < Py_SIZE(self); i++) {
547 int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
553 return PyInt_FromSsize_t(count);
557 tupletraverse(PyTupleObject *o, visitproc visit, void *arg)
561 for (i = Py_SIZE(o); --i >= 0; )
562 Py_VISIT(o->ob_item[i]);
567 tuplerichcompare(PyObject *v, PyObject *w, int op)
569 PyTupleObject *vt, *wt;
571 Py_ssize_t vlen, wlen;
573 if (!PyTuple_Check(v) || !PyTuple_Check(w)) {
574 Py_INCREF(Py_NotImplemented);
575 return Py_NotImplemented;
578 vt = (PyTupleObject *)v;
579 wt = (PyTupleObject *)w;
584 /* Note: the corresponding code for lists has an "early out" test
585 * here when op is EQ or NE and the lengths differ. That pays there,
586 * but Tim was unable to find any real code where EQ/NE tuple
587 * compares don't have the same length, so testing for it here would
588 * have cost without benefit.
591 /* Search for the first index where items are different.
592 * Note that because tuples are immutable, it's safe to reuse
593 * vlen and wlen across the comparison calls.
595 for (i = 0; i < vlen && i < wlen; i++) {
596 int k = PyObject_RichCompareBool(vt->ob_item[i],
597 wt->ob_item[i], Py_EQ);
604 if (i >= vlen || i >= wlen) {
605 /* No more items to compare -- compare sizes */
609 case Py_LT: cmp = vlen < wlen; break;
610 case Py_LE: cmp = vlen <= wlen; break;
611 case Py_EQ: cmp = vlen == wlen; break;
612 case Py_NE: cmp = vlen != wlen; break;
613 case Py_GT: cmp = vlen > wlen; break;
614 case Py_GE: cmp = vlen >= wlen; break;
615 default: return NULL; /* cannot happen */
625 /* We have an item that differs -- shortcuts for EQ/NE */
635 /* Compare the final item again using the proper operator */
636 return PyObject_RichCompare(vt->ob_item[i], wt->ob_item[i], op);
640 tuple_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
643 tuple_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
645 PyObject *arg = NULL;
646 static char *kwlist[] = {"sequence", 0};
648 if (type != &PyTuple_Type)
649 return tuple_subtype_new(type, args, kwds);
650 if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:tuple", kwlist, &arg))
654 return PyTuple_New(0);
656 return PySequence_Tuple(arg);
660 tuple_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
662 PyObject *tmp, *newobj, *item;
665 assert(PyType_IsSubtype(type, &PyTuple_Type));
666 tmp = tuple_new(&PyTuple_Type, args, kwds);
669 assert(PyTuple_Check(tmp));
670 newobj = type->tp_alloc(type, n = PyTuple_GET_SIZE(tmp));
673 for (i = 0; i < n; i++) {
674 item = PyTuple_GET_ITEM(tmp, i);
676 PyTuple_SET_ITEM(newobj, i, item);
682 PyDoc_STRVAR(tuple_doc,
683 "tuple() -> empty tuple\n\
684 tuple(iterable) -> tuple initialized from iterable's items\n\
686 If the argument is a tuple, the return value is the same object.");
688 static PySequenceMethods tuple_as_sequence = {
689 (lenfunc)tuplelength, /* sq_length */
690 (binaryfunc)tupleconcat, /* sq_concat */
691 (ssizeargfunc)tuplerepeat, /* sq_repeat */
692 (ssizeargfunc)tupleitem, /* sq_item */
693 (ssizessizeargfunc)tupleslice, /* sq_slice */
695 0, /* sq_ass_slice */
696 (objobjproc)tuplecontains, /* sq_contains */
700 tuplesubscript(PyTupleObject* self, PyObject* item)
702 if (PyIndex_Check(item)) {
703 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
704 if (i == -1 && PyErr_Occurred())
707 i += PyTuple_GET_SIZE(self);
708 return tupleitem(self, i);
710 else if (PySlice_Check(item)) {
711 Py_ssize_t start, stop, step, slicelength, cur, i;
714 PyObject **src, **dest;
716 if (PySlice_GetIndicesEx((PySliceObject*)item,
717 PyTuple_GET_SIZE(self),
718 &start, &stop, &step, &slicelength) < 0) {
722 if (slicelength <= 0) {
723 return PyTuple_New(0);
725 else if (start == 0 && step == 1 &&
726 slicelength == PyTuple_GET_SIZE(self) &&
727 PyTuple_CheckExact(self)) {
729 return (PyObject *)self;
732 result = PyTuple_New(slicelength);
733 if (!result) return NULL;
736 dest = ((PyTupleObject *)result)->ob_item;
737 for (cur = start, i = 0; i < slicelength;
748 PyErr_Format(PyExc_TypeError,
749 "tuple indices must be integers, not %.200s",
750 Py_TYPE(item)->tp_name);
756 tuple_getnewargs(PyTupleObject *v)
758 return Py_BuildValue("(N)", tupleslice(v, 0, Py_SIZE(v)));
763 tuple_sizeof(PyTupleObject *self)
767 res = PyTuple_Type.tp_basicsize + Py_SIZE(self) * sizeof(PyObject *);
768 return PyInt_FromSsize_t(res);
771 PyDoc_STRVAR(index_doc,
772 "T.index(value, [start, [stop]]) -> integer -- return first index of value.\n"
773 "Raises ValueError if the value is not present."
775 PyDoc_STRVAR(count_doc,
776 "T.count(value) -> integer -- return number of occurrences of value");
777 PyDoc_STRVAR(sizeof_doc,
778 "T.__sizeof__() -- size of T in memory, in bytes");
780 static PyMethodDef tuple_methods[] = {
781 {"__getnewargs__", (PyCFunction)tuple_getnewargs, METH_NOARGS},
782 {"__sizeof__", (PyCFunction)tuple_sizeof, METH_NOARGS, sizeof_doc},
783 {"index", (PyCFunction)tupleindex, METH_VARARGS, index_doc},
784 {"count", (PyCFunction)tuplecount, METH_O, count_doc},
785 {NULL, NULL} /* sentinel */
788 static PyMappingMethods tuple_as_mapping = {
789 (lenfunc)tuplelength,
790 (binaryfunc)tuplesubscript,
794 static PyObject *tuple_iter(PyObject *seq);
796 PyTypeObject PyTuple_Type = {
797 PyVarObject_HEAD_INIT(&PyType_Type, 0)
799 sizeof(PyTupleObject) - sizeof(PyObject *),
801 (destructor)tupledealloc, /* tp_dealloc */
802 (printfunc)tupleprint, /* tp_print */
806 (reprfunc)tuplerepr, /* tp_repr */
807 0, /* tp_as_number */
808 &tuple_as_sequence, /* tp_as_sequence */
809 &tuple_as_mapping, /* tp_as_mapping */
810 (hashfunc)tuplehash, /* tp_hash */
813 PyObject_GenericGetAttr, /* tp_getattro */
815 0, /* tp_as_buffer */
816 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
817 Py_TPFLAGS_BASETYPE | Py_TPFLAGS_TUPLE_SUBCLASS, /* tp_flags */
818 tuple_doc, /* tp_doc */
819 (traverseproc)tupletraverse, /* tp_traverse */
821 tuplerichcompare, /* tp_richcompare */
822 0, /* tp_weaklistoffset */
823 tuple_iter, /* tp_iter */
825 tuple_methods, /* tp_methods */
830 0, /* tp_descr_get */
831 0, /* tp_descr_set */
832 0, /* tp_dictoffset */
835 tuple_new, /* tp_new */
836 PyObject_GC_Del, /* tp_free */
839 /* The following function breaks the notion that tuples are immutable:
840 it changes the size of a tuple. We get away with this only if there
841 is only one module referencing the object. You can also think of it
842 as creating a new tuple object and destroying the old one, only more
843 efficiently. In any case, don't use this if the tuple may already be
844 known to some other part of the code. */
847 _PyTuple_Resize(PyObject **pv, Py_ssize_t newsize)
849 register PyTupleObject *v;
850 register PyTupleObject *sv;
854 v = (PyTupleObject *) *pv;
855 if (v == NULL || Py_TYPE(v) != &PyTuple_Type ||
856 (Py_SIZE(v) != 0 && Py_REFCNT(v) != 1)) {
859 PyErr_BadInternalCall();
862 oldsize = Py_SIZE(v);
863 if (oldsize == newsize)
867 /* Empty tuples are often shared, so we should never
868 resize them in-place even if we do own the only
869 (current) reference */
871 *pv = PyTuple_New(newsize);
872 return *pv == NULL ? -1 : 0;
875 /* XXX UNREF/NEWREF interface should be more symmetrical */
877 if (_PyObject_GC_IS_TRACKED(v))
878 _PyObject_GC_UNTRACK(v);
879 _Py_ForgetReference((PyObject *) v);
880 /* DECREF items deleted by shrinkage */
881 for (i = newsize; i < oldsize; i++) {
882 Py_XDECREF(v->ob_item[i]);
883 v->ob_item[i] = NULL;
885 sv = PyObject_GC_Resize(PyTupleObject, v, newsize);
891 _Py_NewReference((PyObject *) sv);
892 /* Zero out items added by growing */
893 if (newsize > oldsize)
894 memset(&sv->ob_item[oldsize], 0,
895 sizeof(*sv->ob_item) * (newsize - oldsize));
896 *pv = (PyObject *) sv;
897 _PyObject_GC_TRACK(sv);
902 PyTuple_ClearFreeList(void)
904 int freelist_size = 0;
905 #if PyTuple_MAXSAVESIZE > 0
907 for (i = 1; i < PyTuple_MAXSAVESIZE; i++) {
908 PyTupleObject *p, *q;
910 freelist_size += numfree[i];
915 p = (PyTupleObject *)(p->ob_item[0]);
920 return freelist_size;
926 #if PyTuple_MAXSAVESIZE > 0
927 /* empty tuples are used all over the place and applications may
928 * rely on the fact that an empty tuple is a singleton. */
929 Py_XDECREF(free_list[0]);
932 (void)PyTuple_ClearFreeList();
934 #ifdef SHOW_TRACK_COUNT
939 /*********************** Tuple Iterator **************************/
944 PyTupleObject *it_seq; /* Set to NULL when iterator is exhausted */
948 tupleiter_dealloc(tupleiterobject *it)
950 _PyObject_GC_UNTRACK(it);
951 Py_XDECREF(it->it_seq);
956 tupleiter_traverse(tupleiterobject *it, visitproc visit, void *arg)
958 Py_VISIT(it->it_seq);
963 tupleiter_next(tupleiterobject *it)
972 assert(PyTuple_Check(seq));
974 if (it->it_index < PyTuple_GET_SIZE(seq)) {
975 item = PyTuple_GET_ITEM(seq, it->it_index);
987 tupleiter_len(tupleiterobject *it)
991 len = PyTuple_GET_SIZE(it->it_seq) - it->it_index;
992 return PyInt_FromSsize_t(len);
995 PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
997 static PyMethodDef tupleiter_methods[] = {
998 {"__length_hint__", (PyCFunction)tupleiter_len, METH_NOARGS, length_hint_doc},
999 {NULL, NULL} /* sentinel */
1002 PyTypeObject PyTupleIter_Type = {
1003 PyVarObject_HEAD_INIT(&PyType_Type, 0)
1004 "tupleiterator", /* tp_name */
1005 sizeof(tupleiterobject), /* tp_basicsize */
1006 0, /* tp_itemsize */
1008 (destructor)tupleiter_dealloc, /* tp_dealloc */
1014 0, /* tp_as_number */
1015 0, /* tp_as_sequence */
1016 0, /* tp_as_mapping */
1020 PyObject_GenericGetAttr, /* tp_getattro */
1021 0, /* tp_setattro */
1022 0, /* tp_as_buffer */
1023 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
1025 (traverseproc)tupleiter_traverse, /* tp_traverse */
1027 0, /* tp_richcompare */
1028 0, /* tp_weaklistoffset */
1029 PyObject_SelfIter, /* tp_iter */
1030 (iternextfunc)tupleiter_next, /* tp_iternext */
1031 tupleiter_methods, /* tp_methods */
1036 tuple_iter(PyObject *seq)
1038 tupleiterobject *it;
1040 if (!PyTuple_Check(seq)) {
1041 PyErr_BadInternalCall();
1044 it = PyObject_GC_New(tupleiterobject, &PyTupleIter_Type);
1049 it->it_seq = (PyTupleObject *)seq;
1050 _PyObject_GC_TRACK(it);
1051 return (PyObject *)it;