/home/mdboom/Work/builds/cpython/Objects/clinic/listobject.c.h

Source (jump to first uncovered line)
/*[clinic input]
preserve
[clinic start generated code]*/

PyDoc_STRVAR(list_insert__doc__,
"insert($self, index, object, /)\n"
"--\n"
"\n"
"Insert object before index.");

#define LIST_INSERT_METHODDEF    \
    {"insert", _PyCFunction_CAST(list_insert), METH_FASTCALL, list_insert__doc__},

static PyObject *
list_insert_impl(PyListObject *self, Py_ssize_t index, PyObject *object);

static PyObject *
list_insert(PyListObject *self, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    Py_ssize_t index;
    PyObject *object;

    if (!_PyArg_CheckPositional("insert", nargs, 2, 2)) {
        goto exit;
    }
    {
        Py_ssize_t ival = -1;
        PyObject *iobj = _PyNumber_Index(args[0]);
        if (iobj != NULL) {
            ival = PyLong_AsSsize_t(iobj);
            Py_DECREF(iobj);
        }
        if (ival == -1 && PyErr_Occurred()10) {
            goto exit;
        }
        index = ival;
    }
    object = args[1];
    return_value = list_insert_impl(self, index, object);

exit:
    return return_value;
}

PyDoc_STRVAR(list_clear__doc__,
"clear($self, /)\n"
"--\n"
"\n"
"Remove all items from list.");

#define LIST_CLEAR_METHODDEF    \
    {"clear", (PyCFunction)list_clear, METH_NOARGS, list_clear__doc__},

static PyObject *
list_clear_impl(PyListObject *self);

static PyObject *
list_clear(PyListObject *self, PyObject *Py_UNUSED(ignored))
{
    return list_clear_impl(self);
}

PyDoc_STRVAR(list_copy__doc__,
"copy($self, /)\n"
"--\n"
"\n"
"Return a shallow copy of the list.");

#define LIST_COPY_METHODDEF    \
    {"copy", (PyCFunction)list_copy, METH_NOARGS, list_copy__doc__},

static PyObject *
list_copy_impl(PyListObject *self);

static PyObject *
list_copy(PyListObject *self, PyObject *Py_UNUSED(ignored))
{
    return list_copy_impl(self);
}

PyDoc_STRVAR(list_append__doc__,
"append($self, object, /)\n"
"--\n"
"\n"
"Append object to the end of the list.");

#define LIST_APPEND_METHODDEF    \
    {"append", (PyCFunction)list_append, METH_O, list_append__doc__},

PyDoc_STRVAR(list_extend__doc__,
"extend($self, iterable, /)\n"
"--\n"
"\n"
"Extend list by appending elements from the iterable.");

#define LIST_EXTEND_METHODDEF    \
    {"extend", (PyCFunction)list_extend, METH_O, list_extend__doc__},

PyDoc_STRVAR(list_pop__doc__,
"pop($self, index=-1, /)\n"
"--\n"
"\n"
"Remove and return item at index (default last).\n"
"\n"
"Raises IndexError if list is empty or index is out of range.");

#define LIST_POP_METHODDEF    \
    {"pop", _PyCFunction_CAST(list_pop), METH_FASTCALL, list_pop__doc__},

static PyObject *
list_pop_impl(PyListObject *self, Py_ssize_t index);

static PyObject *
list_pop(PyListObject *self, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    Py_ssize_t index = -1;

    if (!_PyArg_CheckPositional("pop", nargs, 0, 1)) {
        goto exit;
    }
    if (nargs < 1) {
        goto skip_optional;
    }
    {
        Py_ssize_t ival = -1;
        PyObject *iobj = _PyNumber_Index(args[0]);
        if (iobj != NULL) {
            ival = PyLong_AsSsize_t(iobj);
            Py_DECREF(iobj);
        }
        if (ival == -1 && PyErr_Occurred()2) {
            goto exit;
        }
        index = ival;
    }
skip_optional:
    return_value = list_pop_impl(self, index);

exit:
    return return_value;
}

PyDoc_STRVAR(list_sort__doc__,
"sort($self, /, *, key=None, reverse=False)\n"
"--\n"
"\n"
"Sort the list in ascending order and return None.\n"
"\n"
"The sort is in-place (i.e. the list itself is modified) and stable (i.e. the\n"
"order of two equal elements is maintained).\n"
"\n"
"If a key function is given, apply it once to each list item and sort them,\n"
"ascending or descending, according to their function values.\n"
"\n"
"The reverse flag can be set to sort in descending order.");

#define LIST_SORT_METHODDEF    \
    {"sort", _PyCFunction_CAST(list_sort), METH_FASTCALL|METH_KEYWORDS, list_sort__doc__},

static PyObject *
list_sort_impl(PyListObject *self, PyObject *keyfunc, int reverse);

static PyObject *
list_sort(PyListObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
    PyObject *return_value = NULL;
    static const char * const _keywords[] = {"key", "reverse", NULL};
    static _PyArg_Parser _parser = {NULL, _keywords, "sort", 0};
    PyObject *argsbuf[2];
    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE47.1k(kwnames) : 0516k) - 0;
    PyObject *keyfunc = Py_None;
    int reverse = 0;

    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 0, 0, argsbuf);
    if (!args) {
        goto exit;
    }
    if (!noptargs) {
        goto skip_optional_kwonly;
    }
    if (args[0]) {
        keyfunc = args[0];
        if (!--noptargs) {
            goto skip_optional_kwonly;
        }
    }
    reverse = _PyLong_AsInt(args[1]);
    if (reverse == -1 && PyErr_Occurred()0) {
        goto exit;
    }
skip_optional_kwonly:
    return_value = list_sort_impl(self, keyfunc, reverse);

exit:
    return return_value;
}

PyDoc_STRVAR(list_reverse__doc__,
"reverse($self, /)\n"
"--\n"
"\n"
"Reverse *IN PLACE*.");

#define LIST_REVERSE_METHODDEF    \
    {"reverse", (PyCFunction)list_reverse, METH_NOARGS, list_reverse__doc__},

static PyObject *
list_reverse_impl(PyListObject *self);

static PyObject *
list_reverse(PyListObject *self, PyObject *Py_UNUSED(ignored))
{
    return list_reverse_impl(self);
}

PyDoc_STRVAR(list_index__doc__,
"index($self, value, start=0, stop=sys.maxsize, /)\n"
"--\n"
"\n"
"Return first index of value.\n"
"\n"
"Raises ValueError if the value is not present.");

#define LIST_INDEX_METHODDEF    \
    {"index", _PyCFunction_CAST(list_index), METH_FASTCALL, list_index__doc__},

static PyObject *
list_index_impl(PyListObject *self, PyObject *value, Py_ssize_t start,
                Py_ssize_t stop);

static PyObject *
list_index(PyListObject *self, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    PyObject *value;
    Py_ssize_t start = 0;
    Py_ssize_t stop = PY_SSIZE_T_MAX;

    if (!_PyArg_CheckPositional("index", nargs, 1, 3)) {
        goto exit;
    }
    value = args[0];
    if (nargs < 2) {
        goto skip_optional;
    }
    if (!_PyEval_SliceIndexNotNone(args[1], &start)) {
        goto exit;
    }
    if (nargs < 3) {
        goto skip_optional;
    }
    if (!_PyEval_SliceIndexNotNone(args[2], &stop)) {
        goto exit;
    }
skip_optional:
    return_value = list_index_impl(self, value, start, stop);

exit:
    return return_value;
}

PyDoc_STRVAR(list_count__doc__,
"count($self, value, /)\n"
"--\n"
"\n"
"Return number of occurrences of value.");

#define LIST_COUNT_METHODDEF    \
    {"count", (PyCFunction)list_count, METH_O, list_count__doc__},

PyDoc_STRVAR(list_remove__doc__,
"remove($self, value, /)\n"
"--\n"
"\n"
"Remove first occurrence of value.\n"
"\n"
"Raises ValueError if the value is not present.");

#define LIST_REMOVE_METHODDEF    \
    {"remove", (PyCFunction)list_remove, METH_O, list_remove__doc__},

PyDoc_STRVAR(list___init____doc__,
"list(iterable=(), /)\n"
"--\n"
"\n"
"Built-in mutable sequence.\n"
"\n"
"If no argument is given, the constructor creates a new empty list.\n"
"The argument must be an iterable if specified.");

static int
list___init___impl(PyListObject *self, PyObject *iterable);

static int
list___init__(PyObject *self, PyObject *args, PyObject *kwargs)
{
    int return_value = -1;
    PyObject *iterable = NULL;

    if ((Py_IS_TYPE(self, &PyList_Type) ||
         Py_TYPE103k(self)->tp_new == PyList_Type.tp_new103k) &&
        !102k_PyArg_NoKeywords102k("list", kwargs)) {
        goto exit;
    }
    if (!_PyArg_CheckPositional("list", PyTuple_GET_SIZE(args), 0, 1)) {
        goto exit;
    }
    if (PyTuple_GET_SIZE(args) < 1) {
        goto skip_optional;
    }
    iterable = PyTuple_GET_ITEM(args, 0);
skip_optional:
    return_value = list___init___impl((PyListObject *)self, iterable);

exit:
    return return_value;
}

PyDoc_STRVAR(list___sizeof____doc__,
"__sizeof__($self, /)\n"
"--\n"
"\n"
"Return the size of the list in memory, in bytes.");

#define LIST___SIZEOF___METHODDEF    \
    {"__sizeof__", (PyCFunction)list___sizeof__, METH_NOARGS, list___sizeof____doc__},

static PyObject *
list___sizeof___impl(PyListObject *self);

static PyObject *
list___sizeof__(PyListObject *self, PyObject *Py_UNUSED(ignored))
{
    return list___sizeof___impl(self);
}

PyDoc_STRVAR(list___reversed____doc__,
"__reversed__($self, /)\n"
"--\n"
"\n"
"Return a reverse iterator over the list.");

#define LIST___REVERSED___METHODDEF    \
    {"__reversed__", (PyCFunction)list___reversed__, METH_NOARGS, list___reversed____doc__},

static PyObject *
list___reversed___impl(PyListObject *self);

static PyObject *
list___reversed__(PyListObject *self, PyObject *Py_UNUSED(ignored))
{
    return list___reversed___impl(self);
}
/*[clinic end generated code: output=eab97a76b1568a03 input=a9049054013a1b77]*/

Coverage Report

Created: 2022-07-08 09:39

Line	Count	Source (jump to first uncovered line)
1	/*[clinic input]
2	preserve
3	[clinic start generated code]*/
4
5	PyDoc_STRVAR(list_insert__doc__,
6	"insert($self, index, object, /)\n"
7	"--\n"
8	"\n"
9	"Insert object before index.");
10
11	#define LIST_INSERT_METHODDEF \
12	{"insert", _PyCFunction_CAST(list_insert), METH_FASTCALL, list_insert__doc__},
13
14	static PyObject *
15	list_insert_impl(PyListObject self, Py_ssize_t index, PyObject object);
16
17	static PyObject *
18	list_insert(PyListObject self, PyObject const *args, Py_ssize_t nargs)
19	{
20	PyObject *return_value = NULL;
21	Py_ssize_t index;
22	PyObject *object;
23
24	if (!_PyArg_CheckPositional("insert", nargs, 2, 2)) {
25	goto exit;
26	}
27	{
28	Py_ssize_t ival = -1;
29	PyObject *iobj = _PyNumber_Index(args[0]);
30	if (iobj != NULL) { Branch (30:13): [True: 18.9k, False: 0]
31	ival = PyLong_AsSsize_t(iobj);
32	Py_DECREF(iobj);
33	}
34	if (ival == -1 && PyErr_Occurred()10 ) { Branch (34:13): [True: 10, False: 18.9k] Branch (34:27): [True: 0, False: 10]
35	goto exit;
36	}
37	index = ival;
38	}
39	object = args[1];
40	return_value = list_insert_impl(self, index, object);
41
42	exit:
43	return return_value;
44	}
45
46	PyDoc_STRVAR(list_clear__doc__,
47	"clear($self, /)\n"
48	"--\n"
49	"\n"
50	"Remove all items from list.");
51
52	#define LIST_CLEAR_METHODDEF \
53	{"clear", (PyCFunction)list_clear, METH_NOARGS, list_clear__doc__},
54
55	static PyObject *
56	list_clear_impl(PyListObject *self);
57
58	static PyObject *
59	list_clear(PyListObject self, PyObject Py_UNUSED(ignored))
60	{
61	return list_clear_impl(self);
62	}
63
64	PyDoc_STRVAR(list_copy__doc__,
65	"copy($self, /)\n"
66	"--\n"
67	"\n"
68	"Return a shallow copy of the list.");
69
70	#define LIST_COPY_METHODDEF \
71	{"copy", (PyCFunction)list_copy, METH_NOARGS, list_copy__doc__},
72
73	static PyObject *
74	list_copy_impl(PyListObject *self);
75
76	static PyObject *
77	list_copy(PyListObject self, PyObject Py_UNUSED(ignored))
78	{
79	return list_copy_impl(self);
80	}
81
82	PyDoc_STRVAR(list_append__doc__,
83	"append($self, object, /)\n"
84	"--\n"
85	"\n"
86	"Append object to the end of the list.");
87
88	#define LIST_APPEND_METHODDEF \
89	{"append", (PyCFunction)list_append, METH_O, list_append__doc__},
90
91	PyDoc_STRVAR(list_extend__doc__,
92	"extend($self, iterable, /)\n"
93	"--\n"
94	"\n"
95	"Extend list by appending elements from the iterable.");
96
97	#define LIST_EXTEND_METHODDEF \
98	{"extend", (PyCFunction)list_extend, METH_O, list_extend__doc__},
99
100	PyDoc_STRVAR(list_pop__doc__,
101	"pop($self, index=-1, /)\n"
102	"--\n"
103	"\n"
104	"Remove and return item at index (default last).\n"
105	"\n"
106	"Raises IndexError if list is empty or index is out of range.");
107
108	#define LIST_POP_METHODDEF \
109	{"pop", _PyCFunction_CAST(list_pop), METH_FASTCALL, list_pop__doc__},
110
111	static PyObject *
112	list_pop_impl(PyListObject *self, Py_ssize_t index);
113
114	static PyObject *
115	list_pop(PyListObject self, PyObject const *args, Py_ssize_t nargs)
116	{
117	PyObject *return_value = NULL;
118	Py_ssize_t index = -1;
119
120	if (!_PyArg_CheckPositional("pop", nargs, 0, 1)) {
121	goto exit;
122	}
123	if (nargs < 1) { Branch (123:9): [True: 1.59M, False: 308k]
124	goto skip_optional;
125	}
126	{
127	Py_ssize_t ival = -1;
128	PyObject *iobj = _PyNumber_Index(args[0]);
129	if (iobj != NULL) { Branch (129:13): [True: 308k, False: 0]
130	ival = PyLong_AsSsize_t(iobj);
131	Py_DECREF(iobj);
132	}
133	if (ival == -1 && PyErr_Occurred()2 ) { Branch (133:13): [True: 2, False: 308k] Branch (133:27): [True: 0, False: 2]
134	goto exit;
135	}
136	index = ival;
137	}
138	skip_optional:
139	return_value = list_pop_impl(self, index);
140
141	exit:
142	return return_value;
143	}
144
145	PyDoc_STRVAR(list_sort__doc__,
146	"sort($self, /, *, key=None, reverse=False)\n"
147	"--\n"
148	"\n"
149	"Sort the list in ascending order and return None.\n"
150	"\n"
151	"The sort is in-place (i.e. the list itself is modified) and stable (i.e. the\n"
152	"order of two equal elements is maintained).\n"
153	"\n"
154	"If a key function is given, apply it once to each list item and sort them,\n"
155	"ascending or descending, according to their function values.\n"
156	"\n"
157	"The reverse flag can be set to sort in descending order.");
158
159	#define LIST_SORT_METHODDEF \
160	{"sort", _PyCFunction_CAST(list_sort), METH_FASTCALL\|METH_KEYWORDS, list_sort__doc__},
161
162	static PyObject *
163	list_sort_impl(PyListObject self, PyObject keyfunc, int reverse);
164
165	static PyObject *
166	list_sort(PyListObject self, PyObject const args, Py_ssize_t nargs, PyObject kwnames)
167	{
168	PyObject *return_value = NULL;
169	static const char * const _keywords[] = {"key", "reverse", NULL};
170	static _PyArg_Parser _parser = {NULL, _keywords, "sort", 0};
171	PyObject *argsbuf[2];
172	Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE47.1k (kwnames) : 0516k ) - 0; Branch (172:36): [True: 47.1k, False: 516k]
173	PyObject *keyfunc = Py_None;
174	int reverse = 0;
175
176	args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 0, 0, argsbuf);
177	if (!args) { Branch (177:9): [True: 6, False: 563k]
178	goto exit;
179	}
180	if (!noptargs) { Branch (180:9): [True: 516k, False: 47.1k]
181	goto skip_optional_kwonly;
182	}
183	if (args[0]) { Branch (183:9): [True: 44.1k, False: 2.95k]
184	keyfunc = args[0];
185	if (!--noptargs) { Branch (185:13): [True: 41.1k, False: 2.98k]
186	goto skip_optional_kwonly;
187	}
188	}
189	reverse = _PyLong_AsInt(args[1]);
190	if (reverse == -1 && PyErr_Occurred()0 ) { Branch (190:9): [True: 0, False: 5.94k] Branch (190:26): [True: 0, False: 0]
191	goto exit;
192	}
193	skip_optional_kwonly:
194	return_value = list_sort_impl(self, keyfunc, reverse);
195
196	exit:
197	return return_value;
198	}
199
200	PyDoc_STRVAR(list_reverse__doc__,
201	"reverse($self, /)\n"
202	"--\n"
203	"\n"
204	"Reverse IN PLACE.");
205
206	#define LIST_REVERSE_METHODDEF \
207	{"reverse", (PyCFunction)list_reverse, METH_NOARGS, list_reverse__doc__},
208
209	static PyObject *
210	list_reverse_impl(PyListObject *self);
211
212	static PyObject *
213	list_reverse(PyListObject self, PyObject Py_UNUSED(ignored))
214	{
215	return list_reverse_impl(self);
216	}
217
218	PyDoc_STRVAR(list_index__doc__,
219	"index($self, value, start=0, stop=sys.maxsize, /)\n"
220	"--\n"
221	"\n"
222	"Return first index of value.\n"
223	"\n"
224	"Raises ValueError if the value is not present.");
225
226	#define LIST_INDEX_METHODDEF \
227	{"index", _PyCFunction_CAST(list_index), METH_FASTCALL, list_index__doc__},
228
229	static PyObject *
230	list_index_impl(PyListObject self, PyObject value, Py_ssize_t start,
231	Py_ssize_t stop);
232
233	static PyObject *
234	list_index(PyListObject self, PyObject const *args, Py_ssize_t nargs)
235	{
236	PyObject *return_value = NULL;
237	PyObject *value;
238	Py_ssize_t start = 0;
239	Py_ssize_t stop = PY_SSIZE_T_MAX;
240
241	if (!_PyArg_CheckPositional("index", nargs, 1, 3)) {
242	goto exit;
243	}
244	value = args[0];
245	if (nargs < 2) { Branch (245:9): [True: 32.8k, False: 69.1k]
246	goto skip_optional;
247	}
248	if (!_PyEval_SliceIndexNotNone(args[1], &start)) { Branch (248:9): [True: 0, False: 69.1k]
249	goto exit;
250	}
251	if (nargs < 3) { Branch (251:9): [True: 119, False: 68.9k]
252	goto skip_optional;
253	}
254	if (!_PyEval_SliceIndexNotNone(args[2], &stop)) { Branch (254:9): [True: 0, False: 68.9k]
255	goto exit;
256	}
257	skip_optional:
258	return_value = list_index_impl(self, value, start, stop);
259
260	exit:
261	return return_value;
262	}
263
264	PyDoc_STRVAR(list_count__doc__,
265	"count($self, value, /)\n"
266	"--\n"
267	"\n"
268	"Return number of occurrences of value.");
269
270	#define LIST_COUNT_METHODDEF \
271	{"count", (PyCFunction)list_count, METH_O, list_count__doc__},
272
273	PyDoc_STRVAR(list_remove__doc__,
274	"remove($self, value, /)\n"
275	"--\n"
276	"\n"
277	"Remove first occurrence of value.\n"
278	"\n"
279	"Raises ValueError if the value is not present.");
280
281	#define LIST_REMOVE_METHODDEF \
282	{"remove", (PyCFunction)list_remove, METH_O, list_remove__doc__},
283
284	PyDoc_STRVAR(list___init____doc__,
285	"list(iterable=(), /)\n"
286	"--\n"
287	"\n"
288	"Built-in mutable sequence.\n"
289	"\n"
290	"If no argument is given, the constructor creates a new empty list.\n"
291	"The argument must be an iterable if specified.");
292
293	static int
294	list___init___impl(PyListObject self, PyObject iterable);
295
296	static int
297	list___init__(PyObject self, PyObject args, PyObject *kwargs)
298	{
299	int return_value = -1;
300	PyObject *iterable = NULL;
301
302	if ((Py_IS_TYPE(self, &PyList_Type) \|\|
303	Py_TYPE103k (self)->tp_new == PyList_Type.tp_new103k ) && Branch (303:10): [True: 102k, False: 1.03k]
304	!102k _PyArg_NoKeywords102k ("list", kwargs)) {
305	goto exit;
306	}
307	if (!_PyArg_CheckPositional("list", PyTuple_GET_SIZE(args), 0, 1)) {
308	goto exit;
309	}
310	if (PyTuple_GET_SIZE(args) < 1) { Branch (310:9): [True: 98.2k, False: 5.53k]
311	goto skip_optional;
312	}
313	iterable = PyTuple_GET_ITEM(args, 0);
314	skip_optional:
315	return_value = list___init___impl((PyListObject *)self, iterable);
316
317	exit:
318	return return_value;
319	}
320
321	PyDoc_STRVAR(list___sizeof____doc__,
322	"__sizeof__($self, /)\n"
323	"--\n"
324	"\n"
325	"Return the size of the list in memory, in bytes.");
326
327	#define LIST___SIZEOF___METHODDEF \
328	{"__sizeof__", (PyCFunction)list___sizeof__, METH_NOARGS, list___sizeof____doc__},
329
330	static PyObject *
331	list___sizeof___impl(PyListObject *self);
332
333	static PyObject *
334	list___sizeof__(PyListObject self, PyObject Py_UNUSED(ignored))
335	{
336	return list___sizeof___impl(self);
337	}
338
339	PyDoc_STRVAR(list___reversed____doc__,
340	"__reversed__($self, /)\n"
341	"--\n"
342	"\n"
343	"Return a reverse iterator over the list.");
344
345	#define LIST___REVERSED___METHODDEF \
346	{"__reversed__", (PyCFunction)list___reversed__, METH_NOARGS, list___reversed____doc__},
347
348	static PyObject *
349	list___reversed___impl(PyListObject *self);
350
351	static PyObject *
352	list___reversed__(PyListObject self, PyObject Py_UNUSED(ignored))
353	{
354	return list___reversed___impl(self);
355	}
356	/[clinic end generated code: output=eab97a76b1568a03 input=a9049054013a1b77]/