1  #ifndef Py_INTERNAL_CALL_H
       2  #define Py_INTERNAL_CALL_H
       3  #ifdef __cplusplus
       4  extern "C" {
       5  #endif
       6  
       7  #ifndef Py_BUILD_CORE
       8  #  error "this header requires Py_BUILD_CORE define"
       9  #endif
      10  
      11  #include "pycore_pystate.h"       // _PyThreadState_GET()
      12  
      13  PyAPI_FUNC(PyObject *) _PyObject_Call_Prepend(
      14      PyThreadState *tstate,
      15      PyObject *callable,
      16      PyObject *obj,
      17      PyObject *args,
      18      PyObject *kwargs);
      19  
      20  PyAPI_FUNC(PyObject *) _PyObject_FastCallDictTstate(
      21      PyThreadState *tstate,
      22      PyObject *callable,
      23      PyObject *const *args,
      24      size_t nargsf,
      25      PyObject *kwargs);
      26  
      27  PyAPI_FUNC(PyObject *) _PyObject_Call(
      28      PyThreadState *tstate,
      29      PyObject *callable,
      30      PyObject *args,
      31      PyObject *kwargs);
      32  
      33  extern PyObject * _PyObject_CallMethodFormat(
      34          PyThreadState *tstate, PyObject *callable, const char *format, ...);
      35  
      36  
      37  // Static inline variant of public PyVectorcall_Function().
      38  static inline vectorcallfunc
      39  _PyVectorcall_FunctionInline(PyObject *callable)
      40  {
      41      assert(callable != NULL);
      42  
      43      PyTypeObject *tp = Py_TYPE(callable);
      44      if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) {
      45          return NULL;
      46      }
      47      assert(PyCallable_Check(callable));
      48  
      49      Py_ssize_t offset = tp->tp_vectorcall_offset;
      50      assert(offset > 0);
      51  
      52      vectorcallfunc ptr;
      53      memcpy(&ptr, (char *) callable + offset, sizeof(ptr));
      54      return ptr;
      55  }
      56  
      57  
      58  /* Call the callable object 'callable' with the "vectorcall" calling
      59     convention.
      60  
      61     args is a C array for positional arguments.
      62  
      63     nargsf is the number of positional arguments plus optionally the flag
      64     PY_VECTORCALL_ARGUMENTS_OFFSET which means that the caller is allowed to
      65     modify args[-1].
      66  
      67     kwnames is a tuple of keyword names. The values of the keyword arguments
      68     are stored in "args" after the positional arguments (note that the number
      69     of keyword arguments does not change nargsf). kwnames can also be NULL if
      70     there are no keyword arguments.
      71  
      72     keywords must only contain strings and all keys must be unique.
      73  
      74     Return the result on success. Raise an exception and return NULL on
      75     error. */
      76  static inline PyObject *
      77  _PyObject_VectorcallTstate(PyThreadState *tstate, PyObject *callable,
      78                             PyObject *const *args, size_t nargsf,
      79                             PyObject *kwnames)
      80  {
      81      vectorcallfunc func;
      82      PyObject *res;
      83  
      84      assert(kwnames == NULL || PyTuple_Check(kwnames));
      85      assert(args != NULL || PyVectorcall_NARGS(nargsf) == 0);
      86  
      87      func = _PyVectorcall_FunctionInline(callable);
      88      if (func == NULL) {
      89          Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
      90          return _PyObject_MakeTpCall(tstate, callable, args, nargs, kwnames);
      91      }
      92      res = func(callable, args, nargsf, kwnames);
      93      return _Py_CheckFunctionResult(tstate, callable, res, NULL);
      94  }
      95  
      96  
      97  static inline PyObject *
      98  _PyObject_CallNoArgsTstate(PyThreadState *tstate, PyObject *func) {
      99      return _PyObject_VectorcallTstate(tstate, func, NULL, 0, NULL);
     100  }
     101  
     102  
     103  // Private static inline function variant of public PyObject_CallNoArgs()
     104  static inline PyObject *
     105  _PyObject_CallNoArgs(PyObject *func) {
     106      EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_API, func);
     107      PyThreadState *tstate = _PyThreadState_GET();
     108      return _PyObject_VectorcallTstate(tstate, func, NULL, 0, NULL);
     109  }
     110  
     111  
     112  static inline PyObject *
     113  _PyObject_FastCallTstate(PyThreadState *tstate, PyObject *func, PyObject *const *args, Py_ssize_t nargs)
     114  {
     115      EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_API, func);
     116      return _PyObject_VectorcallTstate(tstate, func, args, (size_t)nargs, NULL);
     117  }
     118  
     119  PyObject *const *
     120  _PyStack_UnpackDict(PyThreadState *tstate,
     121      PyObject *const *args, Py_ssize_t nargs,
     122      PyObject *kwargs, PyObject **p_kwnames);
     123  
     124  void
     125  _PyStack_UnpackDict_Free(PyObject *const *stack, Py_ssize_t nargs,
     126      PyObject *kwnames);
     127  
     128  void _PyStack_UnpackDict_FreeNoDecRef(PyObject *const *stack, PyObject *kwnames);
     129  
     130  #ifdef __cplusplus
     131  }
     132  #endif
     133  #endif /* !Py_INTERNAL_CALL_H */