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

1 files changed, 825 insertions, 825 deletions

diff --git a/contrib/tools/python3/src/Objects/codeobject.c b/contrib/tools/python3/src/Objects/codeobject.c
index 5f14e96ff7a..cb4fb681243 100644
--- a/contrib/tools/python3/src/Objects/codeobject.c
+++ b/contrib/tools/python3/src/Objects/codeobject.c
@@ -1,7 +1,7 @@
-#include <stdbool.h> 
- 
-#include "Python.h" 
-#include "code.h" 
+#include <stdbool.h>
+
+#include "Python.h"
+#include "code.h"
 #include "opcode.h"
 #include "structmember.h"         // PyMemberDef
 #include "pycore_code.h"
@@ -9,147 +9,147 @@
 #include "pycore_pystate.h"       // _PyInterpreterState_GET()
 #include "pycore_tupleobject.h"
 #include "clinic/codeobject.c.h"
- 
-/* Holder for co_extra information */ 
-typedef struct { 
-    Py_ssize_t ce_size; 
-    void *ce_extras[1]; 
-} _PyCodeObjectExtra; 
- 
+
+/* Holder for co_extra information */
+typedef struct {
+    Py_ssize_t ce_size;
+    void *ce_extras[1];
+} _PyCodeObjectExtra;
+
 /*[clinic input]
 class code "PyCodeObject *" "&PyCode_Type"
 [clinic start generated code]*/
 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=78aa5d576683bb4b]*/
 
-/* all_name_chars(s): true iff s matches [a-zA-Z0-9_]* */ 
-static int 
-all_name_chars(PyObject *o) 
-{ 
-    const unsigned char *s, *e; 
- 
-    if (!PyUnicode_IS_ASCII(o)) 
-        return 0; 
- 
-    s = PyUnicode_1BYTE_DATA(o); 
-    e = s + PyUnicode_GET_LENGTH(o); 
-    for (; s != e; s++) { 
-        if (!Py_ISALNUM(*s) && *s != '_') 
-            return 0; 
-    } 
-    return 1; 
-} 
- 
+/* all_name_chars(s): true iff s matches [a-zA-Z0-9_]* */
 static int
-intern_strings(PyObject *tuple) 
-{ 
-    Py_ssize_t i; 
- 
-    for (i = PyTuple_GET_SIZE(tuple); --i >= 0; ) { 
-        PyObject *v = PyTuple_GET_ITEM(tuple, i); 
-        if (v == NULL || !PyUnicode_CheckExact(v)) { 
+all_name_chars(PyObject *o)
+{
+    const unsigned char *s, *e;
+
+    if (!PyUnicode_IS_ASCII(o))
+        return 0;
+
+    s = PyUnicode_1BYTE_DATA(o);
+    e = s + PyUnicode_GET_LENGTH(o);
+    for (; s != e; s++) {
+        if (!Py_ISALNUM(*s) && *s != '_')
+            return 0;
+    }
+    return 1;
+}
+
+static int
+intern_strings(PyObject *tuple)
+{
+    Py_ssize_t i;
+
+    for (i = PyTuple_GET_SIZE(tuple); --i >= 0; ) {
+        PyObject *v = PyTuple_GET_ITEM(tuple, i);
+        if (v == NULL || !PyUnicode_CheckExact(v)) {
             PyErr_SetString(PyExc_SystemError,
                             "non-string found in code slot");
             return -1;
-        } 
+        }
         PyUnicode_InternInPlace(&_PyTuple_ITEMS(tuple)[i]);
-    } 
+    }
     return 0;
-} 
- 
-/* Intern selected string constants */ 
-static int 
+}
+
+/* Intern selected string constants */
+static int
 intern_string_constants(PyObject *tuple, int *modified)
-{ 
+{
     for (Py_ssize_t i = PyTuple_GET_SIZE(tuple); --i >= 0; ) {
-        PyObject *v = PyTuple_GET_ITEM(tuple, i); 
-        if (PyUnicode_CheckExact(v)) { 
-            if (PyUnicode_READY(v) == -1) { 
+        PyObject *v = PyTuple_GET_ITEM(tuple, i);
+        if (PyUnicode_CheckExact(v)) {
+            if (PyUnicode_READY(v) == -1) {
                 return -1;
-            } 
+            }
 
-            if (all_name_chars(v)) { 
-                PyObject *w = v; 
-                PyUnicode_InternInPlace(&v); 
-                if (w != v) { 
-                    PyTuple_SET_ITEM(tuple, i, v); 
+            if (all_name_chars(v)) {
+                PyObject *w = v;
+                PyUnicode_InternInPlace(&v);
+                if (w != v) {
+                    PyTuple_SET_ITEM(tuple, i, v);
                     if (modified) {
                         *modified = 1;
                     }
-                } 
-            } 
-        } 
-        else if (PyTuple_CheckExact(v)) { 
+                }
+            }
+        }
+        else if (PyTuple_CheckExact(v)) {
             if (intern_string_constants(v, NULL) < 0) {
                 return -1;
             }
-        } 
-        else if (PyFrozenSet_CheckExact(v)) { 
-            PyObject *w = v; 
-            PyObject *tmp = PySequence_Tuple(v); 
-            if (tmp == NULL) { 
+        }
+        else if (PyFrozenSet_CheckExact(v)) {
+            PyObject *w = v;
+            PyObject *tmp = PySequence_Tuple(v);
+            if (tmp == NULL) {
                 return -1;
-            } 
+            }
             int tmp_modified = 0;
             if (intern_string_constants(tmp, &tmp_modified) < 0) {
                 Py_DECREF(tmp);
                 return -1;
             }
             if (tmp_modified) {
-                v = PyFrozenSet_New(tmp); 
-                if (v == NULL) { 
+                v = PyFrozenSet_New(tmp);
+                if (v == NULL) {
                     Py_DECREF(tmp);
                     return -1;
-                } 
+                }
 
                 PyTuple_SET_ITEM(tuple, i, v);
                 Py_DECREF(w);
                 if (modified) {
                     *modified = 1;
-                } 
-            } 
-            Py_DECREF(tmp); 
-        } 
-    } 
+                }
+            }
+            Py_DECREF(tmp);
+        }
+    }
     return 0;
-} 
- 
-PyCodeObject * 
+}
+
+PyCodeObject *
 PyCode_NewWithPosOnlyArgs(int argcount, int posonlyargcount, int kwonlyargcount,
                           int nlocals, int stacksize, int flags,
                           PyObject *code, PyObject *consts, PyObject *names,
                           PyObject *varnames, PyObject *freevars, PyObject *cellvars,
                           PyObject *filename, PyObject *name, int firstlineno,
                           PyObject *lnotab)
-{ 
-    PyCodeObject *co; 
-    Py_ssize_t *cell2arg = NULL; 
-    Py_ssize_t i, n_cellvars, n_varnames, total_args; 
- 
-    /* Check argument types */ 
+{
+    PyCodeObject *co;
+    Py_ssize_t *cell2arg = NULL;
+    Py_ssize_t i, n_cellvars, n_varnames, total_args;
+
+    /* Check argument types */
     if (argcount < posonlyargcount || posonlyargcount < 0 ||
         kwonlyargcount < 0 || nlocals < 0 ||
         stacksize < 0 || flags < 0 ||
-        code == NULL || !PyBytes_Check(code) || 
-        consts == NULL || !PyTuple_Check(consts) || 
-        names == NULL || !PyTuple_Check(names) || 
-        varnames == NULL || !PyTuple_Check(varnames) || 
-        freevars == NULL || !PyTuple_Check(freevars) || 
-        cellvars == NULL || !PyTuple_Check(cellvars) || 
-        name == NULL || !PyUnicode_Check(name) || 
-        filename == NULL || !PyUnicode_Check(filename) || 
-        lnotab == NULL || !PyBytes_Check(lnotab)) { 
-        PyErr_BadInternalCall(); 
-        return NULL; 
-    } 
- 
+        code == NULL || !PyBytes_Check(code) ||
+        consts == NULL || !PyTuple_Check(consts) ||
+        names == NULL || !PyTuple_Check(names) ||
+        varnames == NULL || !PyTuple_Check(varnames) ||
+        freevars == NULL || !PyTuple_Check(freevars) ||
+        cellvars == NULL || !PyTuple_Check(cellvars) ||
+        name == NULL || !PyUnicode_Check(name) ||
+        filename == NULL || !PyUnicode_Check(filename) ||
+        lnotab == NULL || !PyBytes_Check(lnotab)) {
+        PyErr_BadInternalCall();
+        return NULL;
+    }
+
     /* Ensure that strings are ready Unicode string */
     if (PyUnicode_READY(name) < 0) {
-        return NULL; 
+        return NULL;
     }
     if (PyUnicode_READY(filename) < 0) {
         return NULL;
     }
- 
+
     if (intern_strings(names) < 0) {
         return NULL;
     }
@@ -165,7 +165,7 @@ PyCode_NewWithPosOnlyArgs(int argcount, int posonlyargcount, int kwonlyargcount,
     if (intern_string_constants(consts, NULL) < 0) {
         return NULL;
     }
- 
+
     /* Make sure that code is indexable with an int, this is
        a long running assumption in ceval.c and many parts of
        the interpreter. */
@@ -174,104 +174,104 @@ PyCode_NewWithPosOnlyArgs(int argcount, int posonlyargcount, int kwonlyargcount,
         return NULL;
     }
 
-    /* Check for any inner or outer closure references */ 
-    n_cellvars = PyTuple_GET_SIZE(cellvars); 
-    if (!n_cellvars && !PyTuple_GET_SIZE(freevars)) { 
-        flags |= CO_NOFREE; 
-    } else { 
-        flags &= ~CO_NOFREE; 
-    } 
- 
-    n_varnames = PyTuple_GET_SIZE(varnames); 
-    if (argcount <= n_varnames && kwonlyargcount <= n_varnames) { 
-        /* Never overflows. */ 
-        total_args = (Py_ssize_t)argcount + (Py_ssize_t)kwonlyargcount + 
+    /* Check for any inner or outer closure references */
+    n_cellvars = PyTuple_GET_SIZE(cellvars);
+    if (!n_cellvars && !PyTuple_GET_SIZE(freevars)) {
+        flags |= CO_NOFREE;
+    } else {
+        flags &= ~CO_NOFREE;
+    }
+
+    n_varnames = PyTuple_GET_SIZE(varnames);
+    if (argcount <= n_varnames && kwonlyargcount <= n_varnames) {
+        /* Never overflows. */
+        total_args = (Py_ssize_t)argcount + (Py_ssize_t)kwonlyargcount +
                       ((flags & CO_VARARGS) != 0) + ((flags & CO_VARKEYWORDS) != 0);
-    } 
-    else { 
-        total_args = n_varnames + 1; 
-    } 
-    if (total_args > n_varnames) { 
-        PyErr_SetString(PyExc_ValueError, "code: varnames is too small"); 
-        return NULL; 
-    } 
- 
-    /* Create mapping between cells and arguments if needed. */ 
-    if (n_cellvars) { 
-        bool used_cell2arg = false; 
-        cell2arg = PyMem_NEW(Py_ssize_t, n_cellvars); 
-        if (cell2arg == NULL) { 
-            PyErr_NoMemory(); 
-            return NULL; 
-        } 
-        /* Find cells which are also arguments. */ 
-        for (i = 0; i < n_cellvars; i++) { 
-            Py_ssize_t j; 
-            PyObject *cell = PyTuple_GET_ITEM(cellvars, i); 
-            cell2arg[i] = CO_CELL_NOT_AN_ARG; 
-            for (j = 0; j < total_args; j++) { 
-                PyObject *arg = PyTuple_GET_ITEM(varnames, j); 
-                int cmp = PyUnicode_Compare(cell, arg); 
-                if (cmp == -1 && PyErr_Occurred()) { 
-                    PyMem_FREE(cell2arg); 
-                    return NULL; 
-                } 
-                if (cmp == 0) { 
-                    cell2arg[i] = j; 
-                    used_cell2arg = true; 
-                    break; 
-                } 
-            } 
-        } 
-        if (!used_cell2arg) { 
-            PyMem_FREE(cell2arg); 
-            cell2arg = NULL; 
-        } 
-    } 
+    }
+    else {
+        total_args = n_varnames + 1;
+    }
+    if (total_args > n_varnames) {
+        PyErr_SetString(PyExc_ValueError, "code: varnames is too small");
+        return NULL;
+    }
+
+    /* Create mapping between cells and arguments if needed. */
+    if (n_cellvars) {
+        bool used_cell2arg = false;
+        cell2arg = PyMem_NEW(Py_ssize_t, n_cellvars);
+        if (cell2arg == NULL) {
+            PyErr_NoMemory();
+            return NULL;
+        }
+        /* Find cells which are also arguments. */
+        for (i = 0; i < n_cellvars; i++) {
+            Py_ssize_t j;
+            PyObject *cell = PyTuple_GET_ITEM(cellvars, i);
+            cell2arg[i] = CO_CELL_NOT_AN_ARG;
+            for (j = 0; j < total_args; j++) {
+                PyObject *arg = PyTuple_GET_ITEM(varnames, j);
+                int cmp = PyUnicode_Compare(cell, arg);
+                if (cmp == -1 && PyErr_Occurred()) {
+                    PyMem_FREE(cell2arg);
+                    return NULL;
+                }
+                if (cmp == 0) {
+                    cell2arg[i] = j;
+                    used_cell2arg = true;
+                    break;
+                }
+            }
+        }
+        if (!used_cell2arg) {
+            PyMem_FREE(cell2arg);
+            cell2arg = NULL;
+        }
+    }
     co = PyObject_New(PyCodeObject, &PyCode_Type);
-    if (co == NULL) { 
-        if (cell2arg) 
-            PyMem_FREE(cell2arg); 
-        return NULL; 
-    } 
-    co->co_argcount = argcount; 
+    if (co == NULL) {
+        if (cell2arg)
+            PyMem_FREE(cell2arg);
+        return NULL;
+    }
+    co->co_argcount = argcount;
     co->co_posonlyargcount = posonlyargcount;
-    co->co_kwonlyargcount = kwonlyargcount; 
-    co->co_nlocals = nlocals; 
-    co->co_stacksize = stacksize; 
-    co->co_flags = flags; 
-    Py_INCREF(code); 
-    co->co_code = code; 
-    Py_INCREF(consts); 
-    co->co_consts = consts; 
-    Py_INCREF(names); 
-    co->co_names = names; 
-    Py_INCREF(varnames); 
-    co->co_varnames = varnames; 
-    Py_INCREF(freevars); 
-    co->co_freevars = freevars; 
-    Py_INCREF(cellvars); 
-    co->co_cellvars = cellvars; 
-    co->co_cell2arg = cell2arg; 
-    Py_INCREF(filename); 
-    co->co_filename = filename; 
-    Py_INCREF(name); 
-    co->co_name = name; 
-    co->co_firstlineno = firstlineno; 
-    Py_INCREF(lnotab); 
-    co->co_lnotab = lnotab; 
-    co->co_zombieframe = NULL; 
-    co->co_weakreflist = NULL; 
-    co->co_extra = NULL; 
+    co->co_kwonlyargcount = kwonlyargcount;
+    co->co_nlocals = nlocals;
+    co->co_stacksize = stacksize;
+    co->co_flags = flags;
+    Py_INCREF(code);
+    co->co_code = code;
+    Py_INCREF(consts);
+    co->co_consts = consts;
+    Py_INCREF(names);
+    co->co_names = names;
+    Py_INCREF(varnames);
+    co->co_varnames = varnames;
+    Py_INCREF(freevars);
+    co->co_freevars = freevars;
+    Py_INCREF(cellvars);
+    co->co_cellvars = cellvars;
+    co->co_cell2arg = cell2arg;
+    Py_INCREF(filename);
+    co->co_filename = filename;
+    Py_INCREF(name);
+    co->co_name = name;
+    co->co_firstlineno = firstlineno;
+    Py_INCREF(lnotab);
+    co->co_lnotab = lnotab;
+    co->co_zombieframe = NULL;
+    co->co_weakreflist = NULL;
+    co->co_extra = NULL;
 
     co->co_opcache_map = NULL;
     co->co_opcache = NULL;
     co->co_opcache_flag = 0;
     co->co_opcache_size = 0;
-    return co; 
-} 
- 
-PyCodeObject * 
+    return co;
+}
+
+PyCodeObject *
 PyCode_New(int argcount, int kwonlyargcount,
            int nlocals, int stacksize, int flags,
            PyObject *code, PyObject *consts, PyObject *names,
@@ -329,58 +329,58 @@ _PyCode_InitOpcache(PyCodeObject *co)
 }
 
 PyCodeObject *
-PyCode_NewEmpty(const char *filename, const char *funcname, int firstlineno) 
-{ 
-    static PyObject *emptystring = NULL; 
-    static PyObject *nulltuple = NULL; 
-    PyObject *filename_ob = NULL; 
-    PyObject *funcname_ob = NULL; 
-    PyCodeObject *result = NULL; 
-    if (emptystring == NULL) { 
-        emptystring = PyBytes_FromString(""); 
-        if (emptystring == NULL) 
-            goto failed; 
-    } 
-    if (nulltuple == NULL) { 
-        nulltuple = PyTuple_New(0); 
-        if (nulltuple == NULL) 
-            goto failed; 
-    } 
-    funcname_ob = PyUnicode_FromString(funcname); 
-    if (funcname_ob == NULL) 
-        goto failed; 
-    filename_ob = PyUnicode_DecodeFSDefault(filename); 
-    if (filename_ob == NULL) 
-        goto failed; 
- 
+PyCode_NewEmpty(const char *filename, const char *funcname, int firstlineno)
+{
+    static PyObject *emptystring = NULL;
+    static PyObject *nulltuple = NULL;
+    PyObject *filename_ob = NULL;
+    PyObject *funcname_ob = NULL;
+    PyCodeObject *result = NULL;
+    if (emptystring == NULL) {
+        emptystring = PyBytes_FromString("");
+        if (emptystring == NULL)
+            goto failed;
+    }
+    if (nulltuple == NULL) {
+        nulltuple = PyTuple_New(0);
+        if (nulltuple == NULL)
+            goto failed;
+    }
+    funcname_ob = PyUnicode_FromString(funcname);
+    if (funcname_ob == NULL)
+        goto failed;
+    filename_ob = PyUnicode_DecodeFSDefault(filename);
+    if (filename_ob == NULL)
+        goto failed;
+
     result = PyCode_NewWithPosOnlyArgs(
                 0,                    /* argcount */
                 0,                              /* posonlyargcount */
-                0,                              /* kwonlyargcount */ 
-                0,                              /* nlocals */ 
-                0,                              /* stacksize */ 
-                0,                              /* flags */ 
-                emptystring,                    /* code */ 
-                nulltuple,                      /* consts */ 
-                nulltuple,                      /* names */ 
-                nulltuple,                      /* varnames */ 
-                nulltuple,                      /* freevars */ 
-                nulltuple,                      /* cellvars */ 
-                filename_ob,                    /* filename */ 
-                funcname_ob,                    /* name */ 
-                firstlineno,                    /* firstlineno */ 
-                emptystring                     /* lnotab */ 
-                ); 
- 
-failed: 
-    Py_XDECREF(funcname_ob); 
-    Py_XDECREF(filename_ob); 
-    return result; 
-} 
- 
-#define OFF(x) offsetof(PyCodeObject, x) 
- 
-static PyMemberDef code_memberlist[] = { 
+                0,                              /* kwonlyargcount */
+                0,                              /* nlocals */
+                0,                              /* stacksize */
+                0,                              /* flags */
+                emptystring,                    /* code */
+                nulltuple,                      /* consts */
+                nulltuple,                      /* names */
+                nulltuple,                      /* varnames */
+                nulltuple,                      /* freevars */
+                nulltuple,                      /* cellvars */
+                filename_ob,                    /* filename */
+                funcname_ob,                    /* name */
+                firstlineno,                    /* firstlineno */
+                emptystring                     /* lnotab */
+                );
+
+failed:
+    Py_XDECREF(funcname_ob);
+    Py_XDECREF(filename_ob);
+    return result;
+}
+
+#define OFF(x) offsetof(PyCodeObject, x)
+
+static PyMemberDef code_memberlist[] = {
     {"co_argcount",     T_INT,          OFF(co_argcount),        READONLY},
     {"co_posonlyargcount",      T_INT,  OFF(co_posonlyargcount), READONLY},
     {"co_kwonlyargcount",       T_INT,  OFF(co_kwonlyargcount),  READONLY},
@@ -397,105 +397,105 @@ static PyMemberDef code_memberlist[] = {
     {"co_name",         T_OBJECT,       OFF(co_name),            READONLY},
     {"co_firstlineno", T_INT,           OFF(co_firstlineno),     READONLY},
     {"co_lnotab",       T_OBJECT,       OFF(co_lnotab),          READONLY},
-    {NULL}      /* Sentinel */ 
-}; 
- 
-/* Helper for code_new: return a shallow copy of a tuple that is 
-   guaranteed to contain exact strings, by converting string subclasses 
-   to exact strings and complaining if a non-string is found. */ 
-static PyObject* 
-validate_and_copy_tuple(PyObject *tup) 
-{ 
-    PyObject *newtuple; 
-    PyObject *item; 
-    Py_ssize_t i, len; 
- 
-    len = PyTuple_GET_SIZE(tup); 
-    newtuple = PyTuple_New(len); 
-    if (newtuple == NULL) 
-        return NULL; 
- 
-    for (i = 0; i < len; i++) { 
-        item = PyTuple_GET_ITEM(tup, i); 
-        if (PyUnicode_CheckExact(item)) { 
-            Py_INCREF(item); 
-        } 
-        else if (!PyUnicode_Check(item)) { 
-            PyErr_Format( 
-                PyExc_TypeError, 
-                "name tuples must contain only " 
-                "strings, not '%.500s'", 
+    {NULL}      /* Sentinel */
+};
+
+/* Helper for code_new: return a shallow copy of a tuple that is
+   guaranteed to contain exact strings, by converting string subclasses
+   to exact strings and complaining if a non-string is found. */
+static PyObject*
+validate_and_copy_tuple(PyObject *tup)
+{
+    PyObject *newtuple;
+    PyObject *item;
+    Py_ssize_t i, len;
+
+    len = PyTuple_GET_SIZE(tup);
+    newtuple = PyTuple_New(len);
+    if (newtuple == NULL)
+        return NULL;
+
+    for (i = 0; i < len; i++) {
+        item = PyTuple_GET_ITEM(tup, i);
+        if (PyUnicode_CheckExact(item)) {
+            Py_INCREF(item);
+        }
+        else if (!PyUnicode_Check(item)) {
+            PyErr_Format(
+                PyExc_TypeError,
+                "name tuples must contain only "
+                "strings, not '%.500s'",
                 Py_TYPE(item)->tp_name);
-            Py_DECREF(newtuple); 
-            return NULL; 
-        } 
-        else { 
-            item = _PyUnicode_Copy(item); 
-            if (item == NULL) { 
-                Py_DECREF(newtuple); 
-                return NULL; 
-            } 
-        } 
-        PyTuple_SET_ITEM(newtuple, i, item); 
-    } 
- 
-    return newtuple; 
-} 
- 
-PyDoc_STRVAR(code_doc, 
+            Py_DECREF(newtuple);
+            return NULL;
+        }
+        else {
+            item = _PyUnicode_Copy(item);
+            if (item == NULL) {
+                Py_DECREF(newtuple);
+                return NULL;
+            }
+        }
+        PyTuple_SET_ITEM(newtuple, i, item);
+    }
+
+    return newtuple;
+}
+
+PyDoc_STRVAR(code_doc,
 "code(argcount, posonlyargcount, kwonlyargcount, nlocals, stacksize,\n\
       flags, codestring, constants, names, varnames, filename, name,\n\
       firstlineno, lnotab[, freevars[, cellvars]])\n\
-\n\ 
-Create a code object.  Not for the faint of heart."); 
- 
-static PyObject * 
-code_new(PyTypeObject *type, PyObject *args, PyObject *kw) 
-{ 
-    int argcount; 
+\n\
+Create a code object.  Not for the faint of heart.");
+
+static PyObject *
+code_new(PyTypeObject *type, PyObject *args, PyObject *kw)
+{
+    int argcount;
     int posonlyargcount;
-    int kwonlyargcount; 
-    int nlocals; 
-    int stacksize; 
-    int flags; 
-    PyObject *co = NULL; 
-    PyObject *code; 
-    PyObject *consts; 
-    PyObject *names, *ournames = NULL; 
-    PyObject *varnames, *ourvarnames = NULL; 
-    PyObject *freevars = NULL, *ourfreevars = NULL; 
-    PyObject *cellvars = NULL, *ourcellvars = NULL; 
-    PyObject *filename; 
-    PyObject *name; 
-    int firstlineno; 
-    PyObject *lnotab; 
- 
+    int kwonlyargcount;
+    int nlocals;
+    int stacksize;
+    int flags;
+    PyObject *co = NULL;
+    PyObject *code;
+    PyObject *consts;
+    PyObject *names, *ournames = NULL;
+    PyObject *varnames, *ourvarnames = NULL;
+    PyObject *freevars = NULL, *ourfreevars = NULL;
+    PyObject *cellvars = NULL, *ourcellvars = NULL;
+    PyObject *filename;
+    PyObject *name;
+    int firstlineno;
+    PyObject *lnotab;
+
     if (!PyArg_ParseTuple(args, "iiiiiiSO!O!O!UUiS|O!O!:code",
                           &argcount, &posonlyargcount, &kwonlyargcount,
-                              &nlocals, &stacksize, &flags, 
-                          &code, 
-                          &PyTuple_Type, &consts, 
-                          &PyTuple_Type, &names, 
-                          &PyTuple_Type, &varnames, 
-                          &filename, &name, 
-                          &firstlineno, &lnotab, 
-                          &PyTuple_Type, &freevars, 
-                          &PyTuple_Type, &cellvars)) 
-        return NULL; 
- 
+                              &nlocals, &stacksize, &flags,
+                          &code,
+                          &PyTuple_Type, &consts,
+                          &PyTuple_Type, &names,
+                          &PyTuple_Type, &varnames,
+                          &filename, &name,
+                          &firstlineno, &lnotab,
+                          &PyTuple_Type, &freevars,
+                          &PyTuple_Type, &cellvars))
+        return NULL;
+
     if (PySys_Audit("code.__new__", "OOOiiiiii",
                     code, filename, name, argcount, posonlyargcount,
                     kwonlyargcount, nlocals, stacksize, flags) < 0) {
         goto cleanup;
     }
 
-    if (argcount < 0) { 
-        PyErr_SetString( 
-            PyExc_ValueError, 
-            "code: argcount must not be negative"); 
-        goto cleanup; 
-    } 
- 
+    if (argcount < 0) {
+        PyErr_SetString(
+            PyExc_ValueError,
+            "code: argcount must not be negative");
+        goto cleanup;
+    }
+
     if (posonlyargcount < 0) {
         PyErr_SetString(
             PyExc_ValueError,
@@ -503,38 +503,38 @@ code_new(PyTypeObject *type, PyObject *args, PyObject *kw)
         goto cleanup;
     }
 
-    if (kwonlyargcount < 0) { 
-        PyErr_SetString( 
-            PyExc_ValueError, 
-            "code: kwonlyargcount must not be negative"); 
-        goto cleanup; 
-    } 
-    if (nlocals < 0) { 
-        PyErr_SetString( 
-            PyExc_ValueError, 
-            "code: nlocals must not be negative"); 
-        goto cleanup; 
-    } 
- 
-    ournames = validate_and_copy_tuple(names); 
-    if (ournames == NULL) 
-        goto cleanup; 
-    ourvarnames = validate_and_copy_tuple(varnames); 
-    if (ourvarnames == NULL) 
-        goto cleanup; 
-    if (freevars) 
-        ourfreevars = validate_and_copy_tuple(freevars); 
-    else 
-        ourfreevars = PyTuple_New(0); 
-    if (ourfreevars == NULL) 
-        goto cleanup; 
-    if (cellvars) 
-        ourcellvars = validate_and_copy_tuple(cellvars); 
-    else 
-        ourcellvars = PyTuple_New(0); 
-    if (ourcellvars == NULL) 
-        goto cleanup; 
- 
+    if (kwonlyargcount < 0) {
+        PyErr_SetString(
+            PyExc_ValueError,
+            "code: kwonlyargcount must not be negative");
+        goto cleanup;
+    }
+    if (nlocals < 0) {
+        PyErr_SetString(
+            PyExc_ValueError,
+            "code: nlocals must not be negative");
+        goto cleanup;
+    }
+
+    ournames = validate_and_copy_tuple(names);
+    if (ournames == NULL)
+        goto cleanup;
+    ourvarnames = validate_and_copy_tuple(varnames);
+    if (ourvarnames == NULL)
+        goto cleanup;
+    if (freevars)
+        ourfreevars = validate_and_copy_tuple(freevars);
+    else
+        ourfreevars = PyTuple_New(0);
+    if (ourfreevars == NULL)
+        goto cleanup;
+    if (cellvars)
+        ourcellvars = validate_and_copy_tuple(cellvars);
+    else
+        ourcellvars = PyTuple_New(0);
+    if (ourcellvars == NULL)
+        goto cleanup;
+
     co = (PyObject *)PyCode_NewWithPosOnlyArgs(argcount, posonlyargcount,
                                                kwonlyargcount,
                                                nlocals, stacksize, flags,
@@ -543,16 +543,16 @@ code_new(PyTypeObject *type, PyObject *args, PyObject *kw)
                                                ourcellvars, filename,
                                                name, firstlineno, lnotab);
   cleanup:
-    Py_XDECREF(ournames); 
-    Py_XDECREF(ourvarnames); 
-    Py_XDECREF(ourfreevars); 
-    Py_XDECREF(ourcellvars); 
-    return co; 
-} 
- 
-static void 
-code_dealloc(PyCodeObject *co) 
-{ 
+    Py_XDECREF(ournames);
+    Py_XDECREF(ourvarnames);
+    Py_XDECREF(ourfreevars);
+    Py_XDECREF(ourcellvars);
+    return co;
+}
+
+static void
+code_dealloc(PyCodeObject *co)
+{
     if (co->co_opcache != NULL) {
         PyMem_FREE(co->co_opcache);
     }
@@ -562,52 +562,52 @@ code_dealloc(PyCodeObject *co)
     co->co_opcache_flag = 0;
     co->co_opcache_size = 0;
 
-    if (co->co_extra != NULL) { 
+    if (co->co_extra != NULL) {
         PyInterpreterState *interp = _PyInterpreterState_GET();
-        _PyCodeObjectExtra *co_extra = co->co_extra; 
- 
-        for (Py_ssize_t i = 0; i < co_extra->ce_size; i++) { 
-            freefunc free_extra = interp->co_extra_freefuncs[i]; 
- 
-            if (free_extra != NULL) { 
-                free_extra(co_extra->ce_extras[i]); 
-            } 
-        } 
- 
-        PyMem_Free(co_extra); 
-    } 
- 
-    Py_XDECREF(co->co_code); 
-    Py_XDECREF(co->co_consts); 
-    Py_XDECREF(co->co_names); 
-    Py_XDECREF(co->co_varnames); 
-    Py_XDECREF(co->co_freevars); 
-    Py_XDECREF(co->co_cellvars); 
-    Py_XDECREF(co->co_filename); 
-    Py_XDECREF(co->co_name); 
-    Py_XDECREF(co->co_lnotab); 
-    if (co->co_cell2arg != NULL) 
-        PyMem_FREE(co->co_cell2arg); 
-    if (co->co_zombieframe != NULL) 
-        PyObject_GC_Del(co->co_zombieframe); 
-    if (co->co_weakreflist != NULL) 
-        PyObject_ClearWeakRefs((PyObject*)co); 
-    PyObject_DEL(co); 
-} 
- 
-static PyObject * 
+        _PyCodeObjectExtra *co_extra = co->co_extra;
+
+        for (Py_ssize_t i = 0; i < co_extra->ce_size; i++) {
+            freefunc free_extra = interp->co_extra_freefuncs[i];
+
+            if (free_extra != NULL) {
+                free_extra(co_extra->ce_extras[i]);
+            }
+        }
+
+        PyMem_Free(co_extra);
+    }
+
+    Py_XDECREF(co->co_code);
+    Py_XDECREF(co->co_consts);
+    Py_XDECREF(co->co_names);
+    Py_XDECREF(co->co_varnames);
+    Py_XDECREF(co->co_freevars);
+    Py_XDECREF(co->co_cellvars);
+    Py_XDECREF(co->co_filename);
+    Py_XDECREF(co->co_name);
+    Py_XDECREF(co->co_lnotab);
+    if (co->co_cell2arg != NULL)
+        PyMem_FREE(co->co_cell2arg);
+    if (co->co_zombieframe != NULL)
+        PyObject_GC_Del(co->co_zombieframe);
+    if (co->co_weakreflist != NULL)
+        PyObject_ClearWeakRefs((PyObject*)co);
+    PyObject_DEL(co);
+}
+
+static PyObject *
 code_sizeof(PyCodeObject *co, PyObject *Py_UNUSED(args))
-{ 
-    Py_ssize_t res = _PyObject_SIZE(Py_TYPE(co)); 
-    _PyCodeObjectExtra *co_extra = (_PyCodeObjectExtra*) co->co_extra; 
- 
-    if (co->co_cell2arg != NULL && co->co_cellvars != NULL) { 
-        res += PyTuple_GET_SIZE(co->co_cellvars) * sizeof(Py_ssize_t); 
-    } 
-    if (co_extra != NULL) { 
-        res += sizeof(_PyCodeObjectExtra) + 
-               (co_extra->ce_size-1) * sizeof(co_extra->ce_extras[0]); 
-    } 
+{
+    Py_ssize_t res = _PyObject_SIZE(Py_TYPE(co));
+    _PyCodeObjectExtra *co_extra = (_PyCodeObjectExtra*) co->co_extra;
+
+    if (co->co_cell2arg != NULL && co->co_cellvars != NULL) {
+        res += PyTuple_GET_SIZE(co->co_cellvars) * sizeof(Py_ssize_t);
+    }
+    if (co_extra != NULL) {
+        res += sizeof(_PyCodeObjectExtra) +
+               (co_extra->ce_size-1) * sizeof(co_extra->ce_extras[0]);
+    }
     if (co->co_opcache != NULL) {
         assert(co->co_opcache_map != NULL);
         // co_opcache_map
@@ -615,9 +615,9 @@ code_sizeof(PyCodeObject *co, PyObject *Py_UNUSED(args))
         // co_opcache
         res += co->co_opcache_size * sizeof(_PyOpcache);
     }
-    return PyLong_FromSsize_t(res); 
-} 
- 
+    return PyLong_FromSsize_t(res);
+}
+
 /*[clinic input]
 code.replace
 
@@ -642,7 +642,7 @@ code.replace
 Return a copy of the code object with new values for the specified fields.
 [clinic start generated code]*/
 
-static PyObject * 
+static PyObject *
 code_replace_impl(PyCodeObject *self, int co_argcount,
                   int co_posonlyargcount, int co_kwonlyargcount,
                   int co_nlocals, int co_stacksize, int co_flags,
@@ -685,34 +685,34 @@ code_replace_impl(PyCodeObject *self, int co_argcount,
 }
 
 static PyObject *
-code_repr(PyCodeObject *co) 
-{ 
-    int lineno; 
-    if (co->co_firstlineno != 0) 
-        lineno = co->co_firstlineno; 
-    else 
-        lineno = -1; 
-    if (co->co_filename && PyUnicode_Check(co->co_filename)) { 
-        return PyUnicode_FromFormat( 
-            "<code object %U at %p, file \"%U\", line %d>", 
-            co->co_name, co, co->co_filename, lineno); 
-    } else { 
-        return PyUnicode_FromFormat( 
-            "<code object %U at %p, file ???, line %d>", 
-            co->co_name, co, lineno); 
-    } 
-} 
- 
-PyObject* 
-_PyCode_ConstantKey(PyObject *op) 
-{ 
-    PyObject *key; 
- 
+code_repr(PyCodeObject *co)
+{
+    int lineno;
+    if (co->co_firstlineno != 0)
+        lineno = co->co_firstlineno;
+    else
+        lineno = -1;
+    if (co->co_filename && PyUnicode_Check(co->co_filename)) {
+        return PyUnicode_FromFormat(
+            "<code object %U at %p, file \"%U\", line %d>",
+            co->co_name, co, co->co_filename, lineno);
+    } else {
+        return PyUnicode_FromFormat(
+            "<code object %U at %p, file ???, line %d>",
+            co->co_name, co, lineno);
+    }
+}
+
+PyObject*
+_PyCode_ConstantKey(PyObject *op)
+{
+    PyObject *key;
+
     /* Py_None and Py_Ellipsis are singletons. */
-    if (op == Py_None || op == Py_Ellipsis 
-       || PyLong_CheckExact(op) 
-       || PyUnicode_CheckExact(op) 
-          /* code_richcompare() uses _PyCode_ConstantKey() internally */ 
+    if (op == Py_None || op == Py_Ellipsis
+       || PyLong_CheckExact(op)
+       || PyUnicode_CheckExact(op)
+          /* code_richcompare() uses _PyCode_ConstantKey() internally */
        || PyCode_Check(op))
     {
         /* Objects of these types are always different from object of other
@@ -723,399 +723,399 @@ _PyCode_ConstantKey(PyObject *op)
     else if (PyBool_Check(op) || PyBytes_CheckExact(op)) {
         /* Make booleans different from integers 0 and 1.
          * Avoid BytesWarning from comparing bytes with strings. */
-        key = PyTuple_Pack(2, Py_TYPE(op), op); 
-    } 
-    else if (PyFloat_CheckExact(op)) { 
-        double d = PyFloat_AS_DOUBLE(op); 
-        /* all we need is to make the tuple different in either the 0.0 
-         * or -0.0 case from all others, just to avoid the "coercion". 
-         */ 
-        if (d == 0.0 && copysign(1.0, d) < 0.0) 
-            key = PyTuple_Pack(3, Py_TYPE(op), op, Py_None); 
-        else 
-            key = PyTuple_Pack(2, Py_TYPE(op), op); 
-    } 
-    else if (PyComplex_CheckExact(op)) { 
-        Py_complex z; 
-        int real_negzero, imag_negzero; 
-        /* For the complex case we must make complex(x, 0.) 
-           different from complex(x, -0.) and complex(0., y) 
-           different from complex(-0., y), for any x and y. 
-           All four complex zeros must be distinguished.*/ 
-        z = PyComplex_AsCComplex(op); 
-        real_negzero = z.real == 0.0 && copysign(1.0, z.real) < 0.0; 
-        imag_negzero = z.imag == 0.0 && copysign(1.0, z.imag) < 0.0; 
-        /* use True, False and None singleton as tags for the real and imag 
-         * sign, to make tuples different */ 
-        if (real_negzero && imag_negzero) { 
-            key = PyTuple_Pack(3, Py_TYPE(op), op, Py_True); 
-        } 
-        else if (imag_negzero) { 
-            key = PyTuple_Pack(3, Py_TYPE(op), op, Py_False); 
-        } 
-        else if (real_negzero) { 
-            key = PyTuple_Pack(3, Py_TYPE(op), op, Py_None); 
-        } 
-        else { 
-            key = PyTuple_Pack(2, Py_TYPE(op), op); 
-        } 
-    } 
-    else if (PyTuple_CheckExact(op)) { 
-        Py_ssize_t i, len; 
-        PyObject *tuple; 
- 
-        len = PyTuple_GET_SIZE(op); 
-        tuple = PyTuple_New(len); 
-        if (tuple == NULL) 
-            return NULL; 
- 
-        for (i=0; i < len; i++) { 
-            PyObject *item, *item_key; 
- 
-            item = PyTuple_GET_ITEM(op, i); 
-            item_key = _PyCode_ConstantKey(item); 
-            if (item_key == NULL) { 
-                Py_DECREF(tuple); 
-                return NULL; 
-            } 
- 
-            PyTuple_SET_ITEM(tuple, i, item_key); 
-        } 
- 
-        key = PyTuple_Pack(2, tuple, op); 
-        Py_DECREF(tuple); 
-    } 
-    else if (PyFrozenSet_CheckExact(op)) { 
-        Py_ssize_t pos = 0; 
-        PyObject *item; 
-        Py_hash_t hash; 
-        Py_ssize_t i, len; 
-        PyObject *tuple, *set; 
- 
-        len = PySet_GET_SIZE(op); 
-        tuple = PyTuple_New(len); 
-        if (tuple == NULL) 
-            return NULL; 
- 
-        i = 0; 
-        while (_PySet_NextEntry(op, &pos, &item, &hash)) { 
-            PyObject *item_key; 
- 
-            item_key = _PyCode_ConstantKey(item); 
-            if (item_key == NULL) { 
-                Py_DECREF(tuple); 
-                return NULL; 
-            } 
- 
-            assert(i < len); 
-            PyTuple_SET_ITEM(tuple, i, item_key); 
-            i++; 
-        } 
-        set = PyFrozenSet_New(tuple); 
-        Py_DECREF(tuple); 
-        if (set == NULL) 
-            return NULL; 
- 
-        key = PyTuple_Pack(2, set, op); 
-        Py_DECREF(set); 
-        return key; 
-    } 
-    else { 
-        /* for other types, use the object identifier as a unique identifier 
-         * to ensure that they are seen as unequal. */ 
-        PyObject *obj_id = PyLong_FromVoidPtr(op); 
-        if (obj_id == NULL) 
-            return NULL; 
- 
-        key = PyTuple_Pack(2, obj_id, op); 
-        Py_DECREF(obj_id); 
-    } 
-    return key; 
-} 
- 
-static PyObject * 
-code_richcompare(PyObject *self, PyObject *other, int op) 
-{ 
-    PyCodeObject *co, *cp; 
-    int eq; 
-    PyObject *consts1, *consts2; 
-    PyObject *res; 
- 
-    if ((op != Py_EQ && op != Py_NE) || 
-        !PyCode_Check(self) || 
-        !PyCode_Check(other)) { 
-        Py_RETURN_NOTIMPLEMENTED; 
-    } 
- 
-    co = (PyCodeObject *)self; 
-    cp = (PyCodeObject *)other; 
- 
-    eq = PyObject_RichCompareBool(co->co_name, cp->co_name, Py_EQ); 
+        key = PyTuple_Pack(2, Py_TYPE(op), op);
+    }
+    else if (PyFloat_CheckExact(op)) {
+        double d = PyFloat_AS_DOUBLE(op);
+        /* all we need is to make the tuple different in either the 0.0
+         * or -0.0 case from all others, just to avoid the "coercion".
+         */
+        if (d == 0.0 && copysign(1.0, d) < 0.0)
+            key = PyTuple_Pack(3, Py_TYPE(op), op, Py_None);
+        else
+            key = PyTuple_Pack(2, Py_TYPE(op), op);
+    }
+    else if (PyComplex_CheckExact(op)) {
+        Py_complex z;
+        int real_negzero, imag_negzero;
+        /* For the complex case we must make complex(x, 0.)
+           different from complex(x, -0.) and complex(0., y)
+           different from complex(-0., y), for any x and y.
+           All four complex zeros must be distinguished.*/
+        z = PyComplex_AsCComplex(op);
+        real_negzero = z.real == 0.0 && copysign(1.0, z.real) < 0.0;
+        imag_negzero = z.imag == 0.0 && copysign(1.0, z.imag) < 0.0;
+        /* use True, False and None singleton as tags for the real and imag
+         * sign, to make tuples different */
+        if (real_negzero && imag_negzero) {
+            key = PyTuple_Pack(3, Py_TYPE(op), op, Py_True);
+        }
+        else if (imag_negzero) {
+            key = PyTuple_Pack(3, Py_TYPE(op), op, Py_False);
+        }
+        else if (real_negzero) {
+            key = PyTuple_Pack(3, Py_TYPE(op), op, Py_None);
+        }
+        else {
+            key = PyTuple_Pack(2, Py_TYPE(op), op);
+        }
+    }
+    else if (PyTuple_CheckExact(op)) {
+        Py_ssize_t i, len;
+        PyObject *tuple;
+
+        len = PyTuple_GET_SIZE(op);
+        tuple = PyTuple_New(len);
+        if (tuple == NULL)
+            return NULL;
+
+        for (i=0; i < len; i++) {
+            PyObject *item, *item_key;
+
+            item = PyTuple_GET_ITEM(op, i);
+            item_key = _PyCode_ConstantKey(item);
+            if (item_key == NULL) {
+                Py_DECREF(tuple);
+                return NULL;
+            }
+
+            PyTuple_SET_ITEM(tuple, i, item_key);
+        }
+
+        key = PyTuple_Pack(2, tuple, op);
+        Py_DECREF(tuple);
+    }
+    else if (PyFrozenSet_CheckExact(op)) {
+        Py_ssize_t pos = 0;
+        PyObject *item;
+        Py_hash_t hash;
+        Py_ssize_t i, len;
+        PyObject *tuple, *set;
+
+        len = PySet_GET_SIZE(op);
+        tuple = PyTuple_New(len);
+        if (tuple == NULL)
+            return NULL;
+
+        i = 0;
+        while (_PySet_NextEntry(op, &pos, &item, &hash)) {
+            PyObject *item_key;
+
+            item_key = _PyCode_ConstantKey(item);
+            if (item_key == NULL) {
+                Py_DECREF(tuple);
+                return NULL;
+            }
+
+            assert(i < len);
+            PyTuple_SET_ITEM(tuple, i, item_key);
+            i++;
+        }
+        set = PyFrozenSet_New(tuple);
+        Py_DECREF(tuple);
+        if (set == NULL)
+            return NULL;
+
+        key = PyTuple_Pack(2, set, op);
+        Py_DECREF(set);
+        return key;
+    }
+    else {
+        /* for other types, use the object identifier as a unique identifier
+         * to ensure that they are seen as unequal. */
+        PyObject *obj_id = PyLong_FromVoidPtr(op);
+        if (obj_id == NULL)
+            return NULL;
+
+        key = PyTuple_Pack(2, obj_id, op);
+        Py_DECREF(obj_id);
+    }
+    return key;
+}
+
+static PyObject *
+code_richcompare(PyObject *self, PyObject *other, int op)
+{
+    PyCodeObject *co, *cp;
+    int eq;
+    PyObject *consts1, *consts2;
+    PyObject *res;
+
+    if ((op != Py_EQ && op != Py_NE) ||
+        !PyCode_Check(self) ||
+        !PyCode_Check(other)) {
+        Py_RETURN_NOTIMPLEMENTED;
+    }
+
+    co = (PyCodeObject *)self;
+    cp = (PyCodeObject *)other;
+
+    eq = PyObject_RichCompareBool(co->co_name, cp->co_name, Py_EQ);
+    if (!eq) goto unequal;
+    eq = co->co_argcount == cp->co_argcount;
     if (!eq) goto unequal;
-    eq = co->co_argcount == cp->co_argcount; 
-    if (!eq) goto unequal; 
     eq = co->co_posonlyargcount == cp->co_posonlyargcount;
     if (!eq) goto unequal;
-    eq = co->co_kwonlyargcount == cp->co_kwonlyargcount; 
-    if (!eq) goto unequal; 
-    eq = co->co_nlocals == cp->co_nlocals; 
-    if (!eq) goto unequal; 
-    eq = co->co_flags == cp->co_flags; 
-    if (!eq) goto unequal; 
-    eq = co->co_firstlineno == cp->co_firstlineno; 
-    if (!eq) goto unequal; 
-    eq = PyObject_RichCompareBool(co->co_code, cp->co_code, Py_EQ); 
-    if (eq <= 0) goto unequal; 
- 
-    /* compare constants */ 
-    consts1 = _PyCode_ConstantKey(co->co_consts); 
-    if (!consts1) 
-        return NULL; 
-    consts2 = _PyCode_ConstantKey(cp->co_consts); 
-    if (!consts2) { 
-        Py_DECREF(consts1); 
-        return NULL; 
-    } 
-    eq = PyObject_RichCompareBool(consts1, consts2, Py_EQ); 
-    Py_DECREF(consts1); 
-    Py_DECREF(consts2); 
-    if (eq <= 0) goto unequal; 
- 
-    eq = PyObject_RichCompareBool(co->co_names, cp->co_names, Py_EQ); 
-    if (eq <= 0) goto unequal; 
-    eq = PyObject_RichCompareBool(co->co_varnames, cp->co_varnames, Py_EQ); 
-    if (eq <= 0) goto unequal; 
-    eq = PyObject_RichCompareBool(co->co_freevars, cp->co_freevars, Py_EQ); 
-    if (eq <= 0) goto unequal; 
-    eq = PyObject_RichCompareBool(co->co_cellvars, cp->co_cellvars, Py_EQ); 
-    if (eq <= 0) goto unequal; 
- 
-    if (op == Py_EQ) 
-        res = Py_True; 
-    else 
-        res = Py_False; 
-    goto done; 
- 
-  unequal: 
-    if (eq < 0) 
-        return NULL; 
-    if (op == Py_NE) 
-        res = Py_True; 
-    else 
-        res = Py_False; 
- 
-  done: 
-    Py_INCREF(res); 
-    return res; 
-} 
- 
-static Py_hash_t 
-code_hash(PyCodeObject *co) 
-{ 
-    Py_hash_t h, h0, h1, h2, h3, h4, h5, h6; 
-    h0 = PyObject_Hash(co->co_name); 
-    if (h0 == -1) return -1; 
-    h1 = PyObject_Hash(co->co_code); 
-    if (h1 == -1) return -1; 
-    h2 = PyObject_Hash(co->co_consts); 
-    if (h2 == -1) return -1; 
-    h3 = PyObject_Hash(co->co_names); 
-    if (h3 == -1) return -1; 
-    h4 = PyObject_Hash(co->co_varnames); 
-    if (h4 == -1) return -1; 
-    h5 = PyObject_Hash(co->co_freevars); 
-    if (h5 == -1) return -1; 
-    h6 = PyObject_Hash(co->co_cellvars); 
-    if (h6 == -1) return -1; 
-    h = h0 ^ h1 ^ h2 ^ h3 ^ h4 ^ h5 ^ h6 ^ 
+    eq = co->co_kwonlyargcount == cp->co_kwonlyargcount;
+    if (!eq) goto unequal;
+    eq = co->co_nlocals == cp->co_nlocals;
+    if (!eq) goto unequal;
+    eq = co->co_flags == cp->co_flags;
+    if (!eq) goto unequal;
+    eq = co->co_firstlineno == cp->co_firstlineno;
+    if (!eq) goto unequal;
+    eq = PyObject_RichCompareBool(co->co_code, cp->co_code, Py_EQ);
+    if (eq <= 0) goto unequal;
+
+    /* compare constants */
+    consts1 = _PyCode_ConstantKey(co->co_consts);
+    if (!consts1)
+        return NULL;
+    consts2 = _PyCode_ConstantKey(cp->co_consts);
+    if (!consts2) {
+        Py_DECREF(consts1);
+        return NULL;
+    }
+    eq = PyObject_RichCompareBool(consts1, consts2, Py_EQ);
+    Py_DECREF(consts1);
+    Py_DECREF(consts2);
+    if (eq <= 0) goto unequal;
+
+    eq = PyObject_RichCompareBool(co->co_names, cp->co_names, Py_EQ);
+    if (eq <= 0) goto unequal;
+    eq = PyObject_RichCompareBool(co->co_varnames, cp->co_varnames, Py_EQ);
+    if (eq <= 0) goto unequal;
+    eq = PyObject_RichCompareBool(co->co_freevars, cp->co_freevars, Py_EQ);
+    if (eq <= 0) goto unequal;
+    eq = PyObject_RichCompareBool(co->co_cellvars, cp->co_cellvars, Py_EQ);
+    if (eq <= 0) goto unequal;
+
+    if (op == Py_EQ)
+        res = Py_True;
+    else
+        res = Py_False;
+    goto done;
+
+  unequal:
+    if (eq < 0)
+        return NULL;
+    if (op == Py_NE)
+        res = Py_True;
+    else
+        res = Py_False;
+
+  done:
+    Py_INCREF(res);
+    return res;
+}
+
+static Py_hash_t
+code_hash(PyCodeObject *co)
+{
+    Py_hash_t h, h0, h1, h2, h3, h4, h5, h6;
+    h0 = PyObject_Hash(co->co_name);
+    if (h0 == -1) return -1;
+    h1 = PyObject_Hash(co->co_code);
+    if (h1 == -1) return -1;
+    h2 = PyObject_Hash(co->co_consts);
+    if (h2 == -1) return -1;
+    h3 = PyObject_Hash(co->co_names);
+    if (h3 == -1) return -1;
+    h4 = PyObject_Hash(co->co_varnames);
+    if (h4 == -1) return -1;
+    h5 = PyObject_Hash(co->co_freevars);
+    if (h5 == -1) return -1;
+    h6 = PyObject_Hash(co->co_cellvars);
+    if (h6 == -1) return -1;
+    h = h0 ^ h1 ^ h2 ^ h3 ^ h4 ^ h5 ^ h6 ^
         co->co_argcount ^ co->co_posonlyargcount ^ co->co_kwonlyargcount ^
-        co->co_nlocals ^ co->co_flags; 
-    if (h == -1) h = -2; 
-    return h; 
-} 
- 
-/* XXX code objects need to participate in GC? */ 
- 
-static struct PyMethodDef code_methods[] = { 
-    {"__sizeof__", (PyCFunction)code_sizeof, METH_NOARGS}, 
+        co->co_nlocals ^ co->co_flags;
+    if (h == -1) h = -2;
+    return h;
+}
+
+/* XXX code objects need to participate in GC? */
+
+static struct PyMethodDef code_methods[] = {
+    {"__sizeof__", (PyCFunction)code_sizeof, METH_NOARGS},
     CODE_REPLACE_METHODDEF
-    {NULL, NULL}                /* sentinel */ 
-}; 
- 
-PyTypeObject PyCode_Type = { 
-    PyVarObject_HEAD_INIT(&PyType_Type, 0) 
-    "code", 
-    sizeof(PyCodeObject), 
-    0, 
-    (destructor)code_dealloc,           /* tp_dealloc */ 
+    {NULL, NULL}                /* sentinel */
+};
+
+PyTypeObject PyCode_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0)
+    "code",
+    sizeof(PyCodeObject),
+    0,
+    (destructor)code_dealloc,           /* tp_dealloc */
     0,                                  /* tp_vectorcall_offset */
-    0,                                  /* tp_getattr */ 
-    0,                                  /* tp_setattr */ 
+    0,                                  /* tp_getattr */
+    0,                                  /* tp_setattr */
     0,                                  /* tp_as_async */
-    (reprfunc)code_repr,                /* tp_repr */ 
-    0,                                  /* tp_as_number */ 
-    0,                                  /* tp_as_sequence */ 
-    0,                                  /* tp_as_mapping */ 
-    (hashfunc)code_hash,                /* tp_hash */ 
-    0,                                  /* tp_call */ 
-    0,                                  /* tp_str */ 
-    PyObject_GenericGetAttr,            /* tp_getattro */ 
-    0,                                  /* tp_setattro */ 
-    0,                                  /* tp_as_buffer */ 
-    Py_TPFLAGS_DEFAULT,                 /* tp_flags */ 
-    code_doc,                           /* tp_doc */ 
-    0,                                  /* tp_traverse */ 
-    0,                                  /* tp_clear */ 
-    code_richcompare,                   /* tp_richcompare */ 
-    offsetof(PyCodeObject, co_weakreflist),     /* tp_weaklistoffset */ 
-    0,                                  /* tp_iter */ 
-    0,                                  /* tp_iternext */ 
-    code_methods,                       /* tp_methods */ 
-    code_memberlist,                    /* tp_members */ 
-    0,                                  /* tp_getset */ 
-    0,                                  /* tp_base */ 
-    0,                                  /* tp_dict */ 
-    0,                                  /* tp_descr_get */ 
-    0,                                  /* tp_descr_set */ 
-    0,                                  /* tp_dictoffset */ 
-    0,                                  /* tp_init */ 
-    0,                                  /* tp_alloc */ 
-    code_new,                           /* tp_new */ 
-}; 
- 
-/* Use co_lnotab to compute the line number from a bytecode index, addrq.  See 
-   lnotab_notes.txt for the details of the lnotab representation. 
-*/ 
- 
-int 
-PyCode_Addr2Line(PyCodeObject *co, int addrq) 
-{ 
-    Py_ssize_t size = PyBytes_Size(co->co_lnotab) / 2; 
-    unsigned char *p = (unsigned char*)PyBytes_AsString(co->co_lnotab); 
-    int line = co->co_firstlineno; 
-    int addr = 0; 
-    while (--size >= 0) { 
-        addr += *p++; 
-        if (addr > addrq) 
-            break; 
-        line += (signed char)*p; 
-        p++; 
-    } 
-    return line; 
-} 
- 
-/* Update *bounds to describe the first and one-past-the-last instructions in 
-   the same line as lasti.  Return the number of that line. */ 
-int 
-_PyCode_CheckLineNumber(PyCodeObject* co, int lasti, PyAddrPair *bounds) 
-{ 
-    Py_ssize_t size; 
-    int addr, line; 
-    unsigned char* p; 
- 
-    p = (unsigned char*)PyBytes_AS_STRING(co->co_lnotab); 
-    size = PyBytes_GET_SIZE(co->co_lnotab) / 2; 
- 
-    addr = 0; 
-    line = co->co_firstlineno; 
-    assert(line > 0); 
- 
-    /* possible optimization: if f->f_lasti == instr_ub 
-       (likely to be a common case) then we already know 
-       instr_lb -- if we stored the matching value of p 
-       somewhere we could skip the first while loop. */ 
- 
-    /* See lnotab_notes.txt for the description of 
-       co_lnotab.  A point to remember: increments to p 
-       come in (addr, line) pairs. */ 
- 
-    bounds->ap_lower = 0; 
-    while (size > 0) { 
-        if (addr + *p > lasti) 
-            break; 
-        addr += *p++; 
-        if ((signed char)*p) 
-            bounds->ap_lower = addr; 
-        line += (signed char)*p; 
-        p++; 
-        --size; 
-    } 
- 
-    if (size > 0) { 
-        while (--size >= 0) { 
-            addr += *p++; 
-            if ((signed char)*p) 
-                break; 
-            p++; 
-        } 
-        bounds->ap_upper = addr; 
-    } 
-    else { 
-        bounds->ap_upper = INT_MAX; 
-    } 
- 
-    return line; 
-} 
- 
- 
-int 
-_PyCode_GetExtra(PyObject *code, Py_ssize_t index, void **extra) 
-{ 
-    if (!PyCode_Check(code)) { 
-        PyErr_BadInternalCall(); 
-        return -1; 
-    } 
- 
-    PyCodeObject *o = (PyCodeObject*) code; 
-    _PyCodeObjectExtra *co_extra = (_PyCodeObjectExtra*) o->co_extra; 
- 
-    if (co_extra == NULL || co_extra->ce_size <= index) { 
-        *extra = NULL; 
-        return 0; 
-    } 
- 
-    *extra = co_extra->ce_extras[index]; 
-    return 0; 
-} 
- 
- 
-int 
-_PyCode_SetExtra(PyObject *code, Py_ssize_t index, void *extra) 
-{ 
+    (reprfunc)code_repr,                /* tp_repr */
+    0,                                  /* tp_as_number */
+    0,                                  /* tp_as_sequence */
+    0,                                  /* tp_as_mapping */
+    (hashfunc)code_hash,                /* tp_hash */
+    0,                                  /* tp_call */
+    0,                                  /* tp_str */
+    PyObject_GenericGetAttr,            /* tp_getattro */
+    0,                                  /* tp_setattro */
+    0,                                  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,                 /* tp_flags */
+    code_doc,                           /* tp_doc */
+    0,                                  /* tp_traverse */
+    0,                                  /* tp_clear */
+    code_richcompare,                   /* tp_richcompare */
+    offsetof(PyCodeObject, co_weakreflist),     /* tp_weaklistoffset */
+    0,                                  /* tp_iter */
+    0,                                  /* tp_iternext */
+    code_methods,                       /* tp_methods */
+    code_memberlist,                    /* tp_members */
+    0,                                  /* tp_getset */
+    0,                                  /* tp_base */
+    0,                                  /* tp_dict */
+    0,                                  /* tp_descr_get */
+    0,                                  /* tp_descr_set */
+    0,                                  /* tp_dictoffset */
+    0,                                  /* tp_init */
+    0,                                  /* tp_alloc */
+    code_new,                           /* tp_new */
+};
+
+/* Use co_lnotab to compute the line number from a bytecode index, addrq.  See
+   lnotab_notes.txt for the details of the lnotab representation.
+*/
+
+int
+PyCode_Addr2Line(PyCodeObject *co, int addrq)
+{
+    Py_ssize_t size = PyBytes_Size(co->co_lnotab) / 2;
+    unsigned char *p = (unsigned char*)PyBytes_AsString(co->co_lnotab);
+    int line = co->co_firstlineno;
+    int addr = 0;
+    while (--size >= 0) {
+        addr += *p++;
+        if (addr > addrq)
+            break;
+        line += (signed char)*p;
+        p++;
+    }
+    return line;
+}
+
+/* Update *bounds to describe the first and one-past-the-last instructions in
+   the same line as lasti.  Return the number of that line. */
+int
+_PyCode_CheckLineNumber(PyCodeObject* co, int lasti, PyAddrPair *bounds)
+{
+    Py_ssize_t size;
+    int addr, line;
+    unsigned char* p;
+
+    p = (unsigned char*)PyBytes_AS_STRING(co->co_lnotab);
+    size = PyBytes_GET_SIZE(co->co_lnotab) / 2;
+
+    addr = 0;
+    line = co->co_firstlineno;
+    assert(line > 0);
+
+    /* possible optimization: if f->f_lasti == instr_ub
+       (likely to be a common case) then we already know
+       instr_lb -- if we stored the matching value of p
+       somewhere we could skip the first while loop. */
+
+    /* See lnotab_notes.txt for the description of
+       co_lnotab.  A point to remember: increments to p
+       come in (addr, line) pairs. */
+
+    bounds->ap_lower = 0;
+    while (size > 0) {
+        if (addr + *p > lasti)
+            break;
+        addr += *p++;
+        if ((signed char)*p)
+            bounds->ap_lower = addr;
+        line += (signed char)*p;
+        p++;
+        --size;
+    }
+
+    if (size > 0) {
+        while (--size >= 0) {
+            addr += *p++;
+            if ((signed char)*p)
+                break;
+            p++;
+        }
+        bounds->ap_upper = addr;
+    }
+    else {
+        bounds->ap_upper = INT_MAX;
+    }
+
+    return line;
+}
+
+
+int
+_PyCode_GetExtra(PyObject *code, Py_ssize_t index, void **extra)
+{
+    if (!PyCode_Check(code)) {
+        PyErr_BadInternalCall();
+        return -1;
+    }
+
+    PyCodeObject *o = (PyCodeObject*) code;
+    _PyCodeObjectExtra *co_extra = (_PyCodeObjectExtra*) o->co_extra;
+
+    if (co_extra == NULL || co_extra->ce_size <= index) {
+        *extra = NULL;
+        return 0;
+    }
+
+    *extra = co_extra->ce_extras[index];
+    return 0;
+}
+
+
+int
+_PyCode_SetExtra(PyObject *code, Py_ssize_t index, void *extra)
+{
     PyInterpreterState *interp = _PyInterpreterState_GET();
- 
-    if (!PyCode_Check(code) || index < 0 || 
-            index >= interp->co_extra_user_count) { 
-        PyErr_BadInternalCall(); 
-        return -1; 
-    } 
- 
-    PyCodeObject *o = (PyCodeObject*) code; 
-    _PyCodeObjectExtra *co_extra = (_PyCodeObjectExtra *) o->co_extra; 
- 
-    if (co_extra == NULL || co_extra->ce_size <= index) { 
-        Py_ssize_t i = (co_extra == NULL ? 0 : co_extra->ce_size); 
-        co_extra = PyMem_Realloc( 
-                co_extra, 
-                sizeof(_PyCodeObjectExtra) + 
-                (interp->co_extra_user_count-1) * sizeof(void*)); 
-        if (co_extra == NULL) { 
-            return -1; 
-        } 
-        for (; i < interp->co_extra_user_count; i++) { 
-            co_extra->ce_extras[i] = NULL; 
-        } 
-        co_extra->ce_size = interp->co_extra_user_count; 
-        o->co_extra = co_extra; 
-    } 
- 
-    if (co_extra->ce_extras[index] != NULL) { 
-        freefunc free = interp->co_extra_freefuncs[index]; 
-        if (free != NULL) { 
-            free(co_extra->ce_extras[index]); 
-        } 
-    } 
- 
-    co_extra->ce_extras[index] = extra; 
-    return 0; 
-} 
+
+    if (!PyCode_Check(code) || index < 0 ||
+            index >= interp->co_extra_user_count) {
+        PyErr_BadInternalCall();
+        return -1;
+    }
+
+    PyCodeObject *o = (PyCodeObject*) code;
+    _PyCodeObjectExtra *co_extra = (_PyCodeObjectExtra *) o->co_extra;
+
+    if (co_extra == NULL || co_extra->ce_size <= index) {
+        Py_ssize_t i = (co_extra == NULL ? 0 : co_extra->ce_size);
+        co_extra = PyMem_Realloc(
+                co_extra,
+                sizeof(_PyCodeObjectExtra) +
+                (interp->co_extra_user_count-1) * sizeof(void*));
+        if (co_extra == NULL) {
+            return -1;
+        }
+        for (; i < interp->co_extra_user_count; i++) {
+            co_extra->ce_extras[i] = NULL;
+        }
+        co_extra->ce_size = interp->co_extra_user_count;
+        o->co_extra = co_extra;
+    }
+
+    if (co_extra->ce_extras[index] != NULL) {
+        freefunc free = interp->co_extra_freefuncs[index];
+        if (free != NULL) {
+            free(co_extra->ce_extras[index]);
+        }
+    }
+
+    co_extra->ce_extras[index] = extra;
+    return 0;
+}