Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 2 of 2.

1 files changed, 86 insertions, 86 deletions

diff --git a/contrib/tools/python3/src/Python/peephole.c b/contrib/tools/python3/src/Python/peephole.c
index c5c8ed1b5b..6954c87b13 100644
--- a/contrib/tools/python3/src/Python/peephole.c
+++ b/contrib/tools/python3/src/Python/peephole.c
@@ -13,9 +13,9 @@
 #define UNCONDITIONAL_JUMP(op)  (op==JUMP_ABSOLUTE || op==JUMP_FORWARD)
 #define CONDITIONAL_JUMP(op) (op==POP_JUMP_IF_FALSE || op==POP_JUMP_IF_TRUE \
     || op==JUMP_IF_FALSE_OR_POP || op==JUMP_IF_TRUE_OR_POP)
-#define ABSOLUTE_JUMP(op) (op==JUMP_ABSOLUTE \ 
+#define ABSOLUTE_JUMP(op) (op==JUMP_ABSOLUTE \
     || op==POP_JUMP_IF_FALSE || op==POP_JUMP_IF_TRUE \
-    || op==JUMP_IF_FALSE_OR_POP || op==JUMP_IF_TRUE_OR_POP || op==JUMP_IF_NOT_EXC_MATCH) 
+    || op==JUMP_IF_FALSE_OR_POP || op==JUMP_IF_TRUE_OR_POP || op==JUMP_IF_NOT_EXC_MATCH)
 #define JUMPS_ON_TRUE(op) (op==POP_JUMP_IF_TRUE || op==JUMP_IF_TRUE_OR_POP)
 #define GETJUMPTGT(arr, i) (get_arg(arr, i) / sizeof(_Py_CODEUNIT) + \
         (ABSOLUTE_JUMP(_Py_OPCODE(arr[i])) ? 0 : i+1))
@@ -152,15 +152,15 @@ fold_tuple_on_constants(_Py_CODEUNIT *codestr, Py_ssize_t codelen,
         PyTuple_SET_ITEM(newconst, i, constant);
     }
 
-    Py_ssize_t index = PyList_GET_SIZE(consts); 
-#if SIZEOF_SIZE_T > SIZEOF_INT 
-    if ((size_t)index >= UINT_MAX - 1) { 
-        Py_DECREF(newconst); 
-        PyErr_SetString(PyExc_OverflowError, "too many constants"); 
-        return -1; 
-    } 
-#endif 
- 
+    Py_ssize_t index = PyList_GET_SIZE(consts);
+#if SIZEOF_SIZE_T > SIZEOF_INT
+    if ((size_t)index >= UINT_MAX - 1) {
+        Py_DECREF(newconst);
+        PyErr_SetString(PyExc_OverflowError, "too many constants");
+        return -1;
+    }
+#endif
+
     /* Append folded constant onto consts */
     if (PyList_Append(consts, newconst)) {
         Py_DECREF(newconst);
@@ -169,7 +169,7 @@ fold_tuple_on_constants(_Py_CODEUNIT *codestr, Py_ssize_t codelen,
     Py_DECREF(newconst);
 
     return copy_op_arg(codestr, c_start, LOAD_CONST,
-                       (unsigned int)index, opcode_end); 
+                       (unsigned int)index, opcode_end);
 }
 
 static unsigned int *
@@ -194,7 +194,7 @@ markblocks(_Py_CODEUNIT *code, Py_ssize_t len)
             case JUMP_IF_TRUE_OR_POP:
             case POP_JUMP_IF_FALSE:
             case POP_JUMP_IF_TRUE:
-            case JUMP_IF_NOT_EXC_MATCH: 
+            case JUMP_IF_NOT_EXC_MATCH:
             case JUMP_ABSOLUTE:
             case SETUP_FINALLY:
             case SETUP_WITH:
@@ -230,7 +230,7 @@ PyObject *
 PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names,
                 PyObject *lnotab_obj)
 {
-    Py_ssize_t h, i, nexti, op_start, tgt; 
+    Py_ssize_t h, i, nexti, op_start, tgt;
     unsigned int j, nops;
     unsigned char opcode, nextop;
     _Py_CODEUNIT *codestr = NULL;
@@ -250,34 +250,34 @@ PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names,
     lnotab = (unsigned char*)PyBytes_AS_STRING(lnotab_obj);
     tabsiz = PyBytes_GET_SIZE(lnotab_obj);
     assert(tabsiz == 0 || Py_REFCNT(lnotab_obj) == 1);
- 
-    /* Don't optimize if lnotab contains instruction pointer delta larger 
-       than +255 (encoded as multiple bytes), just to keep the peephole optimizer 
-       simple. The optimizer leaves line number deltas unchanged. */ 
- 
-    for (i = 0; i < tabsiz; i += 2) { 
-        if (lnotab[i] == 255) { 
-            goto exitUnchanged; 
-        } 
+
+    /* Don't optimize if lnotab contains instruction pointer delta larger
+       than +255 (encoded as multiple bytes), just to keep the peephole optimizer
+       simple. The optimizer leaves line number deltas unchanged. */
+
+    for (i = 0; i < tabsiz; i += 2) {
+        if (lnotab[i] == 255) {
+            goto exitUnchanged;
+        }
     }
 
     assert(PyBytes_Check(code));
-    Py_ssize_t codesize = PyBytes_GET_SIZE(code); 
-    assert(codesize % sizeof(_Py_CODEUNIT) == 0); 
-    Py_ssize_t codelen = codesize / sizeof(_Py_CODEUNIT); 
-    if (codelen > INT_MAX) { 
-        /* Python assembler is limited to INT_MAX: see assembler.a_offset in 
-           compile.c. */ 
-        goto exitUnchanged; 
-    } 
+    Py_ssize_t codesize = PyBytes_GET_SIZE(code);
+    assert(codesize % sizeof(_Py_CODEUNIT) == 0);
+    Py_ssize_t codelen = codesize / sizeof(_Py_CODEUNIT);
+    if (codelen > INT_MAX) {
+        /* Python assembler is limited to INT_MAX: see assembler.a_offset in
+           compile.c. */
+        goto exitUnchanged;
+    }
 
     /* Make a modifiable copy of the code string */
-    codestr = (_Py_CODEUNIT *)PyMem_Malloc(codesize); 
+    codestr = (_Py_CODEUNIT *)PyMem_Malloc(codesize);
     if (codestr == NULL) {
         PyErr_NoMemory();
         goto exitError;
     }
-    memcpy(codestr, PyBytes_AS_STRING(code), codesize); 
+    memcpy(codestr, PyBytes_AS_STRING(code), codesize);
 
     blocks = markblocks(codestr, codelen);
     if (blocks == NULL)
@@ -306,18 +306,18 @@ PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names,
             case LOAD_CONST:
                 cumlc = lastlc + 1;
                 if (nextop != POP_JUMP_IF_FALSE  ||
-                    !ISBASICBLOCK(blocks, op_start, i + 1)) { 
+                    !ISBASICBLOCK(blocks, op_start, i + 1)) {
                     break;
-                } 
-                PyObject* cnt = PyList_GET_ITEM(consts, get_arg(codestr, i)); 
-                int is_true = PyObject_IsTrue(cnt); 
-                if (is_true == -1) { 
-                    goto exitError; 
-                } 
-                if (is_true == 1) { 
-                    fill_nops(codestr, op_start, nexti + 1); 
-                    cumlc = 0; 
-                } 
+                }
+                PyObject* cnt = PyList_GET_ITEM(consts, get_arg(codestr, i));
+                int is_true = PyObject_IsTrue(cnt);
+                if (is_true == -1) {
+                    goto exitError;
+                }
+                if (is_true == 1) {
+                    fill_nops(codestr, op_start, nexti + 1);
+                    cumlc = 0;
+                }
                 break;
 
                 /* Try to fold tuples of constants.
@@ -382,11 +382,11 @@ PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names,
                            jump past it), and all conditional jumps pop their
                            argument when they're not taken (so change the
                            first jump to pop its argument when it's taken). */
-                        Py_ssize_t arg = (tgt + 1); 
-                        /* cannot overflow: codelen <= INT_MAX */ 
-                        assert((size_t)arg <= UINT_MAX / sizeof(_Py_CODEUNIT)); 
-                        arg *= sizeof(_Py_CODEUNIT); 
-                        h = set_arg(codestr, i, (unsigned int)arg); 
+                        Py_ssize_t arg = (tgt + 1);
+                        /* cannot overflow: codelen <= INT_MAX */
+                        assert((size_t)arg <= UINT_MAX / sizeof(_Py_CODEUNIT));
+                        arg *= sizeof(_Py_CODEUNIT);
+                        h = set_arg(codestr, i, (unsigned int)arg);
                         j = opcode == JUMP_IF_TRUE_OR_POP ?
                             POP_JUMP_IF_TRUE : POP_JUMP_IF_FALSE;
                     }
@@ -412,37 +412,37 @@ PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names,
                     codestr[op_start] = PACKOPARG(RETURN_VALUE, 0);
                     fill_nops(codestr, op_start + 1, i + 1);
                 } else if (UNCONDITIONAL_JUMP(_Py_OPCODE(codestr[tgt]))) {
-                    size_t arg = GETJUMPTGT(codestr, tgt); 
+                    size_t arg = GETJUMPTGT(codestr, tgt);
                     if (opcode == JUMP_FORWARD) { /* JMP_ABS can go backwards */
                         opcode = JUMP_ABSOLUTE;
                     } else if (!ABSOLUTE_JUMP(opcode)) {
-                        if (arg < (size_t)(i + 1)) { 
+                        if (arg < (size_t)(i + 1)) {
                             break;           /* No backward relative jumps */
                         }
-                        arg -= i + 1;          /* Calc relative jump addr */ 
+                        arg -= i + 1;          /* Calc relative jump addr */
                     }
-                    /* cannot overflow: codelen <= INT_MAX */ 
-                    assert(arg <= (UINT_MAX / sizeof(_Py_CODEUNIT))); 
-                    arg *= sizeof(_Py_CODEUNIT); 
-                    copy_op_arg(codestr, op_start, opcode, 
-                                (unsigned int)arg, i + 1); 
+                    /* cannot overflow: codelen <= INT_MAX */
+                    assert(arg <= (UINT_MAX / sizeof(_Py_CODEUNIT)));
+                    arg *= sizeof(_Py_CODEUNIT);
+                    copy_op_arg(codestr, op_start, opcode,
+                                (unsigned int)arg, i + 1);
                 }
                 break;
 
                 /* Remove unreachable ops after RETURN */
             case RETURN_VALUE:
                 h = i + 1;
-                while (h < codelen && ISBASICBLOCK(blocks, i, h)) 
-                { 
-                    /* Leave SETUP_FINALLY and RERAISE in place to help find block limits. */ 
-                    if (_Py_OPCODE(codestr[h]) == SETUP_FINALLY || _Py_OPCODE(codestr[h]) == RERAISE) { 
-                        while (h > i + 1 && 
-                               _Py_OPCODE(codestr[h - 1]) == EXTENDED_ARG) 
-                        { 
-                            h--; 
-                        } 
-                        break; 
-                    } 
+                while (h < codelen && ISBASICBLOCK(blocks, i, h))
+                {
+                    /* Leave SETUP_FINALLY and RERAISE in place to help find block limits. */
+                    if (_Py_OPCODE(codestr[h]) == SETUP_FINALLY || _Py_OPCODE(codestr[h]) == RERAISE) {
+                        while (h > i + 1 &&
+                               _Py_OPCODE(codestr[h - 1]) == EXTENDED_ARG)
+                        {
+                            h--;
+                        }
+                        break;
+                    }
                     h++;
                 }
                 if (h > i + 1) {
@@ -455,14 +455,14 @@ PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names,
 
     /* Fixup lnotab */
     for (i = 0, nops = 0; i < codelen; i++) {
-        size_t block = (size_t)i - nops; 
-        /* cannot overflow: codelen <= INT_MAX */ 
-        assert(block <= UINT_MAX); 
+        size_t block = (size_t)i - nops;
+        /* cannot overflow: codelen <= INT_MAX */
+        assert(block <= UINT_MAX);
         /* original code offset => new code offset */
-        blocks[i] = (unsigned int)block; 
-        if (_Py_OPCODE(codestr[i]) == NOP) { 
+        blocks[i] = (unsigned int)block;
+        if (_Py_OPCODE(codestr[i]) == NOP) {
             nops++;
-        } 
+        }
     }
     cum_orig_offset = 0;
     last_offset = 0;
@@ -494,7 +494,7 @@ PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names,
             case POP_JUMP_IF_TRUE:
             case JUMP_IF_FALSE_OR_POP:
             case JUMP_IF_TRUE_OR_POP:
-            case JUMP_IF_NOT_EXC_MATCH: 
+            case JUMP_IF_NOT_EXC_MATCH:
                 j = blocks[j / sizeof(_Py_CODEUNIT)] * sizeof(_Py_CODEUNIT);
                 break;
 
@@ -507,18 +507,18 @@ PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names,
                 j *= sizeof(_Py_CODEUNIT);
                 break;
         }
-        Py_ssize_t ilen = i - op_start + 1; 
-        if (instrsize(j) > ilen) { 
+        Py_ssize_t ilen = i - op_start + 1;
+        if (instrsize(j) > ilen) {
             goto exitUnchanged;
-        } 
-        /* If instrsize(j) < ilen, we'll emit EXTENDED_ARG 0 */ 
-        if (ilen > 4) { 
-            /* Can only happen when PyCode_Optimize() is called with 
-               malformed bytecode. */ 
-            goto exitUnchanged; 
-        } 
-        write_op_arg(codestr + h, opcode, j, (int)ilen); 
-        h += ilen; 
+        }
+        /* If instrsize(j) < ilen, we'll emit EXTENDED_ARG 0 */
+        if (ilen > 4) {
+            /* Can only happen when PyCode_Optimize() is called with
+               malformed bytecode. */
+            goto exitUnchanged;
+        }
+        write_op_arg(codestr + h, opcode, j, (int)ilen);
+        h += ilen;
     }
     assert(h + (Py_ssize_t)nops == codelen);