mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-05-23 22:02:27 +00:00
Backport METH_FASTCALL from Python 3.7 (#328)
This commit is contained in:
Gautham
GitHub
parent
70c97f598b
commit
cf73bbd678
102 changed files with 2896 additions and 3301 deletions
721
third_party/python/Objects/abstract.c
vendored
721
third_party/python/Objects/abstract.c
vendored
|
|
@ -2190,727 +2190,6 @@ PyMapping_Values(PyObject *o)
|
|||
return fast;
|
||||
}
|
||||
|
||||
/* Operations on callable objects */
|
||||
|
||||
/* XXX PyCallable_Check() is in object.c */
|
||||
|
||||
PyObject *
|
||||
PyObject_CallObject(PyObject *callable, PyObject *args)
|
||||
{
|
||||
return PyEval_CallObjectWithKeywords(callable, args, NULL);
|
||||
}
|
||||
|
||||
PyObject*
|
||||
(_Py_CheckFunctionResult)(PyObject *callable, PyObject *result, const char *where)
|
||||
{
|
||||
int err_occurred = (PyErr_Occurred() != NULL);
|
||||
|
||||
assert((callable != NULL) ^ (where != NULL));
|
||||
|
||||
if (result == NULL) {
|
||||
if (!err_occurred) {
|
||||
if (callable)
|
||||
PyErr_Format(PyExc_SystemError,
|
||||
"%R returned NULL without setting an error",
|
||||
callable);
|
||||
else
|
||||
PyErr_Format(PyExc_SystemError,
|
||||
"%s returned NULL without setting an error",
|
||||
where);
|
||||
#ifdef Py_DEBUG
|
||||
/* Ensure that the bug is caught in debug mode */
|
||||
Py_FatalError("a function returned NULL without setting an error");
|
||||
#endif
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (err_occurred) {
|
||||
Py_DECREF(result);
|
||||
|
||||
if (callable) {
|
||||
_PyErr_FormatFromCause(PyExc_SystemError,
|
||||
"%R returned a result with an error set",
|
||||
callable);
|
||||
}
|
||||
else {
|
||||
_PyErr_FormatFromCause(PyExc_SystemError,
|
||||
"%s returned a result with an error set",
|
||||
where);
|
||||
}
|
||||
#ifdef Py_DEBUG
|
||||
/* Ensure that the bug is caught in debug mode */
|
||||
Py_FatalError("a function returned a result with an error set");
|
||||
#endif
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
PyObject *
|
||||
PyObject_Call(PyObject *callable, PyObject *args, PyObject *kwargs)
|
||||
{
|
||||
ternaryfunc call;
|
||||
PyObject *result;
|
||||
|
||||
/* PyObject_Call() must not be called with an exception set,
|
||||
because it can clear it (directly or indirectly) and so the
|
||||
caller loses its exception */
|
||||
assert(!PyErr_Occurred());
|
||||
assert(PyTuple_Check(args));
|
||||
assert(kwargs == NULL || PyDict_Check(kwargs));
|
||||
|
||||
if (PyFunction_Check(callable)) {
|
||||
return _PyFunction_FastCallDict(callable,
|
||||
&PyTuple_GET_ITEM(args, 0),
|
||||
PyTuple_GET_SIZE(args),
|
||||
kwargs);
|
||||
}
|
||||
else if (PyCFunction_Check(callable)) {
|
||||
return PyCFunction_Call(callable, args, kwargs);
|
||||
}
|
||||
else {
|
||||
call = callable->ob_type->tp_call;
|
||||
if (call == NULL) {
|
||||
PyErr_Format(PyExc_TypeError, "'%.200s' object is not callable",
|
||||
callable->ob_type->tp_name);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (Py_EnterRecursiveCall(" while calling a Python object"))
|
||||
return NULL;
|
||||
|
||||
result = (*call)(callable, args, kwargs);
|
||||
|
||||
Py_LeaveRecursiveCall();
|
||||
|
||||
return _Py_CheckFunctionResult(callable, result, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
/* Issue #29234: Inlining _PyStack_AsTuple() into callers increases their
|
||||
stack consumption, Disable inlining to optimize the stack consumption. */
|
||||
PyObject* dontinline
|
||||
_PyStack_AsTuple(PyObject **stack, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *args;
|
||||
Py_ssize_t i;
|
||||
|
||||
args = PyTuple_New(nargs);
|
||||
if (args == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (i=0; i < nargs; i++) {
|
||||
PyObject *item = stack[i];
|
||||
Py_INCREF(item);
|
||||
PyTuple_SET_ITEM(args, i, item);
|
||||
}
|
||||
|
||||
return args;
|
||||
}
|
||||
|
||||
PyObject*
|
||||
_PyStack_AsTupleSlice(PyObject **stack, Py_ssize_t nargs,
|
||||
Py_ssize_t start, Py_ssize_t end)
|
||||
{
|
||||
PyObject *args;
|
||||
Py_ssize_t i;
|
||||
|
||||
assert(0 <= start);
|
||||
assert(end <= nargs);
|
||||
assert(start <= end);
|
||||
|
||||
args = PyTuple_New(end - start);
|
||||
if (args == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (i=start; i < end; i++) {
|
||||
PyObject *item = stack[i];
|
||||
Py_INCREF(item);
|
||||
PyTuple_SET_ITEM(args, i - start, item);
|
||||
}
|
||||
return args;
|
||||
}
|
||||
|
||||
PyObject *
|
||||
_PyObject_FastCallDict(PyObject *callable, PyObject **args, Py_ssize_t nargs,
|
||||
PyObject *kwargs)
|
||||
{
|
||||
/* _PyObject_FastCallDict() must not be called with an exception set,
|
||||
because it can clear it (directly or indirectly) and so the
|
||||
caller loses its exception */
|
||||
assert(!PyErr_Occurred());
|
||||
|
||||
assert(callable != NULL);
|
||||
assert(nargs >= 0);
|
||||
assert(nargs == 0 || args != NULL);
|
||||
assert(kwargs == NULL || PyDict_Check(kwargs));
|
||||
|
||||
if (PyFunction_Check(callable)) {
|
||||
return _PyFunction_FastCallDict(callable, args, nargs, kwargs);
|
||||
}
|
||||
else if (PyCFunction_Check(callable)) {
|
||||
return _PyCFunction_FastCallDict(callable, args, nargs, kwargs);
|
||||
}
|
||||
else {
|
||||
PyObject *argstuple, *result;
|
||||
ternaryfunc call;
|
||||
|
||||
/* Slow-path: build a temporary tuple */
|
||||
call = callable->ob_type->tp_call;
|
||||
if (call == NULL) {
|
||||
PyErr_Format(PyExc_TypeError, "'%.200s' object is not callable",
|
||||
callable->ob_type->tp_name);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
argstuple = _PyStack_AsTuple(args, nargs);
|
||||
if (argstuple == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (Py_EnterRecursiveCall(" while calling a Python object")) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
result = (*call)(callable, argstuple, kwargs);
|
||||
|
||||
Py_LeaveRecursiveCall();
|
||||
|
||||
Py_DECREF(argstuple);
|
||||
result = _Py_CheckFunctionResult(callable, result, NULL);
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
/* Positional arguments are obj followed by args:
|
||||
call callable(obj, *args, **kwargs) */
|
||||
PyObject *
|
||||
_PyObject_FastCall_Prepend(PyObject *callable,
|
||||
PyObject *obj, PyObject **args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *small_stack[_PY_FASTCALL_SMALL_STACK];
|
||||
PyObject **args2;
|
||||
PyObject *result;
|
||||
|
||||
nargs++;
|
||||
if (nargs <= (Py_ssize_t)Py_ARRAY_LENGTH(small_stack)) {
|
||||
args2 = small_stack;
|
||||
}
|
||||
else {
|
||||
args2 = PyMem_Malloc(nargs * sizeof(PyObject *));
|
||||
if (args2 == NULL) {
|
||||
PyErr_NoMemory();
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* use borrowed references */
|
||||
args2[0] = obj;
|
||||
if (nargs > 1) {
|
||||
memcpy(&args2[1],
|
||||
args,
|
||||
(nargs - 1)* sizeof(PyObject *));
|
||||
}
|
||||
|
||||
result = _PyObject_FastCall(callable, args2, nargs);
|
||||
if (args2 != small_stack) {
|
||||
PyMem_Free(args2);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/* Call callable(obj, *args, **kwargs). */
|
||||
PyObject *
|
||||
_PyObject_Call_Prepend(PyObject *callable,
|
||||
PyObject *obj, PyObject *args, PyObject *kwargs)
|
||||
{
|
||||
PyObject *small_stack[_PY_FASTCALL_SMALL_STACK];
|
||||
PyObject **stack;
|
||||
Py_ssize_t argcount;
|
||||
PyObject *result;
|
||||
|
||||
assert(PyTuple_Check(args));
|
||||
|
||||
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_GET_ITEM(args, 0),
|
||||
argcount * sizeof(PyObject *));
|
||||
|
||||
result = _PyObject_FastCallDict(callable,
|
||||
stack, argcount + 1,
|
||||
kwargs);
|
||||
if (stack != small_stack) {
|
||||
PyMem_Free(stack);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
PyObject *
|
||||
_PyStack_AsDict(PyObject **values, PyObject *kwnames)
|
||||
{
|
||||
Py_ssize_t nkwargs;
|
||||
PyObject *kwdict;
|
||||
Py_ssize_t i;
|
||||
|
||||
assert(kwnames != NULL);
|
||||
nkwargs = PyTuple_GET_SIZE(kwnames);
|
||||
kwdict = _PyDict_NewPresized(nkwargs);
|
||||
if (kwdict == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (i = 0; i < nkwargs; i++) {
|
||||
PyObject *key = PyTuple_GET_ITEM(kwnames, i);
|
||||
PyObject *value = *values++;
|
||||
if (PyDict_SetItem(kwdict, key, value)) {
|
||||
Py_DECREF(kwdict);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
return kwdict;
|
||||
}
|
||||
|
||||
int
|
||||
_PyStack_UnpackDict(PyObject **args, Py_ssize_t nargs, PyObject *kwargs,
|
||||
PyObject ***p_stack, PyObject **p_kwnames)
|
||||
{
|
||||
PyObject **stack, **kwstack;
|
||||
Py_ssize_t nkwargs;
|
||||
Py_ssize_t pos, i;
|
||||
PyObject *key, *value;
|
||||
PyObject *kwnames;
|
||||
|
||||
assert(nargs >= 0);
|
||||
assert(kwargs == NULL || PyDict_CheckExact(kwargs));
|
||||
|
||||
if (kwargs == NULL || (nkwargs = PyDict_GET_SIZE(kwargs)) == 0) {
|
||||
*p_stack = args;
|
||||
*p_kwnames = NULL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if ((size_t)nargs > PY_SSIZE_T_MAX / sizeof(stack[0]) - (size_t)nkwargs) {
|
||||
PyErr_NoMemory();
|
||||
return -1;
|
||||
}
|
||||
|
||||
stack = PyMem_Malloc((nargs + nkwargs) * sizeof(stack[0]));
|
||||
if (stack == NULL) {
|
||||
PyErr_NoMemory();
|
||||
return -1;
|
||||
}
|
||||
|
||||
kwnames = PyTuple_New(nkwargs);
|
||||
if (kwnames == NULL) {
|
||||
PyMem_Free(stack);
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Copy position arguments (borrowed references) */
|
||||
memcpy(stack, args, nargs * sizeof(stack[0]));
|
||||
|
||||
kwstack = stack + nargs;
|
||||
pos = i = 0;
|
||||
/* This loop doesn't support lookup function mutating the dictionary
|
||||
to change its size. It's a deliberate choice for speed, this function is
|
||||
called in the performance critical hot code. */
|
||||
while (PyDict_Next(kwargs, &pos, &key, &value)) {
|
||||
Py_INCREF(key);
|
||||
PyTuple_SET_ITEM(kwnames, i, key);
|
||||
/* The stack contains borrowed references */
|
||||
kwstack[i] = value;
|
||||
i++;
|
||||
}
|
||||
|
||||
*p_stack = stack;
|
||||
*p_kwnames = kwnames;
|
||||
return 0;
|
||||
}
|
||||
|
||||
PyObject *
|
||||
_PyObject_FastCallKeywords(PyObject *callable, PyObject **stack, Py_ssize_t nargs,
|
||||
PyObject *kwnames)
|
||||
{
|
||||
/* _PyObject_FastCallKeywords() must not be called with an exception set,
|
||||
because it can clear it (directly or indirectly) and so the
|
||||
caller loses its exception */
|
||||
assert(!PyErr_Occurred());
|
||||
|
||||
assert(nargs >= 0);
|
||||
assert(kwnames == NULL || PyTuple_CheckExact(kwnames));
|
||||
|
||||
/* kwnames must only contains str strings, no subclass, and all keys must
|
||||
be unique: these checks are implemented in Python/ceval.c and
|
||||
_PyArg_ParseStackAndKeywords(). */
|
||||
|
||||
if (PyFunction_Check(callable)) {
|
||||
return _PyFunction_FastCallKeywords(callable, stack, nargs, kwnames);
|
||||
}
|
||||
if (PyCFunction_Check(callable)) {
|
||||
return _PyCFunction_FastCallKeywords(callable, stack, nargs, kwnames);
|
||||
}
|
||||
else {
|
||||
/* Slow-path: build a temporary tuple for positional arguments and a
|
||||
temporary dictionary for keyword arguments (if any) */
|
||||
|
||||
ternaryfunc call;
|
||||
PyObject *argstuple;
|
||||
PyObject *kwdict, *result;
|
||||
Py_ssize_t nkwargs;
|
||||
|
||||
nkwargs = (kwnames == NULL) ? 0 : PyTuple_GET_SIZE(kwnames);
|
||||
assert((nargs == 0 && nkwargs == 0) || stack != NULL);
|
||||
|
||||
call = callable->ob_type->tp_call;
|
||||
if (call == NULL) {
|
||||
PyErr_Format(PyExc_TypeError, "'%.200s' object is not callable",
|
||||
callable->ob_type->tp_name);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
argstuple = _PyStack_AsTuple(stack, nargs);
|
||||
if (argstuple == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (nkwargs > 0) {
|
||||
kwdict = _PyStack_AsDict(stack + nargs, kwnames);
|
||||
if (kwdict == NULL) {
|
||||
Py_DECREF(argstuple);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
else {
|
||||
kwdict = NULL;
|
||||
}
|
||||
|
||||
if (Py_EnterRecursiveCall(" while calling a Python object")) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
result = (*call)(callable, argstuple, kwdict);
|
||||
|
||||
Py_LeaveRecursiveCall();
|
||||
|
||||
Py_DECREF(argstuple);
|
||||
Py_XDECREF(kwdict);
|
||||
|
||||
result = _Py_CheckFunctionResult(callable, result, NULL);
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
_PyObject_CallFunctionVa(PyObject *callable, const char *format,
|
||||
va_list va, int is_size_t)
|
||||
{
|
||||
PyObject* small_stack[5];
|
||||
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();
|
||||
}
|
||||
|
||||
if (!format || !*format) {
|
||||
return _PyObject_CallNoArg(callable);
|
||||
}
|
||||
|
||||
if (is_size_t) {
|
||||
stack = _Py_VaBuildStack_SizeT(small_stack, small_stack_len, format, va, &nargs);
|
||||
}
|
||||
else {
|
||||
stack = _Py_VaBuildStack(small_stack, small_stack_len, format, va, &nargs);
|
||||
}
|
||||
if (stack == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (nargs == 1 && PyTuple_Check(stack[0])) {
|
||||
/* Special cases for backward compatibility:
|
||||
- PyObject_CallFunction(func, "O", tuple) calls func(*tuple)
|
||||
- PyObject_CallFunction(func, "(OOO)", arg1, arg2, arg3) calls
|
||||
func(*(arg1, arg2, arg3)): func(arg1, arg2, arg3) */
|
||||
PyObject *args = stack[0];
|
||||
result = _PyObject_FastCall(callable,
|
||||
&PyTuple_GET_ITEM(args, 0),
|
||||
PyTuple_GET_SIZE(args));
|
||||
}
|
||||
else {
|
||||
result = _PyObject_FastCall(callable, stack, nargs);
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
va_start(va, format);
|
||||
result = _PyObject_CallFunctionVa(callable, format, va, 0);
|
||||
va_end(va);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
PyObject *
|
||||
_PyObject_CallFunction_SizeT(PyObject *callable, const char *format, ...)
|
||||
{
|
||||
va_list va;
|
||||
PyObject *result;
|
||||
|
||||
va_start(va, format);
|
||||
result = _PyObject_CallFunctionVa(callable, format, va, 1);
|
||||
va_end(va);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static PyObject*
|
||||
callmethod(PyObject* callable, const char *format, va_list va, int is_size_t)
|
||||
{
|
||||
assert(callable != NULL);
|
||||
|
||||
if (!PyCallable_Check(callable)) {
|
||||
type_error("attribute of type '%.200s' is not callable", callable);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return _PyObject_CallFunctionVa(callable, format, va, is_size_t);
|
||||
}
|
||||
|
||||
PyObject *
|
||||
PyObject_CallMethod(PyObject *obj, const char *name, const char *format, ...)
|
||||
{
|
||||
va_list va;
|
||||
PyObject *callable, *retval;
|
||||
|
||||
if (obj == NULL || name == NULL) {
|
||||
return null_error();
|
||||
}
|
||||
|
||||
callable = PyObject_GetAttrString(obj, name);
|
||||
if (callable == NULL)
|
||||
return NULL;
|
||||
|
||||
va_start(va, format);
|
||||
retval = callmethod(callable, format, va, 0);
|
||||
va_end(va);
|
||||
|
||||
Py_DECREF(callable);
|
||||
return retval;
|
||||
}
|
||||
|
||||
PyObject *
|
||||
_PyObject_CallMethodId(PyObject *obj, _Py_Identifier *name,
|
||||
const char *format, ...)
|
||||
{
|
||||
va_list va;
|
||||
PyObject *callable, *retval;
|
||||
|
||||
if (obj == NULL || name == NULL) {
|
||||
return null_error();
|
||||
}
|
||||
|
||||
callable = _PyObject_GetAttrId(obj, name);
|
||||
if (callable == NULL)
|
||||
return NULL;
|
||||
|
||||
va_start(va, format);
|
||||
retval = callmethod(callable, format, va, 0);
|
||||
va_end(va);
|
||||
|
||||
Py_DECREF(callable);
|
||||
return retval;
|
||||
}
|
||||
|
||||
PyObject *
|
||||
_PyObject_CallMethod_SizeT(PyObject *obj, const char *name,
|
||||
const char *format, ...)
|
||||
{
|
||||
va_list va;
|
||||
PyObject *callable, *retval;
|
||||
|
||||
if (obj == NULL || name == NULL) {
|
||||
return null_error();
|
||||
}
|
||||
|
||||
callable = PyObject_GetAttrString(obj, name);
|
||||
if (callable == NULL)
|
||||
return NULL;
|
||||
|
||||
va_start(va, format);
|
||||
retval = callmethod(callable, format, va, 1);
|
||||
va_end(va);
|
||||
|
||||
Py_DECREF(callable);
|
||||
return retval;
|
||||
}
|
||||
|
||||
PyObject *
|
||||
_PyObject_CallMethodId_SizeT(PyObject *obj, _Py_Identifier *name,
|
||||
const char *format, ...)
|
||||
{
|
||||
va_list va;
|
||||
PyObject *callable, *retval;
|
||||
|
||||
if (obj == NULL || name == NULL) {
|
||||
return null_error();
|
||||
}
|
||||
|
||||
callable = _PyObject_GetAttrId(obj, name);
|
||||
if (callable == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
va_start(va, format);
|
||||
retval = callmethod(callable, format, va, 1);
|
||||
va_end(va);
|
||||
|
||||
Py_DECREF(callable);
|
||||
return retval;
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
object_vacall(PyObject *callable, va_list vargs)
|
||||
{
|
||||
PyObject *small_stack[5];
|
||||
PyObject **stack;
|
||||
Py_ssize_t nargs;
|
||||
PyObject *result;
|
||||
Py_ssize_t i;
|
||||
va_list countva;
|
||||
|
||||
if (callable == NULL) {
|
||||
return null_error();
|
||||
}
|
||||
|
||||
/* Count the number of arguments */
|
||||
va_copy(countva, vargs);
|
||||
nargs = 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;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < nargs; ++i) {
|
||||
stack[i] = va_arg(vargs, PyObject *);
|
||||
}
|
||||
|
||||
/* Call the function */
|
||||
result = _PyObject_FastCall(callable, stack, nargs);
|
||||
|
||||
if (stack != small_stack) {
|
||||
PyMem_Free(stack);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
PyObject *
|
||||
PyObject_CallMethodObjArgs(PyObject *callable, PyObject *name, ...)
|
||||
{
|
||||
va_list vargs;
|
||||
PyObject *result;
|
||||
|
||||
if (callable == NULL || name == NULL) {
|
||||
return null_error();
|
||||
}
|
||||
|
||||
callable = PyObject_GetAttr(callable, name);
|
||||
if (callable == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
va_start(vargs, name);
|
||||
result = object_vacall(callable, vargs);
|
||||
va_end(vargs);
|
||||
|
||||
Py_DECREF(callable);
|
||||
return result;
|
||||
}
|
||||
|
||||
PyObject *
|
||||
_PyObject_CallMethodIdObjArgs(PyObject *obj,
|
||||
struct _Py_Identifier *name, ...)
|
||||
{
|
||||
va_list vargs;
|
||||
PyObject *callable, *result;
|
||||
|
||||
if (obj == NULL || name == NULL) {
|
||||
return null_error();
|
||||
}
|
||||
|
||||
callable = _PyObject_GetAttrId(obj, name);
|
||||
if (callable == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
va_start(vargs, name);
|
||||
result = object_vacall(callable, vargs);
|
||||
va_end(vargs);
|
||||
|
||||
Py_DECREF(callable);
|
||||
return result;
|
||||
}
|
||||
|
||||
PyObject *
|
||||
PyObject_CallFunctionObjArgs(PyObject *callable, ...)
|
||||
{
|
||||
va_list vargs;
|
||||
PyObject *result;
|
||||
|
||||
va_start(vargs, callable);
|
||||
result = object_vacall(callable, vargs);
|
||||
va_end(vargs);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/* isinstance(), issubclass() */
|
||||
|
||||
/* abstract_get_bases() has logically 4 return states:
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue