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 *
deque_pop(dequeobject * deque,PyObject * Py_UNUSED (ignored))26 deque_pop(dequeobject *deque, PyObject *Py_UNUSED(ignored))
27 {
28 PyObject *return_value = NULL;
29
30 Py_BEGIN_CRITICAL_SECTION(deque);
31 return_value = deque_pop_impl(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 *
deque_popleft(dequeobject * deque,PyObject * Py_UNUSED (ignored))50 deque_popleft(dequeobject *deque, PyObject *Py_UNUSED(ignored))
51 {
52 PyObject *return_value = NULL;
53
54 Py_BEGIN_CRITICAL_SECTION(deque);
55 return_value = deque_popleft_impl(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 *
deque_append(dequeobject * deque,PyObject * item)74 deque_append(dequeobject *deque, PyObject *item)
75 {
76 PyObject *return_value = NULL;
77
78 Py_BEGIN_CRITICAL_SECTION(deque);
79 return_value = deque_append_impl(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 *
deque_appendleft(dequeobject * deque,PyObject * item)98 deque_appendleft(dequeobject *deque, PyObject *item)
99 {
100 PyObject *return_value = NULL;
101
102 Py_BEGIN_CRITICAL_SECTION(deque);
103 return_value = deque_appendleft_impl(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 *
deque_extend(dequeobject * deque,PyObject * iterable)122 deque_extend(dequeobject *deque, PyObject *iterable)
123 {
124 PyObject *return_value = NULL;
125
126 Py_BEGIN_CRITICAL_SECTION(deque);
127 return_value = deque_extend_impl(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 *
deque_extendleft(dequeobject * deque,PyObject * iterable)146 deque_extendleft(dequeobject *deque, PyObject *iterable)
147 {
148 PyObject *return_value = NULL;
149
150 Py_BEGIN_CRITICAL_SECTION(deque);
151 return_value = deque_extendleft_impl(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 *
deque_copy(dequeobject * deque,PyObject * Py_UNUSED (ignored))170 deque_copy(dequeobject *deque, PyObject *Py_UNUSED(ignored))
171 {
172 PyObject *return_value = NULL;
173
174 Py_BEGIN_CRITICAL_SECTION(deque);
175 return_value = deque_copy_impl(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 *
deque___copy__(dequeobject * deque,PyObject * Py_UNUSED (ignored))194 deque___copy__(dequeobject *deque, PyObject *Py_UNUSED(ignored))
195 {
196 PyObject *return_value = NULL;
197
198 Py_BEGIN_CRITICAL_SECTION(deque);
199 return_value = deque___copy___impl(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 *
deque_clearmethod(dequeobject * deque,PyObject * Py_UNUSED (ignored))218 deque_clearmethod(dequeobject *deque, PyObject *Py_UNUSED(ignored))
219 {
220 PyObject *return_value = NULL;
221
222 Py_BEGIN_CRITICAL_SECTION(deque);
223 return_value = deque_clearmethod_impl(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 *
deque_rotate(dequeobject * deque,PyObject * const * args,Py_ssize_t nargs)242 deque_rotate(dequeobject *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(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 *
deque_reverse(dequeobject * deque,PyObject * Py_UNUSED (ignored))287 deque_reverse(dequeobject *deque, PyObject *Py_UNUSED(ignored))
288 {
289 PyObject *return_value = NULL;
290
291 Py_BEGIN_CRITICAL_SECTION(deque);
292 return_value = deque_reverse_impl(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 *
deque_count(dequeobject * deque,PyObject * v)311 deque_count(dequeobject *deque, PyObject *v)
312 {
313 PyObject *return_value = NULL;
314
315 Py_BEGIN_CRITICAL_SECTION(deque);
316 return_value = deque_count_impl(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 *
deque_index(dequeobject * deque,PyObject * const * args,Py_ssize_t nargs)338 deque_index(dequeobject *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_SIZE(deque);
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(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 *
deque_insert(dequeobject * deque,PyObject * const * args,Py_ssize_t nargs)383 deque_insert(dequeobject *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(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 *
deque_remove(dequeobject * deque,PyObject * value)426 deque_remove(dequeobject *deque, PyObject *value)
427 {
428 PyObject *return_value = NULL;
429
430 Py_BEGIN_CRITICAL_SECTION(deque);
431 return_value = deque_remove_impl(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 *
deque___reduce__(dequeobject * deque,PyObject * Py_UNUSED (ignored))450 deque___reduce__(dequeobject *deque, PyObject *Py_UNUSED(ignored))
451 {
452 return deque___reduce___impl(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
deque_init(PyObject * deque,PyObject * args,PyObject * kwargs)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 PyObject *ob_item[NUM_KEYWORDS];
475 } _kwtuple = {
476 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
477 .ob_item = { &_Py_ID(iterable), &_Py_ID(maxlen), },
478 };
479 #undef NUM_KEYWORDS
480 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
481
482 #else // !Py_BUILD_CORE
483 # define KWTUPLE NULL
484 #endif // !Py_BUILD_CORE
485
486 static const char * const _keywords[] = {"iterable", "maxlen", NULL};
487 static _PyArg_Parser _parser = {
488 .keywords = _keywords,
489 .fname = "deque",
490 .kwtuple = KWTUPLE,
491 };
492 #undef KWTUPLE
493 PyObject *argsbuf[2];
494 PyObject * const *fastargs;
495 Py_ssize_t nargs = PyTuple_GET_SIZE(args);
496 Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
497 PyObject *iterable = NULL;
498 PyObject *maxlenobj = NULL;
499
500 fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 0, 2, 0, argsbuf);
501 if (!fastargs) {
502 goto exit;
503 }
504 if (!noptargs) {
505 goto skip_optional_pos;
506 }
507 if (fastargs[0]) {
508 iterable = fastargs[0];
509 if (!--noptargs) {
510 goto skip_optional_pos;
511 }
512 }
513 maxlenobj = fastargs[1];
514 skip_optional_pos:
515 Py_BEGIN_CRITICAL_SECTION(deque);
516 return_value = deque_init_impl((dequeobject *)deque, iterable, maxlenobj);
517 Py_END_CRITICAL_SECTION();
518
519 exit:
520 return return_value;
521 }
522
523 PyDoc_STRVAR(deque___sizeof____doc__,
524 "__sizeof__($self, /)\n"
525 "--\n"
526 "\n"
527 "Return the size of the deque in memory, in bytes.");
528
529 #define DEQUE___SIZEOF___METHODDEF \
530 {"__sizeof__", (PyCFunction)deque___sizeof__, METH_NOARGS, deque___sizeof____doc__},
531
532 static PyObject *
533 deque___sizeof___impl(dequeobject *deque);
534
535 static PyObject *
deque___sizeof__(dequeobject * deque,PyObject * Py_UNUSED (ignored))536 deque___sizeof__(dequeobject *deque, PyObject *Py_UNUSED(ignored))
537 {
538 PyObject *return_value = NULL;
539
540 Py_BEGIN_CRITICAL_SECTION(deque);
541 return_value = deque___sizeof___impl(deque);
542 Py_END_CRITICAL_SECTION();
543
544 return return_value;
545 }
546
547 PyDoc_STRVAR(deque___reversed____doc__,
548 "__reversed__($self, /)\n"
549 "--\n"
550 "\n"
551 "Return a reverse iterator over the deque.");
552
553 #define DEQUE___REVERSED___METHODDEF \
554 {"__reversed__", (PyCFunction)deque___reversed__, METH_NOARGS, deque___reversed____doc__},
555
556 static PyObject *
557 deque___reversed___impl(dequeobject *deque);
558
559 static PyObject *
deque___reversed__(dequeobject * deque,PyObject * Py_UNUSED (ignored))560 deque___reversed__(dequeobject *deque, PyObject *Py_UNUSED(ignored))
561 {
562 return deque___reversed___impl(deque);
563 }
564
565 PyDoc_STRVAR(_collections__count_elements__doc__,
566 "_count_elements($module, mapping, iterable, /)\n"
567 "--\n"
568 "\n"
569 "Count elements in the iterable, updating the mapping");
570
571 #define _COLLECTIONS__COUNT_ELEMENTS_METHODDEF \
572 {"_count_elements", _PyCFunction_CAST(_collections__count_elements), METH_FASTCALL, _collections__count_elements__doc__},
573
574 static PyObject *
575 _collections__count_elements_impl(PyObject *module, PyObject *mapping,
576 PyObject *iterable);
577
578 static PyObject *
_collections__count_elements(PyObject * module,PyObject * const * args,Py_ssize_t nargs)579 _collections__count_elements(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
580 {
581 PyObject *return_value = NULL;
582 PyObject *mapping;
583 PyObject *iterable;
584
585 if (!_PyArg_CheckPositional("_count_elements", nargs, 2, 2)) {
586 goto exit;
587 }
588 mapping = args[0];
589 iterable = args[1];
590 return_value = _collections__count_elements_impl(module, mapping, iterable);
591
592 exit:
593 return return_value;
594 }
595
596 static PyObject *
597 tuplegetter_new_impl(PyTypeObject *type, Py_ssize_t index, PyObject *doc);
598
599 static PyObject *
tuplegetter_new(PyTypeObject * type,PyObject * args,PyObject * kwargs)600 tuplegetter_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
601 {
602 PyObject *return_value = NULL;
603 PyTypeObject *base_tp = clinic_state()->tuplegetter_type;
604 Py_ssize_t index;
605 PyObject *doc;
606
607 if ((type == base_tp || type->tp_init == base_tp->tp_init) &&
608 !_PyArg_NoKeywords("_tuplegetter", kwargs)) {
609 goto exit;
610 }
611 if (!_PyArg_CheckPositional("_tuplegetter", PyTuple_GET_SIZE(args), 2, 2)) {
612 goto exit;
613 }
614 {
615 Py_ssize_t ival = -1;
616 PyObject *iobj = _PyNumber_Index(PyTuple_GET_ITEM(args, 0));
617 if (iobj != NULL) {
618 ival = PyLong_AsSsize_t(iobj);
619 Py_DECREF(iobj);
620 }
621 if (ival == -1 && PyErr_Occurred()) {
622 goto exit;
623 }
624 index = ival;
625 }
626 doc = PyTuple_GET_ITEM(args, 1);
627 return_value = tuplegetter_new_impl(type, index, doc);
628
629 exit:
630 return return_value;
631 }
632 /*[clinic end generated code: output=64c32b16df7be07a input=a9049054013a1b77]*/
633