diff -r a62072cf50a2 Modules/_collectionsmodule.c --- a/Modules/_collectionsmodule.c Wed Jan 22 12:26:01 2014 +0100 +++ b/Modules/_collectionsmodule.c Wed Jan 22 15:13:25 2014 +0200 @@ -7,6 +7,22 @@ All rights reserved. */ +/*[clinic input] +module collections +module _collections +class collections.deque +class collections.Counter +class _collections.dequeiter +class _collections.dequereviter +[clinic start generated code]*/ +/*[clinic end generated code: checksum=da39a3ee5e6b4b0d3255bfef95601890afd80709]*/ + +/*[python input] +class dequeobject_converter(self_converter): + type = "dequeobject *" +[python start generated code]*/ +/*[python end generated code: checksum=da39a3ee5e6b4b0d3255bfef95601890afd80709]*/ + /* The block length may be set to any number over 1. Larger numbers * reduce the number of calls to the memory allocator, give faster * indexing and rotation, and reduce the link::data overhead ratio. @@ -578,21 +594,55 @@ return rv; } +/*[clinic input] +collections.deque.rotate + + self: dequeobject + n: Py_ssize_t = 1 + Number of steps to rotate to the right (to the left if negative) + / + +Rotate the deque n steps to the right (default n=1). +[clinic start generated code]*/ + +PyDoc_STRVAR(collections_deque_rotate__doc__, +"rotate(n=1)\n" +"Rotate the deque n steps to the right (default n=1).\n" +"\n" +" n\n" +" Number of steps to rotate to the right (to the left if negative)"); + +#define COLLECTIONS_DEQUE_ROTATE_METHODDEF \ + {"rotate", (PyCFunction)collections_deque_rotate, METH_VARARGS, collections_deque_rotate__doc__}, + static PyObject * -deque_rotate(dequeobject *deque, PyObject *args) +collections_deque_rotate_impl(dequeobject *self, Py_ssize_t n); + +static PyObject * +collections_deque_rotate(PyObject *self, PyObject *args) { - Py_ssize_t n=1; + PyObject *return_value = NULL; + Py_ssize_t n = 1; - if (!PyArg_ParseTuple(args, "|n:rotate", &n)) - return NULL; - if (_deque_rotate(deque, n) == 0) + if (!PyArg_ParseTuple(args, + "|n:rotate", + &n)) + goto exit; + return_value = collections_deque_rotate_impl((dequeobject *)self, n); + +exit: + return return_value; +} + +static PyObject * +collections_deque_rotate_impl(dequeobject *self, Py_ssize_t n) +/*[clinic end generated code: checksum=911f7bd289febeb22aa90169649523e5834852f2]*/ +{ + if (_deque_rotate(self, n) == 0) Py_RETURN_NONE; return NULL; } -PyDoc_STRVAR(rotate_doc, -"Rotate the deque n steps to the right (default n=1). If n is negative, rotates left."); - static PyObject * deque_reverse(dequeobject *deque, PyObject *unused) { @@ -1093,10 +1143,10 @@ 0, /* sq_repeat */ (ssizeargfunc)deque_item, /* sq_item */ 0, /* sq_slice */ - (ssizeobjargproc)deque_ass_item, /* sq_ass_item */ + (ssizeobjargproc)deque_ass_item, /* sq_ass_item */ 0, /* sq_ass_slice */ 0, /* sq_contains */ - (binaryfunc)deque_inplace_concat, /* sq_inplace_concat */ + (binaryfunc)deque_inplace_concat, /* sq_inplace_concat */ 0, /* sq_inplace_repeat */ }; @@ -1118,7 +1168,7 @@ {"__copy__", (PyCFunction)deque_copy, METH_NOARGS, copy_doc}, {"count", (PyCFunction)deque_count, - METH_O, count_doc}, + METH_O, count_doc}, {"extend", (PyCFunction)deque_extend, METH_O, extend_doc}, {"extendleft", (PyCFunction)deque_extendleft, @@ -1127,7 +1177,7 @@ METH_NOARGS, pop_doc}, {"popleft", (PyCFunction)deque_popleft, METH_NOARGS, popleft_doc}, - {"__reduce__", (PyCFunction)deque_reduce, + {"__reduce__", (PyCFunction)deque_reduce, METH_NOARGS, reduce_doc}, {"remove", (PyCFunction)deque_remove, METH_O, remove_doc}, @@ -1135,8 +1185,7 @@ METH_NOARGS, reversed_doc}, {"reverse", (PyCFunction)deque_reverse, METH_NOARGS, reverse_doc}, - {"rotate", (PyCFunction)deque_rotate, - METH_VARARGS, rotate_doc}, + COLLECTIONS_DEQUE_ROTATE_METHODDEF {"__sizeof__", (PyCFunction)deque_sizeof, METH_NOARGS, sizeof_doc}, {NULL, NULL} /* sentinel */ @@ -1264,14 +1313,48 @@ return item; } +/*[clinic input] +@classmethod +_collections.dequeiter.__new__ as dequeiter_new + + deque: object(subclass_of="&deque_type") + index: Py_ssize_t = 0 + / + +[clinic start generated code]*/ + +PyDoc_STRVAR(dequeiter_new__doc__, +"dequeiter(deque, index=0)"); + static PyObject * -dequeiter_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +dequeiter_new_impl(PyTypeObject *type, PyObject *deque, Py_ssize_t index); + +static PyObject * +dequeiter_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { - Py_ssize_t i, index=0; + PyObject *return_value = NULL; PyObject *deque; + Py_ssize_t index = 0; + + if (!_PyArg_NoKeywords("__new__", kwargs)) + goto exit; + if (!PyArg_ParseTuple(args, + "O!|n:__new__", + &deque_type, &deque, &index)) + goto exit; + return_value = dequeiter_new_impl(type, deque, index); + +exit: + return return_value; +} + +static PyObject * +dequeiter_new_impl(PyTypeObject *type, PyObject *deque, Py_ssize_t index) +/*[clinic end generated code: checksum=51ca161ee496e5d370adbb9248a9568d35d054d1]*/ +{ + Py_ssize_t i; dequeiterobject *it; - if (!PyArg_ParseTuple(args, "O!|n", &deque_type, &deque, &index)) - return NULL; + assert(type == &dequeiter_type); it = (dequeiterobject*)deque_iter((dequeobject *)deque); @@ -1315,7 +1398,7 @@ static PyTypeObject dequeiter_type = { PyVarObject_HEAD_INIT(NULL, 0) - "_collections._deque_iterator", /* tp_name */ + "_collections._deque_iterator", /* tp_name */ sizeof(dequeiterobject), /* tp_basicsize */ 0, /* tp_itemsize */ /* methods */ @@ -1334,8 +1417,8 @@ PyObject_GenericGetAttr, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */ - 0, /* tp_doc */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */ + dequeiter_new__doc__, /* tp_doc */ (traverseproc)dequeiter_traverse, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ @@ -1406,14 +1489,48 @@ return item; } +/*[clinic input] +@classmethod +_collections.dequereviter.__new__ as dequereviter_new + + deque: object(subclass_of="&deque_type") + index: Py_ssize_t = 0 + / + +[clinic start generated code]*/ + +PyDoc_STRVAR(dequereviter_new__doc__, +"dequereviter(deque, index=0)"); + static PyObject * -dequereviter_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +dequereviter_new_impl(PyTypeObject *type, PyObject *deque, Py_ssize_t index); + +static PyObject * +dequereviter_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { - Py_ssize_t i, index=0; + PyObject *return_value = NULL; PyObject *deque; + Py_ssize_t index = 0; + + if (!_PyArg_NoKeywords("__new__", kwargs)) + goto exit; + if (!PyArg_ParseTuple(args, + "O!|n:__new__", + &deque_type, &deque, &index)) + goto exit; + return_value = dequereviter_new_impl(type, deque, index); + +exit: + return return_value; +} + +static PyObject * +dequereviter_new_impl(PyTypeObject *type, PyObject *deque, Py_ssize_t index) +/*[clinic end generated code: checksum=c31d79a67431d76ad1bf7ea9db15cb2ebcf1c1c5]*/ +{ + Py_ssize_t i; dequeiterobject *it; - if (!PyArg_ParseTuple(args, "O!|n", &deque_type, &deque, &index)) - return NULL; + assert(type == &dequereviter_type); it = (dequeiterobject*)deque_reviter((dequeobject *)deque); @@ -1437,7 +1554,7 @@ static PyTypeObject dequereviter_type = { PyVarObject_HEAD_INIT(NULL, 0) - "_collections._deque_reverse_iterator", /* tp_name */ + "_collections._deque_reverse_iterator", /* tp_name */ sizeof(dequeiterobject), /* tp_basicsize */ 0, /* tp_itemsize */ /* methods */ @@ -1456,8 +1573,8 @@ PyObject_GenericGetAttr, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */ - 0, /* tp_doc */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */ + dequereviter_new__doc__, /* tp_doc */ (traverseproc)dequeiter_traverse, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ @@ -1757,17 +1874,50 @@ /* helper function for Counter *********************************************/ -PyDoc_STRVAR(_count_elements_doc, -"_count_elements(mapping, iterable) -> None\n\ -\n\ -Count elements in the iterable, updating the mappping"); +/*[clinic input] +collections.Counter._count_elements + + mapping: object + iterable: object + / + +Count elements in the iterable, updating the mappping +[clinic start generated code]*/ + +PyDoc_STRVAR(collections_Counter__count_elements__doc__, +"_count_elements(mapping, iterable)\n" +"Count elements in the iterable, updating the mappping"); + +#define COLLECTIONS_COUNTER__COUNT_ELEMENTS_METHODDEF \ + {"_count_elements", (PyCFunction)collections_Counter__count_elements, METH_VARARGS, collections_Counter__count_elements__doc__}, static PyObject * -_count_elements(PyObject *self, PyObject *args) +collections_Counter__count_elements_impl(PyObject *self, PyObject *mapping, PyObject *iterable); + +static PyObject * +collections_Counter__count_elements(PyObject *self, PyObject *args) +{ + PyObject *return_value = NULL; + PyObject *mapping; + PyObject *iterable; + + if (!PyArg_UnpackTuple(args, "_count_elements", + 2, 2, + &mapping, &iterable)) + goto exit; + return_value = collections_Counter__count_elements_impl(self, mapping, iterable); + +exit: + return return_value; +} + +static PyObject * +collections_Counter__count_elements_impl(PyObject *self, PyObject *mapping, PyObject *iterable) +/*[clinic end generated code: checksum=f446302908a73a3d575c1c2129a077b1b74f475a]*/ { _Py_IDENTIFIER(get); _Py_IDENTIFIER(__setitem__); - PyObject *it, *iterable, *mapping, *oldval; + PyObject *it, *oldval; PyObject *newval = NULL; PyObject *key = NULL; PyObject *zero = NULL; @@ -1778,9 +1928,6 @@ PyObject *mapping_setitem; PyObject *dict_setitem; - if (!PyArg_UnpackTuple(args, "_count_elements", 2, 2, &mapping, &iterable)) - return NULL; - it = PyObject_GetIter(iterable); if (it == NULL) return NULL; @@ -1865,7 +2012,7 @@ "); static struct PyMethodDef module_functions[] = { - {"_count_elements", _count_elements, METH_VARARGS, _count_elements_doc}, + COLLECTIONS_COUNTER__COUNT_ELEMENTS_METHODDEF {NULL, NULL} /* sentinel */ };