changeset: 105478:d8b2b205270c tag: tip user: Victor Stinner date: Tue Dec 06 12:05:43 2016 +0100 files: Doc/c-api/object.rst Include/abstract.h Include/ceval.h Objects/abstract.c Objects/typeobject.c Python/ceval.c Python/modsupport.c description: Issue #28838: Rename parameters of "call" functions * Rename "callable_object" and "func" to "callable" * Rename "o" to "obj" * Rename "method_name" to "name" diff -r 9db231dd0b73 -r d8b2b205270c Doc/c-api/object.rst --- a/Doc/c-api/object.rst Tue Dec 06 11:02:54 2016 +0100 +++ b/Doc/c-api/object.rst Tue Dec 06 12:05:43 2016 +0100 @@ -244,22 +244,22 @@ Object Protocol and ``0`` otherwise. This function always succeeds. -.. c:function:: PyObject* PyObject_Call(PyObject *callable_object, PyObject *args, PyObject *kw) +.. c:function:: PyObject* PyObject_Call(PyObject *callable, PyObject *args, PyObject *kw) - Call a callable Python object *callable_object*, with arguments given by the + Call a callable Python object *callable*, with arguments given by the tuple *args*, and named arguments given by the dictionary *kw*. If no named arguments are needed, *kw* may be *NULL*. *args* must not be *NULL*, use an empty tuple if no arguments are needed. Returns the result of the call on success, or *NULL* on failure. This is the equivalent of the Python expression - ``callable_object(*args, **kw)``. + ``callable(*args, **kw)``. -.. c:function:: PyObject* PyObject_CallObject(PyObject *callable_object, PyObject *args) +.. c:function:: PyObject* PyObject_CallObject(PyObject *callable, PyObject *args) - Call a callable Python object *callable_object*, with arguments given by the + Call a callable Python object *callable*, with arguments given by the tuple *args*. If no arguments are needed, then *args* may be *NULL*. Returns the result of the call on success, or *NULL* on failure. This is the equivalent - of the Python expression ``callable_object(*args)``. + of the Python expression ``callable(*args)``. .. c:function:: PyObject* PyObject_CallFunction(PyObject *callable, const char *format, ...) @@ -276,18 +276,18 @@ Object Protocol The type of *format* was changed from ``char *``. -.. c:function:: PyObject* PyObject_CallMethod(PyObject *o, const char *method, const char *format, ...) +.. c:function:: PyObject* PyObject_CallMethod(PyObject *obj, const char *name, const char *format, ...) - Call the method named *method* of object *o* with a variable number of C + Call the method named *name* of object *obj* with a variable number of C arguments. The C arguments are described by a :c:func:`Py_BuildValue` format string that should produce a tuple. The format may be *NULL*, indicating that no arguments are provided. Returns the result of the call on success, or *NULL* - on failure. This is the equivalent of the Python expression ``o.method(args)``. + on failure. This is the equivalent of the Python expression ``obj.name(args)``. Note that if you only pass :c:type:`PyObject \*` args, :c:func:`PyObject_CallMethodObjArgs` is a faster alternative. .. versionchanged:: 3.4 - The types of *method* and *format* were changed from ``char *``. + The types of *name* and *format* were changed from ``char *``. .. c:function:: PyObject* PyObject_CallFunctionObjArgs(PyObject *callable, ..., NULL) @@ -298,9 +298,9 @@ Object Protocol *NULL* on failure. -.. c:function:: PyObject* PyObject_CallMethodObjArgs(PyObject *o, PyObject *name, ..., NULL) +.. c:function:: PyObject* PyObject_CallMethodObjArgs(PyObject *obj, PyObject *name, ..., NULL) - Calls a method of the object *o*, where the name of the method is given as a + Calls a method of the Python object *obj*, where the name of the method is given as a Python string object in *name*. It is called with a variable number of :c:type:`PyObject\*` arguments. The arguments are provided as a variable number of parameters followed by *NULL*. Returns the result of the call on success, or diff -r 9db231dd0b73 -r d8b2b205270c Include/abstract.h --- a/Include/abstract.h Tue Dec 06 11:02:54 2016 +0100 +++ b/Include/abstract.h Tue Dec 06 12:05:43 2016 +0100 @@ -265,7 +265,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx This function always succeeds. */ - PyAPI_FUNC(PyObject *) PyObject_Call(PyObject *callable_object, + PyAPI_FUNC(PyObject *) PyObject_Call(PyObject *callable, PyObject *args, PyObject *kwargs); #ifndef Py_LIMITED_API @@ -300,7 +300,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx PyObject **kwnames, PyObject *func); - /* Call the callable object func with the "fast call" calling convention: + /* Call the callable object 'callable' with the "fast call" calling convention: args is a C array for positional arguments (nargs is the number of positional arguments), kwargs is a dictionary for keyword arguments. @@ -309,11 +309,11 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx Return the result on success. Raise an exception on return NULL on error. */ - PyAPI_FUNC(PyObject *) _PyObject_FastCallDict(PyObject *func, + PyAPI_FUNC(PyObject *) _PyObject_FastCallDict(PyObject *callable, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); - /* Call the callable object func with the "fast call" calling convention: + /* Call the callable object 'callable' with the "fast call" calling convention: args is a C array for positional arguments followed by values of keyword arguments. Keys of keyword arguments are stored as a tuple of strings in kwnames. nargs is the number of positional parameters at @@ -329,7 +329,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx Return the result on success. Raise an exception and return NULL on error. */ PyAPI_FUNC(PyObject *) _PyObject_FastCallKeywords - (PyObject *func, + (PyObject *callable, PyObject **args, Py_ssize_t nargs, PyObject *kwnames); @@ -340,11 +340,11 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx #define _PyObject_CallNoArg(func) \ _PyObject_FastCallDict((func), NULL, 0, NULL) - PyAPI_FUNC(PyObject *) _PyObject_Call_Prepend(PyObject *func, + PyAPI_FUNC(PyObject *) _PyObject_Call_Prepend(PyObject *callable, PyObject *obj, PyObject *args, PyObject *kwargs); - PyAPI_FUNC(PyObject *) _Py_CheckFunctionResult(PyObject *func, + PyAPI_FUNC(PyObject *) _Py_CheckFunctionResult(PyObject *callable, PyObject *result, const char *where); #endif /* Py_LIMITED_API */ @@ -355,18 +355,18 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx NULL. */ - PyAPI_FUNC(PyObject *) PyObject_CallObject(PyObject *callable_object, + PyAPI_FUNC(PyObject *) PyObject_CallObject(PyObject *callable, PyObject *args); /* - Call a callable Python object, callable_object, with + Call a callable Python object, callable, with arguments given by the tuple, args. If no arguments are needed, then args may be NULL. Returns the result of the call on success, or NULL on failure. This is the equivalent of the Python expression: o(*args). */ - PyAPI_FUNC(PyObject *) PyObject_CallFunction(PyObject *callable_object, + PyAPI_FUNC(PyObject *) PyObject_CallFunction(PyObject *callable, const char *format, ...); /* @@ -379,22 +379,22 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx */ - PyAPI_FUNC(PyObject *) PyObject_CallMethod(PyObject *o, - const char *method, + PyAPI_FUNC(PyObject *) PyObject_CallMethod(PyObject *obj, + const char *name, const char *format, ...); /* - Call the method named m of object o with a variable number of + Call the method named 'name' of object 'obj' with a variable number of C arguments. The C arguments are described by a mkvalue format string. The format may be NULL, indicating that no arguments are provided. Returns the result of the call on success, or NULL on failure. This is the equivalent of the - Python expression: o.method(args). + Python expression: obj.method(args). */ #ifndef Py_LIMITED_API - PyAPI_FUNC(PyObject *) _PyObject_CallMethodId(PyObject *o, - _Py_Identifier *method, + PyAPI_FUNC(PyObject *) _PyObject_CallMethodId(PyObject *obj, + _Py_Identifier *name, const char *format, ...); /* @@ -406,15 +406,15 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx PyAPI_FUNC(PyObject *) _PyObject_CallFunction_SizeT(PyObject *callable, const char *format, ...); - PyAPI_FUNC(PyObject *) _PyObject_CallMethod_SizeT(PyObject *o, + PyAPI_FUNC(PyObject *) _PyObject_CallMethod_SizeT(PyObject *obj, const char *name, const char *format, ...); #ifndef Py_LIMITED_API - PyAPI_FUNC(PyObject *) _PyObject_CallMethodId_SizeT(PyObject *o, - _Py_Identifier *name, - const char *format, - ...); + PyAPI_FUNC(PyObject *) _PyObject_CallMethodId_SizeT(PyObject *obj, + _Py_Identifier *name, + const char *format, + ...); #endif /* !Py_LIMITED_API */ PyAPI_FUNC(PyObject *) PyObject_CallFunctionObjArgs(PyObject *callable, @@ -429,11 +429,12 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx */ - PyAPI_FUNC(PyObject *) PyObject_CallMethodObjArgs(PyObject *o, - PyObject *method, ...); + PyAPI_FUNC(PyObject *) PyObject_CallMethodObjArgs(PyObject *obj, + PyObject *name, + ...); #ifndef Py_LIMITED_API - PyAPI_FUNC(PyObject *) _PyObject_CallMethodIdObjArgs(PyObject *o, - struct _Py_Identifier *method, + PyAPI_FUNC(PyObject *) _PyObject_CallMethodIdObjArgs(PyObject *obj, + struct _Py_Identifier *name, ...); #endif /* !Py_LIMITED_API */ diff -r 9db231dd0b73 -r d8b2b205270c Include/ceval.h --- a/Include/ceval.h Tue Dec 06 11:02:54 2016 +0100 +++ b/Include/ceval.h Tue Dec 06 12:05:43 2016 +0100 @@ -8,16 +8,18 @@ extern "C" { /* Interface to random parts in ceval.c */ PyAPI_FUNC(PyObject *) PyEval_CallObjectWithKeywords( - PyObject *func, PyObject *args, PyObject *kwargs); + PyObject *callable, + PyObject *args, + PyObject *kwargs); /* Inline this */ -#define PyEval_CallObject(func,arg) \ - PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL) +#define PyEval_CallObject(callable, arg) \ + PyEval_CallObjectWithKeywords(callable, arg, (PyObject *)NULL) -PyAPI_FUNC(PyObject *) PyEval_CallFunction(PyObject *obj, +PyAPI_FUNC(PyObject *) PyEval_CallFunction(PyObject *callable, const char *format, ...); PyAPI_FUNC(PyObject *) PyEval_CallMethod(PyObject *obj, - const char *methodname, + const char *name, const char *format, ...); #ifndef Py_LIMITED_API diff -r 9db231dd0b73 -r d8b2b205270c Objects/abstract.c --- a/Objects/abstract.c Tue Dec 06 11:02:54 2016 +0100 +++ b/Objects/abstract.c Tue Dec 06 12:05:43 2016 +0100 @@ -2173,24 +2173,24 @@ PyMapping_Values(PyObject *o) /* XXX PyCallable_Check() is in object.c */ PyObject * -PyObject_CallObject(PyObject *o, PyObject *a) +PyObject_CallObject(PyObject *callable, PyObject *args) { - return PyEval_CallObjectWithKeywords(o, a, NULL); + return PyEval_CallObjectWithKeywords(callable, args, NULL); } PyObject* -_Py_CheckFunctionResult(PyObject *func, PyObject *result, const char *where) +_Py_CheckFunctionResult(PyObject *callable, PyObject *result, const char *where) { int err_occurred = (PyErr_Occurred() != NULL); - assert((func != NULL) ^ (where != NULL)); + assert((callable != NULL) ^ (where != NULL)); if (result == NULL) { if (!err_occurred) { - if (func) + if (callable) PyErr_Format(PyExc_SystemError, "%R returned NULL without setting an error", - func); + callable); else PyErr_Format(PyExc_SystemError, "%s returned NULL without setting an error", @@ -2206,10 +2206,10 @@ PyObject* if (err_occurred) { Py_DECREF(result); - if (func) { + if (callable) { _PyErr_FormatFromCause(PyExc_SystemError, "%R returned a result with an error set", - func); + callable); } else { _PyErr_FormatFromCause(PyExc_SystemError, @@ -2227,7 +2227,7 @@ PyObject* } PyObject * -PyObject_Call(PyObject *func, PyObject *args, PyObject *kwargs) +PyObject_Call(PyObject *callable, PyObject *args, PyObject *kwargs) { ternaryfunc call; PyObject *result; @@ -2239,21 +2239,21 @@ PyObject_Call(PyObject *func, PyObject * assert(PyTuple_Check(args)); assert(kwargs == NULL || PyDict_Check(kwargs)); - call = func->ob_type->tp_call; + call = callable->ob_type->tp_call; if (call == NULL) { PyErr_Format(PyExc_TypeError, "'%.200s' object is not callable", - func->ob_type->tp_name); + callable->ob_type->tp_name); return NULL; } if (Py_EnterRecursiveCall(" while calling a Python object")) return NULL; - result = (*call)(func, args, kwargs); + result = (*call)(callable, args, kwargs); Py_LeaveRecursiveCall(); - return _Py_CheckFunctionResult(func, result, NULL); + return _Py_CheckFunctionResult(callable, result, NULL); } PyObject* @@ -2277,7 +2277,7 @@ PyObject* } PyObject * -_PyObject_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, +_PyObject_FastCallDict(PyObject *callable, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { ternaryfunc call; @@ -2288,7 +2288,7 @@ PyObject * caller loses its exception */ assert(!PyErr_Occurred()); - assert(func != NULL); + assert(callable != NULL); assert(nargs >= 0); assert(nargs == 0 || args != NULL); assert(kwargs == NULL || PyDict_Check(kwargs)); @@ -2297,20 +2297,20 @@ PyObject * return NULL; } - if (PyFunction_Check(func)) { - result = _PyFunction_FastCallDict(func, args, nargs, kwargs); + if (PyFunction_Check(callable)) { + result = _PyFunction_FastCallDict(callable, args, nargs, kwargs); } - else if (PyCFunction_Check(func)) { - result = _PyCFunction_FastCallDict(func, args, nargs, kwargs); + else if (PyCFunction_Check(callable)) { + result = _PyCFunction_FastCallDict(callable, args, nargs, kwargs); } else { PyObject *tuple; /* Slow-path: build a temporary tuple */ - call = func->ob_type->tp_call; + call = callable->ob_type->tp_call; if (call == NULL) { PyErr_Format(PyExc_TypeError, "'%.200s' object is not callable", - func->ob_type->tp_name); + callable->ob_type->tp_name); goto exit; } @@ -2319,10 +2319,10 @@ PyObject * goto exit; } - result = (*call)(func, tuple, kwargs); + result = (*call)(callable, tuple, kwargs); Py_DECREF(tuple); - result = _Py_CheckFunctionResult(func, result, NULL); + result = _Py_CheckFunctionResult(callable, result, NULL); } exit: @@ -2331,9 +2331,10 @@ exit: return result; } -/* Positional arguments are obj followed args. */ +/* Positional arguments are obj followed args: + call callable(obj, *args, **kwargs) */ PyObject * -_PyObject_Call_Prepend(PyObject *func, +_PyObject_Call_Prepend(PyObject *callable, PyObject *obj, PyObject *args, PyObject *kwargs) { PyObject *small_stack[8]; @@ -2361,7 +2362,7 @@ PyObject * &PyTuple_GET_ITEM(args, 0), argcount * sizeof(PyObject *)); - result = _PyObject_FastCallDict(func, + result = _PyObject_FastCallDict(callable, stack, argcount + 1, kwargs); if (stack != small_stack) { @@ -2452,7 +2453,7 @@ PyObject ** } PyObject * -_PyObject_FastCallKeywords(PyObject *func, PyObject **stack, Py_ssize_t nargs, +_PyObject_FastCallKeywords(PyObject *callable, PyObject **stack, Py_ssize_t nargs, PyObject *kwnames) { PyObject *kwdict, *result; @@ -2465,12 +2466,12 @@ PyObject * be unique: these are implemented in Python/ceval.c and _PyArg_ParseStack(). */ - if (PyFunction_Check(func)) { - return _PyFunction_FastCallKeywords(func, stack, nargs, kwnames); + if (PyFunction_Check(callable)) { + return _PyFunction_FastCallKeywords(callable, stack, nargs, kwnames); } - if (PyCFunction_Check(func)) { - return _PyCFunction_FastCallKeywords(func, stack, nargs, kwnames); + if (PyCFunction_Check(callable)) { + return _PyCFunction_FastCallKeywords(callable, stack, nargs, kwnames); } if (nkwargs > 0) { @@ -2483,7 +2484,7 @@ PyObject * kwdict = NULL; } - result = _PyObject_FastCallDict(func, stack, nargs, kwdict); + result = _PyObject_FastCallDict(callable, stack, nargs, kwdict); Py_XDECREF(kwdict); return result; } @@ -2558,19 +2559,19 @@ PyObject * } static PyObject* -callmethod(PyObject* func, const char *format, va_list va, int is_size_t) +callmethod(PyObject* callable, const char *format, va_list va, int is_size_t) { PyObject *args, *result; - assert(func != NULL); - - if (!PyCallable_Check(func)) { - type_error("attribute of type '%.200s' is not callable", func); + assert(callable != NULL); + + if (!PyCallable_Check(callable)) { + type_error("attribute of type '%.200s' is not callable", callable); return NULL; } if (!format || !*format) { - return _PyObject_CallNoArg(func); + return _PyObject_CallNoArg(callable); } if (is_size_t) { @@ -2583,98 +2584,104 @@ callmethod(PyObject* func, const char *f return NULL; } - result = call_function_tail(func, args); + result = call_function_tail(callable, args); Py_DECREF(args); return result; } PyObject * -PyObject_CallMethod(PyObject *o, const char *name, const char *format, ...) +PyObject_CallMethod(PyObject *obj, const char *name, const char *format, ...) { va_list va; - PyObject *func = NULL; + PyObject *callable = NULL; PyObject *retval = NULL; - if (o == NULL || name == NULL) { + if (obj == NULL || name == NULL) { return null_error(); } - func = PyObject_GetAttrString(o, name); - if (func == NULL) + callable = PyObject_GetAttrString(obj, name); + if (callable == NULL) return NULL; va_start(va, format); - retval = callmethod(func, format, va, 0); + retval = callmethod(callable, format, va, 0); va_end(va); - Py_DECREF(func); + + Py_DECREF(callable); return retval; } PyObject * -_PyObject_CallMethodId(PyObject *o, _Py_Identifier *name, +_PyObject_CallMethodId(PyObject *obj, _Py_Identifier *name, const char *format, ...) { va_list va; - PyObject *func = NULL; + PyObject *callable = NULL; PyObject *retval = NULL; - if (o == NULL || name == NULL) { + if (obj == NULL || name == NULL) { return null_error(); } - func = _PyObject_GetAttrId(o, name); - if (func == NULL) + callable = _PyObject_GetAttrId(obj, name); + if (callable == NULL) return NULL; va_start(va, format); - retval = callmethod(func, format, va, 0); + retval = callmethod(callable, format, va, 0); va_end(va); - Py_DECREF(func); + + Py_DECREF(callable); return retval; } PyObject * -_PyObject_CallMethod_SizeT(PyObject *o, const char *name, +_PyObject_CallMethod_SizeT(PyObject *obj, const char *name, const char *format, ...) { va_list va; - PyObject *func = NULL; + PyObject *callable = NULL; PyObject *retval; - if (o == NULL || name == NULL) { + if (obj == NULL || name == NULL) { return null_error(); } - func = PyObject_GetAttrString(o, name); - if (func == NULL) + callable = PyObject_GetAttrString(obj, name); + if (callable == NULL) return NULL; + va_start(va, format); - retval = callmethod(func, format, va, 1); + retval = callmethod(callable, format, va, 1); va_end(va); - Py_DECREF(func); + + Py_DECREF(callable); return retval; } PyObject * -_PyObject_CallMethodId_SizeT(PyObject *o, _Py_Identifier *name, +_PyObject_CallMethodId_SizeT(PyObject *obj, _Py_Identifier *name, const char *format, ...) { va_list va; - PyObject *func = NULL; + PyObject *callable = NULL; PyObject *retval; - if (o == NULL || name == NULL) { + if (obj == NULL || name == NULL) { return null_error(); } - func = _PyObject_GetAttrId(o, name); - if (func == NULL) { + callable = _PyObject_GetAttrId(obj, name); + if (callable == NULL) { return NULL; } + va_start(va, format); - retval = callmethod(func, format, va, 1); + retval = callmethod(callable, format, va, 1); va_end(va); - Py_DECREF(func); + + Py_DECREF(callable); return retval; } @@ -2756,20 +2763,21 @@ PyObject_CallMethodObjArgs(PyObject *cal } PyObject * -_PyObject_CallMethodIdObjArgs(PyObject *callable, - struct _Py_Identifier *name, ...) +_PyObject_CallMethodIdObjArgs(PyObject *obj, + struct _Py_Identifier *name, ...) { PyObject *small_stack[5]; PyObject **stack; + PyObject *callable; Py_ssize_t nargs; PyObject *result; va_list vargs; - if (callable == NULL || name == NULL) { + if (obj == NULL || name == NULL) { return null_error(); } - callable = _PyObject_GetAttrId(callable, name); + callable = _PyObject_GetAttrId(obj, name); if (callable == NULL) return NULL; diff -r 9db231dd0b73 -r d8b2b205270c Objects/typeobject.c --- a/Objects/typeobject.c Tue Dec 06 11:02:54 2016 +0100 +++ b/Objects/typeobject.c Tue Dec 06 12:05:43 2016 +0100 @@ -1425,15 +1425,15 @@ PyObject * as lookup_method to cache the interned name string object. */ static PyObject * -call_method(PyObject *o, _Py_Identifier *nameid, const char *format, ...) +call_method(PyObject *obj, _Py_Identifier *name, const char *format, ...) { va_list va; PyObject *func = NULL, *retval; - func = lookup_maybe(o, nameid); + func = lookup_maybe(obj, name); if (func == NULL) { if (!PyErr_Occurred()) - PyErr_SetObject(PyExc_AttributeError, nameid->object); + PyErr_SetObject(PyExc_AttributeError, name->object); return NULL; } @@ -1465,12 +1465,12 @@ call_method(PyObject *o, _Py_Identifier /* Clone of call_method() that returns NotImplemented when the lookup fails. */ static PyObject * -call_maybe(PyObject *o, _Py_Identifier *nameid, const char *format, ...) +call_maybe(PyObject *obj, _Py_Identifier *name, const char *format, ...) { va_list va; PyObject *func = NULL, *retval; - func = lookup_maybe(o, nameid); + func = lookup_maybe(obj, name); if (func == NULL) { if (!PyErr_Occurred()) Py_RETURN_NOTIMPLEMENTED; diff -r 9db231dd0b73 -r d8b2b205270c Python/ceval.c --- a/Python/ceval.c Tue Dec 06 11:02:54 2016 +0100 +++ b/Python/ceval.c Tue Dec 06 12:05:43 2016 +0100 @@ -4637,7 +4637,8 @@ PyEval_MergeCompilerFlags(PyCompilerFlag The arg must be a tuple or NULL. The kw must be a dict or NULL. */ PyObject * -PyEval_CallObjectWithKeywords(PyObject *func, PyObject *args, PyObject *kwargs) +PyEval_CallObjectWithKeywords(PyObject *callable, + PyObject *args, PyObject *kwargs) { #ifdef Py_DEBUG /* PyEval_CallObjectWithKeywords() must not be called with an exception @@ -4647,7 +4648,7 @@ PyEval_CallObjectWithKeywords(PyObject * #endif if (args == NULL) { - return _PyObject_FastCallDict(func, NULL, 0, kwargs); + return _PyObject_FastCallDict(callable, NULL, 0, kwargs); } if (!PyTuple_Check(args)) { @@ -4662,7 +4663,7 @@ PyEval_CallObjectWithKeywords(PyObject * return NULL; } - return PyObject_Call(func, args, kwargs); + return PyObject_Call(callable, args, kwargs); } const char * diff -r 9db231dd0b73 -r d8b2b205270c Python/modsupport.c --- a/Python/modsupport.c Tue Dec 06 11:02:54 2016 +0100 +++ b/Python/modsupport.c Tue Dec 06 12:05:43 2016 +0100 @@ -487,7 +487,7 @@ va_build_value(const char *format, va_li PyObject * -PyEval_CallFunction(PyObject *obj, const char *format, ...) +PyEval_CallFunction(PyObject *callable, const char *format, ...) { va_list vargs; PyObject *args; @@ -501,7 +501,7 @@ PyEval_CallFunction(PyObject *obj, const if (args == NULL) return NULL; - res = PyEval_CallObject(obj, args); + res = PyEval_CallObject(callable, args); Py_DECREF(args); return res; @@ -509,14 +509,14 @@ PyEval_CallFunction(PyObject *obj, const PyObject * -PyEval_CallMethod(PyObject *obj, const char *methodname, const char *format, ...) +PyEval_CallMethod(PyObject *obj, const char *name, const char *format, ...) { va_list vargs; PyObject *meth; PyObject *args; PyObject *res; - meth = PyObject_GetAttrString(obj, methodname); + meth = PyObject_GetAttrString(obj, name); if (meth == NULL) return NULL;