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