Debian Codegraph @

Modules/clinic/_collectionsmodule.c.h

raw
1 /*[clinic input]
2 preserve
3 [clinic start generated code]*/
4
5 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
6 # include "pycore_gc.h" // PyGC_Head
7 # include "pycore_runtime.h" // _Py_ID()
8 #endif
9 #include "pycore_abstract.h" // _PyNumber_Index()
10 #include "pycore_critical_section.h"// Py_BEGIN_CRITICAL_SECTION()
11 #include "pycore_modsupport.h" // _PyArg_CheckPositional()
12
13 PyDoc_STRVAR(deque_pop__doc__,
14 "pop($self, /)\n"
15 "--\n"
16 "\n"
17 "Remove and return the rightmost element.");
18
19 #define DEQUE_POP_METHODDEF \
20 {"pop", (PyCFunction)deque_pop, METH_NOARGS, deque_pop__doc__},
21
22 static PyObject *
23 deque_pop_impl(dequeobject *deque);
24
25 static PyObject *
26 deque_pop(PyObject *deque, PyObject *Py_UNUSED(ignored))
27 {
28 PyObject *return_value = NULL;
29
30 Py_BEGIN_CRITICAL_SECTION(deque);
31 return_value = deque_pop_impl((dequeobject *)deque);
32 Py_END_CRITICAL_SECTION();
33
34 return return_value;
35 }
36
37 PyDoc_STRVAR(deque_popleft__doc__,
38 "popleft($self, /)\n"
39 "--\n"
40 "\n"
41 "Remove and return the leftmost element.");
42
43 #define DEQUE_POPLEFT_METHODDEF \
44 {"popleft", (PyCFunction)deque_popleft, METH_NOARGS, deque_popleft__doc__},
45
46 static PyObject *
47 deque_popleft_impl(dequeobject *deque);
48
49 static PyObject *
50 deque_popleft(PyObject *deque, PyObject *Py_UNUSED(ignored))
51 {
52 PyObject *return_value = NULL;
53
54 Py_BEGIN_CRITICAL_SECTION(deque);
55 return_value = deque_popleft_impl((dequeobject *)deque);
56 Py_END_CRITICAL_SECTION();
57
58 return return_value;
59 }
60
61 PyDoc_STRVAR(deque_append__doc__,
62 "append($self, item, /)\n"
63 "--\n"
64 "\n"
65 "Add an element to the right side of the deque.");
66
67 #define DEQUE_APPEND_METHODDEF \
68 {"append", (PyCFunction)deque_append, METH_O, deque_append__doc__},
69
70 static PyObject *
71 deque_append_impl(dequeobject *deque, PyObject *item);
72
73 static PyObject *
74 deque_append(PyObject *deque, PyObject *item)
75 {
76 PyObject *return_value = NULL;
77
78 Py_BEGIN_CRITICAL_SECTION(deque);
79 return_value = deque_append_impl((dequeobject *)deque, item);
80 Py_END_CRITICAL_SECTION();
81
82 return return_value;
83 }
84
85 PyDoc_STRVAR(deque_appendleft__doc__,
86 "appendleft($self, item, /)\n"
87 "--\n"
88 "\n"
89 "Add an element to the left side of the deque.");
90
91 #define DEQUE_APPENDLEFT_METHODDEF \
92 {"appendleft", (PyCFunction)deque_appendleft, METH_O, deque_appendleft__doc__},
93
94 static PyObject *
95 deque_appendleft_impl(dequeobject *deque, PyObject *item);
96
97 static PyObject *
98 deque_appendleft(PyObject *deque, PyObject *item)
99 {
100 PyObject *return_value = NULL;
101
102 Py_BEGIN_CRITICAL_SECTION(deque);
103 return_value = deque_appendleft_impl((dequeobject *)deque, item);
104 Py_END_CRITICAL_SECTION();
105
106 return return_value;
107 }
108
109 PyDoc_STRVAR(deque_extend__doc__,
110 "extend($self, iterable, /)\n"
111 "--\n"
112 "\n"
113 "Extend the right side of the deque with elements from the iterable.");
114
115 #define DEQUE_EXTEND_METHODDEF \
116 {"extend", (PyCFunction)deque_extend, METH_O, deque_extend__doc__},
117
118 static PyObject *
119 deque_extend_impl(dequeobject *deque, PyObject *iterable);
120
121 static PyObject *
122 deque_extend(PyObject *deque, PyObject *iterable)
123 {
124 PyObject *return_value = NULL;
125
126 Py_BEGIN_CRITICAL_SECTION(deque);
127 return_value = deque_extend_impl((dequeobject *)deque, iterable);
128 Py_END_CRITICAL_SECTION();
129
130 return return_value;
131 }
132
133 PyDoc_STRVAR(deque_extendleft__doc__,
134 "extendleft($self, iterable, /)\n"
135 "--\n"
136 "\n"
137 "Extend the left side of the deque with elements from the iterable.");
138
139 #define DEQUE_EXTENDLEFT_METHODDEF \
140 {"extendleft", (PyCFunction)deque_extendleft, METH_O, deque_extendleft__doc__},
141
142 static PyObject *
143 deque_extendleft_impl(dequeobject *deque, PyObject *iterable);
144
145 static PyObject *
146 deque_extendleft(PyObject *deque, PyObject *iterable)
147 {
148 PyObject *return_value = NULL;
149
150 Py_BEGIN_CRITICAL_SECTION(deque);
151 return_value = deque_extendleft_impl((dequeobject *)deque, iterable);
152 Py_END_CRITICAL_SECTION();
153
154 return return_value;
155 }
156
157 PyDoc_STRVAR(deque_copy__doc__,
158 "copy($self, /)\n"
159 "--\n"
160 "\n"
161 "Return a shallow copy of a deque.");
162
163 #define DEQUE_COPY_METHODDEF \
164 {"copy", (PyCFunction)deque_copy, METH_NOARGS, deque_copy__doc__},
165
166 static PyObject *
167 deque_copy_impl(dequeobject *deque);
168
169 static PyObject *
170 deque_copy(PyObject *deque, PyObject *Py_UNUSED(ignored))
171 {
172 PyObject *return_value = NULL;
173
174 Py_BEGIN_CRITICAL_SECTION(deque);
175 return_value = deque_copy_impl((dequeobject *)deque);
176 Py_END_CRITICAL_SECTION();
177
178 return return_value;
179 }
180
181 PyDoc_STRVAR(deque___copy____doc__,
182 "__copy__($self, /)\n"
183 "--\n"
184 "\n"
185 "Return a shallow copy of a deque.");
186
187 #define DEQUE___COPY___METHODDEF \
188 {"__copy__", (PyCFunction)deque___copy__, METH_NOARGS, deque___copy____doc__},
189
190 static PyObject *
191 deque___copy___impl(dequeobject *deque);
192
193 static PyObject *
194 deque___copy__(PyObject *deque, PyObject *Py_UNUSED(ignored))
195 {
196 PyObject *return_value = NULL;
197
198 Py_BEGIN_CRITICAL_SECTION(deque);
199 return_value = deque___copy___impl((dequeobject *)deque);
200 Py_END_CRITICAL_SECTION();
201
202 return return_value;
203 }
204
205 PyDoc_STRVAR(deque_clearmethod__doc__,
206 "clear($self, /)\n"
207 "--\n"
208 "\n"
209 "Remove all elements from the deque.");
210
211 #define DEQUE_CLEARMETHOD_METHODDEF \
212 {"clear", (PyCFunction)deque_clearmethod, METH_NOARGS, deque_clearmethod__doc__},
213
214 static PyObject *
215 deque_clearmethod_impl(dequeobject *deque);
216
217 static PyObject *
218 deque_clearmethod(PyObject *deque, PyObject *Py_UNUSED(ignored))
219 {
220 PyObject *return_value = NULL;
221
222 Py_BEGIN_CRITICAL_SECTION(deque);
223 return_value = deque_clearmethod_impl((dequeobject *)deque);
224 Py_END_CRITICAL_SECTION();
225
226 return return_value;
227 }
228
229 PyDoc_STRVAR(deque_rotate__doc__,
230 "rotate($self, n=1, /)\n"
231 "--\n"
232 "\n"
233 "Rotate the deque n steps to the right. If n is negative, rotates left.");
234
235 #define DEQUE_ROTATE_METHODDEF \
236 {"rotate", _PyCFunction_CAST(deque_rotate), METH_FASTCALL, deque_rotate__doc__},
237
238 static PyObject *
239 deque_rotate_impl(dequeobject *deque, Py_ssize_t n);
240
241 static PyObject *
242 deque_rotate(PyObject *deque, PyObject *const *args, Py_ssize_t nargs)
243 {
244 PyObject *return_value = NULL;
245 Py_ssize_t n = 1;
246
247 if (!_PyArg_CheckPositional("rotate", nargs, 0, 1)) {
248 goto exit;
249 }
250 if (nargs < 1) {
251 goto skip_optional;
252 }
253 {
254 Py_ssize_t ival = -1;
255 PyObject *iobj = _PyNumber_Index(args[0]);
256 if (iobj != NULL) {
257 ival = PyLong_AsSsize_t(iobj);
258 Py_DECREF(iobj);
259 }
260 if (ival == -1 && PyErr_Occurred()) {
261 goto exit;
262 }
263 n = ival;
264 }
265 skip_optional:
266 Py_BEGIN_CRITICAL_SECTION(deque);
267 return_value = deque_rotate_impl((dequeobject *)deque, n);
268 Py_END_CRITICAL_SECTION();
269
270 exit:
271 return return_value;
272 }
273
274 PyDoc_STRVAR(deque_reverse__doc__,
275 "reverse($self, /)\n"
276 "--\n"
277 "\n"
278 "Reverse *IN PLACE*.");
279
280 #define DEQUE_REVERSE_METHODDEF \
281 {"reverse", (PyCFunction)deque_reverse, METH_NOARGS, deque_reverse__doc__},
282
283 static PyObject *
284 deque_reverse_impl(dequeobject *deque);
285
286 static PyObject *
287 deque_reverse(PyObject *deque, PyObject *Py_UNUSED(ignored))
288 {
289 PyObject *return_value = NULL;
290
291 Py_BEGIN_CRITICAL_SECTION(deque);
292 return_value = deque_reverse_impl((dequeobject *)deque);
293 Py_END_CRITICAL_SECTION();
294
295 return return_value;
296 }
297
298 PyDoc_STRVAR(deque_count__doc__,
299 "count($self, value, /)\n"
300 "--\n"
301 "\n"
302 "Return number of occurrences of value.");
303
304 #define DEQUE_COUNT_METHODDEF \
305 {"count", (PyCFunction)deque_count, METH_O, deque_count__doc__},
306
307 static PyObject *
308 deque_count_impl(dequeobject *deque, PyObject *v);
309
310 static PyObject *
311 deque_count(PyObject *deque, PyObject *v)
312 {
313 PyObject *return_value = NULL;
314
315 Py_BEGIN_CRITICAL_SECTION(deque);
316 return_value = deque_count_impl((dequeobject *)deque, v);
317 Py_END_CRITICAL_SECTION();
318
319 return return_value;
320 }
321
322 PyDoc_STRVAR(deque_index__doc__,
323 "index($self, value, [start, [stop]])\n"
324 "--\n"
325 "\n"
326 "Return first index of value.\n"
327 "\n"
328 "Raises ValueError if the value is not present.");
329
330 #define DEQUE_INDEX_METHODDEF \
331 {"index", _PyCFunction_CAST(deque_index), METH_FASTCALL, deque_index__doc__},
332
333 static PyObject *
334 deque_index_impl(dequeobject *deque, PyObject *v, Py_ssize_t start,
335 Py_ssize_t stop);
336
337 static PyObject *
338 deque_index(PyObject *deque, PyObject *const *args, Py_ssize_t nargs)
339 {
340 PyObject *return_value = NULL;
341 PyObject *v;
342 Py_ssize_t start = 0;
343 Py_ssize_t stop = PY_SSIZE_T_MAX;
344
345 if (!_PyArg_CheckPositional("index", nargs, 1, 3)) {
346 goto exit;
347 }
348 v = args[0];
349 if (nargs < 2) {
350 goto skip_optional;
351 }
352 if (!_PyEval_SliceIndexNotNone(args[1], &start)) {
353 goto exit;
354 }
355 if (nargs < 3) {
356 goto skip_optional;
357 }
358 if (!_PyEval_SliceIndexNotNone(args[2], &stop)) {
359 goto exit;
360 }
361 skip_optional:
362 Py_BEGIN_CRITICAL_SECTION(deque);
363 return_value = deque_index_impl((dequeobject *)deque, v, start, stop);
364 Py_END_CRITICAL_SECTION();
365
366 exit:
367 return return_value;
368 }
369
370 PyDoc_STRVAR(deque_insert__doc__,
371 "insert($self, index, value, /)\n"
372 "--\n"
373 "\n"
374 "Insert value before index.");
375
376 #define DEQUE_INSERT_METHODDEF \
377 {"insert", _PyCFunction_CAST(deque_insert), METH_FASTCALL, deque_insert__doc__},
378
379 static PyObject *
380 deque_insert_impl(dequeobject *deque, Py_ssize_t index, PyObject *value);
381
382 static PyObject *
383 deque_insert(PyObject *deque, PyObject *const *args, Py_ssize_t nargs)
384 {
385 PyObject *return_value = NULL;
386 Py_ssize_t index;
387 PyObject *value;
388
389 if (!_PyArg_CheckPositional("insert", nargs, 2, 2)) {
390 goto exit;
391 }
392 {
393 Py_ssize_t ival = -1;
394 PyObject *iobj = _PyNumber_Index(args[0]);
395 if (iobj != NULL) {
396 ival = PyLong_AsSsize_t(iobj);
397 Py_DECREF(iobj);
398 }
399 if (ival == -1 && PyErr_Occurred()) {
400 goto exit;
401 }
402 index = ival;
403 }
404 value = args[1];
405 Py_BEGIN_CRITICAL_SECTION(deque);
406 return_value = deque_insert_impl((dequeobject *)deque, index, value);
407 Py_END_CRITICAL_SECTION();
408
409 exit:
410 return return_value;
411 }
412
413 PyDoc_STRVAR(deque_remove__doc__,
414 "remove($self, value, /)\n"
415 "--\n"
416 "\n"
417 "Remove first occurrence of value.");
418
419 #define DEQUE_REMOVE_METHODDEF \
420 {"remove", (PyCFunction)deque_remove, METH_O, deque_remove__doc__},
421
422 static PyObject *
423 deque_remove_impl(dequeobject *deque, PyObject *value);
424
425 static PyObject *
426 deque_remove(PyObject *deque, PyObject *value)
427 {
428 PyObject *return_value = NULL;
429
430 Py_BEGIN_CRITICAL_SECTION(deque);
431 return_value = deque_remove_impl((dequeobject *)deque, value);
432 Py_END_CRITICAL_SECTION();
433
434 return return_value;
435 }
436
437 PyDoc_STRVAR(deque___reduce____doc__,
438 "__reduce__($self, /)\n"
439 "--\n"
440 "\n"
441 "Return state information for pickling.");
442
443 #define DEQUE___REDUCE___METHODDEF \
444 {"__reduce__", (PyCFunction)deque___reduce__, METH_NOARGS, deque___reduce____doc__},
445
446 static PyObject *
447 deque___reduce___impl(dequeobject *deque);
448
449 static PyObject *
450 deque___reduce__(PyObject *deque, PyObject *Py_UNUSED(ignored))
451 {
452 return deque___reduce___impl((dequeobject *)deque);
453 }
454
455 PyDoc_STRVAR(deque_init__doc__,
456 "deque([iterable[, maxlen]])\n"
457 "--\n"
458 "\n"
459 "A list-like sequence optimized for data accesses near its endpoints.");
460
461 static int
462 deque_init_impl(dequeobject *deque, PyObject *iterable, PyObject *maxlenobj);
463
464 static int
465 deque_init(PyObject *deque, PyObject *args, PyObject *kwargs)
466 {
467 int return_value = -1;
468 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
469
470 #define NUM_KEYWORDS 2
471 static struct {
472 PyGC_Head _this_is_not_used;
473 PyObject_VAR_HEAD
474 Py_hash_t ob_hash;
475 PyObject *ob_item[NUM_KEYWORDS];
476 } _kwtuple = {
477 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
478 .ob_hash = -1,
479 .ob_item = { &_Py_ID(iterable), &_Py_ID(maxlen), },
480 };
481 #undef NUM_KEYWORDS
482 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
483
484 #else // !Py_BUILD_CORE
485 # define KWTUPLE NULL
486 #endif // !Py_BUILD_CORE
487
488 static const char * const _keywords[] = {"iterable", "maxlen", NULL};
489 static _PyArg_Parser _parser = {
490 .keywords = _keywords,
491 .fname = "deque",
492 .kwtuple = KWTUPLE,
493 };
494 #undef KWTUPLE
495 PyObject *argsbuf[2];
496 PyObject * const *fastargs;
497 Py_ssize_t nargs = PyTuple_GET_SIZE(args);
498 Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
499 PyObject *iterable = NULL;
500 PyObject *maxlenobj = NULL;
501
502 fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser,
503 /*minpos*/ 0, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
504 if (!fastargs) {
505 goto exit;
506 }
507 if (!noptargs) {
508 goto skip_optional_pos;
509 }
510 if (fastargs[0]) {
511 iterable = fastargs[0];
512 if (!--noptargs) {
513 goto skip_optional_pos;
514 }
515 }
516 maxlenobj = fastargs[1];
517 skip_optional_pos:
518 Py_BEGIN_CRITICAL_SECTION(deque);
519 return_value = deque_init_impl((dequeobject *)deque, iterable, maxlenobj);
520 Py_END_CRITICAL_SECTION();
521
522 exit:
523 return return_value;
524 }
525
526 PyDoc_STRVAR(deque___sizeof____doc__,
527 "__sizeof__($self, /)\n"
528 "--\n"
529 "\n"
530 "Return the size of the deque in memory, in bytes.");
531
532 #define DEQUE___SIZEOF___METHODDEF \
533 {"__sizeof__", (PyCFunction)deque___sizeof__, METH_NOARGS, deque___sizeof____doc__},
534
535 static PyObject *
536 deque___sizeof___impl(dequeobject *deque);
537
538 static PyObject *
539 deque___sizeof__(PyObject *deque, PyObject *Py_UNUSED(ignored))
540 {
541 PyObject *return_value = NULL;
542
543 Py_BEGIN_CRITICAL_SECTION(deque);
544 return_value = deque___sizeof___impl((dequeobject *)deque);
545 Py_END_CRITICAL_SECTION();
546
547 return return_value;
548 }
549
550 PyDoc_STRVAR(deque___reversed____doc__,
551 "__reversed__($self, /)\n"
552 "--\n"
553 "\n"
554 "Return a reverse iterator over the deque.");
555
556 #define DEQUE___REVERSED___METHODDEF \
557 {"__reversed__", (PyCFunction)deque___reversed__, METH_NOARGS, deque___reversed____doc__},
558
559 static PyObject *
560 deque___reversed___impl(dequeobject *deque);
561
562 static PyObject *
563 deque___reversed__(PyObject *deque, PyObject *Py_UNUSED(ignored))
564 {
565 return deque___reversed___impl((dequeobject *)deque);
566 }
567
568 PyDoc_STRVAR(_collections__count_elements__doc__,
569 "_count_elements($module, mapping, iterable, /)\n"
570 "--\n"
571 "\n"
572 "Count elements in the iterable, updating the mapping");
573
574 #define _COLLECTIONS__COUNT_ELEMENTS_METHODDEF \
575 {"_count_elements", _PyCFunction_CAST(_collections__count_elements), METH_FASTCALL, _collections__count_elements__doc__},
576
577 static PyObject *
578 _collections__count_elements_impl(PyObject *module, PyObject *mapping,
579 PyObject *iterable);
580
581 static PyObject *
582 _collections__count_elements(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
583 {
584 PyObject *return_value = NULL;
585 PyObject *mapping;
586 PyObject *iterable;
587
588 if (!_PyArg_CheckPositional("_count_elements", nargs, 2, 2)) {
589 goto exit;
590 }
591 mapping = args[0];
592 iterable = args[1];
593 return_value = _collections__count_elements_impl(module, mapping, iterable);
594
595 exit:
596 return return_value;
597 }
598
599 static PyObject *
600 tuplegetter_new_impl(PyTypeObject *type, Py_ssize_t index, PyObject *doc);
601
602 static PyObject *
603 tuplegetter_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
604 {
605 PyObject *return_value = NULL;
606 PyTypeObject *base_tp = clinic_state()->tuplegetter_type;
607 Py_ssize_t index;
608 PyObject *doc;
609
610 if ((type == base_tp || type->tp_init == base_tp->tp_init) &&
611 !_PyArg_NoKeywords("_tuplegetter", kwargs)) {
612 goto exit;
613 }
614 if (!_PyArg_CheckPositional("_tuplegetter", PyTuple_GET_SIZE(args), 2, 2)) {
615 goto exit;
616 }
617 {
618 Py_ssize_t ival = -1;
619 PyObject *iobj = _PyNumber_Index(PyTuple_GET_ITEM(args, 0));
620 if (iobj != NULL) {
621 ival = PyLong_AsSsize_t(iobj);
622 Py_DECREF(iobj);
623 }
624 if (ival == -1 && PyErr_Occurred()) {
625 goto exit;
626 }
627 index = ival;
628 }
629 doc = PyTuple_GET_ITEM(args, 1);
630 return_value = tuplegetter_new_impl(type, index, doc);
631
632 exit:
633 return return_value;
634 }
635 /*[clinic end generated code: output=f5a388add99d3d15 input=a9049054013a1b77]*/