[Python-checkins] cpython: Uniformize argument names of "call" functions

29 Nov 2016

https://hg.python.org/cpython/rev/7efddbf1aa70
changeset:   105395:7efddbf1aa70
user:        Victor Stinner <victor.stinner@gmail.com>
date:        Tue Nov 29 18:47:56 2016 +0100
summary:
  Uniformize argument names of "call" functions

* Callable object: callable, o, callable_object => func
* Object for method calls: o => obj
* Method name: name or nameid => method

Cleanup also the C code:

* Don't initialize variables to NULL if they are not used before their first
  assignement
* Add braces for readability

files:
  Include/abstract.h   |   40 ++--
  Include/ceval.h      |    4 +-
  Objects/abstract.c   |  236 +++++++++++++++---------------
  Objects/typeobject.c |   21 +-
  4 files changed, 152 insertions(+), 149 deletions(-)

diff --git a/Include/abstract.h b/Include/abstract.h
--- a/Include/abstract.h
+++ b/Include/abstract.h
@@ -257,15 +257,15 @@
 
        /* Declared elsewhere
 
-     PyAPI_FUNC(int) PyCallable_Check(PyObject *o);
+     PyAPI_FUNC(int) PyCallable_Check(PyObject *obj);
 
-     Determine if the object, o, is callable.  Return 1 if the
+     Determine if the object, obj, is callable.  Return 1 if the
      object is callable and 0 otherwise.
 
      This function always succeeds.
        */
 
-     PyAPI_FUNC(PyObject *) PyObject_Call(PyObject *callable_object,
+     PyAPI_FUNC(PyObject *) PyObject_Call(PyObject *func,
                                           PyObject *args, PyObject *kwargs);
 
 #ifndef Py_LIMITED_API
@@ -344,7 +344,7 @@
     _PyObject_FastCall((func), &(arg), 1)
 
     PyAPI_FUNC(PyObject *) _PyObject_Call_Prepend(PyObject *func,
-                                                  PyObject *obj, PyObject *args,
+                                                  PyObject *arg0, PyObject *args,
                                                   PyObject *kwargs);
 
      PyAPI_FUNC(PyObject *) _Py_CheckFunctionResult(PyObject *func,
@@ -353,27 +353,27 @@
 #endif   /* Py_LIMITED_API */
 
        /*
-     Call a callable Python object, callable_object, with
+     Call a callable Python object, func, with
      arguments and keywords arguments.  The 'args' argument can not be
      NULL.
        */
 
-     PyAPI_FUNC(PyObject *) PyObject_CallObject(PyObject *callable_object,
+     PyAPI_FUNC(PyObject *) PyObject_CallObject(PyObject *func,
                                                 PyObject *args);
 
        /*
-     Call a callable Python object, callable_object, with
+     Call a callable Python object, func, 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 *func,
                                                   const char *format, ...);
 
        /*
-     Call a callable Python object, callable_object, with a
+     Call a callable Python object, func, with a
      variable number of C arguments. The C arguments are described
      using a mkvalue-style format string. The format may be NULL,
      indicating that no arguments are provided.  Returns the
@@ -382,7 +382,7 @@
        */
 
 
-     PyAPI_FUNC(PyObject *) PyObject_CallMethod(PyObject *o,
+     PyAPI_FUNC(PyObject *) PyObject_CallMethod(PyObject *obj,
                                                 const char *method,
                                                 const char *format, ...);
 
@@ -396,7 +396,7 @@
        */
 
 #ifndef Py_LIMITED_API
-     PyAPI_FUNC(PyObject *) _PyObject_CallMethodId(PyObject *o,
+     PyAPI_FUNC(PyObject *) _PyObject_CallMethodId(PyObject *obj,
                                                    _Py_Identifier *method,
                                                    const char *format, ...);
 
@@ -406,25 +406,25 @@
        */
 #endif /* !Py_LIMITED_API */
 
-     PyAPI_FUNC(PyObject *) _PyObject_CallFunction_SizeT(PyObject *callable,
+     PyAPI_FUNC(PyObject *) _PyObject_CallFunction_SizeT(PyObject *func,
                                                          const char *format,
                                                          ...);
-     PyAPI_FUNC(PyObject *) _PyObject_CallMethod_SizeT(PyObject *o,
-                                                       const char *name,
+     PyAPI_FUNC(PyObject *) _PyObject_CallMethod_SizeT(PyObject *obj,
+                                                       const char *method,
                                                        const char *format,
                                                        ...);
 #ifndef Py_LIMITED_API
-     PyAPI_FUNC(PyObject *) _PyObject_CallMethodId_SizeT(PyObject *o,
-                                                       _Py_Identifier *name,
+     PyAPI_FUNC(PyObject *) _PyObject_CallMethodId_SizeT(PyObject *obj,
+                                                       _Py_Identifier *method,
                                                        const char *format,
                                                        ...);
 #endif /* !Py_LIMITED_API */
 
-     PyAPI_FUNC(PyObject *) PyObject_CallFunctionObjArgs(PyObject *callable,
+     PyAPI_FUNC(PyObject *) PyObject_CallFunctionObjArgs(PyObject *func,
                                                          ...);
 
        /*
-     Call a callable Python object, callable_object, with a
+     Call a callable Python object, func, with a
      variable number of C arguments.  The C arguments are provided
      as PyObject * values, terminated by a NULL.  Returns the
      result of the call on success, or NULL on failure.  This is
@@ -432,10 +432,10 @@
        */
 
 
-     PyAPI_FUNC(PyObject *) PyObject_CallMethodObjArgs(PyObject *o,
+     PyAPI_FUNC(PyObject *) PyObject_CallMethodObjArgs(PyObject *obj,
                                                        PyObject *method, ...);
 #ifndef Py_LIMITED_API
-     PyAPI_FUNC(PyObject *) _PyObject_CallMethodIdObjArgs(PyObject *o,
+     PyAPI_FUNC(PyObject *) _PyObject_CallMethodIdObjArgs(PyObject *obj,
                                                struct _Py_Identifier *method,
                                                ...);
 #endif /* !Py_LIMITED_API */
diff --git a/Include/ceval.h b/Include/ceval.h
--- a/Include/ceval.h
+++ b/Include/ceval.h
@@ -14,10 +14,10 @@
 #define PyEval_CallObject(func,arg) \
     PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)
 
-PyAPI_FUNC(PyObject *) PyEval_CallFunction(PyObject *obj,
+PyAPI_FUNC(PyObject *) PyEval_CallFunction(PyObject *func,
                                            const char *format, ...);
 PyAPI_FUNC(PyObject *) PyEval_CallMethod(PyObject *obj,
-                                         const char *methodname,
+                                         const char *method,
                                          const char *format, ...);
 
 #ifndef Py_LIMITED_API
diff --git a/Objects/abstract.c b/Objects/abstract.c
--- a/Objects/abstract.c
+++ b/Objects/abstract.c
@@ -2173,9 +2173,9 @@
 /* XXX PyCallable_Check() is in object.c */
 
 PyObject *
-PyObject_CallObject(PyObject *o, PyObject *a)
+PyObject_CallObject(PyObject *func, PyObject *args)
 {
-    return PyEval_CallObjectWithKeywords(o, a, NULL);
+    return PyEval_CallObjectWithKeywords(func, args, NULL);
 }
 
 PyObject*
@@ -2331,10 +2331,10 @@
     return result;
 }
 
-/* Positional arguments are obj followed args. */
+/* Positional arguments are arg0 followed args: [arg0, *args]. */
 PyObject *
 _PyObject_Call_Prepend(PyObject *func,
-                       PyObject *obj, PyObject *args, PyObject *kwargs)
+                       PyObject *arg0, PyObject *args, PyObject *kwargs)
 {
     PyObject *small_stack[8];
     PyObject **stack;
@@ -2356,7 +2356,7 @@
     }
 
     /* use borrowed references */
-    stack[0] = obj;
+    stack[0] = arg0;
     memcpy(&stack[1],
               &PyTuple_GET_ITEM(args, 0),
               argcount * sizeof(PyObject *));
@@ -2489,34 +2489,34 @@
 }
 
 static PyObject*
-call_function_tail(PyObject *callable, PyObject *args)
+call_function_tail(PyObject *func, PyObject *args)
 {
     PyObject *result;
 
     assert(args != NULL);
 
     if (!PyTuple_Check(args)) {
-        result = _PyObject_CallArg1(callable, args);
+        result = _PyObject_CallArg1(func, args);
     }
     else {
-        result = PyObject_Call(callable, args, NULL);
+        result = PyObject_Call(func, args, NULL);
     }
 
     return result;
 }
 
 PyObject *
-PyObject_CallFunction(PyObject *callable, const char *format, ...)
+PyObject_CallFunction(PyObject *func, const char *format, ...)
 {
     va_list va;
     PyObject *args, *result;
 
-    if (callable == NULL) {
+    if (func == NULL) {
         return null_error();
     }
 
     if (!format || !*format) {
-        return _PyObject_CallNoArg(callable);
+        return _PyObject_CallNoArg(func);
     }
 
     va_start(va, format);
@@ -2526,23 +2526,23 @@
         return NULL;
     }
 
-    result = call_function_tail(callable, args);
+    result = call_function_tail(func, args);
     Py_DECREF(args);
     return result;
 }
 
 PyObject *
-_PyObject_CallFunction_SizeT(PyObject *callable, const char *format, ...)
+_PyObject_CallFunction_SizeT(PyObject *func, const char *format, ...)
 {
     va_list va;
     PyObject *args, *result;
 
-    if (callable == NULL) {
+    if (func == NULL) {
         return null_error();
     }
 
     if (!format || !*format) {
-        return _PyObject_CallNoArg(callable);
+        return _PyObject_CallNoArg(func);
     }
 
     va_start(va, format);
@@ -2552,7 +2552,7 @@
         return NULL;
     }
 
-    result = call_function_tail(callable, args);
+    result = call_function_tail(func, args);
     Py_DECREF(args);
     return result;
 }
@@ -2589,19 +2589,20 @@
 }
 
 PyObject *
-PyObject_CallMethod(PyObject *o, const char *name, const char *format, ...)
+PyObject_CallMethod(PyObject *obj, const char *method, const char *format, ...)
 {
     va_list va;
     PyObject *func = NULL;
     PyObject *retval = NULL;
 
-    if (o == NULL || name == NULL) {
+    if (obj == NULL || method == NULL) {
         return null_error();
     }
 
-    func = PyObject_GetAttrString(o, name);
-    if (func == NULL)
+    func = PyObject_GetAttrString(obj, method);
+    if (func == NULL) {
         return NULL;
+    }
 
     va_start(va, format);
     retval = callmethod(func, format, va, 0);
@@ -2611,20 +2612,20 @@
 }
 
 PyObject *
-_PyObject_CallMethodId(PyObject *o, _Py_Identifier *name,
+_PyObject_CallMethodId(PyObject *obj, _Py_Identifier *method,
                        const char *format, ...)
 {
     va_list va;
-    PyObject *func = NULL;
-    PyObject *retval = NULL;
-
-    if (o == NULL || name == NULL) {
+    PyObject *func, *retval;
+
+    if (obj == NULL || method == NULL) {
         return null_error();
     }
 
-    func = _PyObject_GetAttrId(o, name);
-    if (func == NULL)
+    func = _PyObject_GetAttrId(obj, method);
+    if (func == NULL) {
         return NULL;
+    }
 
     va_start(va, format);
     retval = callmethod(func, format, va, 0);
@@ -2634,20 +2635,21 @@
 }
 
 PyObject *
-_PyObject_CallMethod_SizeT(PyObject *o, const char *name,
+_PyObject_CallMethod_SizeT(PyObject *obj, const char *method,
                            const char *format, ...)
 {
     va_list va;
-    PyObject *func = NULL;
-    PyObject *retval;
-
-    if (o == NULL || name == NULL) {
+    PyObject *func, *retval;
+
+    if (obj == NULL || method == NULL) {
         return null_error();
     }
 
-    func = PyObject_GetAttrString(o, name);
-    if (func == NULL)
+    func = PyObject_GetAttrString(obj, method);
+    if (func == NULL) {
         return NULL;
+    }
+
     va_start(va, format);
     retval = callmethod(func, format, va, 1);
     va_end(va);
@@ -2656,21 +2658,21 @@
 }
 
 PyObject *
-_PyObject_CallMethodId_SizeT(PyObject *o, _Py_Identifier *name,
+_PyObject_CallMethodId_SizeT(PyObject *obj, _Py_Identifier *method,
                              const char *format, ...)
 {
     va_list va;
-    PyObject *func = NULL;
-    PyObject *retval;
-
-    if (o == NULL || name == NULL) {
+    PyObject *func, *retval;
+
+    if (obj == NULL || method == NULL) {
         return null_error();
     }
 
-    func = _PyObject_GetAttrId(o, name);
+    func = _PyObject_GetAttrId(obj, method);
     if (func == NULL) {
         return NULL;
     }
+
     va_start(va, format);
     retval = callmethod(func, format, va, 1);
     va_end(va);
@@ -2720,7 +2722,80 @@
 }
 
 PyObject *
-PyObject_CallMethodObjArgs(PyObject *callable, PyObject *name, ...)
+PyObject_CallMethodObjArgs(PyObject *obj, PyObject *method, ...)
+{
+    PyObject *small_stack[5];
+    PyObject **stack;
+    Py_ssize_t nargs;
+    PyObject *func, *result;
+    va_list vargs;
+
+    if (obj == NULL || method == NULL) {
+        return null_error();
+    }
+
+    func = PyObject_GetAttr(obj, method);
+    if (func == NULL)
+        return NULL;
+
+    /* count the args */
+    va_start(vargs, method);
+    stack = objargs_mkstack(small_stack, Py_ARRAY_LENGTH(small_stack),
+                            vargs, &nargs);
+    va_end(vargs);
+    if (stack == NULL) {
+        Py_DECREF(func);
+        return NULL;
+    }
+
+    result = _PyObject_FastCall(func, stack, nargs);
+    Py_DECREF(func);
+    if (stack != small_stack) {
+        PyMem_Free(stack);
+    }
+
+    return result;
+}
+
+PyObject *
+_PyObject_CallMethodIdObjArgs(PyObject *obj,
+                              struct _Py_Identifier *method, ...)
+{
+    PyObject *small_stack[5];
+    PyObject **stack;
+    Py_ssize_t nargs;
+    PyObject *func, *result;
+    va_list vargs;
+
+    if (obj == NULL || method == NULL) {
+        return null_error();
+    }
+
+    func = _PyObject_GetAttrId(obj, method);
+    if (func == NULL)
+        return NULL;
+
+    /* count the args */
+    va_start(vargs, method);
+    stack = objargs_mkstack(small_stack, Py_ARRAY_LENGTH(small_stack),
+                            vargs, &nargs);
+    va_end(vargs);
+    if (stack == NULL) {
+        Py_DECREF(func);
+        return NULL;
+    }
+
+    result = _PyObject_FastCall(func, stack, nargs);
+    Py_DECREF(func);
+    if (stack != small_stack) {
+        PyMem_Free(stack);
+    }
+
+    return result;
+}
+
+PyObject *
+PyObject_CallFunctionObjArgs(PyObject *func, ...)
 {
     PyObject *small_stack[5];
     PyObject **stack;
@@ -2728,85 +2803,12 @@
     PyObject *result;
     va_list vargs;
 
-    if (callable == NULL || name == NULL) {
+    if (func == NULL) {
         return null_error();
     }
 
-    callable = PyObject_GetAttr(callable, name);
-    if (callable == NULL)
-        return NULL;
-
     /* count the args */
-    va_start(vargs, name);
-    stack = objargs_mkstack(small_stack, Py_ARRAY_LENGTH(small_stack),
-                            vargs, &nargs);
-    va_end(vargs);
-    if (stack == NULL) {
-        Py_DECREF(callable);
-        return NULL;
-    }
-
-    result = _PyObject_FastCall(callable, stack, nargs);
-    Py_DECREF(callable);
-    if (stack != small_stack) {
-        PyMem_Free(stack);
-    }
-
-    return result;
-}
-
-PyObject *
-_PyObject_CallMethodIdObjArgs(PyObject *callable,
-        struct _Py_Identifier *name, ...)
-{
-    PyObject *small_stack[5];
-    PyObject **stack;
-    Py_ssize_t nargs;
-    PyObject *result;
-    va_list vargs;
-
-    if (callable == NULL || name == NULL) {
-        return null_error();
-    }
-
-    callable = _PyObject_GetAttrId(callable, name);
-    if (callable == NULL)
-        return NULL;
-
-    /* count the args */
-    va_start(vargs, name);
-    stack = objargs_mkstack(small_stack, Py_ARRAY_LENGTH(small_stack),
-                            vargs, &nargs);
-    va_end(vargs);
-    if (stack == NULL) {
-        Py_DECREF(callable);
-        return NULL;
-    }
-
-    result = _PyObject_FastCall(callable, stack, nargs);
-    Py_DECREF(callable);
-    if (stack != small_stack) {
-        PyMem_Free(stack);
-    }
-
-    return result;
-}
-
-PyObject *
-PyObject_CallFunctionObjArgs(PyObject *callable, ...)
-{
-    PyObject *small_stack[5];
-    PyObject **stack;
-    Py_ssize_t nargs;
-    PyObject *result;
-    va_list vargs;
-
-    if (callable == NULL) {
-        return null_error();
-    }
-
-    /* count the args */
-    va_start(vargs, callable);
+    va_start(vargs, func);
     stack = objargs_mkstack(small_stack, Py_ARRAY_LENGTH(small_stack),
                             vargs, &nargs);
     va_end(vargs);
@@ -2814,7 +2816,7 @@
         return NULL;
     }
 
-    result = _PyObject_FastCall(callable, stack, nargs);
+    result = _PyObject_FastCall(func, stack, nargs);
     if (stack != small_stack) {
         PyMem_Free(stack);
     }
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -1425,15 +1425,16 @@
    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 *method, const char *format, ...)
 {
     va_list va;
-    PyObject *func = NULL, *retval;
-
-    func = lookup_maybe(o, nameid);
+    PyObject *func, *retval;
+
+    func = lookup_maybe(obj, method);
     if (func == NULL) {
-        if (!PyErr_Occurred())
-            PyErr_SetObject(PyExc_AttributeError, nameid->object);
+        if (!PyErr_Occurred()) {
+            PyErr_SetObject(PyExc_AttributeError, method->object);
+        }
         return NULL;
     }
 
@@ -1465,12 +1466,12 @@
 /* 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 *method, const char *format, ...)
 {
     va_list va;
-    PyObject *func = NULL, *retval;
-
-    func = lookup_maybe(o, nameid);
+    PyObject *func, *retval;
+
+    func = lookup_maybe(obj, method);
     if (func == NULL) {
         if (!PyErr_Occurred())
             Py_RETURN_NOTIMPLEMENTED;

-- 
Repository URL: https://hg.python.org/cpython

    