1 #include "Python.h" 2 #include "internal/pystate.h" 3 #include "frameobject.h" 4 5 6 int 7 _PyObject_HasFastCall(PyObject *callable) 8 { 9 if (PyFunction_Check(callable)) { 10 return 1; 11 } 12 else if (PyCFunction_Check(callable)) { 13 return !(PyCFunction_GET_FLAGS(callable) & METH_VARARGS); 14 } 15 else { 16 assert (PyCallable_Check(callable)); 17 return 0; 18 } 19 } 20 21 22 static PyObject * 23 null_error(void) 24 { 25 if (!PyErr_Occurred()) 26 PyErr_SetString(PyExc_SystemError, 27 "null argument to internal routine"); 28 return NULL; 29 } 30 31 32 PyObject* 33 _Py_CheckFunctionResult(PyObject *callable, PyObject *result, const char *where) 34 { 35 int err_occurred = (PyErr_Occurred() != NULL); 36 37 assert((callable != NULL) ^ (where != NULL)); 38 39 if (result == NULL) { 40 if (!err_occurred) { 41 if (callable) 42 PyErr_Format(PyExc_SystemError, 43 "%R returned NULL without setting an error", 44 callable); 45 else 46 PyErr_Format(PyExc_SystemError, 47 "%s returned NULL without setting an error", 48 where); 49 #ifdef Py_DEBUG 50 /* Ensure that the bug is caught in debug mode */ 51 Py_FatalError("a function returned NULL without setting an error"); 52 #endif 53 return NULL; 54 } 55 } 56 else { 57 if (err_occurred) { 58 Py_DECREF(result); 59 60 if (callable) { 61 _PyErr_FormatFromCause(PyExc_SystemError, 62 "%R returned a result with an error set", 63 callable); 64 } 65 else { 66 _PyErr_FormatFromCause(PyExc_SystemError, 67 "%s returned a result with an error set", 68 where); 69 } 70 #ifdef Py_DEBUG 71 /* Ensure that the bug is caught in debug mode */ 72 Py_FatalError("a function returned a result with an error set"); 73 #endif 74 return NULL; 75 } 76 } 77 return result; 78 } 79 80 81 /* --- Core PyObject call functions ------------------------------- */ 82 83 PyObject * 84 _PyObject_FastCallDict(PyObject *callable, PyObject *const *args, Py_ssize_t nargs, 85 PyObject *kwargs) 86 { 87 /* _PyObject_FastCallDict() must not be called with an exception set, 88 because it can clear it (directly or indirectly) and so the 89 caller loses its exception */ 90 assert(!PyErr_Occurred()); 91 92 assert(callable != NULL); 93 assert(nargs >= 0); 94 assert(nargs == 0 || args != NULL); 95 assert(kwargs == NULL || PyDict_Check(kwargs)); 96 97 if (PyFunction_Check(callable)) { 98 return _PyFunction_FastCallDict(callable, args, nargs, kwargs); 99 } 100 else if (PyCFunction_Check(callable)) { 101 return _PyCFunction_FastCallDict(callable, args, nargs, kwargs); 102 } 103 else { 104 PyObject *argstuple, *result; 105 ternaryfunc call; 106 107 /* Slow-path: build a temporary tuple */ 108 call = callable->ob_type->tp_call; 109 if (call == NULL) { 110 PyErr_Format(PyExc_TypeError, "'%.200s' object is not callable", 111 callable->ob_type->tp_name); 112 return NULL; 113 } 114 115 argstuple = _PyStack_AsTuple(args, nargs); 116 if (argstuple == NULL) { 117 return NULL; 118 } 119 120 if (Py_EnterRecursiveCall(" while calling a Python object")) { 121 Py_DECREF(argstuple); 122 return NULL; 123 } 124 125 result = (*call)(callable, argstuple, kwargs); 126 127 Py_LeaveRecursiveCall(); 128 Py_DECREF(argstuple); 129 130 result = _Py_CheckFunctionResult(callable, result, NULL); 131 return result; 132 } 133 } 134 135 136 PyObject * 137 _PyObject_FastCallKeywords(PyObject *callable, PyObject *const *stack, Py_ssize_t nargs, 138 PyObject *kwnames) 139 { 140 /* _PyObject_FastCallKeywords() must not be called with an exception set, 141 because it can clear it (directly or indirectly) and so the 142 caller loses its exception */ 143 assert(!PyErr_Occurred()); 144 145 assert(nargs >= 0); 146 assert(kwnames == NULL || PyTuple_CheckExact(kwnames)); 147 148 /* kwnames must only contains str strings, no subclass, and all keys must 149 be unique: these checks are implemented in Python/ceval.c and 150 _PyArg_ParseStackAndKeywords(). */ 151 152 if (PyFunction_Check(callable)) { 153 return _PyFunction_FastCallKeywords(callable, stack, nargs, kwnames); 154 } 155 if (PyCFunction_Check(callable)) { 156 return _PyCFunction_FastCallKeywords(callable, stack, nargs, kwnames); 157 } 158 else { 159 /* Slow-path: build a temporary tuple for positional arguments and a 160 temporary dictionary for keyword arguments (if any) */ 161 162 ternaryfunc call; 163 PyObject *argstuple; 164 PyObject *kwdict, *result; 165 Py_ssize_t nkwargs; 166 167 nkwargs = (kwnames == NULL) ? 0 : PyTuple_GET_SIZE(kwnames); 168 assert((nargs == 0 && nkwargs == 0) || stack != NULL); 169 170 call = callable->ob_type->tp_call; 171 if (call == NULL) { 172 PyErr_Format(PyExc_TypeError, "'%.200s' object is not callable", 173 callable->ob_type->tp_name); 174 return NULL; 175 } 176 177 argstuple = _PyStack_AsTuple(stack, nargs); 178 if (argstuple == NULL) { 179 return NULL; 180 } 181 182 if (nkwargs > 0) { 183 kwdict = _PyStack_AsDict(stack + nargs, kwnames); 184 if (kwdict == NULL) { 185 Py_DECREF(argstuple); 186 return NULL; 187 } 188 } 189 else { 190 kwdict = NULL; 191 } 192 193 if (Py_EnterRecursiveCall(" while calling a Python object")) { 194 Py_DECREF(argstuple); 195 Py_XDECREF(kwdict); 196 return NULL; 197 } 198 199 result = (*call)(callable, argstuple, kwdict); 200 201 Py_LeaveRecursiveCall(); 202 203 Py_DECREF(argstuple); 204 Py_XDECREF(kwdict); 205 206 result = _Py_CheckFunctionResult(callable, result, NULL); 207 return result; 208 } 209 } 210 211 212 PyObject * 213 PyObject_Call(PyObject *callable, PyObject *args, PyObject *kwargs) 214 { 215 ternaryfunc call; 216 PyObject *result; 217 218 /* PyObject_Call() must not be called with an exception set, 219 because it can clear it (directly or indirectly) and so the 220 caller loses its exception */ 221 assert(!PyErr_Occurred()); 222 assert(PyTuple_Check(args)); 223 assert(kwargs == NULL || PyDict_Check(kwargs)); 224 225 if (PyFunction_Check(callable)) { 226 return _PyFunction_FastCallDict(callable, 227 &PyTuple_GET_ITEM(args, 0), 228 PyTuple_GET_SIZE(args), 229 kwargs); 230 } 231 else if (PyCFunction_Check(callable)) { 232 return PyCFunction_Call(callable, args, kwargs); 233 } 234 else { 235 call = callable->ob_type->tp_call; 236 if (call == NULL) { 237 PyErr_Format(PyExc_TypeError, "'%.200s' object is not callable", 238 callable->ob_type->tp_name); 239 return NULL; 240 } 241 242 if (Py_EnterRecursiveCall(" while calling a Python object")) 243 return NULL; 244 245 result = (*call)(callable, args, kwargs); 246 247 Py_LeaveRecursiveCall(); 248 249 return _Py_CheckFunctionResult(callable, result, NULL); 250 } 251 } 252 253 254 /* --- PyFunction call functions ---------------------------------- */ 255 256 static PyObject* _Py_HOT_FUNCTION 257 function_code_fastcall(PyCodeObject *co, PyObject *const *args, Py_ssize_t nargs, 258 PyObject *globals) 259 { 260 PyFrameObject *f; 261 PyThreadState *tstate = PyThreadState_GET(); 262 PyObject **fastlocals; 263 Py_ssize_t i; 264 PyObject *result; 265 266 assert(globals != NULL); 267 /* XXX Perhaps we should create a specialized 268 _PyFrame_New_NoTrack() that doesn't take locals, but does 269 take builtins without sanity checking them. 270 */ 271 assert(tstate != NULL); 272 f = _PyFrame_New_NoTrack(tstate, co, globals, NULL); 273 if (f == NULL) { 274 return NULL; 275 } 276 277 fastlocals = f->f_localsplus; 278 279 for (i = 0; i < nargs; i++) { 280 Py_INCREF(*args); 281 fastlocals[i] = *args++; 282 } 283 result = PyEval_EvalFrameEx(f,0); 284 285 if (Py_REFCNT(f) > 1) { 286 Py_DECREF(f); 287 _PyObject_GC_TRACK(f); 288 } 289 else { 290 ++tstate->recursion_depth; 291 Py_DECREF(f); 292 --tstate->recursion_depth; 293 } 294 return result; 295 } 296 297 298 PyObject * 299 _PyFunction_FastCallDict(PyObject *func, PyObject *const *args, Py_ssize_t nargs, 300 PyObject *kwargs) 301 { 302 PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); 303 PyObject *globals = PyFunction_GET_GLOBALS(func); 304 PyObject *argdefs = PyFunction_GET_DEFAULTS(func); 305 PyObject *kwdefs, *closure, *name, *qualname; 306 PyObject *kwtuple, **k; 307 PyObject **d; 308 Py_ssize_t nd, nk; 309 PyObject *result; 310 311 assert(func != NULL); 312 assert(nargs >= 0); 313 assert(nargs == 0 || args != NULL); 314 assert(kwargs == NULL || PyDict_Check(kwargs)); 315 316 if (co->co_kwonlyargcount == 0 && 317 (kwargs == NULL || PyDict_GET_SIZE(kwargs) == 0) && 318 (co->co_flags & ~PyCF_MASK) == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) 319 { 320 /* Fast paths */ 321 if (argdefs == NULL && co->co_argcount == nargs) { 322 return function_code_fastcall(co, args, nargs, globals); 323 } 324 else if (nargs == 0 && argdefs != NULL 325 && co->co_argcount == PyTuple_GET_SIZE(argdefs)) { 326 /* function called with no arguments, but all parameters have 327 a default value: use default values as arguments .*/ 328 args = &PyTuple_GET_ITEM(argdefs, 0); 329 return function_code_fastcall(co, args, PyTuple_GET_SIZE(argdefs), 330 globals); 331 } 332 } 333 334 nk = (kwargs != NULL) ? PyDict_GET_SIZE(kwargs) : 0; 335 if (nk != 0) { 336 Py_ssize_t pos, i; 337 338 /* bpo-29318, bpo-27840: Caller and callee functions must not share 339 the dictionary: kwargs must be copied. */ 340 kwtuple = PyTuple_New(2 * nk); 341 if (kwtuple == NULL) { 342 return NULL; 343 } 344 345 k = &PyTuple_GET_ITEM(kwtuple, 0); 346 pos = i = 0; 347 while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { 348 /* We must hold strong references because keyword arguments can be 349 indirectly modified while the function is called: 350 see issue #2016 and test_extcall */ 351 Py_INCREF(k[i]); 352 Py_INCREF(k[i+1]); 353 i += 2; 354 } 355 nk = i / 2; 356 } 357 else { 358 kwtuple = NULL; 359 k = NULL; 360 } 361 362 kwdefs = PyFunction_GET_KW_DEFAULTS(func); 363 closure = PyFunction_GET_CLOSURE(func); 364 name = ((PyFunctionObject *)func) -> func_name; 365 qualname = ((PyFunctionObject *)func) -> func_qualname; 366 367 if (argdefs != NULL) { 368 d = &PyTuple_GET_ITEM(argdefs, 0); 369 nd = PyTuple_GET_SIZE(argdefs); 370 } 371 else { 372 d = NULL; 373 nd = 0; 374 } 375 376 result = _PyEval_EvalCodeWithName((PyObject*)co, globals, (PyObject *)NULL, 377 args, nargs, 378 k, k != NULL ? k + 1 : NULL, nk, 2, 379 d, nd, kwdefs, 380 closure, name, qualname); 381 Py_XDECREF(kwtuple); 382 return result; 383 } 384 385 PyObject * 386 _PyFunction_FastCallKeywords(PyObject *func, PyObject *const *stack, 387 Py_ssize_t nargs, PyObject *kwnames) 388 { 389 PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); 390 PyObject *globals = PyFunction_GET_GLOBALS(func); 391 PyObject *argdefs = PyFunction_GET_DEFAULTS(func); 392 PyObject *kwdefs, *closure, *name, *qualname; 393 PyObject **d; 394 Py_ssize_t nkwargs = (kwnames == NULL) ? 0 : PyTuple_GET_SIZE(kwnames); 395 Py_ssize_t nd; 396 397 assert(PyFunction_Check(func)); 398 assert(nargs >= 0); 399 assert(kwnames == NULL || PyTuple_CheckExact(kwnames)); 400 assert((nargs == 0 && nkwargs == 0) || stack != NULL); 401 /* kwnames must only contains str strings, no subclass, and all keys must 402 be unique */ 403 404 if (co->co_kwonlyargcount == 0 && nkwargs == 0 && 405 (co->co_flags & ~PyCF_MASK) == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) 406 { 407 if (argdefs == NULL && co->co_argcount == nargs) { 408 return function_code_fastcall(co, stack, nargs, globals); 409 } 410 else if (nargs == 0 && argdefs != NULL 411 && co->co_argcount == PyTuple_GET_SIZE(argdefs)) { 412 /* function called with no arguments, but all parameters have 413 a default value: use default values as arguments .*/ 414 stack = &PyTuple_GET_ITEM(argdefs, 0); 415 return function_code_fastcall(co, stack, PyTuple_GET_SIZE(argdefs), 416 globals); 417 } 418 } 419 420 kwdefs = PyFunction_GET_KW_DEFAULTS(func); 421 closure = PyFunction_GET_CLOSURE(func); 422 name = ((PyFunctionObject *)func) -> func_name; 423 qualname = ((PyFunctionObject *)func) -> func_qualname; 424 425 if (argdefs != NULL) { 426 d = &PyTuple_GET_ITEM(argdefs, 0); 427 nd = PyTuple_GET_SIZE(argdefs); 428 } 429 else { 430 d = NULL; 431 nd = 0; 432 } 433 return _PyEval_EvalCodeWithName((PyObject*)co, globals, (PyObject *)NULL, 434 stack, nargs, 435 nkwargs ? &PyTuple_GET_ITEM(kwnames, 0) : NULL, 436 stack + nargs, 437 nkwargs, 1, 438 d, (int)nd, kwdefs, 439 closure, name, qualname); 440 } 441 442 443 /* --- PyCFunction call functions --------------------------------- */ 444 445 PyObject * 446 _PyMethodDef_RawFastCallDict(PyMethodDef *method, PyObject *self, 447 PyObject *const *args, Py_ssize_t nargs, 448 PyObject *kwargs) 449 { 450 /* _PyMethodDef_RawFastCallDict() must not be called with an exception set, 451 because it can clear it (directly or indirectly) and so the 452 caller loses its exception */ 453 assert(!PyErr_Occurred()); 454 455 assert(method != NULL); 456 assert(nargs >= 0); 457 assert(nargs == 0 || args != NULL); 458 assert(kwargs == NULL || PyDict_Check(kwargs)); 459 460 PyCFunction meth = method->ml_meth; 461 int flags = method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST); 462 PyObject *result = NULL; 463 464 if (Py_EnterRecursiveCall(" while calling a Python object")) { 465 return NULL; 466 } 467 468 switch (flags) 469 { 470 case METH_NOARGS: 471 if (kwargs != NULL && PyDict_GET_SIZE(kwargs) != 0) { 472 goto no_keyword_error; 473 } 474 475 if (nargs != 0) { 476 PyErr_Format(PyExc_TypeError, 477 "%.200s() takes no arguments (%zd given)", 478 method->ml_name, nargs); 479 goto exit; 480 } 481 482 result = (*meth) (self, NULL); 483 break; 484 485 case METH_O: 486 if (kwargs != NULL && PyDict_GET_SIZE(kwargs) != 0) { 487 goto no_keyword_error; 488 } 489 490 if (nargs != 1) { 491 PyErr_Format(PyExc_TypeError, 492 "%.200s() takes exactly one argument (%zd given)", 493 method->ml_name, nargs); 494 goto exit; 495 } 496 497 result = (*meth) (self, args[0]); 498 break; 499 500 case METH_VARARGS: 501 if (kwargs != NULL && PyDict_GET_SIZE(kwargs) != 0) { 502 goto no_keyword_error; 503 } 504 /* fall through */ 505 506 case METH_VARARGS | METH_KEYWORDS: 507 { 508 /* Slow-path: create a temporary tuple for positional arguments */ 509 PyObject *argstuple = _PyStack_AsTuple(args, nargs); 510 if (argstuple == NULL) { 511 goto exit; 512 } 513 514 if (flags & METH_KEYWORDS) { 515 result = (*(PyCFunctionWithKeywords)meth) (self, argstuple, kwargs); 516 } 517 else { 518 result = (*meth) (self, argstuple); 519 } 520 Py_DECREF(argstuple); 521 break; 522 } 523 524 case METH_FASTCALL: 525 { 526 if (kwargs != NULL && PyDict_GET_SIZE(kwargs) != 0) { 527 goto no_keyword_error; 528 } 529 530 result = (*(_PyCFunctionFast)meth) (self, args, nargs); 531 break; 532 } 533 534 case METH_FASTCALL | METH_KEYWORDS: 535 { 536 PyObject *const *stack; 537 PyObject *kwnames; 538 _PyCFunctionFastWithKeywords fastmeth = (_PyCFunctionFastWithKeywords)meth; 539 540 if (_PyStack_UnpackDict(args, nargs, kwargs, &stack, &kwnames) < 0) { 541 goto exit; 542 } 543 544 result = (*fastmeth) (self, stack, nargs, kwnames); 545 if (stack != args) { 546 PyMem_Free((PyObject **)stack); 547 } 548 Py_XDECREF(kwnames); 549 break; 550 } 551 552 default: 553 PyErr_SetString(PyExc_SystemError, 554 "Bad call flags in _PyMethodDef_RawFastCallDict. " 555 "METH_OLDARGS is no longer supported!"); 556 goto exit; 557 } 558 559 goto exit; 560 561 no_keyword_error: 562 PyErr_Format(PyExc_TypeError, 563 "%.200s() takes no keyword arguments", 564 method->ml_name); 565 566 exit: 567 Py_LeaveRecursiveCall(); 568 return result; 569 } 570 571 572 PyObject * 573 _PyCFunction_FastCallDict(PyObject *func, 574 PyObject *const *args, Py_ssize_t nargs, 575 PyObject *kwargs) 576 { 577 PyObject *result; 578 579 assert(func != NULL); 580 assert(PyCFunction_Check(func)); 581 582 result = _PyMethodDef_RawFastCallDict(((PyCFunctionObject*)func)->m_ml, 583 PyCFunction_GET_SELF(func), 584 args, nargs, kwargs); 585 result = _Py_CheckFunctionResult(func, result, NULL); 586 return result; 587 } 588 589 590 PyObject * 591 _PyMethodDef_RawFastCallKeywords(PyMethodDef *method, PyObject *self, 592 PyObject *const *args, Py_ssize_t nargs, 593 PyObject *kwnames) 594 { 595 /* _PyMethodDef_RawFastCallKeywords() must not be called with an exception set, 596 because it can clear it (directly or indirectly) and so the 597 caller loses its exception */ 598 assert(!PyErr_Occurred()); 599 600 assert(method != NULL); 601 assert(nargs >= 0); 602 assert(kwnames == NULL || PyTuple_CheckExact(kwnames)); 603 /* kwnames must only contains str strings, no subclass, and all keys must 604 be unique */ 605 606 PyCFunction meth = method->ml_meth; 607 int flags = method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST); 608 Py_ssize_t nkwargs = kwnames == NULL ? 0 : PyTuple_GET_SIZE(kwnames); 609 PyObject *result = NULL; 610 611 if (Py_EnterRecursiveCall(" while calling a Python object")) { 612 return NULL; 613 } 614 615 switch (flags) 616 { 617 case METH_NOARGS: 618 if (nkwargs) { 619 goto no_keyword_error; 620 } 621 622 if (nargs != 0) { 623 PyErr_Format(PyExc_TypeError, 624 "%.200s() takes no arguments (%zd given)", 625 method->ml_name, nargs); 626 goto exit; 627 } 628 629 result = (*meth) (self, NULL); 630 break; 631 632 case METH_O: 633 if (nkwargs) { 634 goto no_keyword_error; 635 } 636 637 if (nargs != 1) { 638 PyErr_Format(PyExc_TypeError, 639 "%.200s() takes exactly one argument (%zd given)", 640 method->ml_name, nargs); 641 goto exit; 642 } 643 644 result = (*meth) (self, args[0]); 645 break; 646 647 case METH_FASTCALL: 648 if (nkwargs) { 649 goto no_keyword_error; 650 } 651 result = ((_PyCFunctionFast)meth) (self, args, nargs); 652 break; 653 654 case METH_FASTCALL | METH_KEYWORDS: 655 /* Fast-path: avoid temporary dict to pass keyword arguments */ 656 result = ((_PyCFunctionFastWithKeywords)meth) (self, args, nargs, kwnames); 657 break; 658 659 case METH_VARARGS: 660 if (nkwargs) { 661 goto no_keyword_error; 662 } 663 /* fall through */ 664 665 case METH_VARARGS | METH_KEYWORDS: 666 { 667 /* Slow-path: create a temporary tuple for positional arguments 668 and a temporary dict for keyword arguments */ 669 PyObject *argtuple; 670 671 argtuple = _PyStack_AsTuple(args, nargs); 672 if (argtuple == NULL) { 673 goto exit; 674 } 675 676 if (flags & METH_KEYWORDS) { 677 PyObject *kwdict; 678 679 if (nkwargs > 0) { 680 kwdict = _PyStack_AsDict(args + nargs, kwnames); 681 if (kwdict == NULL) { 682 Py_DECREF(argtuple); 683 goto exit; 684 } 685 } 686 else { 687 kwdict = NULL; 688 } 689 690 result = (*(PyCFunctionWithKeywords)meth) (self, argtuple, kwdict); 691 Py_XDECREF(kwdict); 692 } 693 else { 694 result = (*meth) (self, argtuple); 695 } 696 Py_DECREF(argtuple); 697 break; 698 } 699 700 default: 701 PyErr_SetString(PyExc_SystemError, 702 "Bad call flags in _PyCFunction_FastCallKeywords. " 703 "METH_OLDARGS is no longer supported!"); 704 goto exit; 705 } 706 707 goto exit; 708 709 no_keyword_error: 710 PyErr_Format(PyExc_TypeError, 711 "%.200s() takes no keyword arguments", 712 method->ml_name); 713 714 exit: 715 Py_LeaveRecursiveCall(); 716 return result; 717 } 718 719 720 PyObject * 721 _PyCFunction_FastCallKeywords(PyObject *func, 722 PyObject *const *args, Py_ssize_t nargs, 723 PyObject *kwnames) 724 { 725 PyObject *result; 726 727 assert(func != NULL); 728 assert(PyCFunction_Check(func)); 729 730 result = _PyMethodDef_RawFastCallKeywords(((PyCFunctionObject*)func)->m_ml, 731 PyCFunction_GET_SELF(func), 732 args, nargs, kwnames); 733 result = _Py_CheckFunctionResult(func, result, NULL); 734 return result; 735 } 736 737 738 static PyObject * 739 cfunction_call_varargs(PyObject *func, PyObject *args, PyObject *kwargs) 740 { 741 assert(!PyErr_Occurred()); 742 assert(kwargs == NULL || PyDict_Check(kwargs)); 743 744 PyCFunction meth = PyCFunction_GET_FUNCTION(func); 745 PyObject *self = PyCFunction_GET_SELF(func); 746 PyObject *result; 747 748 if (PyCFunction_GET_FLAGS(func) & METH_KEYWORDS) { 749 if (Py_EnterRecursiveCall(" while calling a Python object")) { 750 return NULL; 751 } 752 753 result = (*(PyCFunctionWithKeywords)meth)(self, args, kwargs); 754 755 Py_LeaveRecursiveCall(); 756 } 757 else { 758 if (kwargs != NULL && PyDict_GET_SIZE(kwargs) != 0) { 759 PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", 760 ((PyCFunctionObject*)func)->m_ml->ml_name); 761 return NULL; 762 } 763 764 if (Py_EnterRecursiveCall(" while calling a Python object")) { 765 return NULL; 766 } 767 768 result = (*meth)(self, args); 769 770 Py_LeaveRecursiveCall(); 771 } 772 773 return _Py_CheckFunctionResult(func, result, NULL); 774 } 775 776 777 PyObject * 778 PyCFunction_Call(PyObject *func, PyObject *args, PyObject *kwargs) 779 { 780 /* first try METH_VARARGS to pass directly args tuple unchanged. 781 _PyMethodDef_RawFastCallDict() creates a new temporary tuple 782 for METH_VARARGS. */ 783 if (PyCFunction_GET_FLAGS(func) & METH_VARARGS) { 784 return cfunction_call_varargs(func, args, kwargs); 785 } 786 else { 787 return _PyCFunction_FastCallDict(func, 788 &PyTuple_GET_ITEM(args, 0), 789 PyTuple_GET_SIZE(args), 790 kwargs); 791 } 792 } 793 794 795 /* --- More complex call functions -------------------------------- */ 796 797 /* External interface to call any callable object. 798 The args must be a tuple or NULL. The kwargs must be a dict or NULL. */ 799 PyObject * 800 PyEval_CallObjectWithKeywords(PyObject *callable, 801 PyObject *args, PyObject *kwargs) 802 { 803 #ifdef Py_DEBUG 804 /* PyEval_CallObjectWithKeywords() must not be called with an exception 805 set. It raises a new exception if parameters are invalid or if 806 PyTuple_New() fails, and so the original exception is lost. */ 807 assert(!PyErr_Occurred()); 808 #endif 809 810 if (args != NULL && !PyTuple_Check(args)) { 811 PyErr_SetString(PyExc_TypeError, 812 "argument list must be a tuple"); 813 return NULL; 814 } 815 816 if (kwargs != NULL && !PyDict_Check(kwargs)) { 817 PyErr_SetString(PyExc_TypeError, 818 "keyword list must be a dictionary"); 819 return NULL; 820 } 821 822 if (args == NULL) { 823 return _PyObject_FastCallDict(callable, NULL, 0, kwargs); 824 } 825 else { 826 return PyObject_Call(callable, args, kwargs); 827 } 828 } 829 830 831 PyObject * 832 PyObject_CallObject(PyObject *callable, PyObject *args) 833 { 834 return PyEval_CallObjectWithKeywords(callable, args, NULL); 835 } 836 837 838 /* Positional arguments are obj followed by args: 839 call callable(obj, *args, **kwargs) */ 840 PyObject * 841 _PyObject_FastCall_Prepend(PyObject *callable, PyObject *obj, 842 PyObject *const *args, Py_ssize_t nargs) 843 { 844 PyObject *small_stack[_PY_FASTCALL_SMALL_STACK]; 845 PyObject **args2; 846 PyObject *result; 847 848 nargs++; 849 if (nargs <= (Py_ssize_t)Py_ARRAY_LENGTH(small_stack)) { 850 args2 = small_stack; 851 } 852 else { 853 args2 = PyMem_Malloc(nargs * sizeof(PyObject *)); 854 if (args2 == NULL) { 855 PyErr_NoMemory(); 856 return NULL; 857 } 858 } 859 860 /* use borrowed references */ 861 args2[0] = obj; 862 if (nargs > 1) { 863 memcpy(&args2[1], args, (nargs - 1) * sizeof(PyObject *)); 864 } 865 866 result = _PyObject_FastCall(callable, args2, nargs); 867 if (args2 != small_stack) { 868 PyMem_Free(args2); 869 } 870 return result; 871 } 872 873 874 /* Call callable(obj, *args, **kwargs). */ 875 PyObject * 876 _PyObject_Call_Prepend(PyObject *callable, 877 PyObject *obj, PyObject *args, PyObject *kwargs) 878 { 879 PyObject *small_stack[_PY_FASTCALL_SMALL_STACK]; 880 PyObject **stack; 881 Py_ssize_t argcount; 882 PyObject *result; 883 884 assert(PyTuple_Check(args)); 885 886 argcount = PyTuple_GET_SIZE(args); 887 if (argcount + 1 <= (Py_ssize_t)Py_ARRAY_LENGTH(small_stack)) { 888 stack = small_stack; 889 } 890 else { 891 stack = PyMem_Malloc((argcount + 1) * sizeof(PyObject *)); 892 if (stack == NULL) { 893 PyErr_NoMemory(); 894 return NULL; 895 } 896 } 897 898 /* use borrowed references */ 899 stack[0] = obj; 900 memcpy(&stack[1], 901 &PyTuple_GET_ITEM(args, 0), 902 argcount * sizeof(PyObject *)); 903 904 result = _PyObject_FastCallDict(callable, 905 stack, argcount + 1, 906 kwargs); 907 if (stack != small_stack) { 908 PyMem_Free(stack); 909 } 910 return result; 911 } 912 913 914 /* --- Call with a format string ---------------------------------- */ 915 916 static PyObject * 917 _PyObject_CallFunctionVa(PyObject *callable, const char *format, 918 va_list va, int is_size_t) 919 { 920 PyObject* small_stack[_PY_FASTCALL_SMALL_STACK]; 921 const Py_ssize_t small_stack_len = Py_ARRAY_LENGTH(small_stack); 922 PyObject **stack; 923 Py_ssize_t nargs, i; 924 PyObject *result; 925 926 if (callable == NULL) { 927 return null_error(); 928 } 929 930 if (!format || !*format) { 931 return _PyObject_CallNoArg(callable); 932 } 933 934 if (is_size_t) { 935 stack = _Py_VaBuildStack_SizeT(small_stack, small_stack_len, 936 format, va, &nargs); 937 } 938 else { 939 stack = _Py_VaBuildStack(small_stack, small_stack_len, 940 format, va, &nargs); 941 } 942 if (stack == NULL) { 943 return NULL; 944 } 945 946 if (nargs == 1 && PyTuple_Check(stack[0])) { 947 /* Special cases for backward compatibility: 948 - PyObject_CallFunction(func, "O", tuple) calls func(*tuple) 949 - PyObject_CallFunction(func, "(OOO)", arg1, arg2, arg3) calls 950 func(*(arg1, arg2, arg3)): func(arg1, arg2, arg3) */ 951 PyObject *args = stack[0]; 952 result = _PyObject_FastCall(callable, 953 &PyTuple_GET_ITEM(args, 0), 954 PyTuple_GET_SIZE(args)); 955 } 956 else { 957 result = _PyObject_FastCall(callable, stack, nargs); 958 } 959 960 for (i = 0; i < nargs; ++i) { 961 Py_DECREF(stack[i]); 962 } 963 if (stack != small_stack) { 964 PyMem_Free(stack); 965 } 966 return result; 967 } 968 969 970 PyObject * 971 PyObject_CallFunction(PyObject *callable, const char *format, ...) 972 { 973 va_list va; 974 PyObject *result; 975 976 va_start(va, format); 977 result = _PyObject_CallFunctionVa(callable, format, va, 0); 978 va_end(va); 979 980 return result; 981 } 982 983 984 /* PyEval_CallFunction is exact copy of PyObject_CallFunction. 985 * This function is kept for backward compatibility. 986 */ 987 PyObject * 988 PyEval_CallFunction(PyObject *callable, const char *format, ...) 989 { 990 va_list va; 991 PyObject *result; 992 993 va_start(va, format); 994 result = _PyObject_CallFunctionVa(callable, format, va, 0); 995 va_end(va); 996 997 return result; 998 } 999 1000 1001 PyObject * 1002 _PyObject_CallFunction_SizeT(PyObject *callable, const char *format, ...) 1003 { 1004 va_list va; 1005 PyObject *result; 1006 1007 va_start(va, format); 1008 result = _PyObject_CallFunctionVa(callable, format, va, 1); 1009 va_end(va); 1010 1011 return result; 1012 } 1013 1014 1015 static PyObject* 1016 callmethod(PyObject* callable, const char *format, va_list va, int is_size_t) 1017 { 1018 assert(callable != NULL); 1019 1020 if (!PyCallable_Check(callable)) { 1021 PyErr_Format(PyExc_TypeError, 1022 "attribute of type '%.200s' is not callable", 1023 Py_TYPE(callable)->tp_name); 1024 return NULL; 1025 } 1026 1027 return _PyObject_CallFunctionVa(callable, format, va, is_size_t); 1028 } 1029 1030 1031 PyObject * 1032 PyObject_CallMethod(PyObject *obj, const char *name, const char *format, ...) 1033 { 1034 va_list va; 1035 PyObject *callable, *retval; 1036 1037 if (obj == NULL || name == NULL) { 1038 return null_error(); 1039 } 1040 1041 callable = PyObject_GetAttrString(obj, name); 1042 if (callable == NULL) 1043 return NULL; 1044 1045 va_start(va, format); 1046 retval = callmethod(callable, format, va, 0); 1047 va_end(va); 1048 1049 Py_DECREF(callable); 1050 return retval; 1051 } 1052 1053 1054 /* PyEval_CallMethod is exact copy of PyObject_CallMethod. 1055 * This function is kept for backward compatibility. 1056 */ 1057 PyObject * 1058 PyEval_CallMethod(PyObject *obj, const char *name, const char *format, ...) 1059 { 1060 va_list va; 1061 PyObject *callable, *retval; 1062 1063 if (obj == NULL || name == NULL) { 1064 return null_error(); 1065 } 1066 1067 callable = PyObject_GetAttrString(obj, name); 1068 if (callable == NULL) 1069 return NULL; 1070 1071 va_start(va, format); 1072 retval = callmethod(callable, format, va, 0); 1073 va_end(va); 1074 1075 Py_DECREF(callable); 1076 return retval; 1077 } 1078 1079 1080 PyObject * 1081 _PyObject_CallMethodId(PyObject *obj, _Py_Identifier *name, 1082 const char *format, ...) 1083 { 1084 va_list va; 1085 PyObject *callable, *retval; 1086 1087 if (obj == NULL || name == NULL) { 1088 return null_error(); 1089 } 1090 1091 callable = _PyObject_GetAttrId(obj, name); 1092 if (callable == NULL) 1093 return NULL; 1094 1095 va_start(va, format); 1096 retval = callmethod(callable, format, va, 0); 1097 va_end(va); 1098 1099 Py_DECREF(callable); 1100 return retval; 1101 } 1102 1103 1104 PyObject * 1105 _PyObject_CallMethod_SizeT(PyObject *obj, const char *name, 1106 const char *format, ...) 1107 { 1108 va_list va; 1109 PyObject *callable, *retval; 1110 1111 if (obj == NULL || name == NULL) { 1112 return null_error(); 1113 } 1114 1115 callable = PyObject_GetAttrString(obj, name); 1116 if (callable == NULL) 1117 return NULL; 1118 1119 va_start(va, format); 1120 retval = callmethod(callable, format, va, 1); 1121 va_end(va); 1122 1123 Py_DECREF(callable); 1124 return retval; 1125 } 1126 1127 1128 PyObject * 1129 _PyObject_CallMethodId_SizeT(PyObject *obj, _Py_Identifier *name, 1130 const char *format, ...) 1131 { 1132 va_list va; 1133 PyObject *callable, *retval; 1134 1135 if (obj == NULL || name == NULL) { 1136 return null_error(); 1137 } 1138 1139 callable = _PyObject_GetAttrId(obj, name); 1140 if (callable == NULL) { 1141 return NULL; 1142 } 1143 1144 va_start(va, format); 1145 retval = callmethod(callable, format, va, 1); 1146 va_end(va); 1147 1148 Py_DECREF(callable); 1149 return retval; 1150 } 1151 1152 1153 /* --- Call with "..." arguments ---------------------------------- */ 1154 1155 static PyObject * 1156 object_vacall(PyObject *callable, va_list vargs) 1157 { 1158 PyObject *small_stack[_PY_FASTCALL_SMALL_STACK]; 1159 PyObject **stack; 1160 Py_ssize_t nargs; 1161 PyObject *result; 1162 Py_ssize_t i; 1163 va_list countva; 1164 1165 if (callable == NULL) { 1166 return null_error(); 1167 } 1168 1169 /* Count the number of arguments */ 1170 va_copy(countva, vargs); 1171 nargs = 0; 1172 while (1) { 1173 PyObject *arg = va_arg(countva, PyObject *); 1174 if (arg == NULL) { 1175 break; 1176 } 1177 nargs++; 1178 } 1179 va_end(countva); 1180 1181 /* Copy arguments */ 1182 if (nargs <= (Py_ssize_t)Py_ARRAY_LENGTH(small_stack)) { 1183 stack = small_stack; 1184 } 1185 else { 1186 stack = PyMem_Malloc(nargs * sizeof(stack[0])); 1187 if (stack == NULL) { 1188 PyErr_NoMemory(); 1189 return NULL; 1190 } 1191 } 1192 1193 for (i = 0; i < nargs; ++i) { 1194 stack[i] = va_arg(vargs, PyObject *); 1195 } 1196 1197 /* Call the function */ 1198 result = _PyObject_FastCall(callable, stack, nargs); 1199 1200 if (stack != small_stack) { 1201 PyMem_Free(stack); 1202 } 1203 return result; 1204 } 1205 1206 1207 PyObject * 1208 PyObject_CallMethodObjArgs(PyObject *callable, PyObject *name, ...) 1209 { 1210 va_list vargs; 1211 PyObject *result; 1212 1213 if (callable == NULL || name == NULL) { 1214 return null_error(); 1215 } 1216 1217 callable = PyObject_GetAttr(callable, name); 1218 if (callable == NULL) { 1219 return NULL; 1220 } 1221 1222 va_start(vargs, name); 1223 result = object_vacall(callable, vargs); 1224 va_end(vargs); 1225 1226 Py_DECREF(callable); 1227 return result; 1228 } 1229 1230 1231 PyObject * 1232 _PyObject_CallMethodIdObjArgs(PyObject *obj, 1233 struct _Py_Identifier *name, ...) 1234 { 1235 va_list vargs; 1236 PyObject *callable, *result; 1237 1238 if (obj == NULL || name == NULL) { 1239 return null_error(); 1240 } 1241 1242 callable = _PyObject_GetAttrId(obj, name); 1243 if (callable == NULL) { 1244 return NULL; 1245 } 1246 1247 va_start(vargs, name); 1248 result = object_vacall(callable, vargs); 1249 va_end(vargs); 1250 1251 Py_DECREF(callable); 1252 return result; 1253 } 1254 1255 1256 PyObject * 1257 PyObject_CallFunctionObjArgs(PyObject *callable, ...) 1258 { 1259 va_list vargs; 1260 PyObject *result; 1261 1262 va_start(vargs, callable); 1263 result = object_vacall(callable, vargs); 1264 va_end(vargs); 1265 1266 return result; 1267 } 1268 1269 1270 /* --- PyStack functions ------------------------------------------ */ 1271 1272 /* Issue #29234: Inlining _PyStack_AsTuple() into callers increases their 1273 stack consumption, Disable inlining to optimize the stack consumption. */ 1274 PyObject* _Py_NO_INLINE 1275 _PyStack_AsTuple(PyObject *const *stack, Py_ssize_t nargs) 1276 { 1277 PyObject *args; 1278 Py_ssize_t i; 1279 1280 args = PyTuple_New(nargs); 1281 if (args == NULL) { 1282 return NULL; 1283 } 1284 1285 for (i=0; i < nargs; i++) { 1286 PyObject *item = stack[i]; 1287 Py_INCREF(item); 1288 PyTuple_SET_ITEM(args, i, item); 1289 } 1290 return args; 1291 } 1292 1293 1294 PyObject* 1295 _PyStack_AsTupleSlice(PyObject *const *stack, Py_ssize_t nargs, 1296 Py_ssize_t start, Py_ssize_t end) 1297 { 1298 PyObject *args; 1299 Py_ssize_t i; 1300 1301 assert(0 <= start); 1302 assert(end <= nargs); 1303 assert(start <= end); 1304 1305 args = PyTuple_New(end - start); 1306 if (args == NULL) { 1307 return NULL; 1308 } 1309 1310 for (i=start; i < end; i++) { 1311 PyObject *item = stack[i]; 1312 Py_INCREF(item); 1313 PyTuple_SET_ITEM(args, i - start, item); 1314 } 1315 return args; 1316 } 1317 1318 1319 PyObject * 1320 _PyStack_AsDict(PyObject *const *values, PyObject *kwnames) 1321 { 1322 Py_ssize_t nkwargs; 1323 PyObject *kwdict; 1324 Py_ssize_t i; 1325 1326 assert(kwnames != NULL); 1327 nkwargs = PyTuple_GET_SIZE(kwnames); 1328 kwdict = _PyDict_NewPresized(nkwargs); 1329 if (kwdict == NULL) { 1330 return NULL; 1331 } 1332 1333 for (i = 0; i < nkwargs; i++) { 1334 PyObject *key = PyTuple_GET_ITEM(kwnames, i); 1335 PyObject *value = *values++; 1336 /* If key already exists, replace it with the new value */ 1337 if (PyDict_SetItem(kwdict, key, value)) { 1338 Py_DECREF(kwdict); 1339 return NULL; 1340 } 1341 } 1342 return kwdict; 1343 } 1344 1345 1346 int 1347 _PyStack_UnpackDict(PyObject *const *args, Py_ssize_t nargs, PyObject *kwargs, 1348 PyObject *const **p_stack, PyObject **p_kwnames) 1349 { 1350 PyObject **stack, **kwstack; 1351 Py_ssize_t nkwargs; 1352 Py_ssize_t pos, i; 1353 PyObject *key, *value; 1354 PyObject *kwnames; 1355 1356 assert(nargs >= 0); 1357 assert(kwargs == NULL || PyDict_CheckExact(kwargs)); 1358 1359 if (kwargs == NULL || (nkwargs = PyDict_GET_SIZE(kwargs)) == 0) { 1360 *p_stack = args; 1361 *p_kwnames = NULL; 1362 return 0; 1363 } 1364 1365 if ((size_t)nargs > PY_SSIZE_T_MAX / sizeof(stack[0]) - (size_t)nkwargs) { 1366 PyErr_NoMemory(); 1367 return -1; 1368 } 1369 1370 stack = PyMem_Malloc((nargs + nkwargs) * sizeof(stack[0])); 1371 if (stack == NULL) { 1372 PyErr_NoMemory(); 1373 return -1; 1374 } 1375 1376 kwnames = PyTuple_New(nkwargs); 1377 if (kwnames == NULL) { 1378 PyMem_Free(stack); 1379 return -1; 1380 } 1381 1382 /* Copy position arguments (borrowed references) */ 1383 memcpy(stack, args, nargs * sizeof(stack[0])); 1384 1385 kwstack = stack + nargs; 1386 pos = i = 0; 1387 /* This loop doesn't support lookup function mutating the dictionary 1388 to change its size. It's a deliberate choice for speed, this function is 1389 called in the performance critical hot code. */ 1390 while (PyDict_Next(kwargs, &pos, &key, &value)) { 1391 Py_INCREF(key); 1392 PyTuple_SET_ITEM(kwnames, i, key); 1393 /* The stack contains borrowed references */ 1394 kwstack[i] = value; 1395 i++; 1396 } 1397 1398 *p_stack = stack; 1399 *p_kwnames = kwnames; 1400 return 0; 1401 } 1402
