#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "pycore_call.h" // _PyObject_CallNoArgs()

#include "pycore_long.h" // _PyLong_GetZero()

#include "pycore_moduleobject.h" // _PyModule_GetState()

#include "pycore_typeobject.h" // _PyType_GetModuleState()

#include "pycore_object.h" // _PyObject_GC_TRACK()

#include "pycore_tuple.h" // _PyTuple_ITEMS()

#include "structmember.h" // PyMemberDef

#include <stddef.h> // offsetof()

/* Itertools module written and maintained

by Raymond D. Hettinger <[email protected]>

*/

typedef struct {

PyTypeObject *accumulate_type;

PyTypeObject *batched_type;

PyTypeObject *chain_type;

PyTypeObject *combinations_type;

PyTypeObject *compress_type;

PyTypeObject *count_type;

PyTypeObject *cwr_type;

PyTypeObject *cycle_type;

PyTypeObject *dropwhile_type;

PyTypeObject *filterfalse_type;

PyTypeObject *groupby_type;

PyTypeObject *_grouper_type;

PyTypeObject *islice_type;

PyTypeObject *pairwise_type;

PyTypeObject *permutations_type;

PyTypeObject *product_type;

PyTypeObject *repeat_type;

PyTypeObject *starmap_type;

PyTypeObject *takewhile_type;

PyTypeObject *tee_type;

PyTypeObject *teedataobject_type;

PyTypeObject *ziplongest_type;

} itertools_state;

static inline itertools_state *

get_module_state(PyObject *mod)

{

void *state = _PyModule_GetState(mod);

assert(state != NULL);

return (itertools_state *)state;

}

static inline itertools_state *

get_module_state_by_cls(PyTypeObject *cls)

{

void *state = _PyType_GetModuleState(cls);

assert(state != NULL);

return (itertools_state *)state;

}

static struct PyModuleDef itertoolsmodule;

static inline itertools_state *

find_state_by_type(PyTypeObject *tp)

{

PyObject *mod = PyType_GetModuleByDef(tp, &itertoolsmodule);

assert(mod != NULL);

return get_module_state(mod);

}

/*[clinic input]

module itertools

class itertools.groupby "groupbyobject *" "clinic_state()->groupby_type"

class itertools._grouper "_grouperobject *" "clinic_state()->_grouper_type"

class itertools.teedataobject "teedataobject *" "clinic_state()->teedataobject_type"

class itertools._tee "teeobject *" "clinic_state()->tee_type"

class itertools.batched "batchedobject *" "clinic_state()->batched_type"

class itertools.cycle "cycleobject *" "clinic_state()->cycle_type"

class itertools.dropwhile "dropwhileobject *" "clinic_state()->dropwhile_type"

class itertools.takewhile "takewhileobject *" "clinic_state()->takewhile_type"

class itertools.starmap "starmapobject *" "clinic_state()->starmap_type"

class itertools.chain "chainobject *" "clinic_state()->chain_type"

class itertools.combinations "combinationsobject *" "clinic_state()->combinations_type"

class itertools.combinations_with_replacement "cwr_object *" "clinic_state()->cwr_type"

class itertools.permutations "permutationsobject *" "clinic_state()->permutations_type"

class itertools.accumulate "accumulateobject *" "clinic_state()->accumulate_type"

class itertools.compress "compressobject *" "clinic_state()->compress_type"

class itertools.filterfalse "filterfalseobject *" "clinic_state()->filterfalse_type"

class itertools.count "countobject *" "clinic_state()->count_type"

class itertools.pairwise "pairwiseobject *" "clinic_state()->pairwise_type"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=aa48fe4de9d4080f]*/

#define clinic_state() (find_state_by_type(type))

#define clinic_state_by_cls() (get_module_state_by_cls(base_tp))

#include "clinic/itertoolsmodule.c.h"

#undef clinic_state_by_cls

#undef clinic_state

/* Deprecation of pickle support: GH-101588 *********************************/

#define ITERTOOL_PICKLE_DEPRECATION \

if (PyErr_WarnEx( \

PyExc_DeprecationWarning, \

"Pickle, copy, and deepcopy support will be " \

"removed from itertools in Python 3.14.", 1) < 0) { \

return NULL; \

}

/* batched object ************************************************************/

/* Note: The built-in zip() function includes a "strict" argument

that was needed because that function would silently truncate data,

and there was no easy way for a user to detect the data loss.

The same reasoning does not apply to batched() which never drops data.

Instead, batched() produces a shorter tuple which can be handled

as the user sees fit. If requested, it would be reasonable to add

"fillvalue" support which had demonstrated value in zip_longest().

For now, the API is kept simple and clean.

*/

typedef struct {

PyObject_HEAD

PyObject *it;

Py_ssize_t batch_size;

} batchedobject;

/*[clinic input]

@classmethod

itertools.batched.__new__ as batched_new

iterable: object

n: Py_ssize_t

Batch data into tuples of length n. The last batch may be shorter than n.

Loops over the input iterable and accumulates data into tuples

up to size n. The input is consumed lazily, just enough to

fill a batch. The result is yielded as soon as a batch is full

or when the input iterable is exhausted.

>>> for batch in batched('ABCDEFG', 3):

... print(batch)

...

('A', 'B', 'C')

('D', 'E', 'F')

('G',)

[clinic start generated code]*/

static PyObject *

batched_new_impl(PyTypeObject *type, PyObject *iterable, Py_ssize_t n)

/*[clinic end generated code: output=7ebc954d655371b6 input=ffd70726927c5129]*/

{

PyObject *it;

batchedobject *bo;

if (n < 1) {

/* We could define the n==0 case to return an empty iterator

but that is at odds with the idea that batching should

never throw-away input data.

*/

PyErr_SetString(PyExc_ValueError, "n must be at least one");

return NULL;

}

it = PyObject_GetIter(iterable);

if (it == NULL) {

return NULL;

}

/* create batchedobject structure */

bo = (batchedobject *)type->tp_alloc(type, 0);

if (bo == NULL) {

Py_DECREF(it);

return NULL;

}

bo->batch_size = n;

bo->it = it;

return (PyObject *)bo;

}

static void

batched_dealloc(batchedobject *bo)

{

PyTypeObject *tp = Py_TYPE(bo);

PyObject_GC_UnTrack(bo);

Py_XDECREF(bo->it);

tp->tp_free(bo);

Py_DECREF(tp);

}

static int

batched_traverse(batchedobject *bo, visitproc visit, void *arg)

{

Py_VISIT(Py_TYPE(bo));

Py_VISIT(bo->it);

return 0;

}

static PyObject *

batched_next(batchedobject *bo)

{

Py_ssize_t i;

Py_ssize_t n = bo->batch_size;

PyObject *it = bo->it;

PyObject *item;

PyObject *result;

if (it == NULL) {

return NULL;

}

result = PyTuple_New(n);

if (result == NULL) {

return NULL;

}

iternextfunc iternext = *Py_TYPE(it)->tp_iternext;

PyObject **items = _PyTuple_ITEMS(result);

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

item = iternext(it);

if (item == NULL) {

goto null_item;

}

items[i] = item;

}

return result;

null_item:

if (PyErr_Occurred()) {

if (!PyErr_ExceptionMatches(PyExc_StopIteration)) {

/* Input raised an exception other than StopIteration */

Py_CLEAR(bo->it);

Py_DECREF(result);

return NULL;

}

PyErr_Clear();

}

if (i == 0) {

Py_CLEAR(bo->it);

Py_DECREF(result);

return NULL;

}

_PyTuple_Resize(&result, i);

return result;

}

static PyType_Slot batched_slots[] = {

{Py_tp_dealloc, batched_dealloc},

{Py_tp_getattro, PyObject_GenericGetAttr},

{Py_tp_doc, (void *)batched_new__doc__},

{Py_tp_traverse, batched_traverse},

{Py_tp_iter, PyObject_SelfIter},

{Py_tp_iternext, batched_next},

{Py_tp_alloc, PyType_GenericAlloc},

{Py_tp_new, batched_new},

{Py_tp_free, PyObject_GC_Del},

{0, NULL},

};

static PyType_Spec batched_spec = {

.name = "itertools.batched",

.basicsize = sizeof(batchedobject),

.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE |

Py_TPFLAGS_IMMUTABLETYPE),

.slots = batched_slots,

};

/* pairwise object ***********************************************************/

typedef struct {

PyObject_HEAD

PyObject *it;

PyObject *old;

} pairwiseobject;

/*[clinic input]

@classmethod

itertools.pairwise.__new__ as pairwise_new

iterable: object

/

Return an iterator of overlapping pairs taken from the input iterator.

s -> (s0,s1), (s1,s2), (s2, s3), ...

[clinic start generated code]*/

static PyObject *

pairwise_new_impl(PyTypeObject *type, PyObject *iterable)

/*[clinic end generated code: output=9f0267062d384456 input=6e7c3cddb431a8d6]*/

{

PyObject *it;

pairwiseobject *po;

it = PyObject_GetIter(iterable);

if (it == NULL) {

return NULL;

}

po = (pairwiseobject *)type->tp_alloc(type, 0);

if (po == NULL) {

Py_DECREF(it);

return NULL;

}

po->it = it;

po->old = NULL;

return (PyObject *)po;

}

static void

pairwise_dealloc(pairwiseobject *po)

{

PyTypeObject *tp = Py_TYPE(po);

PyObject_GC_UnTrack(po);

Py_XDECREF(po->it);

Py_XDECREF(po->old);

tp->tp_free(po);

Py_DECREF(tp);

}

static int

pairwise_traverse(pairwiseobject *po, visitproc visit, void *arg)

{

Py_VISIT(Py_TYPE(po));

Py_VISIT(po->it);

Py_VISIT(po->old);

return 0;

}

static PyObject *

pairwise_next(pairwiseobject *po)

{

PyObject *it = po->it;

PyObject *old = po->old;

PyObject *new, *result;

if (it == NULL) {

return NULL;

}

if (old == NULL) {

po->old = old = (*Py_TYPE(it)->tp_iternext)(it);

if (old == NULL) {

Py_CLEAR(po->it);

return NULL;

}

}

new = (*Py_TYPE(it)->tp_iternext)(it);

if (new == NULL) {

Py_CLEAR(po->it);

Py_CLEAR(po->old);

return NULL;

}

/* Future optimization: Reuse the result tuple as we do in enumerate() */

result = PyTuple_Pack(2, old, new);

Py_SETREF(po->old, new);

return result;

}

static PyType_Slot pairwise_slots[] = {

{Py_tp_dealloc, pairwise_dealloc},

{Py_tp_getattro, PyObject_GenericGetAttr},

{Py_tp_doc, (void *)pairwise_new__doc__},

{Py_tp_traverse, pairwise_traverse},

{Py_tp_iter, PyObject_SelfIter},

{Py_tp_iternext, pairwise_next},

{Py_tp_alloc, PyType_GenericAlloc},

{Py_tp_new, pairwise_new},

{Py_tp_free, PyObject_GC_Del},

{0, NULL},

};

static PyType_Spec pairwise_spec = {

.name = "itertools.pairwise",

.basicsize = sizeof(pairwiseobject),

.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE |

Py_TPFLAGS_IMMUTABLETYPE),

.slots = pairwise_slots,

};

/* groupby object ************************************************************/

typedef struct {

PyObject_HEAD

PyObject *it;

PyObject *keyfunc;

PyObject *tgtkey;

PyObject *currkey;

PyObject *currvalue;

const void *currgrouper; /* borrowed reference */

itertools_state *state;

} groupbyobject;

static PyObject *_grouper_create(groupbyobject *, PyObject *);

/*[clinic input]

@classmethod

itertools.groupby.__new__

iterable as it: object

Elements to divide into groups according to the key function.

key as keyfunc: object = None

A function for computing the group category for each element.

If the key function is not specified or is None, the element itself

is used for grouping.

make an iterator that returns consecutive keys and groups from the iterable

[clinic start generated code]*/

static PyObject *

itertools_groupby_impl(PyTypeObject *type, PyObject *it, PyObject *keyfunc)

/*[clinic end generated code: output=cbb1ae3a90fd4141 input=6b3d123e87ff65a1]*/

{

groupbyobject *gbo;

gbo = (groupbyobject *)type->tp_alloc(type, 0);

if (gbo == NULL)

return NULL;

gbo->tgtkey = NULL;

gbo->currkey = NULL;

gbo->currvalue = NULL;

gbo->keyfunc = Py_NewRef(keyfunc);

gbo->it = PyObject_GetIter(it);

if (gbo->it == NULL) {

Py_DECREF(gbo);

return NULL;

}

gbo->state = find_state_by_type(type);

return (PyObject *)gbo;

}

static void

groupby_dealloc(groupbyobject *gbo)

{

PyTypeObject *tp = Py_TYPE(gbo);

PyObject_GC_UnTrack(gbo);

Py_XDECREF(gbo->it);

Py_XDECREF(gbo->keyfunc);

Py_XDECREF(gbo->tgtkey);

Py_XDECREF(gbo->currkey);

Py_XDECREF(gbo->currvalue);

tp->tp_free(gbo);

Py_DECREF(tp);

}

static int

groupby_traverse(groupbyobject *gbo, visitproc visit, void *arg)

{

Py_VISIT(Py_TYPE(gbo));

Py_VISIT(gbo->it);

Py_VISIT(gbo->keyfunc);

Py_VISIT(gbo->tgtkey);

Py_VISIT(gbo->currkey);

Py_VISIT(gbo->currvalue);

return 0;

}

Py_LOCAL_INLINE(int)

groupby_step(groupbyobject *gbo)

{

PyObject *newvalue, *newkey, *oldvalue;

newvalue = PyIter_Next(gbo->it);

if (newvalue == NULL)

return -1;

if (gbo->keyfunc == Py_None) {

newkey = Py_NewRef(newvalue);

} else {

newkey = PyObject_CallOneArg(gbo->keyfunc, newvalue);

if (newkey == NULL) {

Py_DECREF(newvalue);

return -1;

}

}

oldvalue = gbo->currvalue;

gbo->currvalue = newvalue;

Py_XSETREF(gbo->currkey, newkey);

Py_XDECREF(oldvalue);

return 0;

}

static PyObject *

groupby_next(groupbyobject *gbo)

{

PyObject *r, *grouper;

gbo->currgrouper = NULL;

/* skip to next iteration group */

for (;;) {

if (gbo->currkey == NULL)

/* pass */;

else if (gbo->tgtkey == NULL)

break;

else {

int rcmp;

rcmp = PyObject_RichCompareBool(gbo->tgtkey, gbo->currkey, Py_EQ);

if (rcmp == -1)

return NULL;

else if (rcmp == 0)

break;

}

if (groupby_step(gbo) < 0)

return NULL;

}

Py_INCREF(gbo->currkey);

Py_XSETREF(gbo->tgtkey, gbo->currkey);

grouper = _grouper_create(gbo, gbo->tgtkey);

if (grouper == NULL)

return NULL;

r = PyTuple_Pack(2, gbo->currkey, grouper);

Py_DECREF(grouper);

return r;

}

static PyObject *

groupby_reduce(groupbyobject *lz, PyObject *Py_UNUSED(ignored))

{

/* reduce as a 'new' call with an optional 'setstate' if groupby

* has started

*/

ITERTOOL_PICKLE_DEPRECATION;

PyObject *value;

if (lz->tgtkey && lz->currkey && lz->currvalue)

value = Py_BuildValue("O(OO)(OOO)", Py_TYPE(lz),

lz->it, lz->keyfunc, lz->currkey, lz->currvalue, lz->tgtkey);

else

value = Py_BuildValue("O(OO)", Py_TYPE(lz),

lz->it, lz->keyfunc);

return value;

}

PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");

static PyObject *

groupby_setstate(groupbyobject *lz, PyObject *state)

{

ITERTOOL_PICKLE_DEPRECATION;

PyObject *currkey, *currvalue, *tgtkey;

if (!PyTuple_Check(state)) {

PyErr_SetString(PyExc_TypeError, "state is not a tuple");

return NULL;

}

if (!PyArg_ParseTuple(state, "OOO", &currkey, &currvalue, &tgtkey)) {

return NULL;

}

Py_INCREF(currkey);

Py_XSETREF(lz->currkey, currkey);

Py_INCREF(currvalue);

Py_XSETREF(lz->currvalue, currvalue);

Py_INCREF(tgtkey);

Py_XSETREF(lz->tgtkey, tgtkey);

Py_RETURN_NONE;

}

PyDoc_STRVAR(setstate_doc, "Set state information for unpickling.");

static PyMethodDef groupby_methods[] = {

{"__reduce__", (PyCFunction)groupby_reduce, METH_NOARGS,

reduce_doc},

{"__setstate__", (PyCFunction)groupby_setstate, METH_O,

setstate_doc},

{NULL, NULL} /* sentinel */

};

static PyType_Slot groupby_slots[] = {

{Py_tp_dealloc, groupby_dealloc},

{Py_tp_getattro, PyObject_GenericGetAttr},

{Py_tp_doc, (void *)itertools_groupby__doc__},

{Py_tp_traverse, groupby_traverse},

{Py_tp_iter, PyObject_SelfIter},

{Py_tp_iternext, groupby_next},

{Py_tp_methods, groupby_methods},

{Py_tp_new, itertools_groupby},

{Py_tp_free, PyObject_GC_Del},

{0, NULL},

};

static PyType_Spec groupby_spec = {

.name = "itertools.groupby",

.basicsize= sizeof(groupbyobject),

.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE |

Py_TPFLAGS_IMMUTABLETYPE),

.slots = groupby_slots,

};

/* _grouper object (internal) ************************************************/

typedef struct {

PyObject_HEAD

PyObject *parent;

PyObject *tgtkey;

} _grouperobject;

/*[clinic input]

@classmethod

itertools._grouper.__new__

parent: object(subclass_of='clinic_state_by_cls()->groupby_type')

tgtkey: object

/

[clinic start generated code]*/

static PyObject *

itertools__grouper_impl(PyTypeObject *type, PyObject *parent,

PyObject *tgtkey)

/*[clinic end generated code: output=462efb1cdebb5914 input=afe05eb477118f12]*/

{

return _grouper_create((groupbyobject*) parent, tgtkey);

}

static PyObject *

_grouper_create(groupbyobject *parent, PyObject *tgtkey)

{

itertools_state *state = parent->state;

_grouperobject *igo = PyObject_GC_New(_grouperobject, state->_grouper_type);

if (igo == NULL)

return NULL;

igo->parent = Py_NewRef(parent);

igo->tgtkey = Py_NewRef(tgtkey);

parent->currgrouper = igo; /* borrowed reference */

PyObject_GC_Track(igo);

return (PyObject *)igo;

}

static void

_grouper_dealloc(_grouperobject *igo)

{

PyTypeObject *tp = Py_TYPE(igo);

PyObject_GC_UnTrack(igo);

Py_DECREF(igo->parent);

Py_DECREF(igo->tgtkey);

PyObject_GC_Del(igo);

Py_DECREF(tp);

}

static int

_grouper_traverse(_grouperobject *igo, visitproc visit, void *arg)

{

Py_VISIT(Py_TYPE(igo));

Py_VISIT(igo->parent);

Py_VISIT(igo->tgtkey);

return 0;

}

static PyObject *

_grouper_next(_grouperobject *igo)

{

groupbyobject *gbo = (groupbyobject *)igo->parent;

PyObject *r;

int rcmp;

if (gbo->currgrouper != igo)

return NULL;

if (gbo->currvalue == NULL) {

if (groupby_step(gbo) < 0)

return NULL;

}

assert(gbo->currkey != NULL);

rcmp = PyObject_RichCompareBool(igo->tgtkey, gbo->currkey, Py_EQ);

if (rcmp <= 0)

/* got any error or current group is end */

return NULL;

r = gbo->currvalue;

gbo->currvalue = NULL;

Py_CLEAR(gbo->currkey);

return r;

}

static PyObject *

_grouper_reduce(_grouperobject *lz, PyObject *Py_UNUSED(ignored))

{

ITERTOOL_PICKLE_DEPRECATION;

if (((groupbyobject *)lz->parent)->currgrouper != lz) {

return Py_BuildValue("N(())", _PyEval_GetBuiltin(&_Py_ID(iter)));

}

return Py_BuildValue("O(OO)", Py_TYPE(lz), lz->parent, lz->tgtkey);

}

static PyMethodDef _grouper_methods[] = {

{"__reduce__", (PyCFunction)_grouper_reduce, METH_NOARGS,

reduce_doc},

{NULL, NULL} /* sentinel */

};

static PyType_Slot _grouper_slots[] = {

{Py_tp_dealloc, _grouper_dealloc},

{Py_tp_getattro, PyObject_GenericGetAttr},

{Py_tp_traverse, _grouper_traverse},

{Py_tp_iter, PyObject_SelfIter},

{Py_tp_iternext, _grouper_next},

{Py_tp_methods, _grouper_methods},

{Py_tp_new, itertools__grouper},

{Py_tp_free, PyObject_GC_Del},

{0, NULL},

};

static PyType_Spec _grouper_spec = {

.name = "itertools._grouper",

.basicsize = sizeof(_grouperobject),

.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |

Py_TPFLAGS_IMMUTABLETYPE),

.slots = _grouper_slots,

};

/* tee object and with supporting function and objects ***********************/

/* The teedataobject pre-allocates space for LINKCELLS number of objects.

To help the object fit neatly inside cache lines (space for 16 to 32

pointers), the value should be a multiple of 16 minus space for

the other structure members including PyHEAD overhead. The larger the

value, the less memory overhead per object and the less time spent

allocating/deallocating new links. The smaller the number, the less

wasted space and the more rapid freeing of older data.

*/

#define LINKCELLS 57

typedef struct {

PyObject_HEAD

PyObject *it;

int numread; /* 0 <= numread <= LINKCELLS */

int running;

PyObject *nextlink;

PyObject *(values[LINKCELLS]);

} teedataobject;

typedef struct {

PyObject_HEAD

teedataobject *dataobj;

int index; /* 0 <= index <= LINKCELLS */

PyObject *weakreflist;

itertools_state *state;

} teeobject;

static PyObject *

teedataobject_newinternal(itertools_state *state, PyObject *it)

{

teedataobject *tdo;

tdo = PyObject_GC_New(teedataobject, state->teedataobject_type);

if (tdo == NULL)

return NULL;

tdo->running = 0;

tdo->numread = 0;

tdo->nextlink = NULL;

tdo->it = Py_NewRef(it);

PyObject_GC_Track(tdo);

return (PyObject *)tdo;

}

static PyObject *

teedataobject_jumplink(itertools_state *state, teedataobject *tdo)

{

if (tdo->nextlink == NULL)

tdo->nextlink = teedataobject_newinternal(state, tdo->it);

return Py_XNewRef(tdo->nextlink);

}

static PyObject *

teedataobject_getitem(teedataobject *tdo, int i)

{

PyObject *value;

assert(i < LINKCELLS);

if (i < tdo->numread)

value = tdo->values[i];

else {

/* this is the lead iterator, so fetch more data */

assert(i == tdo->numread);

if (tdo->running) {

PyErr_SetString(PyExc_RuntimeError,

"cannot re-enter the tee iterator");

return NULL;

}

tdo->running = 1;

value = PyIter_Next(tdo->it);

tdo->running = 0;

if (value == NULL)

return NULL;

tdo->numread++;

tdo->values[i] = value;

}

return Py_NewRef(value);

}

static int

teedataobject_traverse(teedataobject *tdo, visitproc visit, void * arg)

{

int i;

Py_VISIT(Py_TYPE(tdo));

Py_VISIT(tdo->it);

for (i = 0; i < tdo->numread; i++)

Py_VISIT(tdo->values[i]);

Py_VISIT(tdo->nextlink);

return 0;

}

static void

teedataobject_safe_decref(PyObject *obj, PyTypeObject *tdo_type)

{

while (obj && Py_IS_TYPE(obj, tdo_type) &&

Py_REFCNT(obj) == 1) {

PyObject *nextlink = ((teedataobject *)obj)->nextlink;

((teedataobject *)obj)->nextlink = NULL;

Py_SETREF(obj, nextlink);

}

Py_XDECREF(obj);

}

static int

teedataobject_clear(teedataobject *tdo)

{

int i;

PyObject *tmp;

Py_CLEAR(tdo->it);

for (i=0 ; i<tdo->numread ; i++)

Py_CLEAR(tdo->values[i]);

tmp = tdo->nextlink;

tdo->nextlink = NULL;

itertools_state *state = get_module_state_by_cls(Py_TYPE(tdo));

teedataobject_safe_decref(tmp, state->teedataobject_type);

return 0;

}

static void

teedataobject_dealloc(teedataobject *tdo)

{

PyTypeObject *tp = Py_TYPE(tdo);

PyObject_GC_UnTrack(tdo);

teedataobject_clear(tdo);

PyObject_GC_Del(tdo);

Py_DECREF(tp);

}

static PyObject *

teedataobject_reduce(teedataobject *tdo, PyObject *Py_UNUSED(ignored))

{

ITERTOOL_PICKLE_DEPRECATION;

int i;

/* create a temporary list of already iterated values */

PyObject *values = PyList_New(tdo->numread);

if (!values)

return NULL;

for (i=0 ; i<tdo->numread ; i++) {

Py_INCREF(tdo->values[i]);

PyList_SET_ITEM(values, i, tdo->values[i]);

}

return Py_BuildValue("O(ONO)", Py_TYPE(tdo), tdo->it,

values,

tdo->nextlink ? tdo->nextlink : Py_None);

}

/*[clinic input]

@classmethod

itertools.teedataobject.__new__

iterable as it: object

values: object(subclass_of='&PyList_Type')

next: object

/

Data container common to multiple tee objects.

[clinic start generated code]*/

static PyObject *

itertools_teedataobject_impl(PyTypeObject *type, PyObject *it,

PyObject *values, PyObject *next)

/*[clinic end generated code: output=3343ceb07e08df5e input=be60f2fabd2b72ba]*/

{

teedataobject *tdo;

Py_ssize_t i, len;

itertools_state *state = get_module_state_by_cls(type);

assert(type == state->teedataobject_type);

tdo = (teedataobject *)teedataobject_newinternal(state, it);

if (!tdo)

return NULL;

len = PyList_GET_SIZE(values);

if (len > LINKCELLS)

goto err;

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

tdo->values[i] = PyList_GET_ITEM(values, i);

Py_INCREF(tdo->values[i]);

}

/* len <= LINKCELLS < INT_MAX */

tdo->numread = Py_SAFE_DOWNCAST(len, Py_ssize_t, int);

if (len == LINKCELLS) {

if (next != Py_None) {

if (!Py_IS_TYPE(next, state->teedataobject_type))

goto err;

assert(tdo->nextlink == NULL);

tdo->nextlink = Py_NewRef(next);

}

} else {

if (next != Py_None)

goto err; /* shouldn't have a next if we are not full */

}

return (PyObject*)tdo;

err:

Py_XDECREF(tdo);

PyErr_SetString(PyExc_ValueError, "Invalid arguments");

return NULL;

}

static PyMethodDef teedataobject_methods[] = {

{"__reduce__", (PyCFunction)teedataobject_reduce, METH_NOARGS,

reduce_doc},

{NULL, NULL} /* sentinel */

};

static PyType_Slot teedataobject_slots[] = {

{Py_tp_dealloc, teedataobject_dealloc},

{Py_tp_getattro, PyObject_GenericGetAttr},

{Py_tp_doc, (void *)itertools_teedataobject__doc__},

{Py_tp_traverse, teedataobject_traverse},

{Py_tp_clear, teedataobject_clear},

{Py_tp_methods, teedataobject_methods},

{Py_tp_new, itertools_teedataobject},

{Py_tp_free, PyObject_GC_Del},

{0, NULL},

};

static PyType_Spec teedataobject_spec = {

.name = "itertools._tee_dataobject",

.basicsize = sizeof(teedataobject),

.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |

Py_TPFLAGS_IMMUTABLETYPE),

.slots = teedataobject_slots,

};

static PyObject *

tee_next(teeobject *to)

{

PyObject *value, *link;

if (to->index >= LINKCELLS) {

link = teedataobject_jumplink(to->state, to->dataobj);

if (link == NULL)

return NULL;

Py_SETREF(to->dataobj, (teedataobject *)link);

to->index = 0;

}

value = teedataobject_getitem(to->dataobj, to->index);

if (value == NULL)

return NULL;

to->index++;

return value;

}

static int

tee_traverse(teeobject *to, visitproc visit, void *arg)

{

Py_VISIT(Py_TYPE(to));

Py_VISIT((PyObject *)to->dataobj);

return 0;

}

static PyObject *

tee_copy(teeobject *to, PyObject *Py_UNUSED(ignored))

{

teeobject *newto;

newto = PyObject_GC_New(teeobject, Py_TYPE(to));

if (newto == NULL)

return NULL;

newto->dataobj = (teedataobject*)Py_NewRef(to->dataobj);

newto->index = to->index;

newto->weakreflist = NULL;

newto->state = to->state;

PyObject_GC_Track(newto);

return (PyObject *)newto;

}

PyDoc_STRVAR(teecopy_doc, "Returns an independent iterator.");

static PyObject *

tee_fromiterable(itertools_state *state, PyObject *iterable)

{

teeobject *to;

PyObject *it;

it = PyObject_GetIter(iterable);

if (it == NULL)

return NULL;

if (PyObject_TypeCheck(it, state->tee_type)) {

to = (teeobject *)tee_copy((teeobject *)it, NULL);

goto done;

}

PyObject *dataobj = teedataobject_newinternal(state, it);