#include "Python.h"

#include "pycore_abstract.h" // _PyIndex_Check()

#include "pycore_ceval.h" // _PyEval_GetBuiltin()

#include "pycore_gc.h" // _PyObject_GC_IS_TRACKED()

#include "pycore_initconfig.h" // _PyStatus_OK()

#include "pycore_modsupport.h" // _PyArg_NoKwnames()

#include "pycore_object.h" // _PyObject_GC_TRACK(), _Py_FatalRefcountError(), _PyDebugAllocatorStats()

#include "clinic/tupleobject.c.h"

static inline PyTupleObject * maybe_freelist_pop(Py_ssize_t);

static inline int maybe_freelist_push(PyTupleObject *);

static PyTupleObject *

tuple_alloc(Py_ssize_t size)

{

if (size < 0) {

PyErr_BadInternalCall();

return NULL;

}

#ifdef Py_DEBUG

assert(size != 0); // The empty tuple is statically allocated.

PyTupleObject *op = maybe_freelist_pop(size);

if (op == NULL) {

/* Check for overflow */

if ((size_t)size > ((size_t)PY_SSIZE_T_MAX - (sizeof(PyTupleObject) -

sizeof(PyObject *))) / sizeof(PyObject *)) {

return (PyTupleObject *)PyErr_NoMemory();

}

op = PyObject_GC_NewVar(PyTupleObject, &PyTuple_Type, size);

if (op == NULL)

return NULL;

}

return op;

}

static inline PyObject *

tuple_get_empty(void)

{

return (PyObject *)&_Py_SINGLETON(tuple_empty);

}

PyObject *

PyTuple_New(Py_ssize_t size)

{

PyTupleObject *op;

if (size == 0) {

return tuple_get_empty();

}

op = tuple_alloc(size);

if (op == NULL) {

return NULL;

}

for (Py_ssize_t i = 0; i < size; i++) {

op->ob_item[i] = NULL;

}

_PyObject_GC_TRACK(op);

return (PyObject *) op;

}

PyTuple_Size(PyObject *op)

{

if (!PyTuple_Check(op)) {

PyErr_BadInternalCall();

return -1;

}

else

return Py_SIZE(op);

}

PyObject *

PyTuple_GetItem(PyObject *op, Py_ssize_t i)

{

if (!PyTuple_Check(op)) {

PyErr_BadInternalCall();

return NULL;

}

if (i < 0 || i >= Py_SIZE(op)) {

PyErr_SetString(PyExc_IndexError, "tuple index out of range");

return NULL;

}

return ((PyTupleObject *)op) -> ob_item[i];

}

PyTuple_SetItem(PyObject *op, Py_ssize_t i, PyObject *newitem)

{

PyObject **p;

if (!PyTuple_Check(op) || Py_REFCNT(op) != 1) {

Py_XDECREF(newitem);

PyErr_BadInternalCall();

return -1;

}

if (i < 0 || i >= Py_SIZE(op)) {

Py_XDECREF(newitem);

PyErr_SetString(PyExc_IndexError,

"tuple assignment index out of range");

return -1;

}

p = ((PyTupleObject *)op) -> ob_item + i;

Py_XSETREF(*p, newitem);

return 0;

}

_PyTuple_MaybeUntrack(PyObject *op)

{

PyTupleObject *t;

Py_ssize_t i, n;

if (!PyTuple_CheckExact(op) || !_PyObject_GC_IS_TRACKED(op))

return;

t = (PyTupleObject *) op;

n = Py_SIZE(t);

for (i = 0; i < n; i++) {

PyObject *elt = PyTuple_GET_ITEM(t, i);

/* Tuple with NULL elements aren't

if (!elt ||

_PyObject_GC_MAY_BE_TRACKED(elt))

return;

}

_PyObject_GC_UNTRACK(op);

}

PyObject *

PyTuple_Pack(Py_ssize_t n, ...)

{

Py_ssize_t i;

PyObject *o;

PyObject **items;

va_list vargs;

if (n == 0) {

return tuple_get_empty();

}

va_start(vargs, n);

PyTupleObject *result = tuple_alloc(n);

if (result == NULL) {

va_end(vargs);

return NULL;

}

items = result->ob_item;

for (i = 0; i < n; i++) {

o = va_arg(vargs, PyObject *);

items[i] = Py_NewRef(o);

}

va_end(vargs);

_PyObject_GC_TRACK(result);

return (PyObject *)result;

}

static void

tupledealloc(PyTupleObject *op)

{

if (Py_SIZE(op) == 0) {

/* The empty tuple is statically allocated. */

if (op == &_Py_SINGLETON(tuple_empty)) {

#ifdef Py_DEBUG

_Py_FatalRefcountError("deallocating the empty tuple singleton");

return;

}

#ifdef Py_DEBUG

/* tuple subclasses have their own empty instances. */

assert(!PyTuple_CheckExact(op));

}

PyObject_GC_UnTrack(op);

Py_TRASHCAN_BEGIN(op, tupledealloc)

Py_ssize_t i = Py_SIZE(op);

while (--i >= 0) {

Py_XDECREF(op->ob_item[i]);

}

// This will abort on the empty singleton (if there is one).

if (!maybe_freelist_push(op)) {

Py_TYPE(op)->tp_free((PyObject *)op);

}

Py_TRASHCAN_END

}

static PyObject *

tuplerepr(PyTupleObject *v)

{

Py_ssize_t i, n;

_PyUnicodeWriter writer;

n = Py_SIZE(v);

if (n == 0)

return PyUnicode_FromString("()");

/* While not mutable, it is still possible to end up with a cycle in a

i = Py_ReprEnter((PyObject *)v);

if (i != 0) {

return i > 0 ? PyUnicode_FromString("(...)") : NULL;

}

_PyUnicodeWriter_Init(&writer);

writer.overallocate = 1;

if (Py_SIZE(v) > 1) {

/* "(" + "1" + ", 2" * (len - 1) + ")" */

writer.min_length = 1 + 1 + (2 + 1) * (Py_SIZE(v) - 1) + 1;

}

else {

/* "(1,)" */

writer.min_length = 4;

}

if (_PyUnicodeWriter_WriteChar(&writer, '(') < 0)

goto error;

/* Do repr() on each element. */

for (i = 0; i < n; ++i) {

PyObject *s;

if (i > 0) {

if (_PyUnicodeWriter_WriteASCIIString(&writer, ", ", 2) < 0)

goto error;

}

s = PyObject_Repr(v->ob_item[i]);

if (s == NULL)

goto error;

if (_PyUnicodeWriter_WriteStr(&writer, s) < 0) {

Py_DECREF(s);

goto error;

}

Py_DECREF(s);

}

writer.overallocate = 0;

if (n > 1) {

if (_PyUnicodeWriter_WriteChar(&writer, ')') < 0)

goto error;

}

else {

if (_PyUnicodeWriter_WriteASCIIString(&writer, ",)", 2) < 0)

goto error;

}

Py_ReprLeave((PyObject *)v);

return _PyUnicodeWriter_Finish(&writer);

error:

_PyUnicodeWriter_Dealloc(&writer);

Py_ReprLeave((PyObject *)v);

return NULL;

}

#if SIZEOF_PY_UHASH_T > 4

#define _PyHASH_XXPRIME_1 ((Py_uhash_t)11400714785074694791ULL)

#define _PyHASH_XXPRIME_2 ((Py_uhash_t)14029467366897019727ULL)

#define _PyHASH_XXPRIME_5 ((Py_uhash_t)2870177450012600261ULL)

#define _PyHASH_XXROTATE(x) ((x << 31) | (x >> 33)) /* Rotate left 31 bits */

#define _PyHASH_XXPRIME_1 ((Py_uhash_t)2654435761UL)

#define _PyHASH_XXPRIME_2 ((Py_uhash_t)2246822519UL)

#define _PyHASH_XXPRIME_5 ((Py_uhash_t)374761393UL)

#define _PyHASH_XXROTATE(x) ((x << 13) | (x >> 19)) /* Rotate left 13 bits */

static Py_hash_t

tuplehash(PyTupleObject *v)

{

Py_ssize_t i, len = Py_SIZE(v);

PyObject **item = v->ob_item;

Py_uhash_t acc = _PyHASH_XXPRIME_5;

for (i = 0; i < len; i++) {

Py_uhash_t lane = PyObject_Hash(item[i]);

if (lane == (Py_uhash_t)-1) {

return -1;

}

acc += lane * _PyHASH_XXPRIME_2;

acc = _PyHASH_XXROTATE(acc);

acc *= _PyHASH_XXPRIME_1;

}

/* Add input length, mangled to keep the historical value of hash(()). */

acc += len ^ (_PyHASH_XXPRIME_5 ^ 3527539UL);

if (acc == (Py_uhash_t)-1) {

return 1546275796;

}

return acc;

}

static Py_ssize_t

tuplelength(PyTupleObject *a)

{

return Py_SIZE(a);

}

static int

tuplecontains(PyTupleObject *a, PyObject *el)

{

Py_ssize_t i;

int cmp;

for (i = 0, cmp = 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)

{

if (i < 0 || i >= Py_SIZE(a)) {

PyErr_SetString(PyExc_IndexError, "tuple index out of range");

return NULL;

}

return Py_NewRef(a->ob_item[i]);

}

PyObject *

_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)

{

if (n == 0) {

return tuple_get_empty();

}

PyTupleObject *tuple = tuple_alloc(n);

if (tuple == NULL) {

return NULL;

}

PyObject **dst = tuple->ob_item;

for (Py_ssize_t i = 0; i < n; i++) {

PyObject *item = src[i];

dst[i] = Py_NewRef(item);

}

_PyObject_GC_TRACK(tuple);

return (PyObject *)tuple;

}

PyObject *

_PyTuple_FromArraySteal(PyObject *const *src, Py_ssize_t n)

{

if (n == 0) {

return tuple_get_empty();

}

PyTupleObject *tuple = tuple_alloc(n);

if (tuple == NULL) {

for (Py_ssize_t i = 0; i < n; i++) {

Py_DECREF(src[i]);

}

return NULL;

}

PyObject **dst = tuple->ob_item;

for (Py_ssize_t i = 0; i < n; i++) {

PyObject *item = src[i];

dst[i] = item;

}

_PyObject_GC_TRACK(tuple);

return (PyObject *)tuple;

}

static PyObject *

tupleslice(PyTupleObject *a, Py_ssize_t ilow,

Py_ssize_t ihigh)

{

if (ilow < 0)

ilow = 0;

if (ihigh > Py_SIZE(a))

ihigh = Py_SIZE(a);

if (ihigh < ilow)

ihigh = ilow;

if (ilow == 0 && ihigh == Py_SIZE(a) && PyTuple_CheckExact(a)) {

return Py_NewRef(a);

}

return _PyTuple_FromArray(a->ob_item + ilow, ihigh - ilow);

}

PyObject *

PyTuple_GetSlice(PyObject *op, Py_ssize_t i, Py_ssize_t j)

{

if (op == NULL || !PyTuple_Check(op)) {

PyErr_BadInternalCall();

return NULL;

}

return tupleslice((PyTupleObject *)op, i, j);

}

static PyObject *

tupleconcat(PyTupleObject *a, PyObject *bb)

{

Py_ssize_t size;

Py_ssize_t i;

PyObject **src, **dest;

PyTupleObject *np;

if (Py_SIZE(a) == 0 && PyTuple_CheckExact(bb)) {

return Py_NewRef(bb);

}

if (!PyTuple_Check(bb)) {

PyErr_Format(PyExc_TypeError,

"can only concatenate tuple (not \"%.200s\") to tuple",

Py_TYPE(bb)->tp_name);

return NULL;

}

PyTupleObject *b = (PyTupleObject *)bb;

if (Py_SIZE(b) == 0 && PyTuple_CheckExact(a)) {

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);

if (size == 0) {

return tuple_get_empty();

}

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 *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++) {

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)

{

const Py_ssize_t input_size = Py_SIZE(a);

if (input_size == 0 || n == 1) {

if (PyTuple_CheckExact(a)) {

/* Since tuples are immutable, we can return a shared

return Py_NewRef(a);

}

}

if (input_size == 0 || n <= 0) {

return tuple_get_empty();

}

assert(n>0);

if (input_size > PY_SSIZE_T_MAX / n)

return PyErr_NoMemory();

Py_ssize_t output_size = input_size * n;

PyTupleObject *np = tuple_alloc(output_size);

if (np == NULL)

return NULL;

PyObject **dest = np->ob_item;

if (input_size == 1) {

PyObject *elem = a->ob_item[0];

_Py_RefcntAdd(elem, n);

PyObject **dest_end = dest + output_size;

while (dest < dest_end) {

*dest++ = elem;

}

}

else {

PyObject **src = a->ob_item;

PyObject **src_end = src + input_size;

while (src < src_end) {

_Py_RefcntAdd(*src, n);

*dest++ = *src++;

}

_Py_memory_repeat((char *)np->ob_item, sizeof(PyObject *)*output_size,

sizeof(PyObject *)*input_size);

}

_PyObject_GC_TRACK(np);

return (PyObject *) np;

}

static PyObject *

tuple_index_impl(PyTupleObject *self, PyObject *value, Py_ssize_t start,

Py_ssize_t stop)

{

Py_ssize_t i;

if (start < 0) {

start += Py_SIZE(self);

if (start < 0)

start = 0;

}

if (stop < 0) {

stop += Py_SIZE(self);

}

else if (stop > Py_SIZE(self)) {

stop = Py_SIZE(self);

}

for (i = start; i < stop; i++) {

int cmp = PyObject_RichCompareBool(self->ob_item[i], value, Py_EQ);

if (cmp > 0)

return PyLong_FromSsize_t(i);

else if (cmp < 0)

return NULL;

}

PyErr_SetString(PyExc_ValueError, "tuple.index(x): x not in tuple");

return NULL;

}

static PyObject *

tuple_count(PyTupleObject *self, PyObject *value)

{

Py_ssize_t count = 0;

Py_ssize_t i;

for (i = 0; i < Py_SIZE(self); i++) {

int cmp = PyObject_RichCompareBool(self->ob_item[i], value, Py_EQ);

if (cmp > 0)

count++;

else if (cmp < 0)

return NULL;

}

return PyLong_FromSsize_t(count);

}

static int

tupletraverse(PyTupleObject *o, visitproc visit, void *arg)

{

Py_ssize_t i;

for (i = Py_SIZE(o); --i >= 0; )

Py_VISIT(o->ob_item[i]);

return 0;

}

static PyObject *

tuplerichcompare(PyObject *v, PyObject *w, int op)

{

PyTupleObject *vt, *wt;

Py_ssize_t i;

Py_ssize_t vlen, wlen;

if (!PyTuple_Check(v) || !PyTuple_Check(w))

Py_RETURN_NOTIMPLEMENTED;

vt = (PyTupleObject *)v;

wt = (PyTupleObject *)w;

vlen = Py_SIZE(vt);

wlen = Py_SIZE(wt);

/* Note: the corresponding code for lists has an "early out" test

/* Search for the first index where items are different.

for (i = 0; i < vlen && i < wlen; i++) {

int k = PyObject_RichCompareBool(vt->ob_item[i],

wt->ob_item[i], Py_EQ);

if (k < 0)

return NULL;

if (!k)

break;

}

if (i >= vlen || i >= wlen) {

/* No more items to compare -- compare sizes */

Py_RETURN_RICHCOMPARE(vlen, wlen, op);

}

/* We have an item that differs -- shortcuts for EQ/NE */

if (op == Py_EQ) {

Py_RETURN_FALSE;

}

if (op == Py_NE) {

Py_RETURN_TRUE;

}

/* Compare the final item again using the proper operator */

return PyObject_RichCompare(vt->ob_item[i], wt->ob_item[i], op);

}

static PyObject *

tuple_subtype_new(PyTypeObject *type, PyObject *iterable);

static PyObject *

tuple_new_impl(PyTypeObject *type, PyObject *iterable)

{

if (type != &PyTuple_Type)

return tuple_subtype_new(type, iterable);

if (iterable == NULL) {

return tuple_get_empty();

}

else {

return PySequence_Tuple(iterable);

}

}

static PyObject *

tuple_vectorcall(PyObject *type, PyObject * const*args,

size_t nargsf, PyObject *kwnames)

{

if (!_PyArg_NoKwnames("tuple", kwnames)) {

return NULL;

}

Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);

if (!_PyArg_CheckPositional("tuple", nargs, 0, 1)) {

return NULL;

}

if (nargs) {

return tuple_new_impl(_PyType_CAST(type), args[0]);

}

else {

return tuple_get_empty();

}

}

static PyObject *

tuple_subtype_new(PyTypeObject *type, PyObject *iterable)

{

PyObject *tmp, *newobj, *item;

Py_ssize_t i, n;

assert(PyType_IsSubtype(type, &PyTuple_Type));

// tuple subclasses must implement the GC protocol

assert(_PyType_IS_GC(type));

tmp = tuple_new_impl(&PyTuple_Type, iterable);

if (tmp == NULL)

return NULL;

assert(PyTuple_Check(tmp));

/* This may allocate an empty tuple that is not the global one. */

newobj = type->tp_alloc(type, n = PyTuple_GET_SIZE(tmp));

if (newobj == NULL) {

Py_DECREF(tmp);

return NULL;

}

for (i = 0; i < n; i++) {

item = PyTuple_GET_ITEM(tmp, i);

PyTuple_SET_ITEM(newobj, i, Py_NewRef(item));

}

Py_DECREF(tmp);

// Don't track if a subclass tp_alloc is PyType_GenericAlloc()

if (!_PyObject_GC_IS_TRACKED(newobj)) {

_PyObject_GC_TRACK(newobj);

}

return newobj;

}

static PySequenceMethods tuple_as_sequence = {

(lenfunc)tuplelength, /* sq_length */

(binaryfunc)tupleconcat, /* sq_concat */

(ssizeargfunc)tuplerepeat, /* sq_repeat */

(ssizeargfunc)tupleitem, /* sq_item */

0, /* sq_slice */

0, /* sq_ass_item */

0, /* sq_ass_slice */

(objobjproc)tuplecontains, /* sq_contains */

};

static PyObject*

tuplesubscript(PyTupleObject* self, PyObject* item)

{

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);

}

else if (PySlice_Check(item)) {

Py_ssize_t start, stop, step, slicelength, i;

size_t cur;

PyObject* it;

PyObject **src, **dest;

if (PySlice_Unpack(item, &start, &stop, &step) < 0) {

return NULL;

}

slicelength = PySlice_AdjustIndices(PyTuple_GET_SIZE(self), &start,

&stop, step);

if (slicelength <= 0) {

return tuple_get_empty();

}

else if (start == 0 && step == 1 &&

slicelength == PyTuple_GET_SIZE(self) &&

PyTuple_CheckExact(self)) {

return Py_NewRef(self);

}

else {

PyTupleObject* result = tuple_alloc(slicelength);

if (!result) return NULL;

src = self->ob_item;

dest = result->ob_item;

for (cur = start, i = 0; i < slicelength;

cur += step, i++) {

it = Py_NewRef(src[cur]);

dest[i] = it;

}

_PyObject_GC_TRACK(result);

return (PyObject *)result;

}

}

else {

PyErr_Format(PyExc_TypeError,

"tuple indices must be integers or slices, not %.200s",

Py_TYPE(item)->tp_name);

return NULL;

}

}

static PyObject *

tuple___getnewargs___impl(PyTupleObject *self)

{

return Py_BuildValue("(N)", tupleslice(self, 0, Py_SIZE(self)));

}

static PyMethodDef tuple_methods[] = {

TUPLE___GETNEWARGS___METHODDEF

TUPLE_INDEX_METHODDEF

TUPLE_COUNT_METHODDEF

{"__class_getitem__", Py_GenericAlias, METH_O|METH_CLASS, PyDoc_STR("See PEP 585")},

{NULL, NULL} /* sentinel */

};

static PyMappingMethods tuple_as_mapping = {

(lenfunc)tuplelength,

(binaryfunc)tuplesubscript,

0

};

static PyObject *tuple_iter(PyObject *seq);

PyTypeObject PyTuple_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"tuple",

sizeof(PyTupleObject) - sizeof(PyObject *),

sizeof(PyObject *),

(destructor)tupledealloc, /* tp_dealloc */

0, /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

(reprfunc)tuplerepr, /* tp_repr */

0, /* tp_as_number */

&tuple_as_sequence, /* tp_as_sequence */

&tuple_as_mapping, /* tp_as_mapping */

(hashfunc)tuplehash, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

PyObject_GenericGetAttr, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |

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 */

0, /* tp_clear */

tuplerichcompare, /* tp_richcompare */

0, /* tp_weaklistoffset */

tuple_iter, /* tp_iter */

0, /* tp_iternext */

tuple_methods, /* tp_methods */

0, /* tp_members */

0, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

0, /* tp_init */

0, /* tp_alloc */

tuple_new, /* tp_new */

PyObject_GC_Del, /* tp_free */

.tp_vectorcall = tuple_vectorcall,

};

_PyTuple_Resize(PyObject **pv, Py_ssize_t newsize)

{

PyTupleObject *v;

PyTupleObject *sv;

Py_ssize_t i;

Py_ssize_t oldsize;

v = (PyTupleObject *) *pv;

if (v == NULL || !Py_IS_TYPE(v, &PyTuple_Type) ||

(Py_SIZE(v) != 0 && Py_REFCNT(v) != 1)) {

*pv = 0;

Py_XDECREF(v);

PyErr_BadInternalCall();

return -1;

}

oldsize = Py_SIZE(v);

if (oldsize == newsize) {

return 0;

}

if (newsize == 0) {

Py_DECREF(v);

*pv = tuple_get_empty();

return 0;

}

if (oldsize == 0) {

#ifdef Py_DEBUG

assert(v == &_Py_SINGLETON(tuple_empty));

/* The empty tuple is statically allocated so we never

Py_DECREF(v);

*pv = PyTuple_New(newsize);

return *pv == NULL ? -1 : 0;

}

if (_PyObject_GC_IS_TRACKED(v)) {

_PyObject_GC_UNTRACK(v);

}

#ifdef Py_TRACE_REFS

_Py_ForgetReference((PyObject *) v);

/* DECREF items deleted by shrinkage */

for (i = newsize; i < oldsize; i++) {

Py_CLEAR(v->ob_item[i]);

}

sv = PyObject_GC_Resize(PyTupleObject, v, newsize);

if (sv == NULL) {

*pv = NULL;

#ifdef Py_REF_DEBUG

_Py_DecRefTotal(_PyInterpreterState_GET());

PyObject_GC_Del(v);

return -1;

}

_Py_NewReferenceNoTotal((PyObject *) sv);

/* Zero out items added by growing */

if (newsize > oldsize)

memset(&sv->ob_item[oldsize], 0,

sizeof(*sv->ob_item) * (newsize - oldsize));

*pv = (PyObject *) sv;

_PyObject_GC_TRACK(sv);

return 0;

}

static void maybe_freelist_clear(PyInterpreterState *, int);

_PyTuple_Fini(PyInterpreterState *interp)

{

maybe_freelist_clear(interp, 1);

}

_PyTuple_ClearFreeList(PyInterpreterState *interp)

{

maybe_freelist_clear(interp, 0);

}

static void

tupleiter_dealloc(_PyTupleIterObject *it)

{

_PyObject_GC_UNTRACK(it);

Py_XDECREF(it->it_seq);

PyObject_GC_Del(it);

}

static int

tupleiter_traverse(_PyTupleIterObject *it, visitproc visit, void *arg)

{

Py_VISIT(it->it_seq);

return 0;

}

static PyObject *

tupleiter_next(_PyTupleIterObject *it)

{

PyTupleObject *seq;