#include "Python.h"

#include "pycore_call.h" // _PyObject_CallNoArgsTstate()

#include "pycore_ceval.h" // _Py_EnterRecursiveCallTstate()

#include "pycore_dict.h" // _PyDict_FromItems()

#include "pycore_function.h" // _PyFunction_Vectorcall() definition

#include "pycore_modsupport.h" // _Py_VaBuildStack()

#include "pycore_object.h" // _PyCFunctionWithKeywords_TrampolineCall()

#include "pycore_pyerrors.h" // _PyErr_Occurred()

#include "pycore_pystate.h" // _PyThreadState_GET()

#include "pycore_tuple.h" // _PyTuple_ITEMS()

static PyObject *

null_error(PyThreadState *tstate)

{

if (!_PyErr_Occurred(tstate)) {

_PyErr_SetString(tstate, PyExc_SystemError,

"null argument to internal routine");

}

return NULL;

}

_Py_CheckFunctionResult(PyThreadState *tstate, PyObject *callable,

PyObject *result, const char *where)

{

assert((callable != NULL) ^ (where != NULL));

if (result == NULL) {

if (!_PyErr_Occurred(tstate)) {

if (callable)

_PyErr_Format(tstate, PyExc_SystemError,

"%R returned NULL without setting an exception",

callable);

else

_PyErr_Format(tstate, PyExc_SystemError,

"%s returned NULL without setting an exception",

where);

#ifdef Py_DEBUG

/* Ensure that the bug is caught in debug mode.

Py_FatalError("a function returned NULL without setting an exception");

return NULL;

}

}

else {

if (_PyErr_Occurred(tstate)) {

Py_DECREF(result);

if (callable) {

_PyErr_FormatFromCauseTstate(

tstate, PyExc_SystemError,

"%R returned a result with an exception set", callable);

}

else {

_PyErr_FormatFromCauseTstate(

tstate, PyExc_SystemError,

"%s returned a result with an exception set", where);

}

#ifdef Py_DEBUG

/* Ensure that the bug is caught in debug mode.

Py_FatalError("a function returned a result with an exception set");

return NULL;

}

}

return result;

}

_Py_CheckSlotResult(PyObject *obj, const char *slot_name, int success)

{

PyThreadState *tstate = _PyThreadState_GET();

if (!success) {

if (!_PyErr_Occurred(tstate)) {

_Py_FatalErrorFormat(__func__,

"Slot %s of type %s failed "

"without setting an exception",

slot_name, Py_TYPE(obj)->tp_name);

}

}

else {

if (_PyErr_Occurred(tstate)) {

_Py_FatalErrorFormat(__func__,

"Slot %s of type %s succeeded "

"with an exception set",

slot_name, Py_TYPE(obj)->tp_name);

}

}

return 1;

}

PyObject *

PyObject_CallNoArgs(PyObject *func)

{

EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_API, func);

PyThreadState *tstate = _PyThreadState_GET();

return _PyObject_VectorcallTstate(tstate, func, NULL, 0, NULL);

}

PyObject *

_PyObject_VectorcallDictTstate(PyThreadState *tstate, PyObject *callable,

PyObject *const *args, size_t nargsf,

PyObject *kwargs)

{

assert(callable != NULL);

/* PyObject_VectorcallDict() must not be called with an exception set,

assert(!_PyErr_Occurred(tstate));

Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);

assert(nargs >= 0);

assert(nargs == 0 || args != NULL);

assert(kwargs == NULL || PyDict_Check(kwargs));

vectorcallfunc func = PyVectorcall_Function(callable);

if (func == NULL) {

/* Use tp_call instead */

return _PyObject_MakeTpCall(tstate, callable, args, nargs, kwargs);

}

PyObject *res;

if (kwargs == NULL || PyDict_GET_SIZE(kwargs) == 0) {

res = func(callable, args, nargsf, NULL);

}

else {

PyObject *kwnames;

PyObject *const *newargs;

newargs = _PyStack_UnpackDict(tstate,

args, nargs,

kwargs, &kwnames);

if (newargs == NULL) {

return NULL;

}

res = func(callable, newargs,

nargs | PY_VECTORCALL_ARGUMENTS_OFFSET, kwnames);

_PyStack_UnpackDict_Free(newargs, nargs, kwnames);

}

return _Py_CheckFunctionResult(tstate, callable, res, NULL);

}

PyObject *

PyObject_VectorcallDict(PyObject *callable, PyObject *const *args,

size_t nargsf, PyObject *kwargs)

{

PyThreadState *tstate = _PyThreadState_GET();

return _PyObject_VectorcallDictTstate(tstate, callable, args, nargsf, kwargs);

}

static void

object_is_not_callable(PyThreadState *tstate, PyObject *callable)

{

if (Py_IS_TYPE(callable, &PyModule_Type)) {

// >>> import pprint

// >>> pprint(thing)

// Traceback (most recent call last):

// File "<stdin>", line 1, in <module>

// TypeError: 'module' object is not callable. Did you mean: 'pprint.pprint(...)'?

PyObject *name = PyModule_GetNameObject(callable);

if (name == NULL) {

_PyErr_Clear(tstate);

goto basic_type_error;

}

PyObject *attr;

int res = PyObject_GetOptionalAttr(callable, name, &attr);

if (res < 0) {

_PyErr_Clear(tstate);

}

else if (res > 0 && PyCallable_Check(attr)) {

_PyErr_Format(tstate, PyExc_TypeError,

"'%.200s' object is not callable. "

"Did you mean: '%U.%U(...)'?",

Py_TYPE(callable)->tp_name, name, name);

Py_DECREF(attr);

Py_DECREF(name);

return;

}

Py_XDECREF(attr);

Py_DECREF(name);

}

basic_type_error:

_PyErr_Format(tstate, PyExc_TypeError, "'%.200s' object is not callable",

Py_TYPE(callable)->tp_name);

}

PyObject *

_PyObject_MakeTpCall(PyThreadState *tstate, PyObject *callable,

PyObject *const *args, Py_ssize_t nargs,

PyObject *keywords)

{

assert(nargs >= 0);

assert(nargs == 0 || args != NULL);

assert(keywords == NULL || PyTuple_Check(keywords) || PyDict_Check(keywords));

/* Slow path: build a temporary tuple for positional arguments and a

ternaryfunc call = Py_TYPE(callable)->tp_call;

if (call == NULL) {

object_is_not_callable(tstate, callable);

return NULL;

}

PyObject *argstuple = PyTuple_FromArray(args, nargs);

if (argstuple == NULL) {

return NULL;

}

PyObject *kwdict;

if (keywords == NULL || PyDict_Check(keywords)) {

kwdict = keywords;

}

else {

if (PyTuple_GET_SIZE(keywords)) {

assert(args != NULL);

kwdict = _PyStack_AsDict(args + nargs, keywords);

if (kwdict == NULL) {

Py_DECREF(argstuple);

return NULL;

}

}

else {

keywords = kwdict = NULL;

}

}

PyObject *result = NULL;

if (_Py_EnterRecursiveCallTstate(tstate, " while calling a Python object") == 0)

{

result = _PyCFunctionWithKeywords_TrampolineCall(

(PyCFunctionWithKeywords)call, callable, argstuple, kwdict);

_Py_LeaveRecursiveCallTstate(tstate);

}

Py_DECREF(argstuple);

if (kwdict != keywords) {

Py_DECREF(kwdict);

}

return _Py_CheckFunctionResult(tstate, callable, result, NULL);

}

PyVectorcall_Function(PyObject *callable)

{

return _PyVectorcall_FunctionInline(callable);

}

static PyObject *

_PyVectorcall_Call(PyThreadState *tstate, vectorcallfunc func,

PyObject *callable, PyObject *tuple, PyObject *kwargs)

{

assert(func != NULL);

Py_ssize_t nargs = PyTuple_GET_SIZE(tuple);

/* Fast path for no keywords */

if (kwargs == NULL || PyDict_GET_SIZE(kwargs) == 0) {

return func(callable, _PyTuple_ITEMS(tuple), nargs, NULL);

}

/* Convert arguments & call */

PyObject *const *args;

PyObject *kwnames;

args = _PyStack_UnpackDict(tstate,

_PyTuple_ITEMS(tuple), nargs,

kwargs, &kwnames);

if (args == NULL) {

return NULL;

}

PyObject *result = func(callable, args,

nargs | PY_VECTORCALL_ARGUMENTS_OFFSET, kwnames);

_PyStack_UnpackDict_Free(args, nargs, kwnames);

return _Py_CheckFunctionResult(tstate, callable, result, NULL);

}

PyObject *

PyVectorcall_Call(PyObject *callable, PyObject *tuple, PyObject *kwargs)

{

PyThreadState *tstate = _PyThreadState_GET();

/* get vectorcallfunc as in _PyVectorcall_Function, but without

Py_ssize_t offset = Py_TYPE(callable)->tp_vectorcall_offset;

if (offset <= 0) {

_PyErr_Format(tstate, PyExc_TypeError,

"'%.200s' object does not support vectorcall",

Py_TYPE(callable)->tp_name);

return NULL;

}

assert(PyCallable_Check(callable));

vectorcallfunc func;

memcpy(&func, (char *) callable + offset, sizeof(func));

if (func == NULL) {

_PyErr_Format(tstate, PyExc_TypeError,

"'%.200s' object does not support vectorcall",

Py_TYPE(callable)->tp_name);

return NULL;

}

return _PyVectorcall_Call(tstate, func, callable, tuple, kwargs);

}

PyObject *

PyObject_Vectorcall(PyObject *callable, PyObject *const *args,

size_t nargsf, PyObject *kwnames)

{

PyThreadState *tstate = _PyThreadState_GET();

return _PyObject_VectorcallTstate(tstate, callable,

args, nargsf, kwnames);

}

PyObject *

_PyObject_Call(PyThreadState *tstate, PyObject *callable,

PyObject *args, PyObject *kwargs)

{

ternaryfunc call;

PyObject *result;

/* PyObject_Call() must not be called with an exception set,

assert(!_PyErr_Occurred(tstate));

assert(PyTuple_Check(args));

assert(kwargs == NULL || PyDict_Check(kwargs));

EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_API, callable);

vectorcallfunc vector_func = PyVectorcall_Function(callable);

if (vector_func != NULL) {

return _PyVectorcall_Call(tstate, vector_func, callable, args, kwargs);

}

else {

call = Py_TYPE(callable)->tp_call;

if (call == NULL) {

object_is_not_callable(tstate, callable);

return NULL;

}

if (_Py_EnterRecursiveCallTstate(tstate, " while calling a Python object")) {

return NULL;

}

result = (*call)(callable, args, kwargs);

_Py_LeaveRecursiveCallTstate(tstate);

return _Py_CheckFunctionResult(tstate, callable, result, NULL);

}

}

PyObject *

PyObject_Call(PyObject *callable, PyObject *args, PyObject *kwargs)

{

PyThreadState *tstate = _PyThreadState_GET();

return _PyObject_Call(tstate, callable, args, kwargs);

}

PyAPI_FUNC(PyObject *)

PyCFunction_Call(PyObject *callable, PyObject *args, PyObject *kwargs)

{

return PyObject_Call(callable, args, kwargs);

}

PyObject *

PyObject_CallOneArg(PyObject *func, PyObject *arg)

{

EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_API, func);

assert(arg != NULL);

PyObject *_args[2];

PyObject **args = _args + 1; // For PY_VECTORCALL_ARGUMENTS_OFFSET

args[0] = arg;

PyThreadState *tstate = _PyThreadState_GET();

size_t nargsf = 1 | PY_VECTORCALL_ARGUMENTS_OFFSET;

return _PyObject_VectorcallTstate(tstate, func, args, nargsf, NULL);

}

PyObject *

_PyFunction_Vectorcall(PyObject *func, PyObject* const* stack,

size_t nargsf, PyObject *kwnames)

{

assert(PyFunction_Check(func));

PyFunctionObject *f = (PyFunctionObject *)func;

Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);

assert(nargs >= 0);

PyThreadState *tstate = _PyThreadState_GET();

assert(nargs == 0 || stack != NULL);

EVAL_CALL_STAT_INC(EVAL_CALL_FUNCTION_VECTORCALL);

if (((PyCodeObject *)f->func_code)->co_flags & CO_OPTIMIZED) {

return _PyEval_Vector(tstate, f, NULL, stack, nargs, kwnames);

}

else {

return _PyEval_Vector(tstate, f, f->func_globals, stack, nargs, kwnames);

}

}

PyAPI_FUNC(PyObject*)

PyEval_CallObjectWithKeywords(PyObject *callable,

PyObject *args, PyObject *kwargs)

{

PyThreadState *tstate = _PyThreadState_GET();

#ifdef Py_DEBUG

/* PyEval_CallObjectWithKeywords() must not be called with an exception

assert(!_PyErr_Occurred(tstate));

if (args != NULL && !PyTuple_Check(args)) {

_PyErr_SetString(tstate, PyExc_TypeError,

"argument list must be a tuple");

return NULL;

}

if (kwargs != NULL && !PyDict_Check(kwargs)) {

_PyErr_SetString(tstate, PyExc_TypeError,

"keyword list must be a dictionary");

return NULL;

}

if (args == NULL) {

return _PyObject_VectorcallDictTstate(tstate, callable,

NULL, 0, kwargs);

}

else {

return _PyObject_Call(tstate, callable, args, kwargs);

}

}

PyObject *

PyObject_CallObject(PyObject *callable, PyObject *args)

{

PyThreadState *tstate = _PyThreadState_GET();

assert(!_PyErr_Occurred(tstate));

if (args == NULL) {

return _PyObject_CallNoArgsTstate(tstate, callable);

}

if (!PyTuple_Check(args)) {

_PyErr_SetString(tstate, PyExc_TypeError,

"argument list must be a tuple");

return NULL;

}

return _PyObject_Call(tstate, callable, args, NULL);

}

PyObject *

_PyObject_Call_Prepend(PyThreadState *tstate, PyObject *callable,

PyObject *obj, PyObject *args, PyObject *kwargs)

{

assert(PyTuple_Check(args));

PyObject *small_stack[_PY_FASTCALL_SMALL_STACK];

PyObject **stack;

Py_ssize_t argcount = PyTuple_GET_SIZE(args);

if (argcount + 1 <= (Py_ssize_t)Py_ARRAY_LENGTH(small_stack)) {

stack = small_stack;

}

else {

stack = PyMem_Malloc((argcount + 1) * sizeof(PyObject *));

if (stack == NULL) {

PyErr_NoMemory();

return NULL;

}

}

/* use borrowed references */

stack[0] = obj;

memcpy(&stack[1],

_PyTuple_ITEMS(args),

argcount * sizeof(PyObject *));

PyObject *result = _PyObject_VectorcallDictTstate(tstate, callable,

stack, argcount + 1,

kwargs);

if (stack != small_stack) {

PyMem_Free(stack);

}

return result;

}

static PyObject *

_PyObject_CallFunctionVa(PyThreadState *tstate, PyObject *callable,

const char *format, va_list va)

{

PyObject* small_stack[_PY_FASTCALL_SMALL_STACK];

const Py_ssize_t small_stack_len = Py_ARRAY_LENGTH(small_stack);

PyObject **stack;

Py_ssize_t nargs, i;

PyObject *result;

if (callable == NULL) {

return null_error(tstate);

}

if (!format || !*format) {

return _PyObject_CallNoArgsTstate(tstate, callable);

}

stack = _Py_VaBuildStack(small_stack, small_stack_len,

format, va, &nargs);

if (stack == NULL) {

return NULL;

}

EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_API, callable);

if (nargs == 1 && PyTuple_Check(stack[0])) {

/* Special cases for backward compatibility:

PyObject *args = stack[0];

result = _PyObject_VectorcallTstate(tstate, callable,

_PyTuple_ITEMS(args),

PyTuple_GET_SIZE(args),

NULL);

}

else {

result = _PyObject_VectorcallTstate(tstate, callable,

stack, nargs, NULL);

}

for (i = 0; i < nargs; ++i) {

Py_DECREF(stack[i]);

}

if (stack != small_stack) {

PyMem_Free(stack);

}

return result;

}

PyObject *

PyObject_CallFunction(PyObject *callable, const char *format, ...)

{

va_list va;

PyObject *result;

PyThreadState *tstate = _PyThreadState_GET();

va_start(va, format);

result = _PyObject_CallFunctionVa(tstate, callable, format, va);

va_end(va);

return result;

}

PyAPI_FUNC(PyObject*)

PyEval_CallFunction(PyObject *callable, const char *format, ...)

{

va_list va;

PyObject *result;

PyThreadState *tstate = _PyThreadState_GET();

va_start(va, format);

result = _PyObject_CallFunctionVa(tstate, callable, format, va);

va_end(va);

return result;

}

PyAPI_FUNC(PyObject *) /* abi_only */

_PyObject_CallFunction_SizeT(PyObject *callable, const char *format, ...)

{

PyThreadState *tstate = _PyThreadState_GET();

va_list va;

va_start(va, format);

PyObject *result = _PyObject_CallFunctionVa(tstate, callable, format, va);

va_end(va);

return result;

}

static PyObject *

callmethod(PyThreadState *tstate, PyObject *obj, PyObject *name,

const char *format, va_list va)

{

PyObject *result = NULL;

_PyCStackRef self, method;

_PyThreadState_PushCStackRef(tstate, &self);

_PyThreadState_PushCStackRef(tstate, &method);

self.ref = PyStackRef_FromPyObjectBorrow(obj);

int res = _PyObject_GetMethodStackRef(tstate, &self.ref, name, &method.ref);

if (res < 0) {

goto exit;

}

PyObject *callable = PyStackRef_AsPyObjectBorrow(method.ref);

PyObject *self_obj = PyStackRef_AsPyObjectBorrow(self.ref);

if (!PyCallable_Check(callable)) {

_PyErr_Format(tstate, PyExc_TypeError,

"attribute of type '%.200s' is not callable",

Py_TYPE(callable)->tp_name);

goto exit;

}

/* Build the positional arguments from the format string. */

PyObject *small_stack[_PY_FASTCALL_SMALL_STACK];

Py_ssize_t nargs = 0;

PyObject **built = NULL;

if (format != NULL && *format != '\0') {

built = _Py_VaBuildStack(small_stack, _PY_FASTCALL_SMALL_STACK,

format, va, &nargs);

if (built == NULL) {

goto exit;

}

}

/* Backward compat: a single tuple from "O" is unpacked. */

PyObject *const *args = built;

Py_ssize_t n = nargs;

if (nargs == 1 && PyTuple_Check(built[0])) {

args = _PyTuple_ITEMS(built[0]);

n = PyTuple_GET_SIZE(built[0]);

}

if (self_obj != NULL) {

result = _PyObject_VectorcallPrepend(tstate, callable, self_obj, args, n, NULL);

}

else {

result = _PyObject_VectorcallTstate(tstate, callable, args, n, NULL);

}

for (Py_ssize_t i = 0; i < nargs; i++) {

Py_DECREF(built[i]);

}

if (built != small_stack) {

PyMem_Free(built);

}

exit:

_PyThreadState_PopCStackRef(tstate, &method);

_PyThreadState_PopCStackRef(tstate, &self);

return result;

}

PyObject *

PyObject_CallMethod(PyObject *obj, const char *name, const char *format, ...)

{

PyThreadState *tstate = _PyThreadState_GET();

if (obj == NULL || name == NULL) {

return null_error(tstate);

}

PyObject *name_obj = PyUnicode_FromString(name);

if (name_obj == NULL) {

return NULL;

}

va_list va;

va_start(va, format);

PyObject *retval = callmethod(tstate, obj, name_obj, format, va);

va_end(va);

Py_DECREF(name_obj);

return retval;

}

PyAPI_FUNC(PyObject*)

PyEval_CallMethod(PyObject *obj, const char *name, const char *format, ...)

{

PyThreadState *tstate = _PyThreadState_GET();

if (obj == NULL || name == NULL) {

return null_error(tstate);

}

PyObject *name_obj = PyUnicode_FromString(name);

if (name_obj == NULL) {

return NULL;

}

va_list va;

va_start(va, format);

PyObject *retval = callmethod(tstate, obj, name_obj, format, va);

va_end(va);

Py_DECREF(name_obj);

return retval;

}

PyObject *

_PyObject_CallMethod(PyObject *obj, PyObject *name,

const char *format, ...)

{

PyThreadState *tstate = _PyThreadState_GET();

if (obj == NULL || name == NULL) {

return null_error(tstate);

}

va_list va;

va_start(va, format);

PyObject *retval = callmethod(tstate, obj, name, format, va);

va_end(va);

return retval;

}

PyObject *

_PyObject_CallMethodId(PyObject *obj, _Py_Identifier *name,

const char *format, ...)

{

PyThreadState *tstate = _PyThreadState_GET();

if (obj == NULL || name == NULL) {

return null_error(tstate);

}

PyObject *name_obj = _PyUnicode_FromId(name); /* borrowed */

if (name_obj == NULL) {

return NULL;

}

va_list va;

va_start(va, format);

PyObject *retval = callmethod(tstate, obj, name_obj, format, va);

va_end(va);

return retval;

}

PyAPI_FUNC(PyObject *) /* abi_only */

_PyObject_CallMethod_SizeT(PyObject *obj, const char *name,

const char *format, ...)

{

PyThreadState *tstate = _PyThreadState_GET();

if (obj == NULL || name == NULL) {

return null_error(tstate);

}

PyObject *name_obj = PyUnicode_FromString(name);

if (name_obj == NULL) {

return NULL;

}

va_list va;

va_start(va, format);

PyObject *retval = callmethod(tstate, obj, name_obj, format, va);

va_end(va);

Py_DECREF(name_obj);

return retval;

}

static PyObject *

object_vacall(PyThreadState *tstate, PyObject *base,

PyObject *callable, va_list vargs)

{

PyObject *small_stack[_PY_FASTCALL_SMALL_STACK];

PyObject **stack;

Py_ssize_t nargs;

PyObject *result;

Py_ssize_t i;

va_list countva;

if (callable == NULL) {

return null_error(tstate);

}

/* Count the number of arguments */

va_copy(countva, vargs);

nargs = base ? 1 : 0;

while (1) {

PyObject *arg = va_arg(countva, PyObject *);

if (arg == NULL) {

break;

}

nargs++;

}

va_end(countva);

/* Copy arguments */

if (nargs <= (Py_ssize_t)Py_ARRAY_LENGTH(small_stack)) {

stack = small_stack;

}

else {

stack = PyMem_Malloc(nargs * sizeof(stack[0]));

if (stack == NULL) {

PyErr_NoMemory();

return NULL;

}

}

i = 0;

if (base) {

stack[i++] = base;

}

for (; i < nargs; ++i) {

stack[i] = va_arg(vargs, PyObject *);

}

#ifdef Py_STATS

if (PyFunction_Check(callable)) {

EVAL_CALL_STAT_INC(EVAL_CALL_API);

}

/* Call the function */

result = _PyObject_VectorcallTstate(tstate, callable, stack, nargs, NULL);

if (stack != small_stack) {

PyMem_Free(stack);

}

return result;

}

PyObject *

_PyObject_VectorcallPrepend(PyThreadState *tstate, PyObject *callable,

PyObject *arg, PyObject *const *args,

size_t nargsf, PyObject *kwnames)

{

Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);

assert(nargs == 0 || args[nargs-1]);

PyObject *result;

if (nargsf & PY_VECTORCALL_ARGUMENTS_OFFSET) {

/* PY_VECTORCALL_ARGUMENTS_OFFSET is set, so we are allowed to mutate the vector */

PyObject **newargs = (PyObject**)args - 1;

nargs += 1;

PyObject *tmp = newargs[0];

newargs[0] = arg;

assert(newargs[nargs-1]);

result = _PyObject_VectorcallTstate(tstate, callable, newargs,

nargs, kwnames);

newargs[0] = tmp;

}

else {

Py_ssize_t nkwargs = (kwnames == NULL) ? 0 : PyTuple_GET_SIZE(kwnames);

Py_ssize_t totalargs = nargs + nkwargs;

if (totalargs == 0) {

return _PyObject_VectorcallTstate(tstate, callable, &arg, 1, NULL);

}

PyObject *newargs_stack[_PY_FASTCALL_SMALL_STACK];

PyObject **newargs;

if (totalargs <= (Py_ssize_t)Py_ARRAY_LENGTH(newargs_stack) - 1) {

newargs = newargs_stack;

}

else {

newargs = PyMem_Malloc((totalargs+1) * sizeof(PyObject *));

if (newargs == NULL) {

_PyErr_NoMemory(tstate);

return NULL;

}

}

/* use borrowed references */

newargs[0] = arg;

/* bpo-37138: since totalargs > 0, it's impossible that args is NULL.

assert(args != NULL);

memcpy(newargs + 1, args, totalargs * sizeof(PyObject *));

result = _PyObject_VectorcallTstate(tstate, callable,

newargs, nargs+1, kwnames);

if (newargs != newargs_stack) {

PyMem_Free(newargs);

}

}

return result;

}

PyObject *

PyObject_VectorcallMethod(PyObject *name, PyObject *const *args,

size_t nargsf, PyObject *kwnames)

{

assert(name != NULL);

assert(args != NULL);

assert(PyVectorcall_NARGS(nargsf) >= 1);

PyThreadState *tstate = _PyThreadState_GET();

_PyCStackRef self, method;

_PyThreadState_PushCStackRef(tstate, &self);

_PyThreadState_PushCStackRef(tstate, &method);

/* Use args[0] as "self" argument */

self.ref = PyStackRef_FromPyObjectBorrow(args[0]);

int unbound = _PyObject_GetMethodStackRef(tstate, &self.ref, name, &method.ref);

if (unbound < 0) {

_PyThreadState_PopCStackRef(tstate, &method);

_PyThreadState_PopCStackRef(tstate, &self);

return NULL;

}

PyObject *callable = PyStackRef_AsPyObjectBorrow(method.ref);

PyObject *self_obj = PyStackRef_AsPyObjectBorrow(self.ref);

PyObject *result;

EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_METHOD, callable);

if (self_obj == NULL) {

/* Skip "self". We can keep PY_VECTORCALL_ARGUMENTS_OFFSET since

result = _PyObject_VectorcallTstate(tstate, callable,

args + 1, nargsf - 1, kwnames);

}

else if (self_obj == args[0]) {

/* We must remove PY_VECTORCALL_ARGUMENTS_OFFSET since

result = _PyObject_VectorcallTstate(tstate, callable, args,

nargsf & ~PY_VECTORCALL_ARGUMENTS_OFFSET,

kwnames);

}

else {

/* classmethod: self_obj is the type, not args[0]. Replace

result = _PyObject_VectorcallPrepend(tstate, callable, self_obj,

args + 1, nargsf - 1, kwnames);

}

_PyThreadState_PopCStackRef(tstate, &method);

_PyThreadState_PopCStackRef(tstate, &self);

return result;

}

PyObject *

PyObject_CallMethodObjArgs(PyObject *obj, PyObject *name, ...)

{

PyThreadState *tstate = _PyThreadState_GET();

if (obj == NULL || name == NULL) {

return null_error(tstate);

}

_PyCStackRef self, method;

_PyThreadState_PushCStackRef(tstate, &self);

_PyThreadState_PushCStackRef(tstate, &method);

self.ref = PyStackRef_FromPyObjectBorrow(obj);

int res = _PyObject_GetMethodStackRef(tstate, &self.ref, name, &method.ref);

if (res < 0) {

_PyThreadState_PopCStackRef(tstate, &method);

_PyThreadState_PopCStackRef(tstate, &self);

return NULL;

}

PyObject *callable = PyStackRef_AsPyObjectBorrow(method.ref);

PyObject *self_obj = PyStackRef_AsPyObjectBorrow(self.ref);

va_list vargs;

va_start(vargs, name);

PyObject *result = object_vacall(tstate, self_obj, callable, vargs);

va_end(vargs);

_PyThreadState_PopCStackRef(tstate, &method);

_PyThreadState_PopCStackRef(tstate, &self);

return result;

}