Restoring authorship annotation for Anton Samokhvalov <[email protected]>. Commit 2 of 2.

1 files changed, 265 insertions, 265 deletions

diff --git a/contrib/tools/cython/Cython/Utility/FunctionArguments.c b/contrib/tools/cython/Cython/Utility/FunctionArguments.c
index ff75ad44262..8333d936664 100644
--- a/contrib/tools/cython/Cython/Utility/FunctionArguments.c
+++ b/contrib/tools/cython/Cython/Utility/FunctionArguments.c
@@ -1,109 +1,109 @@
-//////////////////// ArgTypeTest.proto //////////////////// 
- 
- 
+//////////////////// ArgTypeTest.proto ////////////////////
+
+
 #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact) \
     ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 : \
         __Pyx__ArgTypeTest(obj, type, name, exact))
 
 static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); /*proto*/
 
-//////////////////// ArgTypeTest //////////////////// 
- 
+//////////////////// ArgTypeTest ////////////////////
+
 static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact)
-{ 
-    if (unlikely(!type)) { 
-        PyErr_SetString(PyExc_SystemError, "Missing type object"); 
-        return 0; 
-    } 
-    else if (exact) { 
-        #if PY_MAJOR_VERSION == 2 
+{
+    if (unlikely(!type)) {
+        PyErr_SetString(PyExc_SystemError, "Missing type object");
+        return 0;
+    }
+    else if (exact) {
+        #if PY_MAJOR_VERSION == 2
         if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;
-        #endif 
-    } 
-    else { 
+        #endif
+    }
+    else {
         if (likely(__Pyx_TypeCheck(obj, type))) return 1;
-    } 
+    }
     PyErr_Format(PyExc_TypeError,
         "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
         name, type->tp_name, Py_TYPE(obj)->tp_name);
-    return 0; 
-} 
- 
-//////////////////// RaiseArgTupleInvalid.proto //////////////////// 
- 
-static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, 
-    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /*proto*/ 
- 
-//////////////////// RaiseArgTupleInvalid //////////////////// 
- 
-//  __Pyx_RaiseArgtupleInvalid raises the correct exception when too 
-//  many or too few positional arguments were found.  This handles 
-//  Py_ssize_t formatting correctly. 
- 
-static void __Pyx_RaiseArgtupleInvalid( 
-    const char* func_name, 
-    int exact, 
-    Py_ssize_t num_min, 
-    Py_ssize_t num_max, 
-    Py_ssize_t num_found) 
-{ 
-    Py_ssize_t num_expected; 
-    const char *more_or_less; 
- 
-    if (num_found < num_min) { 
-        num_expected = num_min; 
-        more_or_less = "at least"; 
-    } else { 
-        num_expected = num_max; 
-        more_or_less = "at most"; 
-    } 
-    if (exact) { 
-        more_or_less = "exactly"; 
-    } 
-    PyErr_Format(PyExc_TypeError, 
-                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", 
-                 func_name, more_or_less, num_expected, 
-                 (num_expected == 1) ? "" : "s", num_found); 
-} 
- 
- 
-//////////////////// RaiseKeywordRequired.proto //////////////////// 
- 
+    return 0;
+}
+
+//////////////////// RaiseArgTupleInvalid.proto ////////////////////
+
+static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
+    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /*proto*/
+
+//////////////////// RaiseArgTupleInvalid ////////////////////
+
+//  __Pyx_RaiseArgtupleInvalid raises the correct exception when too
+//  many or too few positional arguments were found.  This handles
+//  Py_ssize_t formatting correctly.
+
+static void __Pyx_RaiseArgtupleInvalid(
+    const char* func_name,
+    int exact,
+    Py_ssize_t num_min,
+    Py_ssize_t num_max,
+    Py_ssize_t num_found)
+{
+    Py_ssize_t num_expected;
+    const char *more_or_less;
+
+    if (num_found < num_min) {
+        num_expected = num_min;
+        more_or_less = "at least";
+    } else {
+        num_expected = num_max;
+        more_or_less = "at most";
+    }
+    if (exact) {
+        more_or_less = "exactly";
+    }
+    PyErr_Format(PyExc_TypeError,
+                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                 func_name, more_or_less, num_expected,
+                 (num_expected == 1) ? "" : "s", num_found);
+}
+
+
+//////////////////// RaiseKeywordRequired.proto ////////////////////
+
 static void __Pyx_RaiseKeywordRequired(const char* func_name, PyObject* kw_name); /*proto*/
- 
-//////////////////// RaiseKeywordRequired //////////////////// 
- 
+
+//////////////////// RaiseKeywordRequired ////////////////////
+
 static void __Pyx_RaiseKeywordRequired(const char* func_name, PyObject* kw_name) {
-    PyErr_Format(PyExc_TypeError, 
-        #if PY_MAJOR_VERSION >= 3 
-        "%s() needs keyword-only argument %U", func_name, kw_name); 
-        #else 
-        "%s() needs keyword-only argument %s", func_name, 
-        PyString_AS_STRING(kw_name)); 
-        #endif 
-} 
- 
- 
-//////////////////// RaiseDoubleKeywords.proto //////////////////// 
- 
-static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /*proto*/ 
- 
-//////////////////// RaiseDoubleKeywords //////////////////// 
- 
-static void __Pyx_RaiseDoubleKeywordsError( 
-    const char* func_name, 
-    PyObject* kw_name) 
-{ 
-    PyErr_Format(PyExc_TypeError, 
-        #if PY_MAJOR_VERSION >= 3 
-        "%s() got multiple values for keyword argument '%U'", func_name, kw_name); 
-        #else 
-        "%s() got multiple values for keyword argument '%s'", func_name, 
-        PyString_AsString(kw_name)); 
-        #endif 
-} 
- 
- 
+    PyErr_Format(PyExc_TypeError,
+        #if PY_MAJOR_VERSION >= 3
+        "%s() needs keyword-only argument %U", func_name, kw_name);
+        #else
+        "%s() needs keyword-only argument %s", func_name,
+        PyString_AS_STRING(kw_name));
+        #endif
+}
+
+
+//////////////////// RaiseDoubleKeywords.proto ////////////////////
+
+static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /*proto*/
+
+//////////////////// RaiseDoubleKeywords ////////////////////
+
+static void __Pyx_RaiseDoubleKeywordsError(
+    const char* func_name,
+    PyObject* kw_name)
+{
+    PyErr_Format(PyExc_TypeError,
+        #if PY_MAJOR_VERSION >= 3
+        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
+        #else
+        "%s() got multiple values for keyword argument '%s'", func_name,
+        PyString_AsString(kw_name));
+        #endif
+}
+
+
 //////////////////// RaiseMappingExpected.proto ////////////////////
 
 static void __Pyx_RaiseMappingExpectedError(PyObject* arg); /*proto*/
@@ -115,186 +115,186 @@ static void __Pyx_RaiseMappingExpectedError(PyObject* arg) {
 }
 
 
-//////////////////// KeywordStringCheck.proto //////////////////// 
- 
+//////////////////// KeywordStringCheck.proto ////////////////////
+
 static int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); /*proto*/
- 
-//////////////////// KeywordStringCheck //////////////////// 
- 
-//  __Pyx_CheckKeywordStrings raises an error if non-string keywords 
-//  were passed to a function, or if any keywords were passed to a 
-//  function that does not accept them. 
- 
+
+//////////////////// KeywordStringCheck ////////////////////
+
+//  __Pyx_CheckKeywordStrings raises an error if non-string keywords
+//  were passed to a function, or if any keywords were passed to a
+//  function that does not accept them.
+
 static int __Pyx_CheckKeywordStrings(
-    PyObject *kwdict, 
-    const char* function_name, 
-    int kw_allowed) 
-{ 
-    PyObject* key = 0; 
-    Py_ssize_t pos = 0; 
-#if CYTHON_COMPILING_IN_PYPY 
-    /* PyPy appears to check keywords at call time, not at unpacking time => not much to do here */ 
-    if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0)) 
-        goto invalid_keyword; 
-    return 1; 
-#else 
-    while (PyDict_Next(kwdict, &pos, &key, 0)) { 
-        #if PY_MAJOR_VERSION < 3 
+    PyObject *kwdict,
+    const char* function_name,
+    int kw_allowed)
+{
+    PyObject* key = 0;
+    Py_ssize_t pos = 0;
+#if CYTHON_COMPILING_IN_PYPY
+    /* PyPy appears to check keywords at call time, not at unpacking time => not much to do here */
+    if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0))
+        goto invalid_keyword;
+    return 1;
+#else
+    while (PyDict_Next(kwdict, &pos, &key, 0)) {
+        #if PY_MAJOR_VERSION < 3
         if (unlikely(!PyString_Check(key)))
-        #endif 
-            if (unlikely(!PyUnicode_Check(key))) 
-                goto invalid_keyword_type; 
-    } 
-    if ((!kw_allowed) && unlikely(key)) 
-        goto invalid_keyword; 
-    return 1; 
-invalid_keyword_type: 
-    PyErr_Format(PyExc_TypeError, 
-        "%.200s() keywords must be strings", function_name); 
-    return 0; 
-#endif 
-invalid_keyword: 
-    PyErr_Format(PyExc_TypeError, 
-    #if PY_MAJOR_VERSION < 3 
-        "%.200s() got an unexpected keyword argument '%.200s'", 
-        function_name, PyString_AsString(key)); 
-    #else 
-        "%s() got an unexpected keyword argument '%U'", 
-        function_name, key); 
-    #endif 
-    return 0; 
-} 
- 
- 
-//////////////////// ParseKeywords.proto //////////////////// 
- 
-static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[], \ 
-    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, \ 
-    const char* function_name); /*proto*/ 
- 
-//////////////////// ParseKeywords //////////////////// 
-//@requires: RaiseDoubleKeywords 
- 
-//  __Pyx_ParseOptionalKeywords copies the optional/unknown keyword 
-//  arguments from the kwds dict into kwds2.  If kwds2 is NULL, unknown 
-//  keywords will raise an invalid keyword error. 
-// 
-//  Three kinds of errors are checked: 1) non-string keywords, 2) 
-//  unexpected keywords and 3) overlap with positional arguments. 
-// 
-//  If num_posargs is greater 0, it denotes the number of positional 
-//  arguments that were passed and that must therefore not appear 
-//  amongst the keywords as well. 
-// 
-//  This method does not check for required keyword arguments. 
- 
-static int __Pyx_ParseOptionalKeywords( 
-    PyObject *kwds, 
-    PyObject **argnames[], 
-    PyObject *kwds2, 
-    PyObject *values[], 
-    Py_ssize_t num_pos_args, 
-    const char* function_name) 
-{ 
-    PyObject *key = 0, *value = 0; 
-    Py_ssize_t pos = 0; 
-    PyObject*** name; 
-    PyObject*** first_kw_arg = argnames + num_pos_args; 
- 
-    while (PyDict_Next(kwds, &pos, &key, &value)) { 
-        name = first_kw_arg; 
-        while (*name && (**name != key)) name++; 
-        if (*name) { 
-            values[name-argnames] = value; 
-            continue; 
-        } 
- 
-        name = first_kw_arg; 
-        #if PY_MAJOR_VERSION < 3 
+        #endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+    }
+    if ((!kw_allowed) && unlikely(key))
+        goto invalid_keyword;
+    return 1;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    return 0;
+#endif
+invalid_keyword:
+    PyErr_Format(PyExc_TypeError,
+    #if PY_MAJOR_VERSION < 3
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+    return 0;
+}
+
+
+//////////////////// ParseKeywords.proto ////////////////////
+
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[], \
+    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, \
+    const char* function_name); /*proto*/
+
+//////////////////// ParseKeywords ////////////////////
+//@requires: RaiseDoubleKeywords
+
+//  __Pyx_ParseOptionalKeywords copies the optional/unknown keyword
+//  arguments from the kwds dict into kwds2.  If kwds2 is NULL, unknown
+//  keywords will raise an invalid keyword error.
+//
+//  Three kinds of errors are checked: 1) non-string keywords, 2)
+//  unexpected keywords and 3) overlap with positional arguments.
+//
+//  If num_posargs is greater 0, it denotes the number of positional
+//  arguments that were passed and that must therefore not appear
+//  amongst the keywords as well.
+//
+//  This method does not check for required keyword arguments.
+
+static int __Pyx_ParseOptionalKeywords(
+    PyObject *kwds,
+    PyObject **argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    const char* function_name)
+{
+    PyObject *key = 0, *value = 0;
+    Py_ssize_t pos = 0;
+    PyObject*** name;
+    PyObject*** first_kw_arg = argnames + num_pos_args;
+
+    while (PyDict_Next(kwds, &pos, &key, &value)) {
+        name = first_kw_arg;
+        while (*name && (**name != key)) name++;
+        if (*name) {
+            values[name-argnames] = value;
+            continue;
+        }
+
+        name = first_kw_arg;
+        #if PY_MAJOR_VERSION < 3
         if (likely(PyString_Check(key))) {
-            while (*name) { 
-                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) 
-                        && _PyString_Eq(**name, key)) { 
-                    values[name-argnames] = value; 
-                    break; 
-                } 
-                name++; 
-            } 
-            if (*name) continue; 
-            else { 
-                // not found after positional args, check for duplicate 
-                PyObject*** argname = argnames; 
-                while (argname != first_kw_arg) { 
-                    if ((**argname == key) || ( 
-                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) 
-                             && _PyString_Eq(**argname, key))) { 
-                        goto arg_passed_twice; 
-                    } 
-                    argname++; 
-                } 
-            } 
-        } else 
-        #endif 
-        if (likely(PyUnicode_Check(key))) { 
-            while (*name) { 
-                int cmp = (**name == key) ? 0 : 
-                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 
+            while (*name) {
+                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
+                        && _PyString_Eq(**name, key)) {
+                    values[name-argnames] = value;
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                // not found after positional args, check for duplicate
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    if ((**argname == key) || (
+                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
+                             && _PyString_Eq(**argname, key))) {
+                        goto arg_passed_twice;
+                    }
+                    argname++;
+                }
+            }
+        } else
+        #endif
+        if (likely(PyUnicode_Check(key))) {
+            while (*name) {
+                int cmp = (**name == key) ? 0 :
+                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
                     (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
-                #endif 
+                #endif
                     // In Py2, we may need to convert the argument name from str to unicode for comparison.
-                    PyUnicode_Compare(**name, key); 
-                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; 
-                if (cmp == 0) { 
-                    values[name-argnames] = value; 
-                    break; 
-                } 
-                name++; 
-            } 
-            if (*name) continue; 
-            else { 
-                // not found after positional args, check for duplicate 
-                PyObject*** argname = argnames; 
-                while (argname != first_kw_arg) { 
-                    int cmp = (**argname == key) ? 0 : 
-                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 
+                    PyUnicode_Compare(**name, key);
+                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                if (cmp == 0) {
+                    values[name-argnames] = value;
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                // not found after positional args, check for duplicate
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    int cmp = (**argname == key) ? 0 :
+                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
                         (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
-                    #endif 
-                        // need to convert argument name from bytes to unicode for comparison 
-                        PyUnicode_Compare(**argname, key); 
-                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; 
-                    if (cmp == 0) goto arg_passed_twice; 
-                    argname++; 
-                } 
-            } 
-        } else 
-            goto invalid_keyword_type; 
- 
-        if (kwds2) { 
-            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; 
-        } else { 
-            goto invalid_keyword; 
-        } 
-    } 
-    return 0; 
-arg_passed_twice: 
-    __Pyx_RaiseDoubleKeywordsError(function_name, key); 
-    goto bad; 
-invalid_keyword_type: 
-    PyErr_Format(PyExc_TypeError, 
-        "%.200s() keywords must be strings", function_name); 
-    goto bad; 
-invalid_keyword: 
-    PyErr_Format(PyExc_TypeError, 
-    #if PY_MAJOR_VERSION < 3 
-        "%.200s() got an unexpected keyword argument '%.200s'", 
-        function_name, PyString_AsString(key)); 
-    #else 
-        "%s() got an unexpected keyword argument '%U'", 
-        function_name, key); 
-    #endif 
-bad: 
-    return -1; 
-} 
+                    #endif
+                        // need to convert argument name from bytes to unicode for comparison
+                        PyUnicode_Compare(**argname, key);
+                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                    if (cmp == 0) goto arg_passed_twice;
+                    argname++;
+                }
+            }
+        } else
+            goto invalid_keyword_type;
+
+        if (kwds2) {
+            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
+        } else {
+            goto invalid_keyword;
+        }
+    }
+    return 0;
+arg_passed_twice:
+    __Pyx_RaiseDoubleKeywordsError(function_name, key);
+    goto bad;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    goto bad;
+invalid_keyword:
+    PyErr_Format(PyExc_TypeError,
+    #if PY_MAJOR_VERSION < 3
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+bad:
+    return -1;
+}
 
 
 //////////////////// MergeKeywords.proto ////////////////////