1/*[clinic input] 2output preset block 3[clinic start generated code]*/ 4/*[clinic end generated code: output=da39a3ee5e6b4b0d input=3c81ac2402d06a8b]*/ 5 6 7/*[clinic input] 8test_object_converter 9 10 a: object 11 b: object(converter="PyUnicode_FSConverter") 12 c: object(subclass_of="&PyUnicode_Type") 13 d: object(type="PyUnicode_Object *") 14 / 15 16[clinic start generated code]*/ 17 18PyDoc_STRVAR(test_object_converter__doc__, 19"test_object_converter($module, a, b, c, d, /)\n" 20"--\n" 21"\n"); 22 23#define TEST_OBJECT_CONVERTER_METHODDEF \ 24 {"test_object_converter", (PyCFunction)(void(*)(void))test_object_converter, METH_FASTCALL, test_object_converter__doc__}, 25 26static PyObject * 27test_object_converter_impl(PyObject *module, PyObject *a, PyObject *b, 28 PyObject *c, PyUnicode_Object *d); 29 30static PyObject * 31test_object_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 32{ 33 PyObject *return_value = NULL; 34 PyObject *a; 35 PyObject *b; 36 PyObject *c; 37 PyUnicode_Object *d; 38 39 if (!_PyArg_CheckPositional("test_object_converter", nargs, 4, 4)) { 40 goto exit; 41 } 42 a = args[0]; 43 if (!PyUnicode_FSConverter(args[1], &b)) { 44 goto exit; 45 } 46 if (!PyUnicode_Check(args[2])) { 47 _PyArg_BadArgument("test_object_converter", "argument 3", "str", args[2]); 48 goto exit; 49 } 50 c = args[2]; 51 d = (PyUnicode_Object *)args[3]; 52 return_value = test_object_converter_impl(module, a, b, c, d); 53 54exit: 55 return return_value; 56} 57 58static PyObject * 59test_object_converter_impl(PyObject *module, PyObject *a, PyObject *b, 60 PyObject *c, PyUnicode_Object *d) 61/*[clinic end generated code: output=a78312d933df9ea1 input=005e6a8a711a869b]*/ 62 63 64/*[clinic input] 65test_object_converter_one_arg 66 67 a: object 68 / 69 70[clinic start generated code]*/ 71 72PyDoc_STRVAR(test_object_converter_one_arg__doc__, 73"test_object_converter_one_arg($module, a, /)\n" 74"--\n" 75"\n"); 76 77#define TEST_OBJECT_CONVERTER_ONE_ARG_METHODDEF \ 78 {"test_object_converter_one_arg", (PyCFunction)test_object_converter_one_arg, METH_O, test_object_converter_one_arg__doc__}, 79 80static PyObject * 81test_object_converter_one_arg(PyObject *module, PyObject *a) 82/*[clinic end generated code: output=6da755f8502139df input=d635d92a421f1ca3]*/ 83 84 85/*[clinic input] 86test_objects_converter 87 88 a: object 89 b: object = NULL 90 / 91 92[clinic start generated code]*/ 93 94PyDoc_STRVAR(test_objects_converter__doc__, 95"test_objects_converter($module, a, b=<unrepresentable>, /)\n" 96"--\n" 97"\n"); 98 99#define TEST_OBJECTS_CONVERTER_METHODDEF \ 100 {"test_objects_converter", (PyCFunction)(void(*)(void))test_objects_converter, METH_FASTCALL, test_objects_converter__doc__}, 101 102static PyObject * 103test_objects_converter_impl(PyObject *module, PyObject *a, PyObject *b); 104 105static PyObject * 106test_objects_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 107{ 108 PyObject *return_value = NULL; 109 PyObject *a; 110 PyObject *b = NULL; 111 112 if (!_PyArg_CheckPositional("test_objects_converter", nargs, 1, 2)) { 113 goto exit; 114 } 115 a = args[0]; 116 if (nargs < 2) { 117 goto skip_optional; 118 } 119 b = args[1]; 120skip_optional: 121 return_value = test_objects_converter_impl(module, a, b); 122 123exit: 124 return return_value; 125} 126 127static PyObject * 128test_objects_converter_impl(PyObject *module, PyObject *a, PyObject *b) 129/*[clinic end generated code: output=0e461f38d3b2bd08 input=4cbb3d9edd2a36f3]*/ 130 131 132/*[clinic input] 133test_object_converter_subclass_of 134 135 a: object(subclass_of="&PyLong_Type") 136 b: object(subclass_of="&PyTuple_Type") 137 c: object(subclass_of="&PyList_Type") 138 d: object(subclass_of="&PySet_Type") 139 e: object(subclass_of="&PyFrozenSet_Type") 140 f: object(subclass_of="&PyDict_Type") 141 g: object(subclass_of="&PyUnicode_Type") 142 h: object(subclass_of="&PyBytes_Type") 143 i: object(subclass_of="&PyByteArray_Type") 144 j: object(subclass_of="&MyType") 145 / 146 147[clinic start generated code]*/ 148 149PyDoc_STRVAR(test_object_converter_subclass_of__doc__, 150"test_object_converter_subclass_of($module, a, b, c, d, e, f, g, h, i,\n" 151" j, /)\n" 152"--\n" 153"\n"); 154 155#define TEST_OBJECT_CONVERTER_SUBCLASS_OF_METHODDEF \ 156 {"test_object_converter_subclass_of", (PyCFunction)(void(*)(void))test_object_converter_subclass_of, METH_FASTCALL, test_object_converter_subclass_of__doc__}, 157 158static PyObject * 159test_object_converter_subclass_of_impl(PyObject *module, PyObject *a, 160 PyObject *b, PyObject *c, PyObject *d, 161 PyObject *e, PyObject *f, PyObject *g, 162 PyObject *h, PyObject *i, PyObject *j); 163 164static PyObject * 165test_object_converter_subclass_of(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 166{ 167 PyObject *return_value = NULL; 168 PyObject *a; 169 PyObject *b; 170 PyObject *c; 171 PyObject *d; 172 PyObject *e; 173 PyObject *f; 174 PyObject *g; 175 PyObject *h; 176 PyObject *i; 177 PyObject *j; 178 179 if (!_PyArg_CheckPositional("test_object_converter_subclass_of", nargs, 10, 10)) { 180 goto exit; 181 } 182 if (!PyLong_Check(args[0])) { 183 _PyArg_BadArgument("test_object_converter_subclass_of", "argument 1", "int", args[0]); 184 goto exit; 185 } 186 a = args[0]; 187 if (!PyTuple_Check(args[1])) { 188 _PyArg_BadArgument("test_object_converter_subclass_of", "argument 2", "tuple", args[1]); 189 goto exit; 190 } 191 b = args[1]; 192 if (!PyList_Check(args[2])) { 193 _PyArg_BadArgument("test_object_converter_subclass_of", "argument 3", "list", args[2]); 194 goto exit; 195 } 196 c = args[2]; 197 if (!PySet_Check(args[3])) { 198 _PyArg_BadArgument("test_object_converter_subclass_of", "argument 4", "set", args[3]); 199 goto exit; 200 } 201 d = args[3]; 202 if (!PyFrozenSet_Check(args[4])) { 203 _PyArg_BadArgument("test_object_converter_subclass_of", "argument 5", "frozenset", args[4]); 204 goto exit; 205 } 206 e = args[4]; 207 if (!PyDict_Check(args[5])) { 208 _PyArg_BadArgument("test_object_converter_subclass_of", "argument 6", "dict", args[5]); 209 goto exit; 210 } 211 f = args[5]; 212 if (!PyUnicode_Check(args[6])) { 213 _PyArg_BadArgument("test_object_converter_subclass_of", "argument 7", "str", args[6]); 214 goto exit; 215 } 216 g = args[6]; 217 if (!PyBytes_Check(args[7])) { 218 _PyArg_BadArgument("test_object_converter_subclass_of", "argument 8", "bytes", args[7]); 219 goto exit; 220 } 221 h = args[7]; 222 if (!PyByteArray_Check(args[8])) { 223 _PyArg_BadArgument("test_object_converter_subclass_of", "argument 9", "bytearray", args[8]); 224 goto exit; 225 } 226 i = args[8]; 227 if (!PyObject_TypeCheck(args[9], &MyType)) { 228 _PyArg_BadArgument("test_object_converter_subclass_of", "argument 10", (&MyType)->tp_name, args[9]); 229 goto exit; 230 } 231 j = args[9]; 232 return_value = test_object_converter_subclass_of_impl(module, a, b, c, d, e, f, g, h, i, j); 233 234exit: 235 return return_value; 236} 237 238static PyObject * 239test_object_converter_subclass_of_impl(PyObject *module, PyObject *a, 240 PyObject *b, PyObject *c, PyObject *d, 241 PyObject *e, PyObject *f, PyObject *g, 242 PyObject *h, PyObject *i, PyObject *j) 243/*[clinic end generated code: output=dcf7772bf0c876dd input=31b06b772d5f983e]*/ 244 245 246/*[clinic input] 247test_PyBytesObject_converter 248 249 a: PyBytesObject 250 / 251 252[clinic start generated code]*/ 253 254PyDoc_STRVAR(test_PyBytesObject_converter__doc__, 255"test_PyBytesObject_converter($module, a, /)\n" 256"--\n" 257"\n"); 258 259#define TEST_PYBYTESOBJECT_CONVERTER_METHODDEF \ 260 {"test_PyBytesObject_converter", (PyCFunction)test_PyBytesObject_converter, METH_O, test_PyBytesObject_converter__doc__}, 261 262static PyObject * 263test_PyBytesObject_converter_impl(PyObject *module, PyBytesObject *a); 264 265static PyObject * 266test_PyBytesObject_converter(PyObject *module, PyObject *arg) 267{ 268 PyObject *return_value = NULL; 269 PyBytesObject *a; 270 271 if (!PyBytes_Check(arg)) { 272 _PyArg_BadArgument("test_PyBytesObject_converter", "argument", "bytes", arg); 273 goto exit; 274 } 275 a = (PyBytesObject *)arg; 276 return_value = test_PyBytesObject_converter_impl(module, a); 277 278exit: 279 return return_value; 280} 281 282static PyObject * 283test_PyBytesObject_converter_impl(PyObject *module, PyBytesObject *a) 284/*[clinic end generated code: output=7539d628e6fceace input=12b10c7cb5750400]*/ 285 286 287/*[clinic input] 288test_PyByteArrayObject_converter 289 290 a: PyByteArrayObject 291 / 292 293[clinic start generated code]*/ 294 295PyDoc_STRVAR(test_PyByteArrayObject_converter__doc__, 296"test_PyByteArrayObject_converter($module, a, /)\n" 297"--\n" 298"\n"); 299 300#define TEST_PYBYTEARRAYOBJECT_CONVERTER_METHODDEF \ 301 {"test_PyByteArrayObject_converter", (PyCFunction)test_PyByteArrayObject_converter, METH_O, test_PyByteArrayObject_converter__doc__}, 302 303static PyObject * 304test_PyByteArrayObject_converter_impl(PyObject *module, PyByteArrayObject *a); 305 306static PyObject * 307test_PyByteArrayObject_converter(PyObject *module, PyObject *arg) 308{ 309 PyObject *return_value = NULL; 310 PyByteArrayObject *a; 311 312 if (!PyByteArray_Check(arg)) { 313 _PyArg_BadArgument("test_PyByteArrayObject_converter", "argument", "bytearray", arg); 314 goto exit; 315 } 316 a = (PyByteArrayObject *)arg; 317 return_value = test_PyByteArrayObject_converter_impl(module, a); 318 319exit: 320 return return_value; 321} 322 323static PyObject * 324test_PyByteArrayObject_converter_impl(PyObject *module, PyByteArrayObject *a) 325/*[clinic end generated code: output=1245af9f5b3e355e input=5a657da535d194ae]*/ 326 327 328/*[clinic input] 329test_unicode_converter 330 331 a: unicode 332 / 333 334[clinic start generated code]*/ 335 336PyDoc_STRVAR(test_unicode_converter__doc__, 337"test_unicode_converter($module, a, /)\n" 338"--\n" 339"\n"); 340 341#define TEST_UNICODE_CONVERTER_METHODDEF \ 342 {"test_unicode_converter", (PyCFunction)test_unicode_converter, METH_O, test_unicode_converter__doc__}, 343 344static PyObject * 345test_unicode_converter_impl(PyObject *module, PyObject *a); 346 347static PyObject * 348test_unicode_converter(PyObject *module, PyObject *arg) 349{ 350 PyObject *return_value = NULL; 351 PyObject *a; 352 353 if (!PyUnicode_Check(arg)) { 354 _PyArg_BadArgument("test_unicode_converter", "argument", "str", arg); 355 goto exit; 356 } 357 if (PyUnicode_READY(arg) == -1) { 358 goto exit; 359 } 360 a = arg; 361 return_value = test_unicode_converter_impl(module, a); 362 363exit: 364 return return_value; 365} 366 367static PyObject * 368test_unicode_converter_impl(PyObject *module, PyObject *a) 369/*[clinic end generated code: output=18f1e3880c862611 input=aa33612df92aa9c5]*/ 370 371 372/*[clinic input] 373test_bool_converter 374 375 a: bool = True 376 b: bool(accept={object}) = True 377 c: bool(accept={int}) = True 378 / 379 380[clinic start generated code]*/ 381 382PyDoc_STRVAR(test_bool_converter__doc__, 383"test_bool_converter($module, a=True, b=True, c=True, /)\n" 384"--\n" 385"\n"); 386 387#define TEST_BOOL_CONVERTER_METHODDEF \ 388 {"test_bool_converter", (PyCFunction)(void(*)(void))test_bool_converter, METH_FASTCALL, test_bool_converter__doc__}, 389 390static PyObject * 391test_bool_converter_impl(PyObject *module, int a, int b, int c); 392 393static PyObject * 394test_bool_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 395{ 396 PyObject *return_value = NULL; 397 int a = 1; 398 int b = 1; 399 int c = 1; 400 401 if (!_PyArg_CheckPositional("test_bool_converter", nargs, 0, 3)) { 402 goto exit; 403 } 404 if (nargs < 1) { 405 goto skip_optional; 406 } 407 a = PyObject_IsTrue(args[0]); 408 if (a < 0) { 409 goto exit; 410 } 411 if (nargs < 2) { 412 goto skip_optional; 413 } 414 b = PyObject_IsTrue(args[1]); 415 if (b < 0) { 416 goto exit; 417 } 418 if (nargs < 3) { 419 goto skip_optional; 420 } 421 c = _PyLong_AsInt(args[2]); 422 if (c == -1 && PyErr_Occurred()) { 423 goto exit; 424 } 425skip_optional: 426 return_value = test_bool_converter_impl(module, a, b, c); 427 428exit: 429 return return_value; 430} 431 432static PyObject * 433test_bool_converter_impl(PyObject *module, int a, int b, int c) 434/*[clinic end generated code: output=b5ec6409d942e0f9 input=939854fa9f248c60]*/ 435 436 437/*[clinic input] 438test_char_converter 439 440 a: char = b'A' 441 b: char = b'\a' 442 c: char = b'\b' 443 d: char = b'\t' 444 e: char = b'\n' 445 f: char = b'\v' 446 g: char = b'\f' 447 h: char = b'\r' 448 i: char = b'"' 449 j: char = b"'" 450 k: char = b'?' 451 l: char = b'\\' 452 m: char = b'\000' 453 n: char = b'\377' 454 / 455 456[clinic start generated code]*/ 457 458PyDoc_STRVAR(test_char_converter__doc__, 459"test_char_converter($module, a=b\'A\', b=b\'\\x07\', c=b\'\\x08\', d=b\'\\t\',\n" 460" e=b\'\\n\', f=b\'\\x0b\', g=b\'\\x0c\', h=b\'\\r\', i=b\'\"\',\n" 461" j=b\"\'\", k=b\'?\', l=b\'\\\\\', m=b\'\\x00\', n=b\'\\xff\', /)\n" 462"--\n" 463"\n"); 464 465#define TEST_CHAR_CONVERTER_METHODDEF \ 466 {"test_char_converter", (PyCFunction)(void(*)(void))test_char_converter, METH_FASTCALL, test_char_converter__doc__}, 467 468static PyObject * 469test_char_converter_impl(PyObject *module, char a, char b, char c, char d, 470 char e, char f, char g, char h, char i, char j, 471 char k, char l, char m, char n); 472 473static PyObject * 474test_char_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 475{ 476 PyObject *return_value = NULL; 477 char a = 'A'; 478 char b = '\x07'; 479 char c = '\x08'; 480 char d = '\t'; 481 char e = '\n'; 482 char f = '\x0b'; 483 char g = '\x0c'; 484 char h = '\r'; 485 char i = '"'; 486 char j = '\''; 487 char k = '?'; 488 char l = '\\'; 489 char m = '\x00'; 490 char n = '\xff'; 491 492 if (!_PyArg_CheckPositional("test_char_converter", nargs, 0, 14)) { 493 goto exit; 494 } 495 if (nargs < 1) { 496 goto skip_optional; 497 } 498 if (PyBytes_Check(args[0]) && PyBytes_GET_SIZE(args[0]) == 1) { 499 a = PyBytes_AS_STRING(args[0])[0]; 500 } 501 else if (PyByteArray_Check(args[0]) && PyByteArray_GET_SIZE(args[0]) == 1) { 502 a = PyByteArray_AS_STRING(args[0])[0]; 503 } 504 else { 505 _PyArg_BadArgument("test_char_converter", "argument 1", "a byte string of length 1", args[0]); 506 goto exit; 507 } 508 if (nargs < 2) { 509 goto skip_optional; 510 } 511 if (PyBytes_Check(args[1]) && PyBytes_GET_SIZE(args[1]) == 1) { 512 b = PyBytes_AS_STRING(args[1])[0]; 513 } 514 else if (PyByteArray_Check(args[1]) && PyByteArray_GET_SIZE(args[1]) == 1) { 515 b = PyByteArray_AS_STRING(args[1])[0]; 516 } 517 else { 518 _PyArg_BadArgument("test_char_converter", "argument 2", "a byte string of length 1", args[1]); 519 goto exit; 520 } 521 if (nargs < 3) { 522 goto skip_optional; 523 } 524 if (PyBytes_Check(args[2]) && PyBytes_GET_SIZE(args[2]) == 1) { 525 c = PyBytes_AS_STRING(args[2])[0]; 526 } 527 else if (PyByteArray_Check(args[2]) && PyByteArray_GET_SIZE(args[2]) == 1) { 528 c = PyByteArray_AS_STRING(args[2])[0]; 529 } 530 else { 531 _PyArg_BadArgument("test_char_converter", "argument 3", "a byte string of length 1", args[2]); 532 goto exit; 533 } 534 if (nargs < 4) { 535 goto skip_optional; 536 } 537 if (PyBytes_Check(args[3]) && PyBytes_GET_SIZE(args[3]) == 1) { 538 d = PyBytes_AS_STRING(args[3])[0]; 539 } 540 else if (PyByteArray_Check(args[3]) && PyByteArray_GET_SIZE(args[3]) == 1) { 541 d = PyByteArray_AS_STRING(args[3])[0]; 542 } 543 else { 544 _PyArg_BadArgument("test_char_converter", "argument 4", "a byte string of length 1", args[3]); 545 goto exit; 546 } 547 if (nargs < 5) { 548 goto skip_optional; 549 } 550 if (PyBytes_Check(args[4]) && PyBytes_GET_SIZE(args[4]) == 1) { 551 e = PyBytes_AS_STRING(args[4])[0]; 552 } 553 else if (PyByteArray_Check(args[4]) && PyByteArray_GET_SIZE(args[4]) == 1) { 554 e = PyByteArray_AS_STRING(args[4])[0]; 555 } 556 else { 557 _PyArg_BadArgument("test_char_converter", "argument 5", "a byte string of length 1", args[4]); 558 goto exit; 559 } 560 if (nargs < 6) { 561 goto skip_optional; 562 } 563 if (PyBytes_Check(args[5]) && PyBytes_GET_SIZE(args[5]) == 1) { 564 f = PyBytes_AS_STRING(args[5])[0]; 565 } 566 else if (PyByteArray_Check(args[5]) && PyByteArray_GET_SIZE(args[5]) == 1) { 567 f = PyByteArray_AS_STRING(args[5])[0]; 568 } 569 else { 570 _PyArg_BadArgument("test_char_converter", "argument 6", "a byte string of length 1", args[5]); 571 goto exit; 572 } 573 if (nargs < 7) { 574 goto skip_optional; 575 } 576 if (PyBytes_Check(args[6]) && PyBytes_GET_SIZE(args[6]) == 1) { 577 g = PyBytes_AS_STRING(args[6])[0]; 578 } 579 else if (PyByteArray_Check(args[6]) && PyByteArray_GET_SIZE(args[6]) == 1) { 580 g = PyByteArray_AS_STRING(args[6])[0]; 581 } 582 else { 583 _PyArg_BadArgument("test_char_converter", "argument 7", "a byte string of length 1", args[6]); 584 goto exit; 585 } 586 if (nargs < 8) { 587 goto skip_optional; 588 } 589 if (PyBytes_Check(args[7]) && PyBytes_GET_SIZE(args[7]) == 1) { 590 h = PyBytes_AS_STRING(args[7])[0]; 591 } 592 else if (PyByteArray_Check(args[7]) && PyByteArray_GET_SIZE(args[7]) == 1) { 593 h = PyByteArray_AS_STRING(args[7])[0]; 594 } 595 else { 596 _PyArg_BadArgument("test_char_converter", "argument 8", "a byte string of length 1", args[7]); 597 goto exit; 598 } 599 if (nargs < 9) { 600 goto skip_optional; 601 } 602 if (PyBytes_Check(args[8]) && PyBytes_GET_SIZE(args[8]) == 1) { 603 i = PyBytes_AS_STRING(args[8])[0]; 604 } 605 else if (PyByteArray_Check(args[8]) && PyByteArray_GET_SIZE(args[8]) == 1) { 606 i = PyByteArray_AS_STRING(args[8])[0]; 607 } 608 else { 609 _PyArg_BadArgument("test_char_converter", "argument 9", "a byte string of length 1", args[8]); 610 goto exit; 611 } 612 if (nargs < 10) { 613 goto skip_optional; 614 } 615 if (PyBytes_Check(args[9]) && PyBytes_GET_SIZE(args[9]) == 1) { 616 j = PyBytes_AS_STRING(args[9])[0]; 617 } 618 else if (PyByteArray_Check(args[9]) && PyByteArray_GET_SIZE(args[9]) == 1) { 619 j = PyByteArray_AS_STRING(args[9])[0]; 620 } 621 else { 622 _PyArg_BadArgument("test_char_converter", "argument 10", "a byte string of length 1", args[9]); 623 goto exit; 624 } 625 if (nargs < 11) { 626 goto skip_optional; 627 } 628 if (PyBytes_Check(args[10]) && PyBytes_GET_SIZE(args[10]) == 1) { 629 k = PyBytes_AS_STRING(args[10])[0]; 630 } 631 else if (PyByteArray_Check(args[10]) && PyByteArray_GET_SIZE(args[10]) == 1) { 632 k = PyByteArray_AS_STRING(args[10])[0]; 633 } 634 else { 635 _PyArg_BadArgument("test_char_converter", "argument 11", "a byte string of length 1", args[10]); 636 goto exit; 637 } 638 if (nargs < 12) { 639 goto skip_optional; 640 } 641 if (PyBytes_Check(args[11]) && PyBytes_GET_SIZE(args[11]) == 1) { 642 l = PyBytes_AS_STRING(args[11])[0]; 643 } 644 else if (PyByteArray_Check(args[11]) && PyByteArray_GET_SIZE(args[11]) == 1) { 645 l = PyByteArray_AS_STRING(args[11])[0]; 646 } 647 else { 648 _PyArg_BadArgument("test_char_converter", "argument 12", "a byte string of length 1", args[11]); 649 goto exit; 650 } 651 if (nargs < 13) { 652 goto skip_optional; 653 } 654 if (PyBytes_Check(args[12]) && PyBytes_GET_SIZE(args[12]) == 1) { 655 m = PyBytes_AS_STRING(args[12])[0]; 656 } 657 else if (PyByteArray_Check(args[12]) && PyByteArray_GET_SIZE(args[12]) == 1) { 658 m = PyByteArray_AS_STRING(args[12])[0]; 659 } 660 else { 661 _PyArg_BadArgument("test_char_converter", "argument 13", "a byte string of length 1", args[12]); 662 goto exit; 663 } 664 if (nargs < 14) { 665 goto skip_optional; 666 } 667 if (PyBytes_Check(args[13]) && PyBytes_GET_SIZE(args[13]) == 1) { 668 n = PyBytes_AS_STRING(args[13])[0]; 669 } 670 else if (PyByteArray_Check(args[13]) && PyByteArray_GET_SIZE(args[13]) == 1) { 671 n = PyByteArray_AS_STRING(args[13])[0]; 672 } 673 else { 674 _PyArg_BadArgument("test_char_converter", "argument 14", "a byte string of length 1", args[13]); 675 goto exit; 676 } 677skip_optional: 678 return_value = test_char_converter_impl(module, a, b, c, d, e, f, g, h, i, j, k, l, m, n); 679 680exit: 681 return return_value; 682} 683 684static PyObject * 685test_char_converter_impl(PyObject *module, char a, char b, char c, char d, 686 char e, char f, char g, char h, char i, char j, 687 char k, char l, char m, char n) 688/*[clinic end generated code: output=9d3aaf5d6857ec9e input=e42330417a44feac]*/ 689 690 691/*[clinic input] 692test_unsigned_char_converter 693 694 a: unsigned_char = 12 695 b: unsigned_char(bitwise=False) = 34 696 c: unsigned_char(bitwise=True) = 56 697 / 698 699[clinic start generated code]*/ 700 701PyDoc_STRVAR(test_unsigned_char_converter__doc__, 702"test_unsigned_char_converter($module, a=12, b=34, c=56, /)\n" 703"--\n" 704"\n"); 705 706#define TEST_UNSIGNED_CHAR_CONVERTER_METHODDEF \ 707 {"test_unsigned_char_converter", (PyCFunction)(void(*)(void))test_unsigned_char_converter, METH_FASTCALL, test_unsigned_char_converter__doc__}, 708 709static PyObject * 710test_unsigned_char_converter_impl(PyObject *module, unsigned char a, 711 unsigned char b, unsigned char c); 712 713static PyObject * 714test_unsigned_char_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 715{ 716 PyObject *return_value = NULL; 717 unsigned char a = 12; 718 unsigned char b = 34; 719 unsigned char c = 56; 720 721 if (!_PyArg_CheckPositional("test_unsigned_char_converter", nargs, 0, 3)) { 722 goto exit; 723 } 724 if (nargs < 1) { 725 goto skip_optional; 726 } 727 { 728 long ival = PyLong_AsLong(args[0]); 729 if (ival == -1 && PyErr_Occurred()) { 730 goto exit; 731 } 732 else if (ival < 0) { 733 PyErr_SetString(PyExc_OverflowError, 734 "unsigned byte integer is less than minimum"); 735 goto exit; 736 } 737 else if (ival > UCHAR_MAX) { 738 PyErr_SetString(PyExc_OverflowError, 739 "unsigned byte integer is greater than maximum"); 740 goto exit; 741 } 742 else { 743 a = (unsigned char) ival; 744 } 745 } 746 if (nargs < 2) { 747 goto skip_optional; 748 } 749 { 750 long ival = PyLong_AsLong(args[1]); 751 if (ival == -1 && PyErr_Occurred()) { 752 goto exit; 753 } 754 else if (ival < 0) { 755 PyErr_SetString(PyExc_OverflowError, 756 "unsigned byte integer is less than minimum"); 757 goto exit; 758 } 759 else if (ival > UCHAR_MAX) { 760 PyErr_SetString(PyExc_OverflowError, 761 "unsigned byte integer is greater than maximum"); 762 goto exit; 763 } 764 else { 765 b = (unsigned char) ival; 766 } 767 } 768 if (nargs < 3) { 769 goto skip_optional; 770 } 771 { 772 unsigned long ival = PyLong_AsUnsignedLongMask(args[2]); 773 if (ival == (unsigned long)-1 && PyErr_Occurred()) { 774 goto exit; 775 } 776 else { 777 c = (unsigned char) ival; 778 } 779 } 780skip_optional: 781 return_value = test_unsigned_char_converter_impl(module, a, b, c); 782 783exit: 784 return return_value; 785} 786 787static PyObject * 788test_unsigned_char_converter_impl(PyObject *module, unsigned char a, 789 unsigned char b, unsigned char c) 790/*[clinic end generated code: output=c0a6ab3144481466 input=021414060993e289]*/ 791 792 793/*[clinic input] 794test_short_converter 795 796 a: short = 12 797 / 798 799[clinic start generated code]*/ 800 801PyDoc_STRVAR(test_short_converter__doc__, 802"test_short_converter($module, a=12, /)\n" 803"--\n" 804"\n"); 805 806#define TEST_SHORT_CONVERTER_METHODDEF \ 807 {"test_short_converter", (PyCFunction)(void(*)(void))test_short_converter, METH_FASTCALL, test_short_converter__doc__}, 808 809static PyObject * 810test_short_converter_impl(PyObject *module, short a); 811 812static PyObject * 813test_short_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 814{ 815 PyObject *return_value = NULL; 816 short a = 12; 817 818 if (!_PyArg_CheckPositional("test_short_converter", nargs, 0, 1)) { 819 goto exit; 820 } 821 if (nargs < 1) { 822 goto skip_optional; 823 } 824 { 825 long ival = PyLong_AsLong(args[0]); 826 if (ival == -1 && PyErr_Occurred()) { 827 goto exit; 828 } 829 else if (ival < SHRT_MIN) { 830 PyErr_SetString(PyExc_OverflowError, 831 "signed short integer is less than minimum"); 832 goto exit; 833 } 834 else if (ival > SHRT_MAX) { 835 PyErr_SetString(PyExc_OverflowError, 836 "signed short integer is greater than maximum"); 837 goto exit; 838 } 839 else { 840 a = (short) ival; 841 } 842 } 843skip_optional: 844 return_value = test_short_converter_impl(module, a); 845 846exit: 847 return return_value; 848} 849 850static PyObject * 851test_short_converter_impl(PyObject *module, short a) 852/*[clinic end generated code: output=3ccda4bd08b6e4b4 input=6a8a7a509a498ff4]*/ 853 854 855/*[clinic input] 856test_unsigned_short_converter 857 858 a: unsigned_short = 12 859 b: unsigned_short(bitwise=False) = 34 860 c: unsigned_short(bitwise=True) = 56 861 / 862 863[clinic start generated code]*/ 864 865PyDoc_STRVAR(test_unsigned_short_converter__doc__, 866"test_unsigned_short_converter($module, a=12, b=34, c=56, /)\n" 867"--\n" 868"\n"); 869 870#define TEST_UNSIGNED_SHORT_CONVERTER_METHODDEF \ 871 {"test_unsigned_short_converter", (PyCFunction)(void(*)(void))test_unsigned_short_converter, METH_FASTCALL, test_unsigned_short_converter__doc__}, 872 873static PyObject * 874test_unsigned_short_converter_impl(PyObject *module, unsigned short a, 875 unsigned short b, unsigned short c); 876 877static PyObject * 878test_unsigned_short_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 879{ 880 PyObject *return_value = NULL; 881 unsigned short a = 12; 882 unsigned short b = 34; 883 unsigned short c = 56; 884 885 if (!_PyArg_CheckPositional("test_unsigned_short_converter", nargs, 0, 3)) { 886 goto exit; 887 } 888 if (nargs < 1) { 889 goto skip_optional; 890 } 891 if (!_PyLong_UnsignedShort_Converter(args[0], &a)) { 892 goto exit; 893 } 894 if (nargs < 2) { 895 goto skip_optional; 896 } 897 if (!_PyLong_UnsignedShort_Converter(args[1], &b)) { 898 goto exit; 899 } 900 if (nargs < 3) { 901 goto skip_optional; 902 } 903 c = (unsigned short)PyLong_AsUnsignedLongMask(args[2]); 904 if (c == (unsigned short)-1 && PyErr_Occurred()) { 905 goto exit; 906 } 907skip_optional: 908 return_value = test_unsigned_short_converter_impl(module, a, b, c); 909 910exit: 911 return return_value; 912} 913 914static PyObject * 915test_unsigned_short_converter_impl(PyObject *module, unsigned short a, 916 unsigned short b, unsigned short c) 917/*[clinic end generated code: output=576b5ce48424f351 input=cdfd8eff3d9176b4]*/ 918 919 920/*[clinic input] 921test_int_converter 922 923 a: int = 12 924 b: int(accept={int}) = 34 925 c: int(accept={str}) = 45 926 d: int(type='myenum') = 67 927 / 928 929[clinic start generated code]*/ 930 931PyDoc_STRVAR(test_int_converter__doc__, 932"test_int_converter($module, a=12, b=34, c=45, d=67, /)\n" 933"--\n" 934"\n"); 935 936#define TEST_INT_CONVERTER_METHODDEF \ 937 {"test_int_converter", (PyCFunction)(void(*)(void))test_int_converter, METH_FASTCALL, test_int_converter__doc__}, 938 939static PyObject * 940test_int_converter_impl(PyObject *module, int a, int b, int c, myenum d); 941 942static PyObject * 943test_int_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 944{ 945 PyObject *return_value = NULL; 946 int a = 12; 947 int b = 34; 948 int c = 45; 949 myenum d = 67; 950 951 if (!_PyArg_CheckPositional("test_int_converter", nargs, 0, 4)) { 952 goto exit; 953 } 954 if (nargs < 1) { 955 goto skip_optional; 956 } 957 a = _PyLong_AsInt(args[0]); 958 if (a == -1 && PyErr_Occurred()) { 959 goto exit; 960 } 961 if (nargs < 2) { 962 goto skip_optional; 963 } 964 b = _PyLong_AsInt(args[1]); 965 if (b == -1 && PyErr_Occurred()) { 966 goto exit; 967 } 968 if (nargs < 3) { 969 goto skip_optional; 970 } 971 if (!PyUnicode_Check(args[2])) { 972 _PyArg_BadArgument("test_int_converter", "argument 3", "a unicode character", args[2]); 973 goto exit; 974 } 975 if (PyUnicode_READY(args[2])) { 976 goto exit; 977 } 978 if (PyUnicode_GET_LENGTH(args[2]) != 1) { 979 _PyArg_BadArgument("test_int_converter", "argument 3", "a unicode character", args[2]); 980 goto exit; 981 } 982 c = PyUnicode_READ_CHAR(args[2], 0); 983 if (nargs < 4) { 984 goto skip_optional; 985 } 986 d = _PyLong_AsInt(args[3]); 987 if (d == -1 && PyErr_Occurred()) { 988 goto exit; 989 } 990skip_optional: 991 return_value = test_int_converter_impl(module, a, b, c, d); 992 993exit: 994 return return_value; 995} 996 997static PyObject * 998test_int_converter_impl(PyObject *module, int a, int b, int c, myenum d) 999/*[clinic end generated code: output=8a1a7b02ebe9eeac input=d20541fc1ca0553e]*/ 1000 1001 1002/*[clinic input] 1003test_unsigned_int_converter 1004 1005 a: unsigned_int = 12 1006 b: unsigned_int(bitwise=False) = 34 1007 c: unsigned_int(bitwise=True) = 56 1008 / 1009 1010[clinic start generated code]*/ 1011 1012PyDoc_STRVAR(test_unsigned_int_converter__doc__, 1013"test_unsigned_int_converter($module, a=12, b=34, c=56, /)\n" 1014"--\n" 1015"\n"); 1016 1017#define TEST_UNSIGNED_INT_CONVERTER_METHODDEF \ 1018 {"test_unsigned_int_converter", (PyCFunction)(void(*)(void))test_unsigned_int_converter, METH_FASTCALL, test_unsigned_int_converter__doc__}, 1019 1020static PyObject * 1021test_unsigned_int_converter_impl(PyObject *module, unsigned int a, 1022 unsigned int b, unsigned int c); 1023 1024static PyObject * 1025test_unsigned_int_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 1026{ 1027 PyObject *return_value = NULL; 1028 unsigned int a = 12; 1029 unsigned int b = 34; 1030 unsigned int c = 56; 1031 1032 if (!_PyArg_CheckPositional("test_unsigned_int_converter", nargs, 0, 3)) { 1033 goto exit; 1034 } 1035 if (nargs < 1) { 1036 goto skip_optional; 1037 } 1038 if (!_PyLong_UnsignedInt_Converter(args[0], &a)) { 1039 goto exit; 1040 } 1041 if (nargs < 2) { 1042 goto skip_optional; 1043 } 1044 if (!_PyLong_UnsignedInt_Converter(args[1], &b)) { 1045 goto exit; 1046 } 1047 if (nargs < 3) { 1048 goto skip_optional; 1049 } 1050 c = (unsigned int)PyLong_AsUnsignedLongMask(args[2]); 1051 if (c == (unsigned int)-1 && PyErr_Occurred()) { 1052 goto exit; 1053 } 1054skip_optional: 1055 return_value = test_unsigned_int_converter_impl(module, a, b, c); 1056 1057exit: 1058 return return_value; 1059} 1060 1061static PyObject * 1062test_unsigned_int_converter_impl(PyObject *module, unsigned int a, 1063 unsigned int b, unsigned int c) 1064/*[clinic end generated code: output=4f53904bfa1a0250 input=5533534828b62fc0]*/ 1065 1066 1067/*[clinic input] 1068test_long_converter 1069 1070 a: long = 12 1071 / 1072 1073[clinic start generated code]*/ 1074 1075PyDoc_STRVAR(test_long_converter__doc__, 1076"test_long_converter($module, a=12, /)\n" 1077"--\n" 1078"\n"); 1079 1080#define TEST_LONG_CONVERTER_METHODDEF \ 1081 {"test_long_converter", (PyCFunction)(void(*)(void))test_long_converter, METH_FASTCALL, test_long_converter__doc__}, 1082 1083static PyObject * 1084test_long_converter_impl(PyObject *module, long a); 1085 1086static PyObject * 1087test_long_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 1088{ 1089 PyObject *return_value = NULL; 1090 long a = 12; 1091 1092 if (!_PyArg_CheckPositional("test_long_converter", nargs, 0, 1)) { 1093 goto exit; 1094 } 1095 if (nargs < 1) { 1096 goto skip_optional; 1097 } 1098 a = PyLong_AsLong(args[0]); 1099 if (a == -1 && PyErr_Occurred()) { 1100 goto exit; 1101 } 1102skip_optional: 1103 return_value = test_long_converter_impl(module, a); 1104 1105exit: 1106 return return_value; 1107} 1108 1109static PyObject * 1110test_long_converter_impl(PyObject *module, long a) 1111/*[clinic end generated code: output=e5e7883fddcf4218 input=d2179e3c9cdcde89]*/ 1112 1113 1114/*[clinic input] 1115test_unsigned_long_converter 1116 1117 a: unsigned_long = 12 1118 b: unsigned_long(bitwise=False) = 34 1119 c: unsigned_long(bitwise=True) = 56 1120 / 1121 1122[clinic start generated code]*/ 1123 1124PyDoc_STRVAR(test_unsigned_long_converter__doc__, 1125"test_unsigned_long_converter($module, a=12, b=34, c=56, /)\n" 1126"--\n" 1127"\n"); 1128 1129#define TEST_UNSIGNED_LONG_CONVERTER_METHODDEF \ 1130 {"test_unsigned_long_converter", (PyCFunction)(void(*)(void))test_unsigned_long_converter, METH_FASTCALL, test_unsigned_long_converter__doc__}, 1131 1132static PyObject * 1133test_unsigned_long_converter_impl(PyObject *module, unsigned long a, 1134 unsigned long b, unsigned long c); 1135 1136static PyObject * 1137test_unsigned_long_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 1138{ 1139 PyObject *return_value = NULL; 1140 unsigned long a = 12; 1141 unsigned long b = 34; 1142 unsigned long c = 56; 1143 1144 if (!_PyArg_CheckPositional("test_unsigned_long_converter", nargs, 0, 3)) { 1145 goto exit; 1146 } 1147 if (nargs < 1) { 1148 goto skip_optional; 1149 } 1150 if (!_PyLong_UnsignedLong_Converter(args[0], &a)) { 1151 goto exit; 1152 } 1153 if (nargs < 2) { 1154 goto skip_optional; 1155 } 1156 if (!_PyLong_UnsignedLong_Converter(args[1], &b)) { 1157 goto exit; 1158 } 1159 if (nargs < 3) { 1160 goto skip_optional; 1161 } 1162 if (!PyLong_Check(args[2])) { 1163 _PyArg_BadArgument("test_unsigned_long_converter", "argument 3", "int", args[2]); 1164 goto exit; 1165 } 1166 c = PyLong_AsUnsignedLongMask(args[2]); 1167skip_optional: 1168 return_value = test_unsigned_long_converter_impl(module, a, b, c); 1169 1170exit: 1171 return return_value; 1172} 1173 1174static PyObject * 1175test_unsigned_long_converter_impl(PyObject *module, unsigned long a, 1176 unsigned long b, unsigned long c) 1177/*[clinic end generated code: output=87c6b29fa217026e input=f450d94cae1ef73b]*/ 1178 1179 1180/*[clinic input] 1181test_long_long_converter 1182 1183 a: long_long = 12 1184 / 1185 1186[clinic start generated code]*/ 1187 1188PyDoc_STRVAR(test_long_long_converter__doc__, 1189"test_long_long_converter($module, a=12, /)\n" 1190"--\n" 1191"\n"); 1192 1193#define TEST_LONG_LONG_CONVERTER_METHODDEF \ 1194 {"test_long_long_converter", (PyCFunction)(void(*)(void))test_long_long_converter, METH_FASTCALL, test_long_long_converter__doc__}, 1195 1196static PyObject * 1197test_long_long_converter_impl(PyObject *module, long long a); 1198 1199static PyObject * 1200test_long_long_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 1201{ 1202 PyObject *return_value = NULL; 1203 long long a = 12; 1204 1205 if (!_PyArg_CheckPositional("test_long_long_converter", nargs, 0, 1)) { 1206 goto exit; 1207 } 1208 if (nargs < 1) { 1209 goto skip_optional; 1210 } 1211 a = PyLong_AsLongLong(args[0]); 1212 if (a == -1 && PyErr_Occurred()) { 1213 goto exit; 1214 } 1215skip_optional: 1216 return_value = test_long_long_converter_impl(module, a); 1217 1218exit: 1219 return return_value; 1220} 1221 1222static PyObject * 1223test_long_long_converter_impl(PyObject *module, long long a) 1224/*[clinic end generated code: output=0488ac9e8c1d77bb input=d5fc81577ff4dd02]*/ 1225 1226 1227/*[clinic input] 1228test_unsigned_long_long_converter 1229 1230 a: unsigned_long_long = 12 1231 b: unsigned_long_long(bitwise=False) = 34 1232 c: unsigned_long_long(bitwise=True) = 56 1233 / 1234 1235[clinic start generated code]*/ 1236 1237PyDoc_STRVAR(test_unsigned_long_long_converter__doc__, 1238"test_unsigned_long_long_converter($module, a=12, b=34, c=56, /)\n" 1239"--\n" 1240"\n"); 1241 1242#define TEST_UNSIGNED_LONG_LONG_CONVERTER_METHODDEF \ 1243 {"test_unsigned_long_long_converter", (PyCFunction)(void(*)(void))test_unsigned_long_long_converter, METH_FASTCALL, test_unsigned_long_long_converter__doc__}, 1244 1245static PyObject * 1246test_unsigned_long_long_converter_impl(PyObject *module, 1247 unsigned long long a, 1248 unsigned long long b, 1249 unsigned long long c); 1250 1251static PyObject * 1252test_unsigned_long_long_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 1253{ 1254 PyObject *return_value = NULL; 1255 unsigned long long a = 12; 1256 unsigned long long b = 34; 1257 unsigned long long c = 56; 1258 1259 if (!_PyArg_CheckPositional("test_unsigned_long_long_converter", nargs, 0, 3)) { 1260 goto exit; 1261 } 1262 if (nargs < 1) { 1263 goto skip_optional; 1264 } 1265 if (!_PyLong_UnsignedLongLong_Converter(args[0], &a)) { 1266 goto exit; 1267 } 1268 if (nargs < 2) { 1269 goto skip_optional; 1270 } 1271 if (!_PyLong_UnsignedLongLong_Converter(args[1], &b)) { 1272 goto exit; 1273 } 1274 if (nargs < 3) { 1275 goto skip_optional; 1276 } 1277 if (!PyLong_Check(args[2])) { 1278 _PyArg_BadArgument("test_unsigned_long_long_converter", "argument 3", "int", args[2]); 1279 goto exit; 1280 } 1281 c = PyLong_AsUnsignedLongLongMask(args[2]); 1282skip_optional: 1283 return_value = test_unsigned_long_long_converter_impl(module, a, b, c); 1284 1285exit: 1286 return return_value; 1287} 1288 1289static PyObject * 1290test_unsigned_long_long_converter_impl(PyObject *module, 1291 unsigned long long a, 1292 unsigned long long b, 1293 unsigned long long c) 1294/*[clinic end generated code: output=aad2c7b43db2f190 input=a15115dc41866ff4]*/ 1295 1296 1297/*[clinic input] 1298test_Py_ssize_t_converter 1299 1300 a: Py_ssize_t = 12 1301 b: Py_ssize_t(accept={int}) = 34 1302 c: Py_ssize_t(accept={int, NoneType}) = 56 1303 / 1304 1305[clinic start generated code]*/ 1306 1307PyDoc_STRVAR(test_Py_ssize_t_converter__doc__, 1308"test_Py_ssize_t_converter($module, a=12, b=34, c=56, /)\n" 1309"--\n" 1310"\n"); 1311 1312#define TEST_PY_SSIZE_T_CONVERTER_METHODDEF \ 1313 {"test_Py_ssize_t_converter", (PyCFunction)(void(*)(void))test_Py_ssize_t_converter, METH_FASTCALL, test_Py_ssize_t_converter__doc__}, 1314 1315static PyObject * 1316test_Py_ssize_t_converter_impl(PyObject *module, Py_ssize_t a, Py_ssize_t b, 1317 Py_ssize_t c); 1318 1319static PyObject * 1320test_Py_ssize_t_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 1321{ 1322 PyObject *return_value = NULL; 1323 Py_ssize_t a = 12; 1324 Py_ssize_t b = 34; 1325 Py_ssize_t c = 56; 1326 1327 if (!_PyArg_CheckPositional("test_Py_ssize_t_converter", nargs, 0, 3)) { 1328 goto exit; 1329 } 1330 if (nargs < 1) { 1331 goto skip_optional; 1332 } 1333 { 1334 Py_ssize_t ival = -1; 1335 PyObject *iobj = _PyNumber_Index(args[0]); 1336 if (iobj != NULL) { 1337 ival = PyLong_AsSsize_t(iobj); 1338 Py_DECREF(iobj); 1339 } 1340 if (ival == -1 && PyErr_Occurred()) { 1341 goto exit; 1342 } 1343 a = ival; 1344 } 1345 if (nargs < 2) { 1346 goto skip_optional; 1347 } 1348 { 1349 Py_ssize_t ival = -1; 1350 PyObject *iobj = _PyNumber_Index(args[1]); 1351 if (iobj != NULL) { 1352 ival = PyLong_AsSsize_t(iobj); 1353 Py_DECREF(iobj); 1354 } 1355 if (ival == -1 && PyErr_Occurred()) { 1356 goto exit; 1357 } 1358 b = ival; 1359 } 1360 if (nargs < 3) { 1361 goto skip_optional; 1362 } 1363 if (!_Py_convert_optional_to_ssize_t(args[2], &c)) { 1364 goto exit; 1365 } 1366skip_optional: 1367 return_value = test_Py_ssize_t_converter_impl(module, a, b, c); 1368 1369exit: 1370 return return_value; 1371} 1372 1373static PyObject * 1374test_Py_ssize_t_converter_impl(PyObject *module, Py_ssize_t a, Py_ssize_t b, 1375 Py_ssize_t c) 1376/*[clinic end generated code: output=3bf73f9fdfeab468 input=3855f184bb3f299d]*/ 1377 1378 1379/*[clinic input] 1380test_slice_index_converter 1381 1382 a: slice_index = 12 1383 b: slice_index(accept={int}) = 34 1384 c: slice_index(accept={int, NoneType}) = 56 1385 / 1386 1387[clinic start generated code]*/ 1388 1389PyDoc_STRVAR(test_slice_index_converter__doc__, 1390"test_slice_index_converter($module, a=12, b=34, c=56, /)\n" 1391"--\n" 1392"\n"); 1393 1394#define TEST_SLICE_INDEX_CONVERTER_METHODDEF \ 1395 {"test_slice_index_converter", (PyCFunction)(void(*)(void))test_slice_index_converter, METH_FASTCALL, test_slice_index_converter__doc__}, 1396 1397static PyObject * 1398test_slice_index_converter_impl(PyObject *module, Py_ssize_t a, Py_ssize_t b, 1399 Py_ssize_t c); 1400 1401static PyObject * 1402test_slice_index_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 1403{ 1404 PyObject *return_value = NULL; 1405 Py_ssize_t a = 12; 1406 Py_ssize_t b = 34; 1407 Py_ssize_t c = 56; 1408 1409 if (!_PyArg_CheckPositional("test_slice_index_converter", nargs, 0, 3)) { 1410 goto exit; 1411 } 1412 if (nargs < 1) { 1413 goto skip_optional; 1414 } 1415 if (!_PyEval_SliceIndex(args[0], &a)) { 1416 goto exit; 1417 } 1418 if (nargs < 2) { 1419 goto skip_optional; 1420 } 1421 if (!_PyEval_SliceIndexNotNone(args[1], &b)) { 1422 goto exit; 1423 } 1424 if (nargs < 3) { 1425 goto skip_optional; 1426 } 1427 if (!_PyEval_SliceIndex(args[2], &c)) { 1428 goto exit; 1429 } 1430skip_optional: 1431 return_value = test_slice_index_converter_impl(module, a, b, c); 1432 1433exit: 1434 return return_value; 1435} 1436 1437static PyObject * 1438test_slice_index_converter_impl(PyObject *module, Py_ssize_t a, Py_ssize_t b, 1439 Py_ssize_t c) 1440/*[clinic end generated code: output=2148703cd3c6e941 input=edeadb0ee126f531]*/ 1441 1442 1443/*[clinic input] 1444test_size_t_converter 1445 1446 a: size_t = 12 1447 / 1448 1449[clinic start generated code]*/ 1450 1451PyDoc_STRVAR(test_size_t_converter__doc__, 1452"test_size_t_converter($module, a=12, /)\n" 1453"--\n" 1454"\n"); 1455 1456#define TEST_SIZE_T_CONVERTER_METHODDEF \ 1457 {"test_size_t_converter", (PyCFunction)(void(*)(void))test_size_t_converter, METH_FASTCALL, test_size_t_converter__doc__}, 1458 1459static PyObject * 1460test_size_t_converter_impl(PyObject *module, size_t a); 1461 1462static PyObject * 1463test_size_t_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 1464{ 1465 PyObject *return_value = NULL; 1466 size_t a = 12; 1467 1468 if (!_PyArg_CheckPositional("test_size_t_converter", nargs, 0, 1)) { 1469 goto exit; 1470 } 1471 if (nargs < 1) { 1472 goto skip_optional; 1473 } 1474 if (!_PyLong_Size_t_Converter(args[0], &a)) { 1475 goto exit; 1476 } 1477skip_optional: 1478 return_value = test_size_t_converter_impl(module, a); 1479 1480exit: 1481 return return_value; 1482} 1483 1484static PyObject * 1485test_size_t_converter_impl(PyObject *module, size_t a) 1486/*[clinic end generated code: output=8a91a9ca8a92dabb input=52e93a0fed0f1fb3]*/ 1487 1488 1489/*[clinic input] 1490test_float_converter 1491 1492 a: float = 12.5 1493 / 1494 1495[clinic start generated code]*/ 1496 1497PyDoc_STRVAR(test_float_converter__doc__, 1498"test_float_converter($module, a=12.5, /)\n" 1499"--\n" 1500"\n"); 1501 1502#define TEST_FLOAT_CONVERTER_METHODDEF \ 1503 {"test_float_converter", (PyCFunction)(void(*)(void))test_float_converter, METH_FASTCALL, test_float_converter__doc__}, 1504 1505static PyObject * 1506test_float_converter_impl(PyObject *module, float a); 1507 1508static PyObject * 1509test_float_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 1510{ 1511 PyObject *return_value = NULL; 1512 float a = 12.5; 1513 1514 if (!_PyArg_CheckPositional("test_float_converter", nargs, 0, 1)) { 1515 goto exit; 1516 } 1517 if (nargs < 1) { 1518 goto skip_optional; 1519 } 1520 if (PyFloat_CheckExact(args[0])) { 1521 a = (float) (PyFloat_AS_DOUBLE(args[0])); 1522 } 1523 else 1524 { 1525 a = (float) PyFloat_AsDouble(args[0]); 1526 if (a == -1.0 && PyErr_Occurred()) { 1527 goto exit; 1528 } 1529 } 1530skip_optional: 1531 return_value = test_float_converter_impl(module, a); 1532 1533exit: 1534 return return_value; 1535} 1536 1537static PyObject * 1538test_float_converter_impl(PyObject *module, float a) 1539/*[clinic end generated code: output=6b9c7443d2601cea input=259c0d98eca35034]*/ 1540 1541 1542/*[clinic input] 1543test_double_converter 1544 1545 a: double = 12.5 1546 / 1547 1548[clinic start generated code]*/ 1549 1550PyDoc_STRVAR(test_double_converter__doc__, 1551"test_double_converter($module, a=12.5, /)\n" 1552"--\n" 1553"\n"); 1554 1555#define TEST_DOUBLE_CONVERTER_METHODDEF \ 1556 {"test_double_converter", (PyCFunction)(void(*)(void))test_double_converter, METH_FASTCALL, test_double_converter__doc__}, 1557 1558static PyObject * 1559test_double_converter_impl(PyObject *module, double a); 1560 1561static PyObject * 1562test_double_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 1563{ 1564 PyObject *return_value = NULL; 1565 double a = 12.5; 1566 1567 if (!_PyArg_CheckPositional("test_double_converter", nargs, 0, 1)) { 1568 goto exit; 1569 } 1570 if (nargs < 1) { 1571 goto skip_optional; 1572 } 1573 if (PyFloat_CheckExact(args[0])) { 1574 a = PyFloat_AS_DOUBLE(args[0]); 1575 } 1576 else 1577 { 1578 a = PyFloat_AsDouble(args[0]); 1579 if (a == -1.0 && PyErr_Occurred()) { 1580 goto exit; 1581 } 1582 } 1583skip_optional: 1584 return_value = test_double_converter_impl(module, a); 1585 1586exit: 1587 return return_value; 1588} 1589 1590static PyObject * 1591test_double_converter_impl(PyObject *module, double a) 1592/*[clinic end generated code: output=5b7b9a0f0791b2cc input=c6a9945706a41c27]*/ 1593 1594 1595/*[clinic input] 1596test_Py_complex_converter 1597 1598 a: Py_complex 1599 / 1600 1601[clinic start generated code]*/ 1602 1603PyDoc_STRVAR(test_Py_complex_converter__doc__, 1604"test_Py_complex_converter($module, a, /)\n" 1605"--\n" 1606"\n"); 1607 1608#define TEST_PY_COMPLEX_CONVERTER_METHODDEF \ 1609 {"test_Py_complex_converter", (PyCFunction)test_Py_complex_converter, METH_O, test_Py_complex_converter__doc__}, 1610 1611static PyObject * 1612test_Py_complex_converter_impl(PyObject *module, Py_complex a); 1613 1614static PyObject * 1615test_Py_complex_converter(PyObject *module, PyObject *arg) 1616{ 1617 PyObject *return_value = NULL; 1618 Py_complex a; 1619 1620 a = PyComplex_AsCComplex(arg); 1621 if (PyErr_Occurred()) { 1622 goto exit; 1623 } 1624 return_value = test_Py_complex_converter_impl(module, a); 1625 1626exit: 1627 return return_value; 1628} 1629 1630static PyObject * 1631test_Py_complex_converter_impl(PyObject *module, Py_complex a) 1632/*[clinic end generated code: output=c2ecbec2144ca540 input=070f216a515beb79]*/ 1633 1634 1635/*[clinic input] 1636test_str_converter 1637 1638 a: str = NULL 1639 b: str = "ab" 1640 c: str(accept={str}) = "cd" 1641 d: str(accept={robuffer}) = "cef" 1642 e: str(accept={str, NoneType}) = "gh" 1643 f: str(accept={robuffer}, zeroes=True) = "ij" 1644 g: str(accept={robuffer, str}, zeroes=True) = "kl" 1645 h: str(accept={robuffer, str, NoneType}, zeroes=True) = "mn" 1646 / 1647 1648[clinic start generated code]*/ 1649 1650PyDoc_STRVAR(test_str_converter__doc__, 1651"test_str_converter($module, a=<unrepresentable>, b=\'ab\', c=\'cd\',\n" 1652" d=\'cef\', e=\'gh\', f=\'ij\', g=\'kl\', h=\'mn\', /)\n" 1653"--\n" 1654"\n"); 1655 1656#define TEST_STR_CONVERTER_METHODDEF \ 1657 {"test_str_converter", (PyCFunction)(void(*)(void))test_str_converter, METH_FASTCALL, test_str_converter__doc__}, 1658 1659static PyObject * 1660test_str_converter_impl(PyObject *module, const char *a, const char *b, 1661 const char *c, const char *d, const char *e, 1662 const char *f, Py_ssize_clean_t f_length, 1663 const char *g, Py_ssize_clean_t g_length, 1664 const char *h, Py_ssize_clean_t h_length); 1665 1666static PyObject * 1667test_str_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 1668{ 1669 PyObject *return_value = NULL; 1670 const char *a = NULL; 1671 const char *b = "ab"; 1672 const char *c = "cd"; 1673 const char *d = "cef"; 1674 const char *e = "gh"; 1675 const char *f = "ij"; 1676 Py_ssize_clean_t f_length; 1677 const char *g = "kl"; 1678 Py_ssize_clean_t g_length; 1679 const char *h = "mn"; 1680 Py_ssize_clean_t h_length; 1681 1682 if (!_PyArg_ParseStack(args, nargs, "|sssyzy#s#z#:test_str_converter", 1683 &a, &b, &c, &d, &e, &f, &f_length, &g, &g_length, &h, &h_length)) { 1684 goto exit; 1685 } 1686 return_value = test_str_converter_impl(module, a, b, c, d, e, f, f_length, g, g_length, h, h_length); 1687 1688exit: 1689 return return_value; 1690} 1691 1692static PyObject * 1693test_str_converter_impl(PyObject *module, const char *a, const char *b, 1694 const char *c, const char *d, const char *e, 1695 const char *f, Py_ssize_clean_t f_length, 1696 const char *g, Py_ssize_clean_t g_length, 1697 const char *h, Py_ssize_clean_t h_length) 1698/*[clinic end generated code: output=ad868ad94a488e32 input=8afe9da8185cd38c]*/ 1699 1700 1701/*[clinic input] 1702test_str_converter_encoding 1703 1704 a: str(encoding="idna") 1705 b: str(encoding="idna", accept={str}) 1706 c: str(encoding="idna", accept={bytes, bytearray, str}) 1707 d: str(encoding="idna", zeroes=True) 1708 e: str(encoding="idna", accept={bytes, bytearray, str}, zeroes=True) 1709 / 1710 1711[clinic start generated code]*/ 1712 1713PyDoc_STRVAR(test_str_converter_encoding__doc__, 1714"test_str_converter_encoding($module, a, b, c, d, e, /)\n" 1715"--\n" 1716"\n"); 1717 1718#define TEST_STR_CONVERTER_ENCODING_METHODDEF \ 1719 {"test_str_converter_encoding", (PyCFunction)(void(*)(void))test_str_converter_encoding, METH_FASTCALL, test_str_converter_encoding__doc__}, 1720 1721static PyObject * 1722test_str_converter_encoding_impl(PyObject *module, char *a, char *b, char *c, 1723 char *d, Py_ssize_clean_t d_length, char *e, 1724 Py_ssize_clean_t e_length); 1725 1726static PyObject * 1727test_str_converter_encoding(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 1728{ 1729 PyObject *return_value = NULL; 1730 char *a = NULL; 1731 char *b = NULL; 1732 char *c = NULL; 1733 char *d = NULL; 1734 Py_ssize_clean_t d_length; 1735 char *e = NULL; 1736 Py_ssize_clean_t e_length; 1737 1738 if (!_PyArg_ParseStack(args, nargs, "esesetes#et#:test_str_converter_encoding", 1739 "idna", &a, "idna", &b, "idna", &c, "idna", &d, &d_length, "idna", &e, &e_length)) { 1740 goto exit; 1741 } 1742 return_value = test_str_converter_encoding_impl(module, a, b, c, d, d_length, e, e_length); 1743 1744exit: 1745 /* Cleanup for a */ 1746 if (a) { 1747 PyMem_FREE(a); 1748 } 1749 /* Cleanup for b */ 1750 if (b) { 1751 PyMem_FREE(b); 1752 } 1753 /* Cleanup for c */ 1754 if (c) { 1755 PyMem_FREE(c); 1756 } 1757 /* Cleanup for d */ 1758 if (d) { 1759 PyMem_FREE(d); 1760 } 1761 /* Cleanup for e */ 1762 if (e) { 1763 PyMem_FREE(e); 1764 } 1765 1766 return return_value; 1767} 1768 1769static PyObject * 1770test_str_converter_encoding_impl(PyObject *module, char *a, char *b, char *c, 1771 char *d, Py_ssize_clean_t d_length, char *e, 1772 Py_ssize_clean_t e_length) 1773/*[clinic end generated code: output=f579dd9e795a364e input=eb4c38e1f898f402]*/ 1774 1775 1776/*[clinic input] 1777test_Py_UNICODE_converter 1778 1779 a: Py_UNICODE 1780 b: Py_UNICODE(accept={str}) 1781 c: Py_UNICODE(accept={str, NoneType}) 1782 d: Py_UNICODE(zeroes=True) 1783 e: Py_UNICODE(accept={str, NoneType}, zeroes=True) 1784 / 1785 1786[clinic start generated code]*/ 1787 1788PyDoc_STRVAR(test_Py_UNICODE_converter__doc__, 1789"test_Py_UNICODE_converter($module, a, b, c, d, e, /)\n" 1790"--\n" 1791"\n"); 1792 1793#define TEST_PY_UNICODE_CONVERTER_METHODDEF \ 1794 {"test_Py_UNICODE_converter", (PyCFunction)(void(*)(void))test_Py_UNICODE_converter, METH_FASTCALL, test_Py_UNICODE_converter__doc__}, 1795 1796static PyObject * 1797test_Py_UNICODE_converter_impl(PyObject *module, const Py_UNICODE *a, 1798 const Py_UNICODE *b, const Py_UNICODE *c, 1799 const Py_UNICODE *d, 1800 Py_ssize_clean_t d_length, 1801 const Py_UNICODE *e, 1802 Py_ssize_clean_t e_length); 1803 1804static PyObject * 1805test_Py_UNICODE_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 1806{ 1807 PyObject *return_value = NULL; 1808 const Py_UNICODE *a; 1809 const Py_UNICODE *b; 1810 const Py_UNICODE *c; 1811 const Py_UNICODE *d; 1812 Py_ssize_clean_t d_length; 1813 const Py_UNICODE *e; 1814 Py_ssize_clean_t e_length; 1815 1816 if (!_PyArg_ParseStack(args, nargs, "O&O&O&u#Z#:test_Py_UNICODE_converter", 1817 _PyUnicode_WideCharString_Converter, &a, _PyUnicode_WideCharString_Converter, &b, _PyUnicode_WideCharString_Opt_Converter, &c, &d, &d_length, &e, &e_length)) { 1818 goto exit; 1819 } 1820 return_value = test_Py_UNICODE_converter_impl(module, a, b, c, d, d_length, e, e_length); 1821 1822exit: 1823 /* Cleanup for a */ 1824 #if !USE_UNICODE_WCHAR_CACHE 1825 PyMem_Free((void *)a); 1826 #endif /* USE_UNICODE_WCHAR_CACHE */ 1827 /* Cleanup for b */ 1828 #if !USE_UNICODE_WCHAR_CACHE 1829 PyMem_Free((void *)b); 1830 #endif /* USE_UNICODE_WCHAR_CACHE */ 1831 /* Cleanup for c */ 1832 #if !USE_UNICODE_WCHAR_CACHE 1833 PyMem_Free((void *)c); 1834 #endif /* USE_UNICODE_WCHAR_CACHE */ 1835 1836 return return_value; 1837} 1838 1839static PyObject * 1840test_Py_UNICODE_converter_impl(PyObject *module, const Py_UNICODE *a, 1841 const Py_UNICODE *b, const Py_UNICODE *c, 1842 const Py_UNICODE *d, 1843 Py_ssize_clean_t d_length, 1844 const Py_UNICODE *e, 1845 Py_ssize_clean_t e_length) 1846/*[clinic end generated code: output=ef45e982fedf0b3d input=064a3b68ad7f04b0]*/ 1847 1848 1849/*[clinic input] 1850test_Py_buffer_converter 1851 1852 a: Py_buffer 1853 b: Py_buffer(accept={buffer}) 1854 c: Py_buffer(accept={str, buffer}) 1855 d: Py_buffer(accept={str, buffer, NoneType}) 1856 e: Py_buffer(accept={rwbuffer}) 1857 / 1858 1859[clinic start generated code]*/ 1860 1861PyDoc_STRVAR(test_Py_buffer_converter__doc__, 1862"test_Py_buffer_converter($module, a, b, c, d, e, /)\n" 1863"--\n" 1864"\n"); 1865 1866#define TEST_PY_BUFFER_CONVERTER_METHODDEF \ 1867 {"test_Py_buffer_converter", (PyCFunction)(void(*)(void))test_Py_buffer_converter, METH_FASTCALL, test_Py_buffer_converter__doc__}, 1868 1869static PyObject * 1870test_Py_buffer_converter_impl(PyObject *module, Py_buffer *a, Py_buffer *b, 1871 Py_buffer *c, Py_buffer *d, Py_buffer *e); 1872 1873static PyObject * 1874test_Py_buffer_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs) 1875{ 1876 PyObject *return_value = NULL; 1877 Py_buffer a = {NULL, NULL}; 1878 Py_buffer b = {NULL, NULL}; 1879 Py_buffer c = {NULL, NULL}; 1880 Py_buffer d = {NULL, NULL}; 1881 Py_buffer e = {NULL, NULL}; 1882 1883 if (!_PyArg_ParseStack(args, nargs, "y*y*s*z*w*:test_Py_buffer_converter", 1884 &a, &b, &c, &d, &e)) { 1885 goto exit; 1886 } 1887 return_value = test_Py_buffer_converter_impl(module, &a, &b, &c, &d, &e); 1888 1889exit: 1890 /* Cleanup for a */ 1891 if (a.obj) { 1892 PyBuffer_Release(&a); 1893 } 1894 /* Cleanup for b */ 1895 if (b.obj) { 1896 PyBuffer_Release(&b); 1897 } 1898 /* Cleanup for c */ 1899 if (c.obj) { 1900 PyBuffer_Release(&c); 1901 } 1902 /* Cleanup for d */ 1903 if (d.obj) { 1904 PyBuffer_Release(&d); 1905 } 1906 /* Cleanup for e */ 1907 if (e.obj) { 1908 PyBuffer_Release(&e); 1909 } 1910 1911 return return_value; 1912} 1913 1914static PyObject * 1915test_Py_buffer_converter_impl(PyObject *module, Py_buffer *a, Py_buffer *b, 1916 Py_buffer *c, Py_buffer *d, Py_buffer *e) 1917/*[clinic end generated code: output=5760c82faa2ed61f input=6a9da0f56f9525fd]*/ 1918 1919 1920/*[clinic input] 1921test_keywords 1922 1923 a: object 1924 b: object 1925 1926[clinic start generated code]*/ 1927 1928PyDoc_STRVAR(test_keywords__doc__, 1929"test_keywords($module, /, a, b)\n" 1930"--\n" 1931"\n"); 1932 1933#define TEST_KEYWORDS_METHODDEF \ 1934 {"test_keywords", (PyCFunction)(void(*)(void))test_keywords, METH_FASTCALL|METH_KEYWORDS, test_keywords__doc__}, 1935 1936static PyObject * 1937test_keywords_impl(PyObject *module, PyObject *a, PyObject *b); 1938 1939static PyObject * 1940test_keywords(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) 1941{ 1942 PyObject *return_value = NULL; 1943 static const char * const _keywords[] = {"a", "b", NULL}; 1944 static _PyArg_Parser _parser = {NULL, _keywords, "test_keywords", 0}; 1945 PyObject *argsbuf[2]; 1946 PyObject *a; 1947 PyObject *b; 1948 1949 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf); 1950 if (!args) { 1951 goto exit; 1952 } 1953 a = args[0]; 1954 b = args[1]; 1955 return_value = test_keywords_impl(module, a, b); 1956 1957exit: 1958 return return_value; 1959} 1960 1961static PyObject * 1962test_keywords_impl(PyObject *module, PyObject *a, PyObject *b) 1963/*[clinic end generated code: output=4be6cf045ea8242e input=0d3484844749c05b]*/ 1964 1965 1966/*[clinic input] 1967test_keywords_kwonly 1968 1969 a: object 1970 * 1971 b: object 1972 1973[clinic start generated code]*/ 1974 1975PyDoc_STRVAR(test_keywords_kwonly__doc__, 1976"test_keywords_kwonly($module, /, a, *, b)\n" 1977"--\n" 1978"\n"); 1979 1980#define TEST_KEYWORDS_KWONLY_METHODDEF \ 1981 {"test_keywords_kwonly", (PyCFunction)(void(*)(void))test_keywords_kwonly, METH_FASTCALL|METH_KEYWORDS, test_keywords_kwonly__doc__}, 1982 1983static PyObject * 1984test_keywords_kwonly_impl(PyObject *module, PyObject *a, PyObject *b); 1985 1986static PyObject * 1987test_keywords_kwonly(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) 1988{ 1989 PyObject *return_value = NULL; 1990 static const char * const _keywords[] = {"a", "b", NULL}; 1991 static _PyArg_Parser _parser = {NULL, _keywords, "test_keywords_kwonly", 0}; 1992 PyObject *argsbuf[2]; 1993 PyObject *a; 1994 PyObject *b; 1995 1996 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 1, argsbuf); 1997 if (!args) { 1998 goto exit; 1999 } 2000 a = args[0]; 2001 b = args[1]; 2002 return_value = test_keywords_kwonly_impl(module, a, b); 2003 2004exit: 2005 return return_value; 2006} 2007 2008static PyObject * 2009test_keywords_kwonly_impl(PyObject *module, PyObject *a, PyObject *b) 2010/*[clinic end generated code: output=d63c4977a7a80713 input=384adc78bfa0bff7]*/ 2011 2012 2013/*[clinic input] 2014test_keywords_opt 2015 2016 a: object 2017 b: object = None 2018 c: object = None 2019 2020[clinic start generated code]*/ 2021 2022PyDoc_STRVAR(test_keywords_opt__doc__, 2023"test_keywords_opt($module, /, a, b=None, c=None)\n" 2024"--\n" 2025"\n"); 2026 2027#define TEST_KEYWORDS_OPT_METHODDEF \ 2028 {"test_keywords_opt", (PyCFunction)(void(*)(void))test_keywords_opt, METH_FASTCALL|METH_KEYWORDS, test_keywords_opt__doc__}, 2029 2030static PyObject * 2031test_keywords_opt_impl(PyObject *module, PyObject *a, PyObject *b, 2032 PyObject *c); 2033 2034static PyObject * 2035test_keywords_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) 2036{ 2037 PyObject *return_value = NULL; 2038 static const char * const _keywords[] = {"a", "b", "c", NULL}; 2039 static _PyArg_Parser _parser = {NULL, _keywords, "test_keywords_opt", 0}; 2040 PyObject *argsbuf[3]; 2041 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1; 2042 PyObject *a; 2043 PyObject *b = Py_None; 2044 PyObject *c = Py_None; 2045 2046 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf); 2047 if (!args) { 2048 goto exit; 2049 } 2050 a = args[0]; 2051 if (!noptargs) { 2052 goto skip_optional_pos; 2053 } 2054 if (args[1]) { 2055 b = args[1]; 2056 if (!--noptargs) { 2057 goto skip_optional_pos; 2058 } 2059 } 2060 c = args[2]; 2061skip_optional_pos: 2062 return_value = test_keywords_opt_impl(module, a, b, c); 2063 2064exit: 2065 return return_value; 2066} 2067 2068static PyObject * 2069test_keywords_opt_impl(PyObject *module, PyObject *a, PyObject *b, 2070 PyObject *c) 2071/*[clinic end generated code: output=e5e50d114d8fc10a input=eda7964f784f4607]*/ 2072 2073 2074/*[clinic input] 2075test_keywords_opt_kwonly 2076 2077 a: object 2078 b: object = None 2079 * 2080 c: object = None 2081 d: object = None 2082 2083[clinic start generated code]*/ 2084 2085PyDoc_STRVAR(test_keywords_opt_kwonly__doc__, 2086"test_keywords_opt_kwonly($module, /, a, b=None, *, c=None, d=None)\n" 2087"--\n" 2088"\n"); 2089 2090#define TEST_KEYWORDS_OPT_KWONLY_METHODDEF \ 2091 {"test_keywords_opt_kwonly", (PyCFunction)(void(*)(void))test_keywords_opt_kwonly, METH_FASTCALL|METH_KEYWORDS, test_keywords_opt_kwonly__doc__}, 2092 2093static PyObject * 2094test_keywords_opt_kwonly_impl(PyObject *module, PyObject *a, PyObject *b, 2095 PyObject *c, PyObject *d); 2096 2097static PyObject * 2098test_keywords_opt_kwonly(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) 2099{ 2100 PyObject *return_value = NULL; 2101 static const char * const _keywords[] = {"a", "b", "c", "d", NULL}; 2102 static _PyArg_Parser _parser = {NULL, _keywords, "test_keywords_opt_kwonly", 0}; 2103 PyObject *argsbuf[4]; 2104 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1; 2105 PyObject *a; 2106 PyObject *b = Py_None; 2107 PyObject *c = Py_None; 2108 PyObject *d = Py_None; 2109 2110 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf); 2111 if (!args) { 2112 goto exit; 2113 } 2114 a = args[0]; 2115 if (!noptargs) { 2116 goto skip_optional_pos; 2117 } 2118 if (args[1]) { 2119 b = args[1]; 2120 if (!--noptargs) { 2121 goto skip_optional_pos; 2122 } 2123 } 2124skip_optional_pos: 2125 if (!noptargs) { 2126 goto skip_optional_kwonly; 2127 } 2128 if (args[2]) { 2129 c = args[2]; 2130 if (!--noptargs) { 2131 goto skip_optional_kwonly; 2132 } 2133 } 2134 d = args[3]; 2135skip_optional_kwonly: 2136 return_value = test_keywords_opt_kwonly_impl(module, a, b, c, d); 2137 2138exit: 2139 return return_value; 2140} 2141 2142static PyObject * 2143test_keywords_opt_kwonly_impl(PyObject *module, PyObject *a, PyObject *b, 2144 PyObject *c, PyObject *d) 2145/*[clinic end generated code: output=3f065cb8309b9317 input=209387a4815e5082]*/ 2146 2147 2148/*[clinic input] 2149test_keywords_kwonly_opt 2150 2151 a: object 2152 * 2153 b: object = None 2154 c: object = None 2155 2156[clinic start generated code]*/ 2157 2158PyDoc_STRVAR(test_keywords_kwonly_opt__doc__, 2159"test_keywords_kwonly_opt($module, /, a, *, b=None, c=None)\n" 2160"--\n" 2161"\n"); 2162 2163#define TEST_KEYWORDS_KWONLY_OPT_METHODDEF \ 2164 {"test_keywords_kwonly_opt", (PyCFunction)(void(*)(void))test_keywords_kwonly_opt, METH_FASTCALL|METH_KEYWORDS, test_keywords_kwonly_opt__doc__}, 2165 2166static PyObject * 2167test_keywords_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b, 2168 PyObject *c); 2169 2170static PyObject * 2171test_keywords_kwonly_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) 2172{ 2173 PyObject *return_value = NULL; 2174 static const char * const _keywords[] = {"a", "b", "c", NULL}; 2175 static _PyArg_Parser _parser = {NULL, _keywords, "test_keywords_kwonly_opt", 0}; 2176 PyObject *argsbuf[3]; 2177 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1; 2178 PyObject *a; 2179 PyObject *b = Py_None; 2180 PyObject *c = Py_None; 2181 2182 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf); 2183 if (!args) { 2184 goto exit; 2185 } 2186 a = args[0]; 2187 if (!noptargs) { 2188 goto skip_optional_kwonly; 2189 } 2190 if (args[1]) { 2191 b = args[1]; 2192 if (!--noptargs) { 2193 goto skip_optional_kwonly; 2194 } 2195 } 2196 c = args[2]; 2197skip_optional_kwonly: 2198 return_value = test_keywords_kwonly_opt_impl(module, a, b, c); 2199 2200exit: 2201 return return_value; 2202} 2203 2204static PyObject * 2205test_keywords_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b, 2206 PyObject *c) 2207/*[clinic end generated code: output=94edba5484e1681e input=18393cc64fa000f4]*/ 2208 2209 2210/*[clinic input] 2211test_posonly_keywords 2212 2213 a: object 2214 / 2215 b: object 2216 2217[clinic start generated code]*/ 2218 2219PyDoc_STRVAR(test_posonly_keywords__doc__, 2220"test_posonly_keywords($module, a, /, b)\n" 2221"--\n" 2222"\n"); 2223 2224#define TEST_POSONLY_KEYWORDS_METHODDEF \ 2225 {"test_posonly_keywords", (PyCFunction)(void(*)(void))test_posonly_keywords, METH_FASTCALL|METH_KEYWORDS, test_posonly_keywords__doc__}, 2226 2227static PyObject * 2228test_posonly_keywords_impl(PyObject *module, PyObject *a, PyObject *b); 2229 2230static PyObject * 2231test_posonly_keywords(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) 2232{ 2233 PyObject *return_value = NULL; 2234 static const char * const _keywords[] = {"", "b", NULL}; 2235 static _PyArg_Parser _parser = {NULL, _keywords, "test_posonly_keywords", 0}; 2236 PyObject *argsbuf[2]; 2237 PyObject *a; 2238 PyObject *b; 2239 2240 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf); 2241 if (!args) { 2242 goto exit; 2243 } 2244 a = args[0]; 2245 b = args[1]; 2246 return_value = test_posonly_keywords_impl(module, a, b); 2247 2248exit: 2249 return return_value; 2250} 2251 2252static PyObject * 2253test_posonly_keywords_impl(PyObject *module, PyObject *a, PyObject *b) 2254/*[clinic end generated code: output=eca1507f0182ffb0 input=1767b0ebdf06060e]*/ 2255 2256 2257/*[clinic input] 2258test_posonly_kwonly 2259 2260 a: object 2261 / 2262 * 2263 c: object 2264 2265[clinic start generated code]*/ 2266 2267PyDoc_STRVAR(test_posonly_kwonly__doc__, 2268"test_posonly_kwonly($module, a, /, *, c)\n" 2269"--\n" 2270"\n"); 2271 2272#define TEST_POSONLY_KWONLY_METHODDEF \ 2273 {"test_posonly_kwonly", (PyCFunction)(void(*)(void))test_posonly_kwonly, METH_FASTCALL|METH_KEYWORDS, test_posonly_kwonly__doc__}, 2274 2275static PyObject * 2276test_posonly_kwonly_impl(PyObject *module, PyObject *a, PyObject *c); 2277 2278static PyObject * 2279test_posonly_kwonly(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) 2280{ 2281 PyObject *return_value = NULL; 2282 static const char * const _keywords[] = {"", "c", NULL}; 2283 static _PyArg_Parser _parser = {NULL, _keywords, "test_posonly_kwonly", 0}; 2284 PyObject *argsbuf[2]; 2285 PyObject *a; 2286 PyObject *c; 2287 2288 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 1, argsbuf); 2289 if (!args) { 2290 goto exit; 2291 } 2292 a = args[0]; 2293 c = args[1]; 2294 return_value = test_posonly_kwonly_impl(module, a, c); 2295 2296exit: 2297 return return_value; 2298} 2299 2300static PyObject * 2301test_posonly_kwonly_impl(PyObject *module, PyObject *a, PyObject *c) 2302/*[clinic end generated code: output=3e14655646b66e9a input=9042f2818f664839]*/ 2303 2304 2305/*[clinic input] 2306test_posonly_keywords_kwonly 2307 2308 a: object 2309 / 2310 b: object 2311 * 2312 c: object 2313 2314[clinic start generated code]*/ 2315 2316PyDoc_STRVAR(test_posonly_keywords_kwonly__doc__, 2317"test_posonly_keywords_kwonly($module, a, /, b, *, c)\n" 2318"--\n" 2319"\n"); 2320 2321#define TEST_POSONLY_KEYWORDS_KWONLY_METHODDEF \ 2322 {"test_posonly_keywords_kwonly", (PyCFunction)(void(*)(void))test_posonly_keywords_kwonly, METH_FASTCALL|METH_KEYWORDS, test_posonly_keywords_kwonly__doc__}, 2323 2324static PyObject * 2325test_posonly_keywords_kwonly_impl(PyObject *module, PyObject *a, PyObject *b, 2326 PyObject *c); 2327 2328static PyObject * 2329test_posonly_keywords_kwonly(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) 2330{ 2331 PyObject *return_value = NULL; 2332 static const char * const _keywords[] = {"", "b", "c", NULL}; 2333 static _PyArg_Parser _parser = {NULL, _keywords, "test_posonly_keywords_kwonly", 0}; 2334 PyObject *argsbuf[3]; 2335 PyObject *a; 2336 PyObject *b; 2337 PyObject *c; 2338 2339 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 1, argsbuf); 2340 if (!args) { 2341 goto exit; 2342 } 2343 a = args[0]; 2344 b = args[1]; 2345 c = args[2]; 2346 return_value = test_posonly_keywords_kwonly_impl(module, a, b, c); 2347 2348exit: 2349 return return_value; 2350} 2351 2352static PyObject * 2353test_posonly_keywords_kwonly_impl(PyObject *module, PyObject *a, PyObject *b, 2354 PyObject *c) 2355/*[clinic end generated code: output=de57172fc97a626e input=29546ebdca492fea]*/ 2356 2357 2358/*[clinic input] 2359test_posonly_keywords_opt 2360 2361 a: object 2362 / 2363 b: object 2364 c: object = None 2365 d: object = None 2366 2367[clinic start generated code]*/ 2368 2369PyDoc_STRVAR(test_posonly_keywords_opt__doc__, 2370"test_posonly_keywords_opt($module, a, /, b, c=None, d=None)\n" 2371"--\n" 2372"\n"); 2373 2374#define TEST_POSONLY_KEYWORDS_OPT_METHODDEF \ 2375 {"test_posonly_keywords_opt", (PyCFunction)(void(*)(void))test_posonly_keywords_opt, METH_FASTCALL|METH_KEYWORDS, test_posonly_keywords_opt__doc__}, 2376 2377static PyObject * 2378test_posonly_keywords_opt_impl(PyObject *module, PyObject *a, PyObject *b, 2379 PyObject *c, PyObject *d); 2380 2381static PyObject * 2382test_posonly_keywords_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) 2383{ 2384 PyObject *return_value = NULL; 2385 static const char * const _keywords[] = {"", "b", "c", "d", NULL}; 2386 static _PyArg_Parser _parser = {NULL, _keywords, "test_posonly_keywords_opt", 0}; 2387 PyObject *argsbuf[4]; 2388 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2; 2389 PyObject *a; 2390 PyObject *b; 2391 PyObject *c = Py_None; 2392 PyObject *d = Py_None; 2393 2394 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 4, 0, argsbuf); 2395 if (!args) { 2396 goto exit; 2397 } 2398 a = args[0]; 2399 b = args[1]; 2400 if (!noptargs) { 2401 goto skip_optional_pos; 2402 } 2403 if (args[2]) { 2404 c = args[2]; 2405 if (!--noptargs) { 2406 goto skip_optional_pos; 2407 } 2408 } 2409 d = args[3]; 2410skip_optional_pos: 2411 return_value = test_posonly_keywords_opt_impl(module, a, b, c, d); 2412 2413exit: 2414 return return_value; 2415} 2416 2417static PyObject * 2418test_posonly_keywords_opt_impl(PyObject *module, PyObject *a, PyObject *b, 2419 PyObject *c, PyObject *d) 2420/*[clinic end generated code: output=8bc6b44a25d4b716 input=cdf5a9625e554e9b]*/ 2421 2422 2423/*[clinic input] 2424test_posonly_keywords_opt2 2425 2426 a: object 2427 / 2428 b: object = None 2429 c: object = None 2430 2431[clinic start generated code]*/ 2432 2433PyDoc_STRVAR(test_posonly_keywords_opt2__doc__, 2434"test_posonly_keywords_opt2($module, a, /, b=None, c=None)\n" 2435"--\n" 2436"\n"); 2437 2438#define TEST_POSONLY_KEYWORDS_OPT2_METHODDEF \ 2439 {"test_posonly_keywords_opt2", (PyCFunction)(void(*)(void))test_posonly_keywords_opt2, METH_FASTCALL|METH_KEYWORDS, test_posonly_keywords_opt2__doc__}, 2440 2441static PyObject * 2442test_posonly_keywords_opt2_impl(PyObject *module, PyObject *a, PyObject *b, 2443 PyObject *c); 2444 2445static PyObject * 2446test_posonly_keywords_opt2(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) 2447{ 2448 PyObject *return_value = NULL; 2449 static const char * const _keywords[] = {"", "b", "c", NULL}; 2450 static _PyArg_Parser _parser = {NULL, _keywords, "test_posonly_keywords_opt2", 0}; 2451 PyObject *argsbuf[3]; 2452 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1; 2453 PyObject *a; 2454 PyObject *b = Py_None; 2455 PyObject *c = Py_None; 2456 2457 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf); 2458 if (!args) { 2459 goto exit; 2460 } 2461 a = args[0]; 2462 if (!noptargs) { 2463 goto skip_optional_pos; 2464 } 2465 if (args[1]) { 2466 b = args[1]; 2467 if (!--noptargs) { 2468 goto skip_optional_pos; 2469 } 2470 } 2471 c = args[2]; 2472skip_optional_pos: 2473 return_value = test_posonly_keywords_opt2_impl(module, a, b, c); 2474 2475exit: 2476 return return_value; 2477} 2478 2479static PyObject * 2480test_posonly_keywords_opt2_impl(PyObject *module, PyObject *a, PyObject *b, 2481 PyObject *c) 2482/*[clinic end generated code: output=a870c45a6510ba91 input=1581299d21d16f14]*/ 2483 2484 2485/*[clinic input] 2486test_posonly_opt_keywords_opt 2487 2488 a: object 2489 b: object = None 2490 / 2491 c: object = None 2492 d: object = None 2493 2494[clinic start generated code]*/ 2495 2496PyDoc_STRVAR(test_posonly_opt_keywords_opt__doc__, 2497"test_posonly_opt_keywords_opt($module, a, b=None, /, c=None, d=None)\n" 2498"--\n" 2499"\n"); 2500 2501#define TEST_POSONLY_OPT_KEYWORDS_OPT_METHODDEF \ 2502 {"test_posonly_opt_keywords_opt", (PyCFunction)(void(*)(void))test_posonly_opt_keywords_opt, METH_FASTCALL|METH_KEYWORDS, test_posonly_opt_keywords_opt__doc__}, 2503 2504static PyObject * 2505test_posonly_opt_keywords_opt_impl(PyObject *module, PyObject *a, 2506 PyObject *b, PyObject *c, PyObject *d); 2507 2508static PyObject * 2509test_posonly_opt_keywords_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) 2510{ 2511 PyObject *return_value = NULL; 2512 static const char * const _keywords[] = {"", "", "c", "d", NULL}; 2513 static _PyArg_Parser _parser = {NULL, _keywords, "test_posonly_opt_keywords_opt", 0}; 2514 PyObject *argsbuf[4]; 2515 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1; 2516 PyObject *a; 2517 PyObject *b = Py_None; 2518 PyObject *c = Py_None; 2519 PyObject *d = Py_None; 2520 2521 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 4, 0, argsbuf); 2522 if (!args) { 2523 goto exit; 2524 } 2525 a = args[0]; 2526 if (nargs < 2) { 2527 goto skip_optional_posonly; 2528 } 2529 noptargs--; 2530 b = args[1]; 2531skip_optional_posonly: 2532 if (!noptargs) { 2533 goto skip_optional_pos; 2534 } 2535 if (args[2]) { 2536 c = args[2]; 2537 if (!--noptargs) { 2538 goto skip_optional_pos; 2539 } 2540 } 2541 d = args[3]; 2542skip_optional_pos: 2543 return_value = test_posonly_opt_keywords_opt_impl(module, a, b, c, d); 2544 2545exit: 2546 return return_value; 2547} 2548 2549static PyObject * 2550test_posonly_opt_keywords_opt_impl(PyObject *module, PyObject *a, 2551 PyObject *b, PyObject *c, PyObject *d) 2552/*[clinic end generated code: output=9ae3d52e071d3b7f input=408798ec3d42949f]*/ 2553 2554 2555/*[clinic input] 2556test_posonly_kwonly_opt 2557 2558 a: object 2559 / 2560 * 2561 b: object 2562 c: object = None 2563 d: object = None 2564 2565[clinic start generated code]*/ 2566 2567PyDoc_STRVAR(test_posonly_kwonly_opt__doc__, 2568"test_posonly_kwonly_opt($module, a, /, *, b, c=None, d=None)\n" 2569"--\n" 2570"\n"); 2571 2572#define TEST_POSONLY_KWONLY_OPT_METHODDEF \ 2573 {"test_posonly_kwonly_opt", (PyCFunction)(void(*)(void))test_posonly_kwonly_opt, METH_FASTCALL|METH_KEYWORDS, test_posonly_kwonly_opt__doc__}, 2574 2575static PyObject * 2576test_posonly_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b, 2577 PyObject *c, PyObject *d); 2578 2579static PyObject * 2580test_posonly_kwonly_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) 2581{ 2582 PyObject *return_value = NULL; 2583 static const char * const _keywords[] = {"", "b", "c", "d", NULL}; 2584 static _PyArg_Parser _parser = {NULL, _keywords, "test_posonly_kwonly_opt", 0}; 2585 PyObject *argsbuf[4]; 2586 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2; 2587 PyObject *a; 2588 PyObject *b; 2589 PyObject *c = Py_None; 2590 PyObject *d = Py_None; 2591 2592 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 1, argsbuf); 2593 if (!args) { 2594 goto exit; 2595 } 2596 a = args[0]; 2597 b = args[1]; 2598 if (!noptargs) { 2599 goto skip_optional_kwonly; 2600 } 2601 if (args[2]) { 2602 c = args[2]; 2603 if (!--noptargs) { 2604 goto skip_optional_kwonly; 2605 } 2606 } 2607 d = args[3]; 2608skip_optional_kwonly: 2609 return_value = test_posonly_kwonly_opt_impl(module, a, b, c, d); 2610 2611exit: 2612 return return_value; 2613} 2614 2615static PyObject * 2616test_posonly_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b, 2617 PyObject *c, PyObject *d) 2618/*[clinic end generated code: output=fb001f586ba68549 input=8d8e5643bbbc2309]*/ 2619 2620 2621/*[clinic input] 2622test_posonly_kwonly_opt2 2623 2624 a: object 2625 / 2626 * 2627 b: object = None 2628 c: object = None 2629 2630[clinic start generated code]*/ 2631 2632PyDoc_STRVAR(test_posonly_kwonly_opt2__doc__, 2633"test_posonly_kwonly_opt2($module, a, /, *, b=None, c=None)\n" 2634"--\n" 2635"\n"); 2636 2637#define TEST_POSONLY_KWONLY_OPT2_METHODDEF \ 2638 {"test_posonly_kwonly_opt2", (PyCFunction)(void(*)(void))test_posonly_kwonly_opt2, METH_FASTCALL|METH_KEYWORDS, test_posonly_kwonly_opt2__doc__}, 2639 2640static PyObject * 2641test_posonly_kwonly_opt2_impl(PyObject *module, PyObject *a, PyObject *b, 2642 PyObject *c); 2643 2644static PyObject * 2645test_posonly_kwonly_opt2(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) 2646{ 2647 PyObject *return_value = NULL; 2648 static const char * const _keywords[] = {"", "b", "c", NULL}; 2649 static _PyArg_Parser _parser = {NULL, _keywords, "test_posonly_kwonly_opt2", 0}; 2650 PyObject *argsbuf[3]; 2651 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1; 2652 PyObject *a; 2653 PyObject *b = Py_None; 2654 PyObject *c = Py_None; 2655 2656 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf); 2657 if (!args) { 2658 goto exit; 2659 } 2660 a = args[0]; 2661 if (!noptargs) { 2662 goto skip_optional_kwonly; 2663 } 2664 if (args[1]) { 2665 b = args[1]; 2666 if (!--noptargs) { 2667 goto skip_optional_kwonly; 2668 } 2669 } 2670 c = args[2]; 2671skip_optional_kwonly: 2672 return_value = test_posonly_kwonly_opt2_impl(module, a, b, c); 2673 2674exit: 2675 return return_value; 2676} 2677 2678static PyObject * 2679test_posonly_kwonly_opt2_impl(PyObject *module, PyObject *a, PyObject *b, 2680 PyObject *c) 2681/*[clinic end generated code: output=51aae7cac77b458a input=f7e5eed94f75fff0]*/ 2682 2683 2684/*[clinic input] 2685test_posonly_opt_kwonly_opt 2686 2687 a: object 2688 b: object = None 2689 / 2690 * 2691 c: object = None 2692 d: object = None 2693 2694[clinic start generated code]*/ 2695 2696PyDoc_STRVAR(test_posonly_opt_kwonly_opt__doc__, 2697"test_posonly_opt_kwonly_opt($module, a, b=None, /, *, c=None, d=None)\n" 2698"--\n" 2699"\n"); 2700 2701#define TEST_POSONLY_OPT_KWONLY_OPT_METHODDEF \ 2702 {"test_posonly_opt_kwonly_opt", (PyCFunction)(void(*)(void))test_posonly_opt_kwonly_opt, METH_FASTCALL|METH_KEYWORDS, test_posonly_opt_kwonly_opt__doc__}, 2703 2704static PyObject * 2705test_posonly_opt_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b, 2706 PyObject *c, PyObject *d); 2707 2708static PyObject * 2709test_posonly_opt_kwonly_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) 2710{ 2711 PyObject *return_value = NULL; 2712 static const char * const _keywords[] = {"", "", "c", "d", NULL}; 2713 static _PyArg_Parser _parser = {NULL, _keywords, "test_posonly_opt_kwonly_opt", 0}; 2714 PyObject *argsbuf[4]; 2715 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1; 2716 PyObject *a; 2717 PyObject *b = Py_None; 2718 PyObject *c = Py_None; 2719 PyObject *d = Py_None; 2720 2721 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf); 2722 if (!args) { 2723 goto exit; 2724 } 2725 a = args[0]; 2726 if (nargs < 2) { 2727 goto skip_optional_posonly; 2728 } 2729 noptargs--; 2730 b = args[1]; 2731skip_optional_posonly: 2732 if (!noptargs) { 2733 goto skip_optional_kwonly; 2734 } 2735 if (args[2]) { 2736 c = args[2]; 2737 if (!--noptargs) { 2738 goto skip_optional_kwonly; 2739 } 2740 } 2741 d = args[3]; 2742skip_optional_kwonly: 2743 return_value = test_posonly_opt_kwonly_opt_impl(module, a, b, c, d); 2744 2745exit: 2746 return return_value; 2747} 2748 2749static PyObject * 2750test_posonly_opt_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b, 2751 PyObject *c, PyObject *d) 2752/*[clinic end generated code: output=68844c45143d1668 input=1e557dc979d120fd]*/ 2753 2754 2755/*[clinic input] 2756test_posonly_keywords_kwonly_opt 2757 2758 a: object 2759 / 2760 b: object 2761 * 2762 c: object 2763 d: object = None 2764 e: object = None 2765 2766[clinic start generated code]*/ 2767 2768PyDoc_STRVAR(test_posonly_keywords_kwonly_opt__doc__, 2769"test_posonly_keywords_kwonly_opt($module, a, /, b, *, c, d=None, e=None)\n" 2770"--\n" 2771"\n"); 2772 2773#define TEST_POSONLY_KEYWORDS_KWONLY_OPT_METHODDEF \ 2774 {"test_posonly_keywords_kwonly_opt", (PyCFunction)(void(*)(void))test_posonly_keywords_kwonly_opt, METH_FASTCALL|METH_KEYWORDS, test_posonly_keywords_kwonly_opt__doc__}, 2775 2776static PyObject * 2777test_posonly_keywords_kwonly_opt_impl(PyObject *module, PyObject *a, 2778 PyObject *b, PyObject *c, PyObject *d, 2779 PyObject *e); 2780 2781static PyObject * 2782test_posonly_keywords_kwonly_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) 2783{ 2784 PyObject *return_value = NULL; 2785 static const char * const _keywords[] = {"", "b", "c", "d", "e", NULL}; 2786 static _PyArg_Parser _parser = {NULL, _keywords, "test_posonly_keywords_kwonly_opt", 0}; 2787 PyObject *argsbuf[5]; 2788 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 3; 2789 PyObject *a; 2790 PyObject *b; 2791 PyObject *c; 2792 PyObject *d = Py_None; 2793 PyObject *e = Py_None; 2794 2795 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 1, argsbuf); 2796 if (!args) { 2797 goto exit; 2798 } 2799 a = args[0]; 2800 b = args[1]; 2801 c = args[2]; 2802 if (!noptargs) { 2803 goto skip_optional_kwonly; 2804 } 2805 if (args[3]) { 2806 d = args[3]; 2807 if (!--noptargs) { 2808 goto skip_optional_kwonly; 2809 } 2810 } 2811 e = args[4]; 2812skip_optional_kwonly: 2813 return_value = test_posonly_keywords_kwonly_opt_impl(module, a, b, c, d, e); 2814 2815exit: 2816 return return_value; 2817} 2818 2819static PyObject * 2820test_posonly_keywords_kwonly_opt_impl(PyObject *module, PyObject *a, 2821 PyObject *b, PyObject *c, PyObject *d, 2822 PyObject *e) 2823/*[clinic end generated code: output=996ff645551897ac input=c3884a4f956fdc89]*/ 2824 2825 2826/*[clinic input] 2827test_posonly_keywords_kwonly_opt2 2828 2829 a: object 2830 / 2831 b: object 2832 * 2833 c: object = None 2834 d: object = None 2835 2836[clinic start generated code]*/ 2837 2838PyDoc_STRVAR(test_posonly_keywords_kwonly_opt2__doc__, 2839"test_posonly_keywords_kwonly_opt2($module, a, /, b, *, c=None, d=None)\n" 2840"--\n" 2841"\n"); 2842 2843#define TEST_POSONLY_KEYWORDS_KWONLY_OPT2_METHODDEF \ 2844 {"test_posonly_keywords_kwonly_opt2", (PyCFunction)(void(*)(void))test_posonly_keywords_kwonly_opt2, METH_FASTCALL|METH_KEYWORDS, test_posonly_keywords_kwonly_opt2__doc__}, 2845 2846static PyObject * 2847test_posonly_keywords_kwonly_opt2_impl(PyObject *module, PyObject *a, 2848 PyObject *b, PyObject *c, PyObject *d); 2849 2850static PyObject * 2851test_posonly_keywords_kwonly_opt2(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) 2852{ 2853 PyObject *return_value = NULL; 2854 static const char * const _keywords[] = {"", "b", "c", "d", NULL}; 2855 static _PyArg_Parser _parser = {NULL, _keywords, "test_posonly_keywords_kwonly_opt2", 0}; 2856 PyObject *argsbuf[4]; 2857 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2; 2858 PyObject *a; 2859 PyObject *b; 2860 PyObject *c = Py_None; 2861 PyObject *d = Py_None; 2862 2863 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf); 2864 if (!args) { 2865 goto exit; 2866 } 2867 a = args[0]; 2868 b = args[1]; 2869 if (!noptargs) { 2870 goto skip_optional_kwonly; 2871 } 2872 if (args[2]) { 2873 c = args[2]; 2874 if (!--noptargs) { 2875 goto skip_optional_kwonly; 2876 } 2877 } 2878 d = args[3]; 2879skip_optional_kwonly: 2880 return_value = test_posonly_keywords_kwonly_opt2_impl(module, a, b, c, d); 2881 2882exit: 2883 return return_value; 2884} 2885 2886static PyObject * 2887test_posonly_keywords_kwonly_opt2_impl(PyObject *module, PyObject *a, 2888 PyObject *b, PyObject *c, PyObject *d) 2889/*[clinic end generated code: output=e5a3e992fd4b28b3 input=68d01d7c0f6dafb0]*/ 2890 2891 2892/*[clinic input] 2893test_posonly_keywords_opt_kwonly_opt 2894 2895 a: object 2896 / 2897 b: object 2898 c: object = None 2899 * 2900 d: object = None 2901 e: object = None 2902 2903[clinic start generated code]*/ 2904 2905PyDoc_STRVAR(test_posonly_keywords_opt_kwonly_opt__doc__, 2906"test_posonly_keywords_opt_kwonly_opt($module, a, /, b, c=None, *,\n" 2907" d=None, e=None)\n" 2908"--\n" 2909"\n"); 2910 2911#define TEST_POSONLY_KEYWORDS_OPT_KWONLY_OPT_METHODDEF \ 2912 {"test_posonly_keywords_opt_kwonly_opt", (PyCFunction)(void(*)(void))test_posonly_keywords_opt_kwonly_opt, METH_FASTCALL|METH_KEYWORDS, test_posonly_keywords_opt_kwonly_opt__doc__}, 2913 2914static PyObject * 2915test_posonly_keywords_opt_kwonly_opt_impl(PyObject *module, PyObject *a, 2916 PyObject *b, PyObject *c, 2917 PyObject *d, PyObject *e); 2918 2919static PyObject * 2920test_posonly_keywords_opt_kwonly_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) 2921{ 2922 PyObject *return_value = NULL; 2923 static const char * const _keywords[] = {"", "b", "c", "d", "e", NULL}; 2924 static _PyArg_Parser _parser = {NULL, _keywords, "test_posonly_keywords_opt_kwonly_opt", 0}; 2925 PyObject *argsbuf[5]; 2926 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2; 2927 PyObject *a; 2928 PyObject *b; 2929 PyObject *c = Py_None; 2930 PyObject *d = Py_None; 2931 PyObject *e = Py_None; 2932 2933 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 3, 0, argsbuf); 2934 if (!args) { 2935 goto exit; 2936 } 2937 a = args[0]; 2938 b = args[1]; 2939 if (!noptargs) { 2940 goto skip_optional_pos; 2941 } 2942 if (args[2]) { 2943 c = args[2]; 2944 if (!--noptargs) { 2945 goto skip_optional_pos; 2946 } 2947 } 2948skip_optional_pos: 2949 if (!noptargs) { 2950 goto skip_optional_kwonly; 2951 } 2952 if (args[3]) { 2953 d = args[3]; 2954 if (!--noptargs) { 2955 goto skip_optional_kwonly; 2956 } 2957 } 2958 e = args[4]; 2959skip_optional_kwonly: 2960 return_value = test_posonly_keywords_opt_kwonly_opt_impl(module, a, b, c, d, e); 2961 2962exit: 2963 return return_value; 2964} 2965 2966static PyObject * 2967test_posonly_keywords_opt_kwonly_opt_impl(PyObject *module, PyObject *a, 2968 PyObject *b, PyObject *c, 2969 PyObject *d, PyObject *e) 2970/*[clinic end generated code: output=ff9fb6c3d2cbbaa4 input=d0883d45876f186c]*/ 2971 2972 2973/*[clinic input] 2974test_posonly_keywords_opt2_kwonly_opt 2975 2976 a: object 2977 / 2978 b: object = None 2979 c: object = None 2980 * 2981 d: object = None 2982 e: object = None 2983 2984[clinic start generated code]*/ 2985 2986PyDoc_STRVAR(test_posonly_keywords_opt2_kwonly_opt__doc__, 2987"test_posonly_keywords_opt2_kwonly_opt($module, a, /, b=None, c=None, *,\n" 2988" d=None, e=None)\n" 2989"--\n" 2990"\n"); 2991 2992#define TEST_POSONLY_KEYWORDS_OPT2_KWONLY_OPT_METHODDEF \ 2993 {"test_posonly_keywords_opt2_kwonly_opt", (PyCFunction)(void(*)(void))test_posonly_keywords_opt2_kwonly_opt, METH_FASTCALL|METH_KEYWORDS, test_posonly_keywords_opt2_kwonly_opt__doc__}, 2994 2995static PyObject * 2996test_posonly_keywords_opt2_kwonly_opt_impl(PyObject *module, PyObject *a, 2997 PyObject *b, PyObject *c, 2998 PyObject *d, PyObject *e); 2999 3000static PyObject * 3001test_posonly_keywords_opt2_kwonly_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) 3002{ 3003 PyObject *return_value = NULL; 3004 static const char * const _keywords[] = {"", "b", "c", "d", "e", NULL}; 3005 static _PyArg_Parser _parser = {NULL, _keywords, "test_posonly_keywords_opt2_kwonly_opt", 0}; 3006 PyObject *argsbuf[5]; 3007 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1; 3008 PyObject *a; 3009 PyObject *b = Py_None; 3010 PyObject *c = Py_None; 3011 PyObject *d = Py_None; 3012 PyObject *e = Py_None; 3013 3014 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf); 3015 if (!args) { 3016 goto exit; 3017 } 3018 a = args[0]; 3019 if (!noptargs) { 3020 goto skip_optional_pos; 3021 } 3022 if (args[1]) { 3023 b = args[1]; 3024 if (!--noptargs) { 3025 goto skip_optional_pos; 3026 } 3027 } 3028 if (args[2]) { 3029 c = args[2]; 3030 if (!--noptargs) { 3031 goto skip_optional_pos; 3032 } 3033 } 3034skip_optional_pos: 3035 if (!noptargs) { 3036 goto skip_optional_kwonly; 3037 } 3038 if (args[3]) { 3039 d = args[3]; 3040 if (!--noptargs) { 3041 goto skip_optional_kwonly; 3042 } 3043 } 3044 e = args[4]; 3045skip_optional_kwonly: 3046 return_value = test_posonly_keywords_opt2_kwonly_opt_impl(module, a, b, c, d, e); 3047 3048exit: 3049 return return_value; 3050} 3051 3052static PyObject * 3053test_posonly_keywords_opt2_kwonly_opt_impl(PyObject *module, PyObject *a, 3054 PyObject *b, PyObject *c, 3055 PyObject *d, PyObject *e) 3056/*[clinic end generated code: output=c809d7a84a2205e1 input=c95e2e1ec93035ad]*/ 3057 3058 3059/*[clinic input] 3060test_posonly_opt_keywords_opt_kwonly_opt 3061 3062 a: object 3063 b: object = None 3064 / 3065 c: object = None 3066 d: object = None 3067 * 3068 e: object = None 3069 f: object = None 3070 3071[clinic start generated code]*/ 3072 3073PyDoc_STRVAR(test_posonly_opt_keywords_opt_kwonly_opt__doc__, 3074"test_posonly_opt_keywords_opt_kwonly_opt($module, a, b=None, /, c=None,\n" 3075" d=None, *, e=None, f=None)\n" 3076"--\n" 3077"\n"); 3078 3079#define TEST_POSONLY_OPT_KEYWORDS_OPT_KWONLY_OPT_METHODDEF \ 3080 {"test_posonly_opt_keywords_opt_kwonly_opt", (PyCFunction)(void(*)(void))test_posonly_opt_keywords_opt_kwonly_opt, METH_FASTCALL|METH_KEYWORDS, test_posonly_opt_keywords_opt_kwonly_opt__doc__}, 3081 3082static PyObject * 3083test_posonly_opt_keywords_opt_kwonly_opt_impl(PyObject *module, PyObject *a, 3084 PyObject *b, PyObject *c, 3085 PyObject *d, PyObject *e, 3086 PyObject *f); 3087 3088static PyObject * 3089test_posonly_opt_keywords_opt_kwonly_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) 3090{ 3091 PyObject *return_value = NULL; 3092 static const char * const _keywords[] = {"", "", "c", "d", "e", "f", NULL}; 3093 static _PyArg_Parser _parser = {NULL, _keywords, "test_posonly_opt_keywords_opt_kwonly_opt", 0}; 3094 PyObject *argsbuf[6]; 3095 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1; 3096 PyObject *a; 3097 PyObject *b = Py_None; 3098 PyObject *c = Py_None; 3099 PyObject *d = Py_None; 3100 PyObject *e = Py_None; 3101 PyObject *f = Py_None; 3102 3103 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 4, 0, argsbuf); 3104 if (!args) { 3105 goto exit; 3106 } 3107 a = args[0]; 3108 if (nargs < 2) { 3109 goto skip_optional_posonly; 3110 } 3111 noptargs--; 3112 b = args[1]; 3113skip_optional_posonly: 3114 if (!noptargs) { 3115 goto skip_optional_pos; 3116 } 3117 if (args[2]) { 3118 c = args[2]; 3119 if (!--noptargs) { 3120 goto skip_optional_pos; 3121 } 3122 } 3123 if (args[3]) { 3124 d = args[3]; 3125 if (!--noptargs) { 3126 goto skip_optional_pos; 3127 } 3128 } 3129skip_optional_pos: 3130 if (!noptargs) { 3131 goto skip_optional_kwonly; 3132 } 3133 if (args[4]) { 3134 e = args[4]; 3135 if (!--noptargs) { 3136 goto skip_optional_kwonly; 3137 } 3138 } 3139 f = args[5]; 3140skip_optional_kwonly: 3141 return_value = test_posonly_opt_keywords_opt_kwonly_opt_impl(module, a, b, c, d, e, f); 3142 3143exit: 3144 return return_value; 3145} 3146 3147static PyObject * 3148test_posonly_opt_keywords_opt_kwonly_opt_impl(PyObject *module, PyObject *a, 3149 PyObject *b, PyObject *c, 3150 PyObject *d, PyObject *e, 3151 PyObject *f) 3152/*[clinic end generated code: output=719e4f6c224402d4 input=9914857713c5bbf8]*/ 3153 3154/*[clinic input] 3155test_keyword_only_parameter 3156 3157 3158 * 3159 co_lnotab: PyBytesObject(c_default="(PyBytesObject *)self->co_lnotab") = None 3160 3161[clinic start generated code]*/ 3162 3163PyDoc_STRVAR(test_keyword_only_parameter__doc__, 3164"test_keyword_only_parameter($module, /, *, co_lnotab=None)\n" 3165"--\n" 3166"\n"); 3167 3168#define TEST_KEYWORD_ONLY_PARAMETER_METHODDEF \ 3169 {"test_keyword_only_parameter", (PyCFunction)(void(*)(void))test_keyword_only_parameter, METH_FASTCALL|METH_KEYWORDS, test_keyword_only_parameter__doc__}, 3170 3171static PyObject * 3172test_keyword_only_parameter_impl(PyObject *module, PyBytesObject *co_lnotab); 3173 3174static PyObject * 3175test_keyword_only_parameter(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) 3176{ 3177 PyObject *return_value = NULL; 3178 static const char * const _keywords[] = {"co_lnotab", NULL}; 3179 static _PyArg_Parser _parser = {NULL, _keywords, "test_keyword_only_parameter", 0}; 3180 PyObject *argsbuf[1]; 3181 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; 3182 PyBytesObject *co_lnotab = (PyBytesObject *)self->co_lnotab; 3183 3184 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 0, 0, argsbuf); 3185 if (!args) { 3186 goto exit; 3187 } 3188 if (!noptargs) { 3189 goto skip_optional_kwonly; 3190 } 3191 if (!PyBytes_Check(args[0])) { 3192 _PyArg_BadArgument("test_keyword_only_parameter", "argument 'co_lnotab'", "bytes", args[0]); 3193 goto exit; 3194 } 3195 co_lnotab = (PyBytesObject *)args[0]; 3196skip_optional_kwonly: 3197 return_value = test_keyword_only_parameter_impl(module, co_lnotab); 3198 3199exit: 3200 return return_value; 3201} 3202 3203static PyObject * 3204test_keyword_only_parameter_impl(PyObject *module, PyBytesObject *co_lnotab) 3205/*[clinic end generated code: output=f25914b402039493 input=303df5046c7e37a3]*/ 3206 3207 3208/*[clinic input] 3209output push 3210output preset buffer 3211[clinic start generated code]*/ 3212/*[clinic end generated code: output=da39a3ee5e6b4b0d input=5bff3376ee0df0b5]*/ 3213 3214#ifdef CONDITION_A 3215/*[clinic input] 3216test_preprocessor_guarded_condition_a 3217[clinic start generated code]*/ 3218 3219static PyObject * 3220test_preprocessor_guarded_condition_a_impl(PyObject *module) 3221/*[clinic end generated code: output=ad012af18085add6 input=8edb8706a98cda7e]*/ 3222#elif CONDITION_B 3223/*[clinic input] 3224test_preprocessor_guarded_elif_condition_b 3225[clinic start generated code]*/ 3226 3227static PyObject * 3228test_preprocessor_guarded_elif_condition_b_impl(PyObject *module) 3229/*[clinic end generated code: output=615f2dee82b138d1 input=53777cebbf7fee32]*/ 3230#else 3231/*[clinic input] 3232test_preprocessor_guarded_else 3233[clinic start generated code]*/ 3234 3235static PyObject * 3236test_preprocessor_guarded_else_impl(PyObject *module) 3237/*[clinic end generated code: output=13af7670aac51b12 input=6657ab31d74c29fc]*/ 3238#endif 3239 3240/*[clinic input] 3241dump buffer 3242output pop 3243[clinic start generated code]*/ 3244 3245#if defined(CONDITION_A) 3246 3247PyDoc_STRVAR(test_preprocessor_guarded_condition_a__doc__, 3248"test_preprocessor_guarded_condition_a($module, /)\n" 3249"--\n" 3250"\n"); 3251 3252#define TEST_PREPROCESSOR_GUARDED_CONDITION_A_METHODDEF \ 3253 {"test_preprocessor_guarded_condition_a", (PyCFunction)test_preprocessor_guarded_condition_a, METH_NOARGS, test_preprocessor_guarded_condition_a__doc__}, 3254 3255static PyObject * 3256test_preprocessor_guarded_condition_a(PyObject *module, PyObject *Py_UNUSED(ignored)) 3257{ 3258 return test_preprocessor_guarded_condition_a_impl(module); 3259} 3260 3261#endif /* defined(CONDITION_A) */ 3262 3263#if !defined(CONDITION_A) && (CONDITION_B) 3264 3265PyDoc_STRVAR(test_preprocessor_guarded_elif_condition_b__doc__, 3266"test_preprocessor_guarded_elif_condition_b($module, /)\n" 3267"--\n" 3268"\n"); 3269 3270#define TEST_PREPROCESSOR_GUARDED_ELIF_CONDITION_B_METHODDEF \ 3271 {"test_preprocessor_guarded_elif_condition_b", (PyCFunction)test_preprocessor_guarded_elif_condition_b, METH_NOARGS, test_preprocessor_guarded_elif_condition_b__doc__}, 3272 3273static PyObject * 3274test_preprocessor_guarded_elif_condition_b(PyObject *module, PyObject *Py_UNUSED(ignored)) 3275{ 3276 return test_preprocessor_guarded_elif_condition_b_impl(module); 3277} 3278 3279#endif /* !defined(CONDITION_A) && (CONDITION_B) */ 3280 3281#if !defined(CONDITION_A) && !(CONDITION_B) 3282 3283PyDoc_STRVAR(test_preprocessor_guarded_else__doc__, 3284"test_preprocessor_guarded_else($module, /)\n" 3285"--\n" 3286"\n"); 3287 3288#define TEST_PREPROCESSOR_GUARDED_ELSE_METHODDEF \ 3289 {"test_preprocessor_guarded_else", (PyCFunction)test_preprocessor_guarded_else, METH_NOARGS, test_preprocessor_guarded_else__doc__}, 3290 3291static PyObject * 3292test_preprocessor_guarded_else(PyObject *module, PyObject *Py_UNUSED(ignored)) 3293{ 3294 return test_preprocessor_guarded_else_impl(module); 3295} 3296 3297#endif /* !defined(CONDITION_A) && !(CONDITION_B) */ 3298 3299#ifndef TEST_PREPROCESSOR_GUARDED_CONDITION_A_METHODDEF 3300 #define TEST_PREPROCESSOR_GUARDED_CONDITION_A_METHODDEF 3301#endif /* !defined(TEST_PREPROCESSOR_GUARDED_CONDITION_A_METHODDEF) */ 3302 3303#ifndef TEST_PREPROCESSOR_GUARDED_ELIF_CONDITION_B_METHODDEF 3304 #define TEST_PREPROCESSOR_GUARDED_ELIF_CONDITION_B_METHODDEF 3305#endif /* !defined(TEST_PREPROCESSOR_GUARDED_ELIF_CONDITION_B_METHODDEF) */ 3306 3307#ifndef TEST_PREPROCESSOR_GUARDED_ELSE_METHODDEF 3308 #define TEST_PREPROCESSOR_GUARDED_ELSE_METHODDEF 3309#endif /* !defined(TEST_PREPROCESSOR_GUARDED_ELSE_METHODDEF) */ 3310/*[clinic end generated code: output=3804bb18d454038c input=3fc80c9989d2f2e1]*/ 3311