#include "Python.h"

#include "structmember.h"

/* Itertools module written and maintained

by Raymond D. Hettinger <python@rcn.com>

*/

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

typedef struct {

PyObject_HEAD

PyObject *it;

PyObject *keyfunc;

PyObject *tgtkey;

PyObject *currkey;

PyObject *currvalue;

} groupbyobject;

static PyTypeObject groupby_type;

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

static PyObject *

groupby_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

static char *kwargs[] = {"iterable", "key", NULL};

groupbyobject *gbo;

PyObject *it, *keyfunc = Py_None;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:groupby", kwargs,

&it, &keyfunc))

return NULL;

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

if (gbo == NULL)

return NULL;

gbo->tgtkey = NULL;

gbo->currkey = NULL;

gbo->currvalue = NULL;

gbo->keyfunc = keyfunc;

Py_INCREF(keyfunc);

gbo->it = PyObject_GetIter(it);

if (gbo->it == NULL) {

Py_DECREF(gbo);

return NULL;

}

return (PyObject *)gbo;

}

static void

groupby_dealloc(groupbyobject *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);

Py_TYPE(gbo)->tp_free(gbo);

}

static int

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

{

Py_VISIT(gbo->it);

Py_VISIT(gbo->keyfunc);

Py_VISIT(gbo->tgtkey);

Py_VISIT(gbo->currkey);

Py_VISIT(gbo->currvalue);

return 0;

}

static PyObject *

groupby_next(groupbyobject *gbo)

{

PyObject *newvalue, *newkey, *r, *grouper, *tmp;

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

}

newvalue = PyIter_Next(gbo->it);

if (newvalue == NULL)

return NULL;

if (gbo->keyfunc == Py_None) {

newkey = newvalue;

Py_INCREF(newvalue);

} else {

newkey = PyObject_CallFunctionObjArgs(gbo->keyfunc,

newvalue, NULL);

if (newkey == NULL) {

Py_DECREF(newvalue);

return NULL;

}

}

tmp = gbo->currkey;

gbo->currkey = newkey;

Py_XDECREF(tmp);

tmp = gbo->currvalue;

gbo->currvalue = newvalue;

Py_XDECREF(tmp);

}

Py_INCREF(gbo->currkey);

tmp = gbo->tgtkey;

gbo->tgtkey = gbo->currkey;

Py_XDECREF(tmp);

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

if (grouper == NULL)

return NULL;

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

Py_DECREF(grouper);

return r;

}

PyDoc_STRVAR(groupby_doc,

"groupby(iterable[, keyfunc]) -> create an iterator which returns\n\

(key, sub-iterator) grouped by each value of key(value).\n");

static PyTypeObject groupby_type = {

PyVarObject_HEAD_INIT(NULL, 0)

"itertools.groupby", /* tp_name */

sizeof(groupbyobject), /* tp_basicsize */

0, /* tp_itemsize */

/* methods */

(destructor)groupby_dealloc, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_compare */

0, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* 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, /* tp_flags */

groupby_doc, /* tp_doc */

(traverseproc)groupby_traverse, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

PyObject_SelfIter, /* tp_iter */

(iternextfunc)groupby_next, /* tp_iternext */

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

groupby_new, /* tp_new */

PyObject_GC_Del, /* tp_free */

};

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

typedef struct {

PyObject_HEAD

PyObject *parent;

PyObject *tgtkey;

} _grouperobject;

static PyTypeObject _grouper_type;

static PyObject *

_grouper_create(groupbyobject *parent, PyObject *tgtkey)

{

_grouperobject *igo;

igo = PyObject_GC_New(_grouperobject, &_grouper_type);

if (igo == NULL)

return NULL;

igo->parent = (PyObject *)parent;

Py_INCREF(parent);

igo->tgtkey = tgtkey;

Py_INCREF(tgtkey);

PyObject_GC_Track(igo);

return (PyObject *)igo;

}

static void

_grouper_dealloc(_grouperobject *igo)

{

PyObject_GC_UnTrack(igo);

Py_DECREF(igo->parent);

Py_DECREF(igo->tgtkey);

PyObject_GC_Del(igo);

}

static int

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

{

Py_VISIT(igo->parent);

Py_VISIT(igo->tgtkey);

return 0;

}

static PyObject *

_grouper_next(_grouperobject *igo)

{

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

PyObject *newvalue, *newkey, *r;

int rcmp;

if (gbo->currvalue == NULL) {

newvalue = PyIter_Next(gbo->it);

if (newvalue == NULL)

return NULL;

if (gbo->keyfunc == Py_None) {

newkey = newvalue;

Py_INCREF(newvalue);

} else {

newkey = PyObject_CallFunctionObjArgs(gbo->keyfunc,

newvalue, NULL);

if (newkey == NULL) {

Py_DECREF(newvalue);

return NULL;

}

}

assert(gbo->currkey == NULL);

gbo->currkey = newkey;

gbo->currvalue = newvalue;

}

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 PyTypeObject _grouper_type = {

PyVarObject_HEAD_INIT(NULL, 0)

"itertools._grouper", /* tp_name */

sizeof(_grouperobject), /* tp_basicsize */

0, /* tp_itemsize */

/* methods */

(destructor)_grouper_dealloc, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_compare */

0, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* 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, /* tp_flags */

0, /* tp_doc */

(traverseproc)_grouper_traverse,/* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

PyObject_SelfIter, /* tp_iter */

(iternextfunc)_grouper_next, /* tp_iternext */

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

0, /* tp_new */

PyObject_GC_Del, /* tp_free */

};

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

PyObject *nextlink;

PyObject *(values[LINKCELLS]);

} teedataobject;

typedef struct {

PyObject_HEAD

teedataobject *dataobj;

int index;

PyObject *weakreflist;

} teeobject;

static PyTypeObject teedataobject_type;

static PyObject *

teedataobject_new(PyObject *it)

{

teedataobject *tdo;

tdo = PyObject_GC_New(teedataobject, &teedataobject_type);

if (tdo == NULL)

return NULL;

tdo->numread = 0;

tdo->nextlink = NULL;

Py_INCREF(it);

tdo->it = it;

PyObject_GC_Track(tdo);

return (PyObject *)tdo;

}

static PyObject *

teedataobject_jumplink(teedataobject *tdo)

{

if (tdo->nextlink == NULL)

tdo->nextlink = teedataobject_new(tdo->it);

Py_XINCREF(tdo->nextlink);

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

value = PyIter_Next(tdo->it);

if (value == NULL)

return NULL;

tdo->numread++;

tdo->values[i] = value;

}

Py_INCREF(value);

return value;

}

static int

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

{

int i;

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)

{

while (obj && Py_TYPE(obj) == &teedataobject_type &&

Py_REFCNT(obj) == 1) {

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

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

Py_DECREF(obj);

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;

teedataobject_safe_decref(tmp);

return 0;

}

static void

teedataobject_dealloc(teedataobject *tdo)

{

PyObject_GC_UnTrack(tdo);

teedataobject_clear(tdo);

PyObject_GC_Del(tdo);

}

PyDoc_STRVAR(teedataobject_doc, "Data container common to multiple tee objects.");

static PyTypeObject teedataobject_type = {

PyVarObject_HEAD_INIT(0, 0) /* Must fill in type value later */

"itertools.tee_dataobject", /* tp_name */

sizeof(teedataobject), /* tp_basicsize */

0, /* tp_itemsize */

/* methods */

(destructor)teedataobject_dealloc, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_compare */

0, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* 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, /* tp_flags */

teedataobject_doc, /* tp_doc */

(traverseproc)teedataobject_traverse, /* tp_traverse */

(inquiry)teedataobject_clear, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

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

0, /* tp_new */

PyObject_GC_Del, /* tp_free */

};

static PyTypeObject tee_type;

static PyObject *

tee_next(teeobject *to)

{

PyObject *value, *link;

if (to->index >= LINKCELLS) {

link = teedataobject_jumplink(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((PyObject *)to->dataobj);

return 0;

}

static PyObject *

tee_copy(teeobject *to)

{

teeobject *newto;

newto = PyObject_GC_New(teeobject, &tee_type);

if (newto == NULL)

return NULL;

Py_INCREF(to->dataobj);

newto->dataobj = to->dataobj;

newto->index = to->index;

newto->weakreflist = NULL;

PyObject_GC_Track(newto);

return (PyObject *)newto;

}

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

static PyObject *

tee_fromiterable(PyObject *iterable)

{

teeobject *to;

PyObject *it = NULL;

it = PyObject_GetIter(iterable);

if (it == NULL)

return NULL;

if (PyObject_TypeCheck(it, &tee_type)) {

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

goto done;

}

to = PyObject_GC_New(teeobject, &tee_type);

if (to == NULL)

goto done;

to->dataobj = (teedataobject *)teedataobject_new(it);

if (!to->dataobj) {

PyObject_GC_Del(to);

to = NULL;

goto done;

}

to->index = 0;

to->weakreflist = NULL;

PyObject_GC_Track(to);

done:

Py_XDECREF(it);

return (PyObject *)to;

}

static PyObject *

tee_new(PyTypeObject *type, PyObject *args, PyObject *kw)

{

PyObject *iterable;

if (!PyArg_UnpackTuple(args, "tee", 1, 1, &iterable))

return NULL;

return tee_fromiterable(iterable);

}

static int

tee_clear(teeobject *to)

{

if (to->weakreflist != NULL)

PyObject_ClearWeakRefs((PyObject *) to);

Py_CLEAR(to->dataobj);

return 0;

}

static void

tee_dealloc(teeobject *to)

{

PyObject_GC_UnTrack(to);

tee_clear(to);

PyObject_GC_Del(to);

}

PyDoc_STRVAR(teeobject_doc,

"Iterator wrapped to make it copyable");

static PyMethodDef tee_methods[] = {

{"__copy__", (PyCFunction)tee_copy, METH_NOARGS, teecopy_doc},

{NULL, NULL} /* sentinel */

};

static PyTypeObject tee_type = {

PyVarObject_HEAD_INIT(NULL, 0)

"itertools.tee", /* tp_name */

sizeof(teeobject), /* tp_basicsize */

0, /* tp_itemsize */

/* methods */

(destructor)tee_dealloc, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_compare */

0, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

0, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */

teeobject_doc, /* tp_doc */

(traverseproc)tee_traverse, /* tp_traverse */

(inquiry)tee_clear, /* tp_clear */

0, /* tp_richcompare */

offsetof(teeobject, weakreflist), /* tp_weaklistoffset */

PyObject_SelfIter, /* tp_iter */

(iternextfunc)tee_next, /* tp_iternext */

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

tee_new, /* tp_new */

PyObject_GC_Del, /* tp_free */

};

static PyObject *

tee(PyObject *self, PyObject *args)

{

Py_ssize_t i, n=2;

PyObject *it, *iterable, *copyable, *result;

if (!PyArg_ParseTuple(args, "O|n", &iterable, &n))

return NULL;

if (n < 0) {

PyErr_SetString(PyExc_ValueError, "n must be >= 0");

return NULL;

}

result = PyTuple_New(n);

if (result == NULL)

return NULL;

if (n == 0)

return result;

it = PyObject_GetIter(iterable);

if (it == NULL) {

Py_DECREF(result);

return NULL;

}

if (!PyObject_HasAttrString(it, "__copy__")) {

copyable = tee_fromiterable(it);

Py_DECREF(it);

if (copyable == NULL) {

Py_DECREF(result);

return NULL;

}

} else

copyable = it;

PyTuple_SET_ITEM(result, 0, copyable);

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

copyable = PyObject_CallMethod(copyable, "__copy__", NULL);

if (copyable == NULL) {

Py_DECREF(result);

return NULL;

}

PyTuple_SET_ITEM(result, i, copyable);

}

return result;

}

PyDoc_STRVAR(tee_doc,

"tee(iterable, n=2) --> tuple of n independent iterators.");

/* cycle object **********************************************************/

typedef struct {

PyObject_HEAD

PyObject *it;

PyObject *saved;

int firstpass;

} cycleobject;

static PyTypeObject cycle_type;

static PyObject *

cycle_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

PyObject *it;

PyObject *iterable;

PyObject *saved;

cycleobject *lz;

if (type == &cycle_type && !_PyArg_NoKeywords("cycle()", kwds))

return NULL;

if (!PyArg_UnpackTuple(args, "cycle", 1, 1, &iterable))

return NULL;

/* Get iterator. */

it = PyObject_GetIter(iterable);

if (it == NULL)

return NULL;

saved = PyList_New(0);

if (saved == NULL) {

Py_DECREF(it);

return NULL;

}

/* create cycleobject structure */

lz = (cycleobject *)type->tp_alloc(type, 0);

if (lz == NULL) {

Py_DECREF(it);

Py_DECREF(saved);

return NULL;

}

lz->it = it;

lz->saved = saved;

lz->firstpass = 0;

return (PyObject *)lz;

}

static void

cycle_dealloc(cycleobject *lz)

{

PyObject_GC_UnTrack(lz);

Py_XDECREF(lz->saved);

Py_XDECREF(lz->it);

Py_TYPE(lz)->tp_free(lz);

}

static int

cycle_traverse(cycleobject *lz, visitproc visit, void *arg)

{

Py_VISIT(lz->it);

Py_VISIT(lz->saved);

return 0;

}

static PyObject *

cycle_next(cycleobject *lz)

{

PyObject *item;

PyObject *it;

PyObject *tmp;

while (1) {

item = PyIter_Next(lz->it);

if (item != NULL) {

if (!lz->firstpass && PyList_Append(lz->saved, item)) {

Py_DECREF(item);

return NULL;

}

return item;

}

if (PyErr_Occurred()) {

if (PyErr_ExceptionMatches(PyExc_StopIteration))

PyErr_Clear();

else

return NULL;

}

if (PyList_Size(lz->saved) == 0)

return NULL;

it = PyObject_GetIter(lz->saved);

if (it == NULL)

return NULL;

tmp = lz->it;

lz->it = it;

lz->firstpass = 1;

Py_DECREF(tmp);

}

}

PyDoc_STRVAR(cycle_doc,

"cycle(iterable) --> cycle object\n\

\n\

Return elements from the iterable until it is exhausted.\n\

Then repeat the sequence indefinitely.");

static PyTypeObject cycle_type = {

PyVarObject_HEAD_INIT(NULL, 0)

"itertools.cycle", /* tp_name */

sizeof(cycleobject), /* tp_basicsize */

0, /* tp_itemsize */

/* methods */

(destructor)cycle_dealloc, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_compare */

0, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* 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, /* tp_flags */

cycle_doc, /* tp_doc */

(traverseproc)cycle_traverse, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

PyObject_SelfIter, /* tp_iter */

(iternextfunc)cycle_next, /* tp_iternext */

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

cycle_new, /* tp_new */

PyObject_GC_Del, /* tp_free */

};

/* dropwhile object **********************************************************/

typedef struct {

PyObject_HEAD

PyObject *func;

PyObject *it;

long start;

} dropwhileobject;

static PyTypeObject dropwhile_type;

static PyObject *

dropwhile_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

PyObject *func, *seq;

PyObject *it;

dropwhileobject *lz;

if (type == &dropwhile_type && !_PyArg_NoKeywords("dropwhile()", kwds))

return NULL;

if (!PyArg_UnpackTuple(args, "dropwhile", 2, 2, &func, &seq))

return NULL;

/* Get iterator. */

it = PyObject_GetIter(seq);

if (it == NULL)

return NULL;

/* create dropwhileobject structure */

lz = (dropwhileobject *)type->tp_alloc(type, 0);

if (lz == NULL) {

Py_DECREF(it);

return NULL;

}

Py_INCREF(func);

lz->func = func;

lz->it = it;

lz->start = 0;

return (PyObject *)lz;

}

static void

dropwhile_dealloc(dropwhileobject *lz)

{

PyObject_GC_UnTrack(lz);

Py_XDECREF(lz->func);

Py_XDECREF(lz->it);

Py_TYPE(lz)->tp_free(lz);

}

static int

dropwhile_traverse(dropwhileobject *lz, visitproc visit, void *arg)

{

Py_VISIT(lz->it);

Py_VISIT(lz->func);

return 0;

}

static PyObject *

dropwhile_next(dropwhileobject *lz)

{

PyObject *item, *good;

PyObject *it = lz->it;

long ok;

PyObject *(*iternext)(PyObject *);

iternext = *Py_TYPE(it)->tp_iternext;

for (;;) {

item = iternext(it);

if (item == NULL)

return NULL;

if (lz->start == 1)

return item;

good = PyObject_CallFunctionObjArgs(lz->func, item, NULL);

if (good == NULL) {

Py_DECREF(item);

return NULL;

}

ok = PyObject_IsTrue(good);

Py_DECREF(good);

if (ok == 0) {

lz->start = 1;

return item;

}

Py_DECREF(item);

if (ok < 0)

return NULL;

}

}

PyDoc_STRVAR(dropwhile_doc,

"dropwhile(predicate, iterable) --> dropwhile object\n\

\n\

Drop items from the iterable while predicate(item) is true.\n\

Afterwards, return every element until the iterable is exhausted.");

static PyTypeObject dropwhile_type = {

PyVarObject_HEAD_INIT(NULL, 0)

"itertools.dropwhile", /* tp_name */

sizeof(dropwhileobject), /* tp_basicsize */

0, /* tp_itemsize */

/* methods */

(destructor)dropwhile_dealloc, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_compare */

0, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* 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, /* tp_flags */

dropwhile_doc, /* tp_doc */

(traverseproc)dropwhile_traverse, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

PyObject_SelfIter, /* tp_iter */

(iternextfunc)dropwhile_next, /* tp_iternext */

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

dropwhile_new, /* tp_new */

PyObject_GC_Del, /* tp_free */

};

/* takewhile object **********************************************************/

typedef struct {

PyObject_HEAD

PyObject *func;

PyObject *it;

long stop;

} takewhileobject;

static PyTypeObject takewhile_type;

static PyObject *

takewhile_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

PyObject *func, *seq;

PyObject *it;

takewhileobject *lz;