1 /*[clinic input]
2 preserve
3 [clinic start generated code]*/
4
5 PyDoc_STRVAR(test_empty_function__doc__,
6 "test_empty_function($module, /)\n"
7 "--\n"
8 "\n");
9
10 #define TEST_EMPTY_FUNCTION_METHODDEF \
11 {"test_empty_function", (PyCFunction)test_empty_function, METH_NOARGS, test_empty_function__doc__},
12
13 static PyObject *
14 test_empty_function_impl(PyObject *module);
15
16 static PyObject *
17 test_empty_function(PyObject *module, PyObject *Py_UNUSED(ignored))
18 {
19 return test_empty_function_impl(module);
20 }
21
22 PyDoc_STRVAR(objects_converter__doc__,
23 "objects_converter($module, a, b=<unrepresentable>, /)\n"
24 "--\n"
25 "\n");
26
27 #define OBJECTS_CONVERTER_METHODDEF \
28 {"objects_converter", _PyCFunction_CAST(objects_converter), METH_FASTCALL, objects_converter__doc__},
29
30 static PyObject *
31 objects_converter_impl(PyObject *module, PyObject *a, PyObject *b);
32
33 static PyObject *
34 objects_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
35 {
36 PyObject *return_value = NULL;
37 PyObject *a;
38 PyObject *b = NULL;
39
40 if (!_PyArg_CheckPositional("objects_converter", nargs, 1, 2)) {
41 goto exit;
42 }
43 a = args[0];
44 if (nargs < 2) {
45 goto skip_optional;
46 }
47 b = args[1];
48 skip_optional:
49 return_value = objects_converter_impl(module, a, b);
50
51 exit:
52 return return_value;
53 }
54
55 PyDoc_STRVAR(bytes_object_converter__doc__,
56 "bytes_object_converter($module, a, /)\n"
57 "--\n"
58 "\n");
59
60 #define BYTES_OBJECT_CONVERTER_METHODDEF \
61 {"bytes_object_converter", (PyCFunction)bytes_object_converter, METH_O, bytes_object_converter__doc__},
62
63 static PyObject *
64 bytes_object_converter_impl(PyObject *module, PyBytesObject *a);
65
66 static PyObject *
67 bytes_object_converter(PyObject *module, PyObject *arg)
68 {
69 PyObject *return_value = NULL;
70 PyBytesObject *a;
71
72 if (!PyBytes_Check(arg)) {
73 _PyArg_BadArgument("bytes_object_converter", "argument", "bytes", arg);
74 goto exit;
75 }
76 a = (PyBytesObject *)arg;
77 return_value = bytes_object_converter_impl(module, a);
78
79 exit:
80 return return_value;
81 }
82
83 PyDoc_STRVAR(byte_array_object_converter__doc__,
84 "byte_array_object_converter($module, a, /)\n"
85 "--\n"
86 "\n");
87
88 #define BYTE_ARRAY_OBJECT_CONVERTER_METHODDEF \
89 {"byte_array_object_converter", (PyCFunction)byte_array_object_converter, METH_O, byte_array_object_converter__doc__},
90
91 static PyObject *
92 byte_array_object_converter_impl(PyObject *module, PyByteArrayObject *a);
93
94 static PyObject *
95 byte_array_object_converter(PyObject *module, PyObject *arg)
96 {
97 PyObject *return_value = NULL;
98 PyByteArrayObject *a;
99
100 if (!PyByteArray_Check(arg)) {
101 _PyArg_BadArgument("byte_array_object_converter", "argument", "bytearray", arg);
102 goto exit;
103 }
104 a = (PyByteArrayObject *)arg;
105 return_value = byte_array_object_converter_impl(module, a);
106
107 exit:
108 return return_value;
109 }
110
111 PyDoc_STRVAR(unicode_converter__doc__,
112 "unicode_converter($module, a, /)\n"
113 "--\n"
114 "\n");
115
116 #define UNICODE_CONVERTER_METHODDEF \
117 {"unicode_converter", (PyCFunction)unicode_converter, METH_O, unicode_converter__doc__},
118
119 static PyObject *
120 unicode_converter_impl(PyObject *module, PyObject *a);
121
122 static PyObject *
123 unicode_converter(PyObject *module, PyObject *arg)
124 {
125 PyObject *return_value = NULL;
126 PyObject *a;
127
128 if (!PyUnicode_Check(arg)) {
129 _PyArg_BadArgument("unicode_converter", "argument", "str", arg);
130 goto exit;
131 }
132 if (PyUnicode_READY(arg) == -1) {
133 goto exit;
134 }
135 a = arg;
136 return_value = unicode_converter_impl(module, a);
137
138 exit:
139 return return_value;
140 }
141
142 PyDoc_STRVAR(bool_converter__doc__,
143 "bool_converter($module, a=True, b=True, c=True, /)\n"
144 "--\n"
145 "\n");
146
147 #define BOOL_CONVERTER_METHODDEF \
148 {"bool_converter", _PyCFunction_CAST(bool_converter), METH_FASTCALL, bool_converter__doc__},
149
150 static PyObject *
151 bool_converter_impl(PyObject *module, int a, int b, int c);
152
153 static PyObject *
154 bool_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
155 {
156 PyObject *return_value = NULL;
157 int a = 1;
158 int b = 1;
159 int c = 1;
160
161 if (!_PyArg_CheckPositional("bool_converter", nargs, 0, 3)) {
162 goto exit;
163 }
164 if (nargs < 1) {
165 goto skip_optional;
166 }
167 a = PyObject_IsTrue(args[0]);
168 if (a < 0) {
169 goto exit;
170 }
171 if (nargs < 2) {
172 goto skip_optional;
173 }
174 b = PyObject_IsTrue(args[1]);
175 if (b < 0) {
176 goto exit;
177 }
178 if (nargs < 3) {
179 goto skip_optional;
180 }
181 c = _PyLong_AsInt(args[2]);
182 if (c == -1 && PyErr_Occurred()) {
183 goto exit;
184 }
185 skip_optional:
186 return_value = bool_converter_impl(module, a, b, c);
187
188 exit:
189 return return_value;
190 }
191
192 PyDoc_STRVAR(char_converter__doc__,
193 "char_converter($module, a=b\'A\', b=b\'\\x07\', c=b\'\\x08\', d=b\'\\t\', e=b\'\\n\',\n"
194 " f=b\'\\x0b\', g=b\'\\x0c\', h=b\'\\r\', i=b\'\"\', j=b\"\'\", k=b\'?\',\n"
195 " l=b\'\\\\\', m=b\'\\x00\', n=b\'\\xff\', /)\n"
196 "--\n"
197 "\n");
198
199 #define CHAR_CONVERTER_METHODDEF \
200 {"char_converter", _PyCFunction_CAST(char_converter), METH_FASTCALL, char_converter__doc__},
201
202 static PyObject *
203 char_converter_impl(PyObject *module, char a, char b, char c, char d, char e,
204 char f, char g, char h, char i, char j, char k, char l,
205 char m, char n);
206
207 static PyObject *
208 char_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
209 {
210 PyObject *return_value = NULL;
211 char a = 'A';
212 char b = '\x07';
213 char c = '\x08';
214 char d = '\t';
215 char e = '\n';
216 char f = '\x0b';
217 char g = '\x0c';
218 char h = '\r';
219 char i = '"';
220 char j = '\'';
221 char k = '?';
222 char l = '\\';
223 char m = '\x00';
224 char n = '\xff';
225
226 if (!_PyArg_CheckPositional("char_converter", nargs, 0, 14)) {
227 goto exit;
228 }
229 if (nargs < 1) {
230 goto skip_optional;
231 }
232 if (PyBytes_Check(args[0]) && PyBytes_GET_SIZE(args[0]) == 1) {
233 a = PyBytes_AS_STRING(args[0])[0];
234 }
235 else if (PyByteArray_Check(args[0]) && PyByteArray_GET_SIZE(args[0]) == 1) {
236 a = PyByteArray_AS_STRING(args[0])[0];
237 }
238 else {
239 _PyArg_BadArgument("char_converter", "argument 1", "a byte string of length 1", args[0]);
240 goto exit;
241 }
242 if (nargs < 2) {
243 goto skip_optional;
244 }
245 if (PyBytes_Check(args[1]) && PyBytes_GET_SIZE(args[1]) == 1) {
246 b = PyBytes_AS_STRING(args[1])[0];
247 }
248 else if (PyByteArray_Check(args[1]) && PyByteArray_GET_SIZE(args[1]) == 1) {
249 b = PyByteArray_AS_STRING(args[1])[0];
250 }
251 else {
252 _PyArg_BadArgument("char_converter", "argument 2", "a byte string of length 1", args[1]);
253 goto exit;
254 }
255 if (nargs < 3) {
256 goto skip_optional;
257 }
258 if (PyBytes_Check(args[2]) && PyBytes_GET_SIZE(args[2]) == 1) {
259 c = PyBytes_AS_STRING(args[2])[0];
260 }
261 else if (PyByteArray_Check(args[2]) && PyByteArray_GET_SIZE(args[2]) == 1) {
262 c = PyByteArray_AS_STRING(args[2])[0];
263 }
264 else {
265 _PyArg_BadArgument("char_converter", "argument 3", "a byte string of length 1", args[2]);
266 goto exit;
267 }
268 if (nargs < 4) {
269 goto skip_optional;
270 }
271 if (PyBytes_Check(args[3]) && PyBytes_GET_SIZE(args[3]) == 1) {
272 d = PyBytes_AS_STRING(args[3])[0];
273 }
274 else if (PyByteArray_Check(args[3]) && PyByteArray_GET_SIZE(args[3]) == 1) {
275 d = PyByteArray_AS_STRING(args[3])[0];
276 }
277 else {
278 _PyArg_BadArgument("char_converter", "argument 4", "a byte string of length 1", args[3]);
279 goto exit;
280 }
281 if (nargs < 5) {
282 goto skip_optional;
283 }
284 if (PyBytes_Check(args[4]) && PyBytes_GET_SIZE(args[4]) == 1) {
285 e = PyBytes_AS_STRING(args[4])[0];
286 }
287 else if (PyByteArray_Check(args[4]) && PyByteArray_GET_SIZE(args[4]) == 1) {
288 e = PyByteArray_AS_STRING(args[4])[0];
289 }
290 else {
291 _PyArg_BadArgument("char_converter", "argument 5", "a byte string of length 1", args[4]);
292 goto exit;
293 }
294 if (nargs < 6) {
295 goto skip_optional;
296 }
297 if (PyBytes_Check(args[5]) && PyBytes_GET_SIZE(args[5]) == 1) {
298 f = PyBytes_AS_STRING(args[5])[0];
299 }
300 else if (PyByteArray_Check(args[5]) && PyByteArray_GET_SIZE(args[5]) == 1) {
301 f = PyByteArray_AS_STRING(args[5])[0];
302 }
303 else {
304 _PyArg_BadArgument("char_converter", "argument 6", "a byte string of length 1", args[5]);
305 goto exit;
306 }
307 if (nargs < 7) {
308 goto skip_optional;
309 }
310 if (PyBytes_Check(args[6]) && PyBytes_GET_SIZE(args[6]) == 1) {
311 g = PyBytes_AS_STRING(args[6])[0];
312 }
313 else if (PyByteArray_Check(args[6]) && PyByteArray_GET_SIZE(args[6]) == 1) {
314 g = PyByteArray_AS_STRING(args[6])[0];
315 }
316 else {
317 _PyArg_BadArgument("char_converter", "argument 7", "a byte string of length 1", args[6]);
318 goto exit;
319 }
320 if (nargs < 8) {
321 goto skip_optional;
322 }
323 if (PyBytes_Check(args[7]) && PyBytes_GET_SIZE(args[7]) == 1) {
324 h = PyBytes_AS_STRING(args[7])[0];
325 }
326 else if (PyByteArray_Check(args[7]) && PyByteArray_GET_SIZE(args[7]) == 1) {
327 h = PyByteArray_AS_STRING(args[7])[0];
328 }
329 else {
330 _PyArg_BadArgument("char_converter", "argument 8", "a byte string of length 1", args[7]);
331 goto exit;
332 }
333 if (nargs < 9) {
334 goto skip_optional;
335 }
336 if (PyBytes_Check(args[8]) && PyBytes_GET_SIZE(args[8]) == 1) {
337 i = PyBytes_AS_STRING(args[8])[0];
338 }
339 else if (PyByteArray_Check(args[8]) && PyByteArray_GET_SIZE(args[8]) == 1) {
340 i = PyByteArray_AS_STRING(args[8])[0];
341 }
342 else {
343 _PyArg_BadArgument("char_converter", "argument 9", "a byte string of length 1", args[8]);
344 goto exit;
345 }
346 if (nargs < 10) {
347 goto skip_optional;
348 }
349 if (PyBytes_Check(args[9]) && PyBytes_GET_SIZE(args[9]) == 1) {
350 j = PyBytes_AS_STRING(args[9])[0];
351 }
352 else if (PyByteArray_Check(args[9]) && PyByteArray_GET_SIZE(args[9]) == 1) {
353 j = PyByteArray_AS_STRING(args[9])[0];
354 }
355 else {
356 _PyArg_BadArgument("char_converter", "argument 10", "a byte string of length 1", args[9]);
357 goto exit;
358 }
359 if (nargs < 11) {
360 goto skip_optional;
361 }
362 if (PyBytes_Check(args[10]) && PyBytes_GET_SIZE(args[10]) == 1) {
363 k = PyBytes_AS_STRING(args[10])[0];
364 }
365 else if (PyByteArray_Check(args[10]) && PyByteArray_GET_SIZE(args[10]) == 1) {
366 k = PyByteArray_AS_STRING(args[10])[0];
367 }
368 else {
369 _PyArg_BadArgument("char_converter", "argument 11", "a byte string of length 1", args[10]);
370 goto exit;
371 }
372 if (nargs < 12) {
373 goto skip_optional;
374 }
375 if (PyBytes_Check(args[11]) && PyBytes_GET_SIZE(args[11]) == 1) {
376 l = PyBytes_AS_STRING(args[11])[0];
377 }
378 else if (PyByteArray_Check(args[11]) && PyByteArray_GET_SIZE(args[11]) == 1) {
379 l = PyByteArray_AS_STRING(args[11])[0];
380 }
381 else {
382 _PyArg_BadArgument("char_converter", "argument 12", "a byte string of length 1", args[11]);
383 goto exit;
384 }
385 if (nargs < 13) {
386 goto skip_optional;
387 }
388 if (PyBytes_Check(args[12]) && PyBytes_GET_SIZE(args[12]) == 1) {
389 m = PyBytes_AS_STRING(args[12])[0];
390 }
391 else if (PyByteArray_Check(args[12]) && PyByteArray_GET_SIZE(args[12]) == 1) {
392 m = PyByteArray_AS_STRING(args[12])[0];
393 }
394 else {
395 _PyArg_BadArgument("char_converter", "argument 13", "a byte string of length 1", args[12]);
396 goto exit;
397 }
398 if (nargs < 14) {
399 goto skip_optional;
400 }
401 if (PyBytes_Check(args[13]) && PyBytes_GET_SIZE(args[13]) == 1) {
402 n = PyBytes_AS_STRING(args[13])[0];
403 }
404 else if (PyByteArray_Check(args[13]) && PyByteArray_GET_SIZE(args[13]) == 1) {
405 n = PyByteArray_AS_STRING(args[13])[0];
406 }
407 else {
408 _PyArg_BadArgument("char_converter", "argument 14", "a byte string of length 1", args[13]);
409 goto exit;
410 }
411 skip_optional:
412 return_value = char_converter_impl(module, a, b, c, d, e, f, g, h, i, j, k, l, m, n);
413
414 exit:
415 return return_value;
416 }
417
418 PyDoc_STRVAR(unsigned_char_converter__doc__,
419 "unsigned_char_converter($module, a=12, b=34, c=56, /)\n"
420 "--\n"
421 "\n");
422
423 #define UNSIGNED_CHAR_CONVERTER_METHODDEF \
424 {"unsigned_char_converter", _PyCFunction_CAST(unsigned_char_converter), METH_FASTCALL, unsigned_char_converter__doc__},
425
426 static PyObject *
427 unsigned_char_converter_impl(PyObject *module, unsigned char a,
428 unsigned char b, unsigned char c);
429
430 static PyObject *
431 unsigned_char_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
432 {
433 PyObject *return_value = NULL;
434 unsigned char a = 12;
435 unsigned char b = 34;
436 unsigned char c = 56;
437
438 if (!_PyArg_CheckPositional("unsigned_char_converter", nargs, 0, 3)) {
439 goto exit;
440 }
441 if (nargs < 1) {
442 goto skip_optional;
443 }
444 {
445 long ival = PyLong_AsLong(args[0]);
446 if (ival == -1 && PyErr_Occurred()) {
447 goto exit;
448 }
449 else if (ival < 0) {
450 PyErr_SetString(PyExc_OverflowError,
451 "unsigned byte integer is less than minimum");
452 goto exit;
453 }
454 else if (ival > UCHAR_MAX) {
455 PyErr_SetString(PyExc_OverflowError,
456 "unsigned byte integer is greater than maximum");
457 goto exit;
458 }
459 else {
460 a = (unsigned char) ival;
461 }
462 }
463 if (nargs < 2) {
464 goto skip_optional;
465 }
466 {
467 long ival = PyLong_AsLong(args[1]);
468 if (ival == -1 && PyErr_Occurred()) {
469 goto exit;
470 }
471 else if (ival < 0) {
472 PyErr_SetString(PyExc_OverflowError,
473 "unsigned byte integer is less than minimum");
474 goto exit;
475 }
476 else if (ival > UCHAR_MAX) {
477 PyErr_SetString(PyExc_OverflowError,
478 "unsigned byte integer is greater than maximum");
479 goto exit;
480 }
481 else {
482 b = (unsigned char) ival;
483 }
484 }
485 if (nargs < 3) {
486 goto skip_optional;
487 }
488 {
489 unsigned long ival = PyLong_AsUnsignedLongMask(args[2]);
490 if (ival == (unsigned long)-1 && PyErr_Occurred()) {
491 goto exit;
492 }
493 else {
494 c = (unsigned char) ival;
495 }
496 }
497 skip_optional:
498 return_value = unsigned_char_converter_impl(module, a, b, c);
499
500 exit:
501 return return_value;
502 }
503
504 PyDoc_STRVAR(short_converter__doc__,
505 "short_converter($module, a=12, /)\n"
506 "--\n"
507 "\n");
508
509 #define SHORT_CONVERTER_METHODDEF \
510 {"short_converter", _PyCFunction_CAST(short_converter), METH_FASTCALL, short_converter__doc__},
511
512 static PyObject *
513 short_converter_impl(PyObject *module, short a);
514
515 static PyObject *
516 short_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
517 {
518 PyObject *return_value = NULL;
519 short a = 12;
520
521 if (!_PyArg_CheckPositional("short_converter", nargs, 0, 1)) {
522 goto exit;
523 }
524 if (nargs < 1) {
525 goto skip_optional;
526 }
527 {
528 long ival = PyLong_AsLong(args[0]);
529 if (ival == -1 && PyErr_Occurred()) {
530 goto exit;
531 }
532 else if (ival < SHRT_MIN) {
533 PyErr_SetString(PyExc_OverflowError,
534 "signed short integer is less than minimum");
535 goto exit;
536 }
537 else if (ival > SHRT_MAX) {
538 PyErr_SetString(PyExc_OverflowError,
539 "signed short integer is greater than maximum");
540 goto exit;
541 }
542 else {
543 a = (short) ival;
544 }
545 }
546 skip_optional:
547 return_value = short_converter_impl(module, a);
548
549 exit:
550 return return_value;
551 }
552
553 PyDoc_STRVAR(unsigned_short_converter__doc__,
554 "unsigned_short_converter($module, a=12, b=34, c=56, /)\n"
555 "--\n"
556 "\n");
557
558 #define UNSIGNED_SHORT_CONVERTER_METHODDEF \
559 {"unsigned_short_converter", _PyCFunction_CAST(unsigned_short_converter), METH_FASTCALL, unsigned_short_converter__doc__},
560
561 static PyObject *
562 unsigned_short_converter_impl(PyObject *module, unsigned short a,
563 unsigned short b, unsigned short c);
564
565 static PyObject *
566 unsigned_short_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
567 {
568 PyObject *return_value = NULL;
569 unsigned short a = 12;
570 unsigned short b = 34;
571 unsigned short c = 56;
572
573 if (!_PyArg_CheckPositional("unsigned_short_converter", nargs, 0, 3)) {
574 goto exit;
575 }
576 if (nargs < 1) {
577 goto skip_optional;
578 }
579 if (!_PyLong_UnsignedShort_Converter(args[0], &a)) {
580 goto exit;
581 }
582 if (nargs < 2) {
583 goto skip_optional;
584 }
585 if (!_PyLong_UnsignedShort_Converter(args[1], &b)) {
586 goto exit;
587 }
588 if (nargs < 3) {
589 goto skip_optional;
590 }
591 c = (unsigned short)PyLong_AsUnsignedLongMask(args[2]);
592 if (c == (unsigned short)-1 && PyErr_Occurred()) {
593 goto exit;
594 }
595 skip_optional:
596 return_value = unsigned_short_converter_impl(module, a, b, c);
597
598 exit:
599 return return_value;
600 }
601
602 PyDoc_STRVAR(int_converter__doc__,
603 "int_converter($module, a=12, b=34, c=45, /)\n"
604 "--\n"
605 "\n");
606
607 #define INT_CONVERTER_METHODDEF \
608 {"int_converter", _PyCFunction_CAST(int_converter), METH_FASTCALL, int_converter__doc__},
609
610 static PyObject *
611 int_converter_impl(PyObject *module, int a, int b, int c);
612
613 static PyObject *
614 int_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
615 {
616 PyObject *return_value = NULL;
617 int a = 12;
618 int b = 34;
619 int c = 45;
620
621 if (!_PyArg_CheckPositional("int_converter", nargs, 0, 3)) {
622 goto exit;
623 }
624 if (nargs < 1) {
625 goto skip_optional;
626 }
627 a = _PyLong_AsInt(args[0]);
628 if (a == -1 && PyErr_Occurred()) {
629 goto exit;
630 }
631 if (nargs < 2) {
632 goto skip_optional;
633 }
634 b = _PyLong_AsInt(args[1]);
635 if (b == -1 && PyErr_Occurred()) {
636 goto exit;
637 }
638 if (nargs < 3) {
639 goto skip_optional;
640 }
641 if (!PyUnicode_Check(args[2])) {
642 _PyArg_BadArgument("int_converter", "argument 3", "a unicode character", args[2]);
643 goto exit;
644 }
645 if (PyUnicode_READY(args[2])) {
646 goto exit;
647 }
648 if (PyUnicode_GET_LENGTH(args[2]) != 1) {
649 _PyArg_BadArgument("int_converter", "argument 3", "a unicode character", args[2]);
650 goto exit;
651 }
652 c = PyUnicode_READ_CHAR(args[2], 0);
653 skip_optional:
654 return_value = int_converter_impl(module, a, b, c);
655
656 exit:
657 return return_value;
658 }
659
660 PyDoc_STRVAR(unsigned_int_converter__doc__,
661 "unsigned_int_converter($module, a=12, b=34, c=56, /)\n"
662 "--\n"
663 "\n");
664
665 #define UNSIGNED_INT_CONVERTER_METHODDEF \
666 {"unsigned_int_converter", _PyCFunction_CAST(unsigned_int_converter), METH_FASTCALL, unsigned_int_converter__doc__},
667
668 static PyObject *
669 unsigned_int_converter_impl(PyObject *module, unsigned int a, unsigned int b,
670 unsigned int c);
671
672 static PyObject *
673 unsigned_int_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
674 {
675 PyObject *return_value = NULL;
676 unsigned int a = 12;
677 unsigned int b = 34;
678 unsigned int c = 56;
679
680 if (!_PyArg_CheckPositional("unsigned_int_converter", nargs, 0, 3)) {
681 goto exit;
682 }
683 if (nargs < 1) {
684 goto skip_optional;
685 }
686 if (!_PyLong_UnsignedInt_Converter(args[0], &a)) {
687 goto exit;
688 }
689 if (nargs < 2) {
690 goto skip_optional;
691 }
692 if (!_PyLong_UnsignedInt_Converter(args[1], &b)) {
693 goto exit;
694 }
695 if (nargs < 3) {
696 goto skip_optional;
697 }
698 c = (unsigned int)PyLong_AsUnsignedLongMask(args[2]);
699 if (c == (unsigned int)-1 && PyErr_Occurred()) {
700 goto exit;
701 }
702 skip_optional:
703 return_value = unsigned_int_converter_impl(module, a, b, c);
704
705 exit:
706 return return_value;
707 }
708
709 PyDoc_STRVAR(long_converter__doc__,
710 "long_converter($module, a=12, /)\n"
711 "--\n"
712 "\n");
713
714 #define LONG_CONVERTER_METHODDEF \
715 {"long_converter", _PyCFunction_CAST(long_converter), METH_FASTCALL, long_converter__doc__},
716
717 static PyObject *
718 long_converter_impl(PyObject *module, long a);
719
720 static PyObject *
721 long_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
722 {
723 PyObject *return_value = NULL;
724 long a = 12;
725
726 if (!_PyArg_CheckPositional("long_converter", nargs, 0, 1)) {
727 goto exit;
728 }
729 if (nargs < 1) {
730 goto skip_optional;
731 }
732 a = PyLong_AsLong(args[0]);
733 if (a == -1 && PyErr_Occurred()) {
734 goto exit;
735 }
736 skip_optional:
737 return_value = long_converter_impl(module, a);
738
739 exit:
740 return return_value;
741 }
742
743 PyDoc_STRVAR(unsigned_long_converter__doc__,
744 "unsigned_long_converter($module, a=12, b=34, c=56, /)\n"
745 "--\n"
746 "\n");
747
748 #define UNSIGNED_LONG_CONVERTER_METHODDEF \
749 {"unsigned_long_converter", _PyCFunction_CAST(unsigned_long_converter), METH_FASTCALL, unsigned_long_converter__doc__},
750
751 static PyObject *
752 unsigned_long_converter_impl(PyObject *module, unsigned long a,
753 unsigned long b, unsigned long c);
754
755 static PyObject *
756 unsigned_long_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
757 {
758 PyObject *return_value = NULL;
759 unsigned long a = 12;
760 unsigned long b = 34;
761 unsigned long c = 56;
762
763 if (!_PyArg_CheckPositional("unsigned_long_converter", nargs, 0, 3)) {
764 goto exit;
765 }
766 if (nargs < 1) {
767 goto skip_optional;
768 }
769 if (!_PyLong_UnsignedLong_Converter(args[0], &a)) {
770 goto exit;
771 }
772 if (nargs < 2) {
773 goto skip_optional;
774 }
775 if (!_PyLong_UnsignedLong_Converter(args[1], &b)) {
776 goto exit;
777 }
778 if (nargs < 3) {
779 goto skip_optional;
780 }
781 if (!PyLong_Check(args[2])) {
782 _PyArg_BadArgument("unsigned_long_converter", "argument 3", "int", args[2]);
783 goto exit;
784 }
785 c = PyLong_AsUnsignedLongMask(args[2]);
786 skip_optional:
787 return_value = unsigned_long_converter_impl(module, a, b, c);
788
789 exit:
790 return return_value;
791 }
792
793 PyDoc_STRVAR(long_long_converter__doc__,
794 "long_long_converter($module, a=12, /)\n"
795 "--\n"
796 "\n");
797
798 #define LONG_LONG_CONVERTER_METHODDEF \
799 {"long_long_converter", _PyCFunction_CAST(long_long_converter), METH_FASTCALL, long_long_converter__doc__},
800
801 static PyObject *
802 long_long_converter_impl(PyObject *module, long long a);
803
804 static PyObject *
805 long_long_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
806 {
807 PyObject *return_value = NULL;
808 long long a = 12;
809
810 if (!_PyArg_CheckPositional("long_long_converter", nargs, 0, 1)) {
811 goto exit;
812 }
813 if (nargs < 1) {
814 goto skip_optional;
815 }
816 a = PyLong_AsLongLong(args[0]);
817 if (a == -1 && PyErr_Occurred()) {
818 goto exit;
819 }
820 skip_optional:
821 return_value = long_long_converter_impl(module, a);
822
823 exit:
824 return return_value;
825 }
826
827 PyDoc_STRVAR(unsigned_long_long_converter__doc__,
828 "unsigned_long_long_converter($module, a=12, b=34, c=56, /)\n"
829 "--\n"
830 "\n");
831
832 #define UNSIGNED_LONG_LONG_CONVERTER_METHODDEF \
833 {"unsigned_long_long_converter", _PyCFunction_CAST(unsigned_long_long_converter), METH_FASTCALL, unsigned_long_long_converter__doc__},
834
835 static PyObject *
836 unsigned_long_long_converter_impl(PyObject *module, unsigned long long a,
837 unsigned long long b, unsigned long long c);
838
839 static PyObject *
840 unsigned_long_long_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
841 {
842 PyObject *return_value = NULL;
843 unsigned long long a = 12;
844 unsigned long long b = 34;
845 unsigned long long c = 56;
846
847 if (!_PyArg_CheckPositional("unsigned_long_long_converter", nargs, 0, 3)) {
848 goto exit;
849 }
850 if (nargs < 1) {
851 goto skip_optional;
852 }
853 if (!_PyLong_UnsignedLongLong_Converter(args[0], &a)) {
854 goto exit;
855 }
856 if (nargs < 2) {
857 goto skip_optional;
858 }
859 if (!_PyLong_UnsignedLongLong_Converter(args[1], &b)) {
860 goto exit;
861 }
862 if (nargs < 3) {
863 goto skip_optional;
864 }
865 if (!PyLong_Check(args[2])) {
866 _PyArg_BadArgument("unsigned_long_long_converter", "argument 3", "int", args[2]);
867 goto exit;
868 }
869 c = PyLong_AsUnsignedLongLongMask(args[2]);
870 skip_optional:
871 return_value = unsigned_long_long_converter_impl(module, a, b, c);
872
873 exit:
874 return return_value;
875 }
876
877 PyDoc_STRVAR(py_ssize_t_converter__doc__,
878 "py_ssize_t_converter($module, a=12, b=34, c=56, /)\n"
879 "--\n"
880 "\n");
881
882 #define PY_SSIZE_T_CONVERTER_METHODDEF \
883 {"py_ssize_t_converter", _PyCFunction_CAST(py_ssize_t_converter), METH_FASTCALL, py_ssize_t_converter__doc__},
884
885 static PyObject *
886 py_ssize_t_converter_impl(PyObject *module, Py_ssize_t a, Py_ssize_t b,
887 Py_ssize_t c);
888
889 static PyObject *
890 py_ssize_t_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
891 {
892 PyObject *return_value = NULL;
893 Py_ssize_t a = 12;
894 Py_ssize_t b = 34;
895 Py_ssize_t c = 56;
896
897 if (!_PyArg_CheckPositional("py_ssize_t_converter", nargs, 0, 3)) {
898 goto exit;
899 }
900 if (nargs < 1) {
901 goto skip_optional;
902 }
903 {
904 Py_ssize_t ival = -1;
905 PyObject *iobj = _PyNumber_Index(args[0]);
906 if (iobj != NULL) {
907 ival = PyLong_AsSsize_t(iobj);
908 Py_DECREF(iobj);
909 }
910 if (ival == -1 && PyErr_Occurred()) {
911 goto exit;
912 }
913 a = ival;
914 }
915 if (nargs < 2) {
916 goto skip_optional;
917 }
918 {
919 Py_ssize_t ival = -1;
920 PyObject *iobj = _PyNumber_Index(args[1]);
921 if (iobj != NULL) {
922 ival = PyLong_AsSsize_t(iobj);
923 Py_DECREF(iobj);
924 }
925 if (ival == -1 && PyErr_Occurred()) {
926 goto exit;
927 }
928 b = ival;
929 }
930 if (nargs < 3) {
931 goto skip_optional;
932 }
933 if (!_Py_convert_optional_to_ssize_t(args[2], &c)) {
934 goto exit;
935 }
936 skip_optional:
937 return_value = py_ssize_t_converter_impl(module, a, b, c);
938
939 exit:
940 return return_value;
941 }
942
943 PyDoc_STRVAR(slice_index_converter__doc__,
944 "slice_index_converter($module, a=12, b=34, c=56, /)\n"
945 "--\n"
946 "\n");
947
948 #define SLICE_INDEX_CONVERTER_METHODDEF \
949 {"slice_index_converter", _PyCFunction_CAST(slice_index_converter), METH_FASTCALL, slice_index_converter__doc__},
950
951 static PyObject *
952 slice_index_converter_impl(PyObject *module, Py_ssize_t a, Py_ssize_t b,
953 Py_ssize_t c);
954
955 static PyObject *
956 slice_index_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
957 {
958 PyObject *return_value = NULL;
959 Py_ssize_t a = 12;
960 Py_ssize_t b = 34;
961 Py_ssize_t c = 56;
962
963 if (!_PyArg_CheckPositional("slice_index_converter", nargs, 0, 3)) {
964 goto exit;
965 }
966 if (nargs < 1) {
967 goto skip_optional;
968 }
969 if (!_PyEval_SliceIndex(args[0], &a)) {
970 goto exit;
971 }
972 if (nargs < 2) {
973 goto skip_optional;
974 }
975 if (!_PyEval_SliceIndexNotNone(args[1], &b)) {
976 goto exit;
977 }
978 if (nargs < 3) {
979 goto skip_optional;
980 }
981 if (!_PyEval_SliceIndex(args[2], &c)) {
982 goto exit;
983 }
984 skip_optional:
985 return_value = slice_index_converter_impl(module, a, b, c);
986
987 exit:
988 return return_value;
989 }
990
991 PyDoc_STRVAR(size_t_converter__doc__,
992 "size_t_converter($module, a=12, /)\n"
993 "--\n"
994 "\n");
995
996 #define SIZE_T_CONVERTER_METHODDEF \
997 {"size_t_converter", _PyCFunction_CAST(size_t_converter), METH_FASTCALL, size_t_converter__doc__},
998
999 static PyObject *
1000 size_t_converter_impl(PyObject *module, size_t a);
1001
1002 static PyObject *
1003 size_t_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1004 {
1005 PyObject *return_value = NULL;
1006 size_t a = 12;
1007
1008 if (!_PyArg_CheckPositional("size_t_converter", nargs, 0, 1)) {
1009 goto exit;
1010 }
1011 if (nargs < 1) {
1012 goto skip_optional;
1013 }
1014 if (!_PyLong_Size_t_Converter(args[0], &a)) {
1015 goto exit;
1016 }
1017 skip_optional:
1018 return_value = size_t_converter_impl(module, a);
1019
1020 exit:
1021 return return_value;
1022 }
1023
1024 PyDoc_STRVAR(float_converter__doc__,
1025 "float_converter($module, a=12.5, /)\n"
1026 "--\n"
1027 "\n");
1028
1029 #define FLOAT_CONVERTER_METHODDEF \
1030 {"float_converter", _PyCFunction_CAST(float_converter), METH_FASTCALL, float_converter__doc__},
1031
1032 static PyObject *
1033 float_converter_impl(PyObject *module, float a);
1034
1035 static PyObject *
1036 float_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1037 {
1038 PyObject *return_value = NULL;
1039 float a = 12.5;
1040
1041 if (!_PyArg_CheckPositional("float_converter", nargs, 0, 1)) {
1042 goto exit;
1043 }
1044 if (nargs < 1) {
1045 goto skip_optional;
1046 }
1047 if (PyFloat_CheckExact(args[0])) {
1048 a = (float) (PyFloat_AS_DOUBLE(args[0]));
1049 }
1050 else
1051 {
1052 a = (float) PyFloat_AsDouble(args[0]);
1053 if (a == -1.0 && PyErr_Occurred()) {
1054 goto exit;
1055 }
1056 }
1057 skip_optional:
1058 return_value = float_converter_impl(module, a);
1059
1060 exit:
1061 return return_value;
1062 }
1063
1064 PyDoc_STRVAR(double_converter__doc__,
1065 "double_converter($module, a=12.5, /)\n"
1066 "--\n"
1067 "\n");
1068
1069 #define DOUBLE_CONVERTER_METHODDEF \
1070 {"double_converter", _PyCFunction_CAST(double_converter), METH_FASTCALL, double_converter__doc__},
1071
1072 static PyObject *
1073 double_converter_impl(PyObject *module, double a);
1074
1075 static PyObject *
1076 double_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1077 {
1078 PyObject *return_value = NULL;
1079 double a = 12.5;
1080
1081 if (!_PyArg_CheckPositional("double_converter", nargs, 0, 1)) {
1082 goto exit;
1083 }
1084 if (nargs < 1) {
1085 goto skip_optional;
1086 }
1087 if (PyFloat_CheckExact(args[0])) {
1088 a = PyFloat_AS_DOUBLE(args[0]);
1089 }
1090 else
1091 {
1092 a = PyFloat_AsDouble(args[0]);
1093 if (a == -1.0 && PyErr_Occurred()) {
1094 goto exit;
1095 }
1096 }
1097 skip_optional:
1098 return_value = double_converter_impl(module, a);
1099
1100 exit:
1101 return return_value;
1102 }
1103
1104 PyDoc_STRVAR(py_complex_converter__doc__,
1105 "py_complex_converter($module, a, /)\n"
1106 "--\n"
1107 "\n");
1108
1109 #define PY_COMPLEX_CONVERTER_METHODDEF \
1110 {"py_complex_converter", (PyCFunction)py_complex_converter, METH_O, py_complex_converter__doc__},
1111
1112 static PyObject *
1113 py_complex_converter_impl(PyObject *module, Py_complex a);
1114
1115 static PyObject *
1116 py_complex_converter(PyObject *module, PyObject *arg)
1117 {
1118 PyObject *return_value = NULL;
1119 Py_complex a;
1120
1121 a = PyComplex_AsCComplex(arg);
1122 if (PyErr_Occurred()) {
1123 goto exit;
1124 }
1125 return_value = py_complex_converter_impl(module, a);
1126
1127 exit:
1128 return return_value;
1129 }
1130
1131 PyDoc_STRVAR(str_converter__doc__,
1132 "str_converter($module, a=\'a\', b=\'b\', c=\'c\', /)\n"
1133 "--\n"
1134 "\n");
1135
1136 #define STR_CONVERTER_METHODDEF \
1137 {"str_converter", _PyCFunction_CAST(str_converter), METH_FASTCALL, str_converter__doc__},
1138
1139 static PyObject *
1140 str_converter_impl(PyObject *module, const char *a, const char *b,
1141 const char *c, Py_ssize_t c_length);
1142
1143 static PyObject *
1144 str_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1145 {
1146 PyObject *return_value = NULL;
1147 const char *a = "a";
1148 const char *b = "b";
1149 const char *c = "c";
1150 Py_ssize_t c_length;
1151
1152 if (!_PyArg_ParseStack(args, nargs, "|sys#:str_converter",
1153 &a, &b, &c, &c_length)) {
1154 goto exit;
1155 }
1156 return_value = str_converter_impl(module, a, b, c, c_length);
1157
1158 exit:
1159 return return_value;
1160 }
1161
1162 PyDoc_STRVAR(str_converter_encoding__doc__,
1163 "str_converter_encoding($module, a, b, c, /)\n"
1164 "--\n"
1165 "\n");
1166
1167 #define STR_CONVERTER_ENCODING_METHODDEF \
1168 {"str_converter_encoding", _PyCFunction_CAST(str_converter_encoding), METH_FASTCALL, str_converter_encoding__doc__},
1169
1170 static PyObject *
1171 str_converter_encoding_impl(PyObject *module, char *a, char *b, char *c,
1172 Py_ssize_t c_length);
1173
1174 static PyObject *
1175 str_converter_encoding(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1176 {
1177 PyObject *return_value = NULL;
1178 char *a = NULL;
1179 char *b = NULL;
1180 char *c = NULL;
1181 Py_ssize_t c_length;
1182
1183 if (!_PyArg_ParseStack(args, nargs, "esetet#:str_converter_encoding",
1184 "idna", &a, "idna", &b, "idna", &c, &c_length)) {
1185 goto exit;
1186 }
1187 return_value = str_converter_encoding_impl(module, a, b, c, c_length);
1188 /* Post parse cleanup for a */
1189 PyMem_FREE(a);
1190 /* Post parse cleanup for b */
1191 PyMem_FREE(b);
1192 /* Post parse cleanup for c */
1193 PyMem_FREE(c);
1194
1195 exit:
1196 return return_value;
1197 }
1198
1199 PyDoc_STRVAR(py_buffer_converter__doc__,
1200 "py_buffer_converter($module, a, b, /)\n"
1201 "--\n"
1202 "\n");
1203
1204 #define PY_BUFFER_CONVERTER_METHODDEF \
1205 {"py_buffer_converter", _PyCFunction_CAST(py_buffer_converter), METH_FASTCALL, py_buffer_converter__doc__},
1206
1207 static PyObject *
1208 py_buffer_converter_impl(PyObject *module, Py_buffer *a, Py_buffer *b);
1209
1210 static PyObject *
1211 py_buffer_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1212 {
1213 PyObject *return_value = NULL;
1214 Py_buffer a = {NULL, NULL};
1215 Py_buffer b = {NULL, NULL};
1216
1217 if (!_PyArg_ParseStack(args, nargs, "z*w*:py_buffer_converter",
1218 &a, &b)) {
1219 goto exit;
1220 }
1221 return_value = py_buffer_converter_impl(module, &a, &b);
1222
1223 exit:
1224 /* Cleanup for a */
1225 if (a.obj) {
1226 PyBuffer_Release(&a);
1227 }
1228 /* Cleanup for b */
1229 if (b.obj) {
1230 PyBuffer_Release(&b);
1231 }
1232
1233 return return_value;
1234 }
1235
1236 PyDoc_STRVAR(keywords__doc__,
1237 "keywords($module, /, a, b)\n"
1238 "--\n"
1239 "\n");
1240
1241 #define KEYWORDS_METHODDEF \
1242 {"keywords", _PyCFunction_CAST(keywords), METH_FASTCALL|METH_KEYWORDS, keywords__doc__},
1243
1244 static PyObject *
1245 keywords_impl(PyObject *module, PyObject *a, PyObject *b);
1246
1247 static PyObject *
1248 keywords(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1249 {
1250 PyObject *return_value = NULL;
1251 static const char * const _keywords[] = {"a", "b", NULL};
1252 static _PyArg_Parser _parser = {NULL, _keywords, "keywords", 0};
1253 PyObject *argsbuf[2];
1254 PyObject *a;
1255 PyObject *b;
1256
1257 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
1258 if (!args) {
1259 goto exit;
1260 }
1261 a = args[0];
1262 b = args[1];
1263 return_value = keywords_impl(module, a, b);
1264
1265 exit:
1266 return return_value;
1267 }
1268
1269 PyDoc_STRVAR(keywords_kwonly__doc__,
1270 "keywords_kwonly($module, /, a, *, b)\n"
1271 "--\n"
1272 "\n");
1273
1274 #define KEYWORDS_KWONLY_METHODDEF \
1275 {"keywords_kwonly", _PyCFunction_CAST(keywords_kwonly), METH_FASTCALL|METH_KEYWORDS, keywords_kwonly__doc__},
1276
1277 static PyObject *
1278 keywords_kwonly_impl(PyObject *module, PyObject *a, PyObject *b);
1279
1280 static PyObject *
1281 keywords_kwonly(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1282 {
1283 PyObject *return_value = NULL;
1284 static const char * const _keywords[] = {"a", "b", NULL};
1285 static _PyArg_Parser _parser = {NULL, _keywords, "keywords_kwonly", 0};
1286 PyObject *argsbuf[2];
1287 PyObject *a;
1288 PyObject *b;
1289
1290 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 1, argsbuf);
1291 if (!args) {
1292 goto exit;
1293 }
1294 a = args[0];
1295 b = args[1];
1296 return_value = keywords_kwonly_impl(module, a, b);
1297
1298 exit:
1299 return return_value;
1300 }
1301
1302 PyDoc_STRVAR(keywords_opt__doc__,
1303 "keywords_opt($module, /, a, b=None, c=None)\n"
1304 "--\n"
1305 "\n");
1306
1307 #define KEYWORDS_OPT_METHODDEF \
1308 {"keywords_opt", _PyCFunction_CAST(keywords_opt), METH_FASTCALL|METH_KEYWORDS, keywords_opt__doc__},
1309
1310 static PyObject *
1311 keywords_opt_impl(PyObject *module, PyObject *a, PyObject *b, PyObject *c);
1312
1313 static PyObject *
1314 keywords_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1315 {
1316 PyObject *return_value = NULL;
1317 static const char * const _keywords[] = {"a", "b", "c", NULL};
1318 static _PyArg_Parser _parser = {NULL, _keywords, "keywords_opt", 0};
1319 PyObject *argsbuf[3];
1320 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
1321 PyObject *a;
1322 PyObject *b = Py_None;
1323 PyObject *c = Py_None;
1324
1325 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
1326 if (!args) {
1327 goto exit;
1328 }
1329 a = args[0];
1330 if (!noptargs) {
1331 goto skip_optional_pos;
1332 }
1333 if (args[1]) {
1334 b = args[1];
1335 if (!--noptargs) {
1336 goto skip_optional_pos;
1337 }
1338 }
1339 c = args[2];
1340 skip_optional_pos:
1341 return_value = keywords_opt_impl(module, a, b, c);
1342
1343 exit:
1344 return return_value;
1345 }
1346
1347 PyDoc_STRVAR(keywords_opt_kwonly__doc__,
1348 "keywords_opt_kwonly($module, /, a, b=None, *, c=None, d=None)\n"
1349 "--\n"
1350 "\n");
1351
1352 #define KEYWORDS_OPT_KWONLY_METHODDEF \
1353 {"keywords_opt_kwonly", _PyCFunction_CAST(keywords_opt_kwonly), METH_FASTCALL|METH_KEYWORDS, keywords_opt_kwonly__doc__},
1354
1355 static PyObject *
1356 keywords_opt_kwonly_impl(PyObject *module, PyObject *a, PyObject *b,
1357 PyObject *c, PyObject *d);
1358
1359 static PyObject *
1360 keywords_opt_kwonly(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1361 {
1362 PyObject *return_value = NULL;
1363 static const char * const _keywords[] = {"a", "b", "c", "d", NULL};
1364 static _PyArg_Parser _parser = {NULL, _keywords, "keywords_opt_kwonly", 0};
1365 PyObject *argsbuf[4];
1366 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
1367 PyObject *a;
1368 PyObject *b = Py_None;
1369 PyObject *c = Py_None;
1370 PyObject *d = Py_None;
1371
1372 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
1373 if (!args) {
1374 goto exit;
1375 }
1376 a = args[0];
1377 if (!noptargs) {
1378 goto skip_optional_pos;
1379 }
1380 if (args[1]) {
1381 b = args[1];
1382 if (!--noptargs) {
1383 goto skip_optional_pos;
1384 }
1385 }
1386 skip_optional_pos:
1387 if (!noptargs) {
1388 goto skip_optional_kwonly;
1389 }
1390 if (args[2]) {
1391 c = args[2];
1392 if (!--noptargs) {
1393 goto skip_optional_kwonly;
1394 }
1395 }
1396 d = args[3];
1397 skip_optional_kwonly:
1398 return_value = keywords_opt_kwonly_impl(module, a, b, c, d);
1399
1400 exit:
1401 return return_value;
1402 }
1403
1404 PyDoc_STRVAR(keywords_kwonly_opt__doc__,
1405 "keywords_kwonly_opt($module, /, a, *, b=None, c=None)\n"
1406 "--\n"
1407 "\n");
1408
1409 #define KEYWORDS_KWONLY_OPT_METHODDEF \
1410 {"keywords_kwonly_opt", _PyCFunction_CAST(keywords_kwonly_opt), METH_FASTCALL|METH_KEYWORDS, keywords_kwonly_opt__doc__},
1411
1412 static PyObject *
1413 keywords_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b,
1414 PyObject *c);
1415
1416 static PyObject *
1417 keywords_kwonly_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1418 {
1419 PyObject *return_value = NULL;
1420 static const char * const _keywords[] = {"a", "b", "c", NULL};
1421 static _PyArg_Parser _parser = {NULL, _keywords, "keywords_kwonly_opt", 0};
1422 PyObject *argsbuf[3];
1423 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
1424 PyObject *a;
1425 PyObject *b = Py_None;
1426 PyObject *c = Py_None;
1427
1428 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
1429 if (!args) {
1430 goto exit;
1431 }
1432 a = args[0];
1433 if (!noptargs) {
1434 goto skip_optional_kwonly;
1435 }
1436 if (args[1]) {
1437 b = args[1];
1438 if (!--noptargs) {
1439 goto skip_optional_kwonly;
1440 }
1441 }
1442 c = args[2];
1443 skip_optional_kwonly:
1444 return_value = keywords_kwonly_opt_impl(module, a, b, c);
1445
1446 exit:
1447 return return_value;
1448 }
1449
1450 PyDoc_STRVAR(posonly_keywords__doc__,
1451 "posonly_keywords($module, a, /, b)\n"
1452 "--\n"
1453 "\n");
1454
1455 #define POSONLY_KEYWORDS_METHODDEF \
1456 {"posonly_keywords", _PyCFunction_CAST(posonly_keywords), METH_FASTCALL|METH_KEYWORDS, posonly_keywords__doc__},
1457
1458 static PyObject *
1459 posonly_keywords_impl(PyObject *module, PyObject *a, PyObject *b);
1460
1461 static PyObject *
1462 posonly_keywords(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1463 {
1464 PyObject *return_value = NULL;
1465 static const char * const _keywords[] = {"", "b", NULL};
1466 static _PyArg_Parser _parser = {NULL, _keywords, "posonly_keywords", 0};
1467 PyObject *argsbuf[2];
1468 PyObject *a;
1469 PyObject *b;
1470
1471 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
1472 if (!args) {
1473 goto exit;
1474 }
1475 a = args[0];
1476 b = args[1];
1477 return_value = posonly_keywords_impl(module, a, b);
1478
1479 exit:
1480 return return_value;
1481 }
1482
1483 PyDoc_STRVAR(posonly_kwonly__doc__,
1484 "posonly_kwonly($module, a, /, *, b)\n"
1485 "--\n"
1486 "\n");
1487
1488 #define POSONLY_KWONLY_METHODDEF \
1489 {"posonly_kwonly", _PyCFunction_CAST(posonly_kwonly), METH_FASTCALL|METH_KEYWORDS, posonly_kwonly__doc__},
1490
1491 static PyObject *
1492 posonly_kwonly_impl(PyObject *module, PyObject *a, PyObject *b);
1493
1494 static PyObject *
1495 posonly_kwonly(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1496 {
1497 PyObject *return_value = NULL;
1498 static const char * const _keywords[] = {"", "b", NULL};
1499 static _PyArg_Parser _parser = {NULL, _keywords, "posonly_kwonly", 0};
1500 PyObject *argsbuf[2];
1501 PyObject *a;
1502 PyObject *b;
1503
1504 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 1, argsbuf);
1505 if (!args) {
1506 goto exit;
1507 }
1508 a = args[0];
1509 b = args[1];
1510 return_value = posonly_kwonly_impl(module, a, b);
1511
1512 exit:
1513 return return_value;
1514 }
1515
1516 PyDoc_STRVAR(posonly_keywords_kwonly__doc__,
1517 "posonly_keywords_kwonly($module, a, /, b, *, c)\n"
1518 "--\n"
1519 "\n");
1520
1521 #define POSONLY_KEYWORDS_KWONLY_METHODDEF \
1522 {"posonly_keywords_kwonly", _PyCFunction_CAST(posonly_keywords_kwonly), METH_FASTCALL|METH_KEYWORDS, posonly_keywords_kwonly__doc__},
1523
1524 static PyObject *
1525 posonly_keywords_kwonly_impl(PyObject *module, PyObject *a, PyObject *b,
1526 PyObject *c);
1527
1528 static PyObject *
1529 posonly_keywords_kwonly(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1530 {
1531 PyObject *return_value = NULL;
1532 static const char * const _keywords[] = {"", "b", "c", NULL};
1533 static _PyArg_Parser _parser = {NULL, _keywords, "posonly_keywords_kwonly", 0};
1534 PyObject *argsbuf[3];
1535 PyObject *a;
1536 PyObject *b;
1537 PyObject *c;
1538
1539 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 1, argsbuf);
1540 if (!args) {
1541 goto exit;
1542 }
1543 a = args[0];
1544 b = args[1];
1545 c = args[2];
1546 return_value = posonly_keywords_kwonly_impl(module, a, b, c);
1547
1548 exit:
1549 return return_value;
1550 }
1551
1552 PyDoc_STRVAR(posonly_keywords_opt__doc__,
1553 "posonly_keywords_opt($module, a, /, b, c=None, d=None)\n"
1554 "--\n"
1555 "\n");
1556
1557 #define POSONLY_KEYWORDS_OPT_METHODDEF \
1558 {"posonly_keywords_opt", _PyCFunction_CAST(posonly_keywords_opt), METH_FASTCALL|METH_KEYWORDS, posonly_keywords_opt__doc__},
1559
1560 static PyObject *
1561 posonly_keywords_opt_impl(PyObject *module, PyObject *a, PyObject *b,
1562 PyObject *c, PyObject *d);
1563
1564 static PyObject *
1565 posonly_keywords_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1566 {
1567 PyObject *return_value = NULL;
1568 static const char * const _keywords[] = {"", "b", "c", "d", NULL};
1569 static _PyArg_Parser _parser = {NULL, _keywords, "posonly_keywords_opt", 0};
1570 PyObject *argsbuf[4];
1571 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
1572 PyObject *a;
1573 PyObject *b;
1574 PyObject *c = Py_None;
1575 PyObject *d = Py_None;
1576
1577 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 4, 0, argsbuf);
1578 if (!args) {
1579 goto exit;
1580 }
1581 a = args[0];
1582 b = args[1];
1583 if (!noptargs) {
1584 goto skip_optional_pos;
1585 }
1586 if (args[2]) {
1587 c = args[2];
1588 if (!--noptargs) {
1589 goto skip_optional_pos;
1590 }
1591 }
1592 d = args[3];
1593 skip_optional_pos:
1594 return_value = posonly_keywords_opt_impl(module, a, b, c, d);
1595
1596 exit:
1597 return return_value;
1598 }
1599
1600 PyDoc_STRVAR(posonly_opt_keywords_opt__doc__,
1601 "posonly_opt_keywords_opt($module, a, b=None, /, c=None, d=None)\n"
1602 "--\n"
1603 "\n");
1604
1605 #define POSONLY_OPT_KEYWORDS_OPT_METHODDEF \
1606 {"posonly_opt_keywords_opt", _PyCFunction_CAST(posonly_opt_keywords_opt), METH_FASTCALL|METH_KEYWORDS, posonly_opt_keywords_opt__doc__},
1607
1608 static PyObject *
1609 posonly_opt_keywords_opt_impl(PyObject *module, PyObject *a, PyObject *b,
1610 PyObject *c, PyObject *d);
1611
1612 static PyObject *
1613 posonly_opt_keywords_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1614 {
1615 PyObject *return_value = NULL;
1616 static const char * const _keywords[] = {"", "", "c", "d", NULL};
1617 static _PyArg_Parser _parser = {NULL, _keywords, "posonly_opt_keywords_opt", 0};
1618 PyObject *argsbuf[4];
1619 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
1620 PyObject *a;
1621 PyObject *b = Py_None;
1622 PyObject *c = Py_None;
1623 PyObject *d = Py_None;
1624
1625 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 4, 0, argsbuf);
1626 if (!args) {
1627 goto exit;
1628 }
1629 a = args[0];
1630 if (nargs < 2) {
1631 goto skip_optional_posonly;
1632 }
1633 noptargs--;
1634 b = args[1];
1635 skip_optional_posonly:
1636 if (!noptargs) {
1637 goto skip_optional_pos;
1638 }
1639 if (args[2]) {
1640 c = args[2];
1641 if (!--noptargs) {
1642 goto skip_optional_pos;
1643 }
1644 }
1645 d = args[3];
1646 skip_optional_pos:
1647 return_value = posonly_opt_keywords_opt_impl(module, a, b, c, d);
1648
1649 exit:
1650 return return_value;
1651 }
1652
1653 PyDoc_STRVAR(posonly_kwonly_opt__doc__,
1654 "posonly_kwonly_opt($module, a, /, *, b, c=None, d=None)\n"
1655 "--\n"
1656 "\n");
1657
1658 #define POSONLY_KWONLY_OPT_METHODDEF \
1659 {"posonly_kwonly_opt", _PyCFunction_CAST(posonly_kwonly_opt), METH_FASTCALL|METH_KEYWORDS, posonly_kwonly_opt__doc__},
1660
1661 static PyObject *
1662 posonly_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b,
1663 PyObject *c, PyObject *d);
1664
1665 static PyObject *
1666 posonly_kwonly_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1667 {
1668 PyObject *return_value = NULL;
1669 static const char * const _keywords[] = {"", "b", "c", "d", NULL};
1670 static _PyArg_Parser _parser = {NULL, _keywords, "posonly_kwonly_opt", 0};
1671 PyObject *argsbuf[4];
1672 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
1673 PyObject *a;
1674 PyObject *b;
1675 PyObject *c = Py_None;
1676 PyObject *d = Py_None;
1677
1678 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 1, argsbuf);
1679 if (!args) {
1680 goto exit;
1681 }
1682 a = args[0];
1683 b = args[1];
1684 if (!noptargs) {
1685 goto skip_optional_kwonly;
1686 }
1687 if (args[2]) {
1688 c = args[2];
1689 if (!--noptargs) {
1690 goto skip_optional_kwonly;
1691 }
1692 }
1693 d = args[3];
1694 skip_optional_kwonly:
1695 return_value = posonly_kwonly_opt_impl(module, a, b, c, d);
1696
1697 exit:
1698 return return_value;
1699 }
1700
1701 PyDoc_STRVAR(posonly_opt_kwonly_opt__doc__,
1702 "posonly_opt_kwonly_opt($module, a, b=None, /, *, c=None, d=None)\n"
1703 "--\n"
1704 "\n");
1705
1706 #define POSONLY_OPT_KWONLY_OPT_METHODDEF \
1707 {"posonly_opt_kwonly_opt", _PyCFunction_CAST(posonly_opt_kwonly_opt), METH_FASTCALL|METH_KEYWORDS, posonly_opt_kwonly_opt__doc__},
1708
1709 static PyObject *
1710 posonly_opt_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b,
1711 PyObject *c, PyObject *d);
1712
1713 static PyObject *
1714 posonly_opt_kwonly_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1715 {
1716 PyObject *return_value = NULL;
1717 static const char * const _keywords[] = {"", "", "c", "d", NULL};
1718 static _PyArg_Parser _parser = {NULL, _keywords, "posonly_opt_kwonly_opt", 0};
1719 PyObject *argsbuf[4];
1720 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
1721 PyObject *a;
1722 PyObject *b = Py_None;
1723 PyObject *c = Py_None;
1724 PyObject *d = Py_None;
1725
1726 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
1727 if (!args) {
1728 goto exit;
1729 }
1730 a = args[0];
1731 if (nargs < 2) {
1732 goto skip_optional_posonly;
1733 }
1734 noptargs--;
1735 b = args[1];
1736 skip_optional_posonly:
1737 if (!noptargs) {
1738 goto skip_optional_kwonly;
1739 }
1740 if (args[2]) {
1741 c = args[2];
1742 if (!--noptargs) {
1743 goto skip_optional_kwonly;
1744 }
1745 }
1746 d = args[3];
1747 skip_optional_kwonly:
1748 return_value = posonly_opt_kwonly_opt_impl(module, a, b, c, d);
1749
1750 exit:
1751 return return_value;
1752 }
1753
1754 PyDoc_STRVAR(posonly_keywords_kwonly_opt__doc__,
1755 "posonly_keywords_kwonly_opt($module, a, /, b, *, c, d=None, e=None)\n"
1756 "--\n"
1757 "\n");
1758
1759 #define POSONLY_KEYWORDS_KWONLY_OPT_METHODDEF \
1760 {"posonly_keywords_kwonly_opt", _PyCFunction_CAST(posonly_keywords_kwonly_opt), METH_FASTCALL|METH_KEYWORDS, posonly_keywords_kwonly_opt__doc__},
1761
1762 static PyObject *
1763 posonly_keywords_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b,
1764 PyObject *c, PyObject *d, PyObject *e);
1765
1766 static PyObject *
1767 posonly_keywords_kwonly_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1768 {
1769 PyObject *return_value = NULL;
1770 static const char * const _keywords[] = {"", "b", "c", "d", "e", NULL};
1771 static _PyArg_Parser _parser = {NULL, _keywords, "posonly_keywords_kwonly_opt", 0};
1772 PyObject *argsbuf[5];
1773 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 3;
1774 PyObject *a;
1775 PyObject *b;
1776 PyObject *c;
1777 PyObject *d = Py_None;
1778 PyObject *e = Py_None;
1779
1780 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 1, argsbuf);
1781 if (!args) {
1782 goto exit;
1783 }
1784 a = args[0];
1785 b = args[1];
1786 c = args[2];
1787 if (!noptargs) {
1788 goto skip_optional_kwonly;
1789 }
1790 if (args[3]) {
1791 d = args[3];
1792 if (!--noptargs) {
1793 goto skip_optional_kwonly;
1794 }
1795 }
1796 e = args[4];
1797 skip_optional_kwonly:
1798 return_value = posonly_keywords_kwonly_opt_impl(module, a, b, c, d, e);
1799
1800 exit:
1801 return return_value;
1802 }
1803
1804 PyDoc_STRVAR(posonly_keywords_opt_kwonly_opt__doc__,
1805 "posonly_keywords_opt_kwonly_opt($module, a, /, b, c=None, *, d=None,\n"
1806 " e=None)\n"
1807 "--\n"
1808 "\n");
1809
1810 #define POSONLY_KEYWORDS_OPT_KWONLY_OPT_METHODDEF \
1811 {"posonly_keywords_opt_kwonly_opt", _PyCFunction_CAST(posonly_keywords_opt_kwonly_opt), METH_FASTCALL|METH_KEYWORDS, posonly_keywords_opt_kwonly_opt__doc__},
1812
1813 static PyObject *
1814 posonly_keywords_opt_kwonly_opt_impl(PyObject *module, PyObject *a,
1815 PyObject *b, PyObject *c, PyObject *d,
1816 PyObject *e);
1817
1818 static PyObject *
1819 posonly_keywords_opt_kwonly_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1820 {
1821 PyObject *return_value = NULL;
1822 static const char * const _keywords[] = {"", "b", "c", "d", "e", NULL};
1823 static _PyArg_Parser _parser = {NULL, _keywords, "posonly_keywords_opt_kwonly_opt", 0};
1824 PyObject *argsbuf[5];
1825 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
1826 PyObject *a;
1827 PyObject *b;
1828 PyObject *c = Py_None;
1829 PyObject *d = Py_None;
1830 PyObject *e = Py_None;
1831
1832 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 3, 0, argsbuf);
1833 if (!args) {
1834 goto exit;
1835 }
1836 a = args[0];
1837 b = args[1];
1838 if (!noptargs) {
1839 goto skip_optional_pos;
1840 }
1841 if (args[2]) {
1842 c = args[2];
1843 if (!--noptargs) {
1844 goto skip_optional_pos;
1845 }
1846 }
1847 skip_optional_pos:
1848 if (!noptargs) {
1849 goto skip_optional_kwonly;
1850 }
1851 if (args[3]) {
1852 d = args[3];
1853 if (!--noptargs) {
1854 goto skip_optional_kwonly;
1855 }
1856 }
1857 e = args[4];
1858 skip_optional_kwonly:
1859 return_value = posonly_keywords_opt_kwonly_opt_impl(module, a, b, c, d, e);
1860
1861 exit:
1862 return return_value;
1863 }
1864
1865 PyDoc_STRVAR(posonly_opt_keywords_opt_kwonly_opt__doc__,
1866 "posonly_opt_keywords_opt_kwonly_opt($module, a, b=None, /, c=None, *,\n"
1867 " d=None)\n"
1868 "--\n"
1869 "\n");
1870
1871 #define POSONLY_OPT_KEYWORDS_OPT_KWONLY_OPT_METHODDEF \
1872 {"posonly_opt_keywords_opt_kwonly_opt", _PyCFunction_CAST(posonly_opt_keywords_opt_kwonly_opt), METH_FASTCALL|METH_KEYWORDS, posonly_opt_keywords_opt_kwonly_opt__doc__},
1873
1874 static PyObject *
1875 posonly_opt_keywords_opt_kwonly_opt_impl(PyObject *module, PyObject *a,
1876 PyObject *b, PyObject *c,
1877 PyObject *d);
1878
1879 static PyObject *
1880 posonly_opt_keywords_opt_kwonly_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1881 {
1882 PyObject *return_value = NULL;
1883 static const char * const _keywords[] = {"", "", "c", "d", NULL};
1884 static _PyArg_Parser _parser = {NULL, _keywords, "posonly_opt_keywords_opt_kwonly_opt", 0};
1885 PyObject *argsbuf[4];
1886 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
1887 PyObject *a;
1888 PyObject *b = Py_None;
1889 PyObject *c = Py_None;
1890 PyObject *d = Py_None;
1891
1892 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
1893 if (!args) {
1894 goto exit;
1895 }
1896 a = args[0];
1897 if (nargs < 2) {
1898 goto skip_optional_posonly;
1899 }
1900 noptargs--;
1901 b = args[1];
1902 skip_optional_posonly:
1903 if (!noptargs) {
1904 goto skip_optional_pos;
1905 }
1906 if (args[2]) {
1907 c = args[2];
1908 if (!--noptargs) {
1909 goto skip_optional_pos;
1910 }
1911 }
1912 skip_optional_pos:
1913 if (!noptargs) {
1914 goto skip_optional_kwonly;
1915 }
1916 d = args[3];
1917 skip_optional_kwonly:
1918 return_value = posonly_opt_keywords_opt_kwonly_opt_impl(module, a, b, c, d);
1919
1920 exit:
1921 return return_value;
1922 }
1923
1924 PyDoc_STRVAR(keyword_only_parameter__doc__,
1925 "keyword_only_parameter($module, /, *, a)\n"
1926 "--\n"
1927 "\n");
1928
1929 #define KEYWORD_ONLY_PARAMETER_METHODDEF \
1930 {"keyword_only_parameter", _PyCFunction_CAST(keyword_only_parameter), METH_FASTCALL|METH_KEYWORDS, keyword_only_parameter__doc__},
1931
1932 static PyObject *
1933 keyword_only_parameter_impl(PyObject *module, PyObject *a);
1934
1935 static PyObject *
1936 keyword_only_parameter(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1937 {
1938 PyObject *return_value = NULL;
1939 static const char * const _keywords[] = {"a", NULL};
1940 static _PyArg_Parser _parser = {NULL, _keywords, "keyword_only_parameter", 0};
1941 PyObject *argsbuf[1];
1942 PyObject *a;
1943
1944 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 0, 1, argsbuf);
1945 if (!args) {
1946 goto exit;
1947 }
1948 a = args[0];
1949 return_value = keyword_only_parameter_impl(module, a);
1950
1951 exit:
1952 return return_value;
1953 }
1954
1955 PyDoc_STRVAR(posonly_vararg__doc__,
1956 "posonly_vararg($module, a, /, b, *args)\n"
1957 "--\n"
1958 "\n");
1959
1960 #define POSONLY_VARARG_METHODDEF \
1961 {"posonly_vararg", _PyCFunction_CAST(posonly_vararg), METH_FASTCALL|METH_KEYWORDS, posonly_vararg__doc__},
1962
1963 static PyObject *
1964 posonly_vararg_impl(PyObject *module, PyObject *a, PyObject *b,
1965 PyObject *args);
1966
1967 static PyObject *
1968 posonly_vararg(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1969 {
1970 PyObject *return_value = NULL;
1971 static const char * const _keywords[] = {"", "b", NULL};
1972 static _PyArg_Parser _parser = {NULL, _keywords, "posonly_vararg", 0};
1973 PyObject *argsbuf[3];
1974 PyObject *a;
1975 PyObject *b;
1976 PyObject *__clinic_args = NULL;
1977
1978 args = _PyArg_UnpackKeywordsWithVararg(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, 2, argsbuf);
1979 if (!args) {
1980 goto exit;
1981 }
1982 a = args[0];
1983 b = args[1];
1984 __clinic_args = args[2];
1985 return_value = posonly_vararg_impl(module, a, b, __clinic_args);
1986
1987 exit:
1988 Py_XDECREF(__clinic_args);
1989 return return_value;
1990 }
1991
1992 PyDoc_STRVAR(vararg_and_posonly__doc__,
1993 "vararg_and_posonly($module, a, /, *args)\n"
1994 "--\n"
1995 "\n");
1996
1997 #define VARARG_AND_POSONLY_METHODDEF \
1998 {"vararg_and_posonly", _PyCFunction_CAST(vararg_and_posonly), METH_FASTCALL, vararg_and_posonly__doc__},
1999
2000 static PyObject *
2001 vararg_and_posonly_impl(PyObject *module, PyObject *a, PyObject *args);
2002
2003 static PyObject *
2004 vararg_and_posonly(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2005 {
2006 PyObject *return_value = NULL;
2007 PyObject *a;
2008 PyObject *__clinic_args = NULL;
2009
2010 if (!_PyArg_CheckPositional("vararg_and_posonly", nargs, 1, PY_SSIZE_T_MAX)) {
2011 goto exit;
2012 }
2013 a = args[0];
2014 __clinic_args = PyTuple_New(nargs - 1);
2015 if (!__clinic_args) {
2016 goto exit;
2017 }
2018 for (Py_ssize_t i = 0; i < nargs - 1; ++i) {
2019 PyTuple_SET_ITEM(__clinic_args, i, Py_NewRef(args[1 + i]));
2020 }
2021 return_value = vararg_and_posonly_impl(module, a, __clinic_args);
2022
2023 exit:
2024 Py_XDECREF(__clinic_args);
2025 return return_value;
2026 }
2027
2028 PyDoc_STRVAR(vararg__doc__,
2029 "vararg($module, /, a, *args)\n"
2030 "--\n"
2031 "\n");
2032
2033 #define VARARG_METHODDEF \
2034 {"vararg", _PyCFunction_CAST(vararg), METH_FASTCALL|METH_KEYWORDS, vararg__doc__},
2035
2036 static PyObject *
2037 vararg_impl(PyObject *module, PyObject *a, PyObject *args);
2038
2039 static PyObject *
2040 vararg(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
2041 {
2042 PyObject *return_value = NULL;
2043 static const char * const _keywords[] = {"a", NULL};
2044 static _PyArg_Parser _parser = {NULL, _keywords, "vararg", 0};
2045 PyObject *argsbuf[2];
2046 PyObject *a;
2047 PyObject *__clinic_args = NULL;
2048
2049 args = _PyArg_UnpackKeywordsWithVararg(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, 1, argsbuf);
2050 if (!args) {
2051 goto exit;
2052 }
2053 a = args[0];
2054 __clinic_args = args[1];
2055 return_value = vararg_impl(module, a, __clinic_args);
2056
2057 exit:
2058 Py_XDECREF(__clinic_args);
2059 return return_value;
2060 }
2061
2062 PyDoc_STRVAR(vararg_with_default__doc__,
2063 "vararg_with_default($module, /, a, *args, b=False)\n"
2064 "--\n"
2065 "\n");
2066
2067 #define VARARG_WITH_DEFAULT_METHODDEF \
2068 {"vararg_with_default", _PyCFunction_CAST(vararg_with_default), METH_FASTCALL|METH_KEYWORDS, vararg_with_default__doc__},
2069
2070 static PyObject *
2071 vararg_with_default_impl(PyObject *module, PyObject *a, PyObject *args,
2072 int b);
2073
2074 static PyObject *
2075 vararg_with_default(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
2076 {
2077 PyObject *return_value = NULL;
2078 static const char * const _keywords[] = {"a", "b", NULL};
2079 static _PyArg_Parser _parser = {NULL, _keywords, "vararg_with_default", 0};
2080 PyObject *argsbuf[3];
2081 Py_ssize_t noptargs = Py_MIN(nargs, 1) + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
2082 PyObject *a;
2083 PyObject *__clinic_args = NULL;
2084 int b = 0;
2085
2086 args = _PyArg_UnpackKeywordsWithVararg(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, 1, argsbuf);
2087 if (!args) {
2088 goto exit;
2089 }
2090 a = args[0];
2091 __clinic_args = args[1];
2092 if (!noptargs) {
2093 goto skip_optional_kwonly;
2094 }
2095 b = PyObject_IsTrue(args[2]);
2096 if (b < 0) {
2097 goto exit;
2098 }
2099 skip_optional_kwonly:
2100 return_value = vararg_with_default_impl(module, a, __clinic_args, b);
2101
2102 exit:
2103 Py_XDECREF(__clinic_args);
2104 return return_value;
2105 }
2106
2107 PyDoc_STRVAR(vararg_with_only_defaults__doc__,
2108 "vararg_with_only_defaults($module, /, *args, b=None)\n"
2109 "--\n"
2110 "\n");
2111
2112 #define VARARG_WITH_ONLY_DEFAULTS_METHODDEF \
2113 {"vararg_with_only_defaults", _PyCFunction_CAST(vararg_with_only_defaults), METH_FASTCALL|METH_KEYWORDS, vararg_with_only_defaults__doc__},
2114
2115 static PyObject *
2116 vararg_with_only_defaults_impl(PyObject *module, PyObject *args, PyObject *b);
2117
2118 static PyObject *
2119 vararg_with_only_defaults(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
2120 {
2121 PyObject *return_value = NULL;
2122 static const char * const _keywords[] = {"b", NULL};
2123 static _PyArg_Parser _parser = {NULL, _keywords, "vararg_with_only_defaults", 0};
2124 PyObject *argsbuf[2];
2125 Py_ssize_t noptargs = 0 + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
2126 PyObject *__clinic_args = NULL;
2127 PyObject *b = Py_None;
2128
2129 args = _PyArg_UnpackKeywordsWithVararg(args, nargs, NULL, kwnames, &_parser, 0, 0, 0, 0, argsbuf);
2130 if (!args) {
2131 goto exit;
2132 }
2133 __clinic_args = args[0];
2134 if (!noptargs) {
2135 goto skip_optional_kwonly;
2136 }
2137 b = args[1];
2138 skip_optional_kwonly:
2139 return_value = vararg_with_only_defaults_impl(module, __clinic_args, b);
2140
2141 exit:
2142 Py_XDECREF(__clinic_args);
2143 return return_value;
2144 }
2145
2146 PyDoc_STRVAR(gh_32092_oob__doc__,
2147 "gh_32092_oob($module, /, pos1, pos2, *varargs, kw1=None, kw2=None)\n"
2148 "--\n"
2149 "\n"
2150 "Proof-of-concept of GH-32092 OOB bug.");
2151
2152 #define GH_32092_OOB_METHODDEF \
2153 {"gh_32092_oob", _PyCFunction_CAST(gh_32092_oob), METH_FASTCALL|METH_KEYWORDS, gh_32092_oob__doc__},
2154
2155 static PyObject *
2156 gh_32092_oob_impl(PyObject *module, PyObject *pos1, PyObject *pos2,
2157 PyObject *varargs, PyObject *kw1, PyObject *kw2);
2158
2159 static PyObject *
2160 gh_32092_oob(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
2161 {
2162 PyObject *return_value = NULL;
2163 static const char * const _keywords[] = {"pos1", "pos2", "kw1", "kw2", NULL};
2164 static _PyArg_Parser _parser = {NULL, _keywords, "gh_32092_oob", 0};
2165 PyObject *argsbuf[5];
2166 Py_ssize_t noptargs = Py_MIN(nargs, 2) + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
2167 PyObject *pos1;
2168 PyObject *pos2;
2169 PyObject *varargs = NULL;
2170 PyObject *kw1 = Py_None;
2171 PyObject *kw2 = Py_None;
2172
2173 args = _PyArg_UnpackKeywordsWithVararg(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, 2, argsbuf);
2174 if (!args) {
2175 goto exit;
2176 }
2177 pos1 = args[0];
2178 pos2 = args[1];
2179 varargs = args[2];
2180 if (!noptargs) {
2181 goto skip_optional_kwonly;
2182 }
2183 if (args[3]) {
2184 kw1 = args[3];
2185 if (!--noptargs) {
2186 goto skip_optional_kwonly;
2187 }
2188 }
2189 kw2 = args[4];
2190 skip_optional_kwonly:
2191 return_value = gh_32092_oob_impl(module, pos1, pos2, varargs, kw1, kw2);
2192
2193 exit:
2194 Py_XDECREF(varargs);
2195 return return_value;
2196 }
2197
2198 PyDoc_STRVAR(gh_32092_kw_pass__doc__,
2199 "gh_32092_kw_pass($module, /, pos, *args, kw=None)\n"
2200 "--\n"
2201 "\n"
2202 "Proof-of-concept of GH-32092 keyword args passing bug.");
2203
2204 #define GH_32092_KW_PASS_METHODDEF \
2205 {"gh_32092_kw_pass", _PyCFunction_CAST(gh_32092_kw_pass), METH_FASTCALL|METH_KEYWORDS, gh_32092_kw_pass__doc__},
2206
2207 static PyObject *
2208 gh_32092_kw_pass_impl(PyObject *module, PyObject *pos, PyObject *args,
2209 PyObject *kw);
2210
2211 static PyObject *
2212 gh_32092_kw_pass(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
2213 {
2214 PyObject *return_value = NULL;
2215 static const char * const _keywords[] = {"pos", "kw", NULL};
2216 static _PyArg_Parser _parser = {NULL, _keywords, "gh_32092_kw_pass", 0};
2217 PyObject *argsbuf[3];
2218 Py_ssize_t noptargs = Py_MIN(nargs, 1) + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
2219 PyObject *pos;
2220 PyObject *__clinic_args = NULL;
2221 PyObject *kw = Py_None;
2222
2223 args = _PyArg_UnpackKeywordsWithVararg(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, 1, argsbuf);
2224 if (!args) {
2225 goto exit;
2226 }
2227 pos = args[0];
2228 __clinic_args = args[1];
2229 if (!noptargs) {
2230 goto skip_optional_kwonly;
2231 }
2232 kw = args[2];
2233 skip_optional_kwonly:
2234 return_value = gh_32092_kw_pass_impl(module, pos, __clinic_args, kw);
2235
2236 exit:
2237 Py_XDECREF(__clinic_args);
2238 return return_value;
2239 }
2240
2241 PyDoc_STRVAR(gh_99233_refcount__doc__,
2242 "gh_99233_refcount($module, /, *args)\n"
2243 "--\n"
2244 "\n"
2245 "Proof-of-concept of GH-99233 refcount error bug.");
2246
2247 #define GH_99233_REFCOUNT_METHODDEF \
2248 {"gh_99233_refcount", _PyCFunction_CAST(gh_99233_refcount), METH_FASTCALL, gh_99233_refcount__doc__},
2249
2250 static PyObject *
2251 gh_99233_refcount_impl(PyObject *module, PyObject *args);
2252
2253 static PyObject *
2254 gh_99233_refcount(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2255 {
2256 PyObject *return_value = NULL;
2257 PyObject *__clinic_args = NULL;
2258
2259 if (!_PyArg_CheckPositional("gh_99233_refcount", nargs, 0, PY_SSIZE_T_MAX)) {
2260 goto exit;
2261 }
2262 __clinic_args = PyTuple_New(nargs - 0);
2263 if (!__clinic_args) {
2264 goto exit;
2265 }
2266 for (Py_ssize_t i = 0; i < nargs - 0; ++i) {
2267 PyTuple_SET_ITEM(__clinic_args, i, Py_NewRef(args[0 + i]));
2268 }
2269 return_value = gh_99233_refcount_impl(module, __clinic_args);
2270
2271 exit:
2272 Py_XDECREF(__clinic_args);
2273 return return_value;
2274 }
2275
2276 PyDoc_STRVAR(gh_99240_double_free__doc__,
2277 "gh_99240_double_free($module, a, b, /)\n"
2278 "--\n"
2279 "\n"
2280 "Proof-of-concept of GH-99240 double-free bug.");
2281
2282 #define GH_99240_DOUBLE_FREE_METHODDEF \
2283 {"gh_99240_double_free", _PyCFunction_CAST(gh_99240_double_free), METH_FASTCALL, gh_99240_double_free__doc__},
2284
2285 static PyObject *
2286 gh_99240_double_free_impl(PyObject *module, char *a, char *b);
2287
2288 static PyObject *
2289 gh_99240_double_free(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2290 {
2291 PyObject *return_value = NULL;
2292 char *a = NULL;
2293 char *b = NULL;
2294
2295 if (!_PyArg_ParseStack(args, nargs, "eses:gh_99240_double_free",
2296 "idna", &a, "idna", &b)) {
2297 goto exit;
2298 }
2299 return_value = gh_99240_double_free_impl(module, a, b);
2300 /* Post parse cleanup for a */
2301 PyMem_FREE(a);
2302 /* Post parse cleanup for b */
2303 PyMem_FREE(b);
2304
2305 exit:
2306 return return_value;
2307 }
2308 /*[clinic end generated code: output=6b719efc1b8bd2c8 input=a9049054013a1b77]*/