Python code coverage for Objects/enumobject.c

#	count	content
1	n/a	/* enumerate object */
2	n/a
3	n/a	#include "Python.h"
4	n/a
5	n/a	#include "clinic/enumobject.c.h"
6	n/a
7	n/a	/*[clinic input]
8	n/a	class enumerate "enumobject *" "&PyEnum_Type"
9	n/a	class reversed "reversedobject *" "&PyReversed_Type"
10	n/a	[clinic start generated code]*/
11	n/a	/[clinic end generated code: output=da39a3ee5e6b4b0d input=d2dfdf1a88c88975]/
12	n/a
13	n/a	typedef struct {
14	n/a	PyObject_HEAD
15	n/a	Py_ssize_t en_index; /* current index of enumeration */
16	n/a	PyObject* en_sit; /* secondary iterator of enumeration */
17	n/a	PyObject* en_result; /* result tuple */
18	n/a	PyObject* en_longindex; /* index for sequences >= PY_SSIZE_T_MAX */
19	n/a	} enumobject;
20	n/a
21	n/a
22	n/a	/*[clinic input]
23	n/a	@classmethod
24	n/a	enumerate.__new__ as enum_new
25	n/a
26	n/a	iterable: object
27	n/a	an object supporting iteration
28	n/a	start: object = 0
29	n/a
30	n/a	Return an enumerate object.
31	n/a
32	n/a	The enumerate object yields pairs containing a count (from start, which
33	n/a	defaults to zero) and a value yielded by the iterable argument.
34	n/a
35	n/a	enumerate is useful for obtaining an indexed list:
36	n/a	(0, seq[0]), (1, seq[1]), (2, seq[2]), ...
37	n/a	[clinic start generated code]*/
38	n/a
39	n/a	static PyObject *
40	n/a	enum_new_impl(PyTypeObject type, PyObject iterable, PyObject *start)
41	n/a	/[clinic end generated code: output=e95e6e439f812c10 input=782e4911efcb8acf]/
42	n/a	{
43	n/a	enumobject *en;
44	n/a
45	n/a	en = (enumobject *)type->tp_alloc(type, 0);
46	n/a	if (en == NULL)
47	n/a	return NULL;
48	n/a	if (start != NULL) {
49	n/a	start = PyNumber_Index(start);
50	n/a	if (start == NULL) {
51	n/a	Py_DECREF(en);
52	n/a	return NULL;
53	n/a	}
54	n/a	assert(PyLong_Check(start));
55	n/a	en->en_index = PyLong_AsSsize_t(start);
56	n/a	if (en->en_index == -1 && PyErr_Occurred()) {
57	n/a	PyErr_Clear();
58	n/a	en->en_index = PY_SSIZE_T_MAX;
59	n/a	en->en_longindex = start;
60	n/a	} else {
61	n/a	en->en_longindex = NULL;
62	n/a	Py_DECREF(start);
63	n/a	}
64	n/a	} else {
65	n/a	en->en_index = 0;
66	n/a	en->en_longindex = NULL;
67	n/a	}
68	n/a	en->en_sit = PyObject_GetIter(iterable);
69	n/a	if (en->en_sit == NULL) {
70	n/a	Py_DECREF(en);
71	n/a	return NULL;
72	n/a	}
73	n/a	en->en_result = PyTuple_Pack(2, Py_None, Py_None);
74	n/a	if (en->en_result == NULL) {
75	n/a	Py_DECREF(en);
76	n/a	return NULL;
77	n/a	}
78	n/a	return (PyObject *)en;
79	n/a	}
80	n/a
81	n/a	static void
82	n/a	enum_dealloc(enumobject *en)
83	n/a	{
84	n/a	PyObject_GC_UnTrack(en);
85	n/a	Py_XDECREF(en->en_sit);
86	n/a	Py_XDECREF(en->en_result);
87	n/a	Py_XDECREF(en->en_longindex);
88	n/a	Py_TYPE(en)->tp_free(en);
89	n/a	}
90	n/a
91	n/a	static int
92	n/a	enum_traverse(enumobject en, visitproc visit, void arg)
93	n/a	{
94	n/a	Py_VISIT(en->en_sit);
95	n/a	Py_VISIT(en->en_result);
96	n/a	Py_VISIT(en->en_longindex);
97	n/a	return 0;
98	n/a	}
99	n/a
100	n/a	static PyObject *
101	n/a	enum_next_long(enumobject en, PyObject next_item)
102	n/a	{
103	n/a	static PyObject *one = NULL;
104	n/a	PyObject *result = en->en_result;
105	n/a	PyObject *next_index;
106	n/a	PyObject *stepped_up;
107	n/a
108	n/a	if (en->en_longindex == NULL) {
109	n/a	en->en_longindex = PyLong_FromSsize_t(PY_SSIZE_T_MAX);
110	n/a	if (en->en_longindex == NULL)
111	n/a	return NULL;
112	n/a	}
113	n/a	if (one == NULL) {
114	n/a	one = PyLong_FromLong(1);
115	n/a	if (one == NULL)
116	n/a	return NULL;
117	n/a	}
118	n/a	next_index = en->en_longindex;
119	n/a	assert(next_index != NULL);
120	n/a	stepped_up = PyNumber_Add(next_index, one);
121	n/a	if (stepped_up == NULL)
122	n/a	return NULL;
123	n/a	en->en_longindex = stepped_up;
124	n/a
125	n/a	if (result->ob_refcnt == 1) {
126	n/a	Py_INCREF(result);
127	n/a	Py_DECREF(PyTuple_GET_ITEM(result, 0));
128	n/a	Py_DECREF(PyTuple_GET_ITEM(result, 1));
129	n/a	} else {
130	n/a	result = PyTuple_New(2);
131	n/a	if (result == NULL) {
132	n/a	Py_DECREF(next_index);
133	n/a	Py_DECREF(next_item);
134	n/a	return NULL;
135	n/a	}
136	n/a	}
137	n/a	PyTuple_SET_ITEM(result, 0, next_index);
138	n/a	PyTuple_SET_ITEM(result, 1, next_item);
139	n/a	return result;
140	n/a	}
141	n/a
142	n/a	static PyObject *
143	n/a	enum_next(enumobject *en)
144	n/a	{
145	n/a	PyObject *next_index;
146	n/a	PyObject *next_item;
147	n/a	PyObject *result = en->en_result;
148	n/a	PyObject *it = en->en_sit;
149	n/a
150	n/a	next_item = (*Py_TYPE(it)->tp_iternext)(it);
151	n/a	if (next_item == NULL)
152	n/a	return NULL;
153	n/a
154	n/a	if (en->en_index == PY_SSIZE_T_MAX)
155	n/a	return enum_next_long(en, next_item);
156	n/a
157	n/a	next_index = PyLong_FromSsize_t(en->en_index);
158	n/a	if (next_index == NULL) {
159	n/a	Py_DECREF(next_item);
160	n/a	return NULL;
161	n/a	}
162	n/a	en->en_index++;
163	n/a
164	n/a	if (result->ob_refcnt == 1) {
165	n/a	Py_INCREF(result);
166	n/a	Py_DECREF(PyTuple_GET_ITEM(result, 0));
167	n/a	Py_DECREF(PyTuple_GET_ITEM(result, 1));
168	n/a	} else {
169	n/a	result = PyTuple_New(2);
170	n/a	if (result == NULL) {
171	n/a	Py_DECREF(next_index);
172	n/a	Py_DECREF(next_item);
173	n/a	return NULL;
174	n/a	}
175	n/a	}
176	n/a	PyTuple_SET_ITEM(result, 0, next_index);
177	n/a	PyTuple_SET_ITEM(result, 1, next_item);
178	n/a	return result;
179	n/a	}
180	n/a
181	n/a	static PyObject *
182	n/a	enum_reduce(enumobject *en)
183	n/a	{
184	n/a	if (en->en_longindex != NULL)
185	n/a	return Py_BuildValue("O(OO)", Py_TYPE(en), en->en_sit, en->en_longindex);
186	n/a	else
187	n/a	return Py_BuildValue("O(On)", Py_TYPE(en), en->en_sit, en->en_index);
188	n/a	}
189	n/a
190	n/a	PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");
191	n/a
192	n/a	static PyMethodDef enum_methods[] = {
193	n/a	{"__reduce__", (PyCFunction)enum_reduce, METH_NOARGS, reduce_doc},
194	n/a	{NULL, NULL} /* sentinel */
195	n/a	};
196	n/a
197	n/a	PyTypeObject PyEnum_Type = {
198	n/a	PyVarObject_HEAD_INIT(&PyType_Type, 0)
199	n/a	"enumerate", /* tp_name */
200	n/a	sizeof(enumobject), /* tp_basicsize */
201	n/a	0, /* tp_itemsize */
202	n/a	/* methods */
203	n/a	(destructor)enum_dealloc, /* tp_dealloc */
204	n/a	0, /* tp_print */
205	n/a	0, /* tp_getattr */
206	n/a	0, /* tp_setattr */
207	n/a	0, /* tp_reserved */
208	n/a	0, /* tp_repr */
209	n/a	0, /* tp_as_number */
210	n/a	0, /* tp_as_sequence */
211	n/a	0, /* tp_as_mapping */
212	n/a	0, /* tp_hash */
213	n/a	0, /* tp_call */
214	n/a	0, /* tp_str */
215	n/a	PyObject_GenericGetAttr, /* tp_getattro */
216	n/a	0, /* tp_setattro */
217	n/a	0, /* tp_as_buffer */
218	n/a	Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_HAVE_GC \|
219	n/a	Py_TPFLAGS_BASETYPE, /* tp_flags */
220	n/a	enum_new__doc__, /* tp_doc */
221	n/a	(traverseproc)enum_traverse, /* tp_traverse */
222	n/a	0, /* tp_clear */
223	n/a	0, /* tp_richcompare */
224	n/a	0, /* tp_weaklistoffset */
225	n/a	PyObject_SelfIter, /* tp_iter */
226	n/a	(iternextfunc)enum_next, /* tp_iternext */
227	n/a	enum_methods, /* tp_methods */
228	n/a	0, /* tp_members */
229	n/a	0, /* tp_getset */
230	n/a	0, /* tp_base */
231	n/a	0, /* tp_dict */
232	n/a	0, /* tp_descr_get */
233	n/a	0, /* tp_descr_set */
234	n/a	0, /* tp_dictoffset */
235	n/a	0, /* tp_init */
236	n/a	PyType_GenericAlloc, /* tp_alloc */
237	n/a	enum_new, /* tp_new */
238	n/a	PyObject_GC_Del, /* tp_free */
239	n/a	};
240	n/a
241	n/a	/* Reversed Object ***************************************************************/
242	n/a
243	n/a	typedef struct {
244	n/a	PyObject_HEAD
245	n/a	Py_ssize_t index;
246	n/a	PyObject* seq;
247	n/a	} reversedobject;
248	n/a
249	n/a	/*[clinic input]
250	n/a	@classmethod
251	n/a	reversed.__new__ as reversed_new
252	n/a
253	n/a	sequence as seq: object
254	n/a	/
255	n/a
256	n/a	Return a reverse iterator over the values of the given sequence.
257	n/a	[clinic start generated code]*/
258	n/a
259	n/a	static PyObject *
260	n/a	reversed_new_impl(PyTypeObject type, PyObject seq)
261	n/a	/[clinic end generated code: output=f7854cc1df26f570 input=aeb720361e5e3f1d]/
262	n/a	{
263	n/a	Py_ssize_t n;
264	n/a	PyObject *reversed_meth;
265	n/a	reversedobject *ro;
266	n/a	_Py_IDENTIFIER(__reversed__);
267	n/a
268	n/a	reversed_meth = _PyObject_LookupSpecial(seq, &PyId___reversed__);
269	n/a	if (reversed_meth == Py_None) {
270	n/a	Py_DECREF(reversed_meth);
271	n/a	PyErr_Format(PyExc_TypeError,
272	n/a	"'%.200s' object is not reversible",
273	n/a	Py_TYPE(seq)->tp_name);
274	n/a	return NULL;
275	n/a	}
276	n/a	if (reversed_meth != NULL) {
277	n/a	PyObject *res = _PyObject_CallNoArg(reversed_meth);
278	n/a	Py_DECREF(reversed_meth);
279	n/a	return res;
280	n/a	}
281	n/a	else if (PyErr_Occurred())
282	n/a	return NULL;
283	n/a
284	n/a	if (!PySequence_Check(seq)) {
285	n/a	PyErr_Format(PyExc_TypeError,
286	n/a	"'%.200s' object is not reversible",
287	n/a	Py_TYPE(seq)->tp_name);
288	n/a	return NULL;
289	n/a	}
290	n/a
291	n/a	n = PySequence_Size(seq);
292	n/a	if (n == -1)
293	n/a	return NULL;
294	n/a
295	n/a	ro = (reversedobject *)type->tp_alloc(type, 0);
296	n/a	if (ro == NULL)
297	n/a	return NULL;
298	n/a
299	n/a	ro->index = n-1;
300	n/a	Py_INCREF(seq);
301	n/a	ro->seq = seq;
302	n/a	return (PyObject *)ro;
303	n/a	}
304	n/a
305	n/a	static void
306	n/a	reversed_dealloc(reversedobject *ro)
307	n/a	{
308	n/a	PyObject_GC_UnTrack(ro);
309	n/a	Py_XDECREF(ro->seq);
310	n/a	Py_TYPE(ro)->tp_free(ro);
311	n/a	}
312	n/a
313	n/a	static int
314	n/a	reversed_traverse(reversedobject ro, visitproc visit, void arg)
315	n/a	{
316	n/a	Py_VISIT(ro->seq);
317	n/a	return 0;
318	n/a	}
319	n/a
320	n/a	static PyObject *
321	n/a	reversed_next(reversedobject *ro)
322	n/a	{
323	n/a	PyObject *item;
324	n/a	Py_ssize_t index = ro->index;
325	n/a
326	n/a	if (index >= 0) {
327	n/a	item = PySequence_GetItem(ro->seq, index);
328	n/a	if (item != NULL) {
329	n/a	ro->index--;
330	n/a	return item;
331	n/a	}
332	n/a	if (PyErr_ExceptionMatches(PyExc_IndexError) \|\|
333	n/a	PyErr_ExceptionMatches(PyExc_StopIteration))
334	n/a	PyErr_Clear();
335	n/a	}
336	n/a	ro->index = -1;
337	n/a	Py_CLEAR(ro->seq);
338	n/a	return NULL;
339	n/a	}
340	n/a
341	n/a	static PyObject *
342	n/a	reversed_len(reversedobject *ro)
343	n/a	{
344	n/a	Py_ssize_t position, seqsize;
345	n/a
346	n/a	if (ro->seq == NULL)
347	n/a	return PyLong_FromLong(0);
348	n/a	seqsize = PySequence_Size(ro->seq);
349	n/a	if (seqsize == -1)
350	n/a	return NULL;
351	n/a	position = ro->index + 1;
352	n/a	return PyLong_FromSsize_t((seqsize < position) ? 0 : position);
353	n/a	}
354	n/a
355	n/a	PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
356	n/a
357	n/a	static PyObject *
358	n/a	reversed_reduce(reversedobject *ro)
359	n/a	{
360	n/a	if (ro->seq)
361	n/a	return Py_BuildValue("O(O)n", Py_TYPE(ro), ro->seq, ro->index);
362	n/a	else
363	n/a	return Py_BuildValue("O(())", Py_TYPE(ro));
364	n/a	}
365	n/a
366	n/a	static PyObject *
367	n/a	reversed_setstate(reversedobject ro, PyObject state)
368	n/a	{
369	n/a	Py_ssize_t index = PyLong_AsSsize_t(state);
370	n/a	if (index == -1 && PyErr_Occurred())
371	n/a	return NULL;
372	n/a	if (ro->seq != 0) {
373	n/a	Py_ssize_t n = PySequence_Size(ro->seq);
374	n/a	if (n < 0)
375	n/a	return NULL;
376	n/a	if (index < -1)
377	n/a	index = -1;
378	n/a	else if (index > n-1)
379	n/a	index = n-1;
380	n/a	ro->index = index;
381	n/a	}
382	n/a	Py_RETURN_NONE;
383	n/a	}
384	n/a
385	n/a	PyDoc_STRVAR(setstate_doc, "Set state information for unpickling.");
386	n/a
387	n/a	static PyMethodDef reversediter_methods[] = {
388	n/a	{"__length_hint__", (PyCFunction)reversed_len, METH_NOARGS, length_hint_doc},
389	n/a	{"__reduce__", (PyCFunction)reversed_reduce, METH_NOARGS, reduce_doc},
390	n/a	{"__setstate__", (PyCFunction)reversed_setstate, METH_O, setstate_doc},
391	n/a	{NULL, NULL} /* sentinel */
392	n/a	};
393	n/a
394	n/a	PyTypeObject PyReversed_Type = {
395	n/a	PyVarObject_HEAD_INIT(&PyType_Type, 0)
396	n/a	"reversed", /* tp_name */
397	n/a	sizeof(reversedobject), /* tp_basicsize */
398	n/a	0, /* tp_itemsize */
399	n/a	/* methods */
400	n/a	(destructor)reversed_dealloc, /* tp_dealloc */
401	n/a	0, /* tp_print */
402	n/a	0, /* tp_getattr */
403	n/a	0, /* tp_setattr */
404	n/a	0, /* tp_reserved */
405	n/a	0, /* tp_repr */
406	n/a	0, /* tp_as_number */
407	n/a	0, /* tp_as_sequence */
408	n/a	0, /* tp_as_mapping */
409	n/a	0, /* tp_hash */
410	n/a	0, /* tp_call */
411	n/a	0, /* tp_str */
412	n/a	PyObject_GenericGetAttr, /* tp_getattro */
413	n/a	0, /* tp_setattro */
414	n/a	0, /* tp_as_buffer */
415	n/a	Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_HAVE_GC \|
416	n/a	Py_TPFLAGS_BASETYPE, /* tp_flags */
417	n/a	reversed_new__doc__, /* tp_doc */
418	n/a	(traverseproc)reversed_traverse,/* tp_traverse */
419	n/a	0, /* tp_clear */
420	n/a	0, /* tp_richcompare */
421	n/a	0, /* tp_weaklistoffset */
422	n/a	PyObject_SelfIter, /* tp_iter */
423	n/a	(iternextfunc)reversed_next, /* tp_iternext */
424	n/a	reversediter_methods, /* tp_methods */
425	n/a	0, /* tp_members */
426	n/a	0, /* tp_getset */
427	n/a	0, /* tp_base */
428	n/a	0, /* tp_dict */
429	n/a	0, /* tp_descr_get */
430	n/a	0, /* tp_descr_set */
431	n/a	0, /* tp_dictoffset */
432	n/a	0, /* tp_init */
433	n/a	PyType_GenericAlloc, /* tp_alloc */
434	n/a	reversed_new, /* tp_new */
435	n/a	PyObject_GC_Del, /* tp_free */
436	n/a	};