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

1 files changed, 145 insertions, 145 deletions

diff --git a/contrib/tools/python3/src/Modules/_bisectmodule.c b/contrib/tools/python3/src/Modules/_bisectmodule.c
index 82d800d9a87..152e83fd2b5 100644
--- a/contrib/tools/python3/src/Modules/_bisectmodule.c
+++ b/contrib/tools/python3/src/Modules/_bisectmodule.c
@@ -1,11 +1,11 @@
-/* Bisection algorithms. Drop in replacement for bisect.py
-
-Converted to C by Dmitry Vasiliev (dima at hlabs.spb.ru).
-*/
-
-#define PY_SSIZE_T_CLEAN
-#include "Python.h"
-
+/* Bisection algorithms. Drop in replacement for bisect.py 
+ 
+Converted to C by Dmitry Vasiliev (dima at hlabs.spb.ru). 
+*/ 
+ 
+#define PY_SSIZE_T_CLEAN 
+#include "Python.h" 
+ 
 /*[clinic input]
 module _bisect
 [clinic start generated code]*/
@@ -13,44 +13,44 @@ module _bisect
 
 #include "clinic/_bisectmodule.c.h"
 
-_Py_IDENTIFIER(insert);
-
+_Py_IDENTIFIER(insert); 
+ 
 static inline Py_ssize_t
-internal_bisect_right(PyObject *list, PyObject *item, Py_ssize_t lo, Py_ssize_t hi)
-{
-    PyObject *litem;
-    Py_ssize_t mid;
-    int res;
-
-    if (lo < 0) {
-        PyErr_SetString(PyExc_ValueError, "lo must be non-negative");
-        return -1;
-    }
-    if (hi == -1) {
-        hi = PySequence_Size(list);
-        if (hi < 0)
-            return -1;
-    }
-    while (lo < hi) {
-        /* The (size_t)cast ensures that the addition and subsequent division
-           are performed as unsigned operations, avoiding difficulties from
-           signed overflow.  (See issue 13496.) */
-        mid = ((size_t)lo + hi) / 2;
-        litem = PySequence_GetItem(list, mid);
-        if (litem == NULL)
-            return -1;
-        res = PyObject_RichCompareBool(item, litem, Py_LT);
-        Py_DECREF(litem);
-        if (res < 0)
-            return -1;
-        if (res)
-            hi = mid;
-        else
-            lo = mid + 1;
-    }
-    return lo;
-}
-
+internal_bisect_right(PyObject *list, PyObject *item, Py_ssize_t lo, Py_ssize_t hi) 
+{ 
+    PyObject *litem; 
+    Py_ssize_t mid; 
+    int res; 
+ 
+    if (lo < 0) { 
+        PyErr_SetString(PyExc_ValueError, "lo must be non-negative"); 
+        return -1; 
+    } 
+    if (hi == -1) { 
+        hi = PySequence_Size(list); 
+        if (hi < 0) 
+            return -1; 
+    } 
+    while (lo < hi) { 
+        /* The (size_t)cast ensures that the addition and subsequent division 
+           are performed as unsigned operations, avoiding difficulties from 
+           signed overflow.  (See issue 13496.) */ 
+        mid = ((size_t)lo + hi) / 2; 
+        litem = PySequence_GetItem(list, mid); 
+        if (litem == NULL) 
+            return -1; 
+        res = PyObject_RichCompareBool(item, litem, Py_LT); 
+        Py_DECREF(litem); 
+        if (res < 0) 
+            return -1; 
+        if (res) 
+            hi = mid; 
+        else 
+            lo = mid + 1; 
+    } 
+    return lo; 
+} 
+ 
 /*[clinic input]
 _bisect.bisect_right -> Py_ssize_t
 
@@ -73,13 +73,13 @@ static Py_ssize_t
 _bisect_bisect_right_impl(PyObject *module, PyObject *a, PyObject *x,
                           Py_ssize_t lo, Py_ssize_t hi)
 /*[clinic end generated code: output=419e150cf1d2a235 input=e72212b282c83375]*/
-{
+{ 
     return internal_bisect_right(a, x, lo, hi);
-}
-
+} 
+ 
 /*[clinic input]
 _bisect.insort_right
-
+ 
     a: object
     x: object
     lo: Py_ssize_t = 0
@@ -93,65 +93,65 @@ Optional args lo (default 0) and hi (default len(a)) bound the
 slice of a to be searched.
 [clinic start generated code]*/
 
-static PyObject *
+static PyObject * 
 _bisect_insort_right_impl(PyObject *module, PyObject *a, PyObject *x,
                           Py_ssize_t lo, Py_ssize_t hi)
 /*[clinic end generated code: output=c2caa3d4cd02035a input=d1c45bfa68182669]*/
-{
+{ 
     PyObject *result;
     Py_ssize_t index = internal_bisect_right(a, x, lo, hi);
-    if (index < 0)
-        return NULL;
+    if (index < 0) 
+        return NULL; 
     if (PyList_CheckExact(a)) {
         if (PyList_Insert(a, index, x) < 0)
-            return NULL;
+            return NULL; 
     }
     else {
         result = _PyObject_CallMethodId(a, &PyId_insert, "nO", index, x);
-        if (result == NULL)
-            return NULL;
-        Py_DECREF(result);
-    }
-
-    Py_RETURN_NONE;
-}
-
+        if (result == NULL) 
+            return NULL; 
+        Py_DECREF(result); 
+    } 
+ 
+    Py_RETURN_NONE; 
+} 
+ 
 static inline Py_ssize_t
-internal_bisect_left(PyObject *list, PyObject *item, Py_ssize_t lo, Py_ssize_t hi)
-{
-    PyObject *litem;
-    Py_ssize_t mid;
-    int res;
-
-    if (lo < 0) {
-        PyErr_SetString(PyExc_ValueError, "lo must be non-negative");
-        return -1;
-    }
-    if (hi == -1) {
-        hi = PySequence_Size(list);
-        if (hi < 0)
-            return -1;
-    }
-    while (lo < hi) {
-        /* The (size_t)cast ensures that the addition and subsequent division
-           are performed as unsigned operations, avoiding difficulties from
-           signed overflow.  (See issue 13496.) */
-        mid = ((size_t)lo + hi) / 2;
-        litem = PySequence_GetItem(list, mid);
-        if (litem == NULL)
-            return -1;
-        res = PyObject_RichCompareBool(litem, item, Py_LT);
-        Py_DECREF(litem);
-        if (res < 0)
-            return -1;
-        if (res)
-            lo = mid + 1;
-        else
-            hi = mid;
-    }
-    return lo;
-}
-
+internal_bisect_left(PyObject *list, PyObject *item, Py_ssize_t lo, Py_ssize_t hi) 
+{ 
+    PyObject *litem; 
+    Py_ssize_t mid; 
+    int res; 
+ 
+    if (lo < 0) { 
+        PyErr_SetString(PyExc_ValueError, "lo must be non-negative"); 
+        return -1; 
+    } 
+    if (hi == -1) { 
+        hi = PySequence_Size(list); 
+        if (hi < 0) 
+            return -1; 
+    } 
+    while (lo < hi) { 
+        /* The (size_t)cast ensures that the addition and subsequent division 
+           are performed as unsigned operations, avoiding difficulties from 
+           signed overflow.  (See issue 13496.) */ 
+        mid = ((size_t)lo + hi) / 2; 
+        litem = PySequence_GetItem(list, mid); 
+        if (litem == NULL) 
+            return -1; 
+        res = PyObject_RichCompareBool(litem, item, Py_LT); 
+        Py_DECREF(litem); 
+        if (res < 0) 
+            return -1; 
+        if (res) 
+            lo = mid + 1; 
+        else 
+            hi = mid; 
+    } 
+    return lo; 
+} 
+ 
 
 /*[clinic input]
 _bisect.bisect_left -> Py_ssize_t
@@ -175,11 +175,11 @@ static Py_ssize_t
 _bisect_bisect_left_impl(PyObject *module, PyObject *a, PyObject *x,
                          Py_ssize_t lo, Py_ssize_t hi)
 /*[clinic end generated code: output=af82168bc2856f24 input=2bd90f34afe5609f]*/
-{
+{ 
     return internal_bisect_left(a, x, lo, hi);
-}
-
-
+} 
+ 
+ 
 /*[clinic input]
 _bisect.insort_left
 
@@ -196,59 +196,59 @@ Optional args lo (default 0) and hi (default len(a)) bound the
 slice of a to be searched.
 [clinic start generated code]*/
 
-static PyObject *
+static PyObject * 
 _bisect_insort_left_impl(PyObject *module, PyObject *a, PyObject *x,
                          Py_ssize_t lo, Py_ssize_t hi)
 /*[clinic end generated code: output=9e8356c0844a182b input=bc4583308bce00cc]*/
-{
+{ 
     PyObject *result;
     Py_ssize_t index = internal_bisect_left(a, x, lo, hi);
-    if (index < 0)
-        return NULL;
+    if (index < 0) 
+        return NULL; 
     if (PyList_CheckExact(a)) {
         if (PyList_Insert(a, index, x) < 0)
-            return NULL;
-    } else {
+            return NULL; 
+    } else { 
         result = _PyObject_CallMethodId(a, &PyId_insert, "nO", index, x);
-        if (result == NULL)
-            return NULL;
-        Py_DECREF(result);
-    }
-
-    Py_RETURN_NONE;
-}
-
-static PyMethodDef bisect_methods[] = {
+        if (result == NULL) 
+            return NULL; 
+        Py_DECREF(result); 
+    } 
+ 
+    Py_RETURN_NONE; 
+} 
+ 
+static PyMethodDef bisect_methods[] = { 
     _BISECT_BISECT_RIGHT_METHODDEF
     _BISECT_INSORT_RIGHT_METHODDEF
     _BISECT_BISECT_LEFT_METHODDEF
     _BISECT_INSORT_LEFT_METHODDEF
-    {NULL, NULL} /* sentinel */
-};
-
-PyDoc_STRVAR(module_doc,
-"Bisection algorithms.\n\
-\n\
-This module provides support for maintaining a list in sorted order without\n\
-having to sort the list after each insertion. For long lists of items with\n\
-expensive comparison operations, this can be an improvement over the more\n\
-common approach.\n");
-
-
-static struct PyModuleDef _bisectmodule = {
-    PyModuleDef_HEAD_INIT,
-    "_bisect",
-    module_doc,
-    -1,
-    bisect_methods,
-    NULL,
-    NULL,
-    NULL,
-    NULL
-};
-
-PyMODINIT_FUNC
-PyInit__bisect(void)
-{
-    return PyModule_Create(&_bisectmodule);
-}
+    {NULL, NULL} /* sentinel */ 
+}; 
+ 
+PyDoc_STRVAR(module_doc, 
+"Bisection algorithms.\n\ 
+\n\ 
+This module provides support for maintaining a list in sorted order without\n\ 
+having to sort the list after each insertion. For long lists of items with\n\ 
+expensive comparison operations, this can be an improvement over the more\n\ 
+common approach.\n"); 
+ 
+ 
+static struct PyModuleDef _bisectmodule = { 
+    PyModuleDef_HEAD_INIT, 
+    "_bisect", 
+    module_doc, 
+    -1, 
+    bisect_methods, 
+    NULL, 
+    NULL, 
+    NULL, 
+    NULL 
+}; 
+ 
+PyMODINIT_FUNC 
+PyInit__bisect(void) 
+{ 
+    return PyModule_Create(&_bisectmodule); 
+}