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

1 files changed, 296 insertions, 296 deletions

diff --git a/contrib/tools/python3/src/Objects/codeobject.c b/contrib/tools/python3/src/Objects/codeobject.c
index cb4fb681243..9bc5a51c44d 100644
--- a/contrib/tools/python3/src/Objects/codeobject.c
+++ b/contrib/tools/python3/src/Objects/codeobject.c
@@ -2,13 +2,13 @@
 
 #include "Python.h"
 #include "code.h"
-#include "opcode.h"
-#include "structmember.h"         // PyMemberDef
-#include "pycore_code.h"
-#include "pycore_interp.h"        // PyInterpreterState.co_extra_freefuncs
-#include "pycore_pystate.h"       // _PyInterpreterState_GET()
-#include "pycore_tupleobject.h"
-#include "clinic/codeobject.c.h"
+#include "opcode.h" 
+#include "structmember.h"         // PyMemberDef 
+#include "pycore_code.h" 
+#include "pycore_interp.h"        // PyInterpreterState.co_extra_freefuncs 
+#include "pycore_pystate.h"       // _PyInterpreterState_GET() 
+#include "pycore_tupleobject.h" 
+#include "clinic/codeobject.c.h" 
 
 /* Holder for co_extra information */
 typedef struct {
@@ -16,11 +16,11 @@ typedef struct {
     void *ce_extras[1];
 } _PyCodeObjectExtra;
 
-/*[clinic input]
-class code "PyCodeObject *" "&PyCode_Type"
-[clinic start generated code]*/
-/*[clinic end generated code: output=da39a3ee5e6b4b0d input=78aa5d576683bb4b]*/
-
+/*[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)
@@ -39,7 +39,7 @@ all_name_chars(PyObject *o)
     return 1;
 }
 
-static int
+static int 
 intern_strings(PyObject *tuple)
 {
     Py_ssize_t i;
@@ -47,88 +47,88 @@ intern_strings(PyObject *tuple)
     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;
+            PyErr_SetString(PyExc_SystemError, 
+                            "non-string found in code slot"); 
+            return -1; 
         }
-        PyUnicode_InternInPlace(&_PyTuple_ITEMS(tuple)[i]);
+        PyUnicode_InternInPlace(&_PyTuple_ITEMS(tuple)[i]); 
     }
-    return 0;
+    return 0; 
 }
 
 /* Intern selected string constants */
 static int
-intern_string_constants(PyObject *tuple, int *modified)
+intern_string_constants(PyObject *tuple, int *modified) 
 {
-    for (Py_ssize_t i = PyTuple_GET_SIZE(tuple); --i >= 0; ) {
+    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) {
-                return -1;
+                return -1; 
             }
-
+ 
             if (all_name_chars(v)) {
                 PyObject *w = v;
                 PyUnicode_InternInPlace(&v);
                 if (w != v) {
                     PyTuple_SET_ITEM(tuple, i, v);
-                    if (modified) {
-                        *modified = 1;
-                    }
+                    if (modified) { 
+                        *modified = 1; 
+                    } 
                 }
             }
         }
         else if (PyTuple_CheckExact(v)) {
-            if (intern_string_constants(v, NULL) < 0) {
-                return -1;
-            }
+            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) {
-                return -1;
-            }
-            int tmp_modified = 0;
-            if (intern_string_constants(tmp, &tmp_modified) < 0) {
-                Py_DECREF(tmp);
-                return -1;
+                return -1; 
             }
-            if (tmp_modified) {
+            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) {
-                    Py_DECREF(tmp);
-                    return -1;
+                    Py_DECREF(tmp); 
+                    return -1; 
                 }
-
-                PyTuple_SET_ITEM(tuple, i, v);
-                Py_DECREF(w);
-                if (modified) {
-                    *modified = 1;
+ 
+                PyTuple_SET_ITEM(tuple, i, v); 
+                Py_DECREF(w); 
+                if (modified) { 
+                    *modified = 1; 
                 }
             }
             Py_DECREF(tmp);
         }
     }
-    return 0;
+    return 0; 
 }
 
 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)
+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 */
-    if (argcount < posonlyargcount || posonlyargcount < 0 ||
-        kwonlyargcount < 0 || nlocals < 0 ||
-        stacksize < 0 || flags < 0 ||
+    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) ||
@@ -142,38 +142,38 @@ PyCode_NewWithPosOnlyArgs(int argcount, int posonlyargcount, int kwonlyargcount,
         return NULL;
     }
 
-    /* Ensure that strings are ready Unicode string */
-    if (PyUnicode_READY(name) < 0) {
-        return NULL;
-    }
-    if (PyUnicode_READY(filename) < 0) {
-        return NULL;
-    }
-
-    if (intern_strings(names) < 0) {
-        return NULL;
-    }
-    if (intern_strings(varnames) < 0) {
-        return NULL;
-    }
-    if (intern_strings(freevars) < 0) {
-        return NULL;
-    }
-    if (intern_strings(cellvars) < 0) {
+    /* Ensure that strings are ready Unicode string */ 
+    if (PyUnicode_READY(name) < 0) { 
         return NULL;
-    }
-    if (intern_string_constants(consts, NULL) < 0) {
-        return NULL;
-    }
+    } 
+    if (PyUnicode_READY(filename) < 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. */
-    if (PyBytes_GET_SIZE(code) > INT_MAX) {
-        PyErr_SetString(PyExc_OverflowError, "co_code larger than INT_MAX");
-        return NULL;
-    }
+    if (intern_strings(names) < 0) { 
+        return NULL; 
+    } 
+    if (intern_strings(varnames) < 0) { 
+        return NULL; 
+    } 
+    if (intern_strings(freevars) < 0) { 
+        return NULL; 
+    } 
+    if (intern_strings(cellvars) < 0) { 
+        return NULL; 
+    } 
+    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. */ 
+    if (PyBytes_GET_SIZE(code) > INT_MAX) { 
+        PyErr_SetString(PyExc_OverflowError, "co_code larger than INT_MAX"); 
+        return NULL; 
+    } 
+ 
     /* Check for any inner or outer closure references */
     n_cellvars = PyTuple_GET_SIZE(cellvars);
     if (!n_cellvars && !PyTuple_GET_SIZE(freevars)) {
@@ -186,7 +186,7 @@ PyCode_NewWithPosOnlyArgs(int argcount, int posonlyargcount, int kwonlyargcount,
     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);
+                      ((flags & CO_VARARGS) != 0) + ((flags & CO_VARKEYWORDS) != 0); 
     }
     else {
         total_args = n_varnames + 1;
@@ -228,14 +228,14 @@ PyCode_NewWithPosOnlyArgs(int argcount, int posonlyargcount, int kwonlyargcount,
             cell2arg = NULL;
         }
     }
-    co = PyObject_New(PyCodeObject, &PyCode_Type);
+    co = PyObject_New(PyCodeObject, &PyCode_Type); 
     if (co == NULL) {
         if (cell2arg)
             PyMem_FREE(cell2arg);
         return NULL;
     }
     co->co_argcount = argcount;
-    co->co_posonlyargcount = posonlyargcount;
+    co->co_posonlyargcount = posonlyargcount; 
     co->co_kwonlyargcount = kwonlyargcount;
     co->co_nlocals = nlocals;
     co->co_stacksize = stacksize;
@@ -263,72 +263,72 @@ PyCode_NewWithPosOnlyArgs(int argcount, int posonlyargcount, int kwonlyargcount,
     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;
+ 
+    co->co_opcache_map = NULL; 
+    co->co_opcache = NULL; 
+    co->co_opcache_flag = 0; 
+    co->co_opcache_size = 0; 
     return co;
 }
 
 PyCodeObject *
-PyCode_New(int argcount, 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)
-{
-    return PyCode_NewWithPosOnlyArgs(argcount, 0, kwonlyargcount, nlocals,
-                                     stacksize, flags, code, consts, names,
-                                     varnames, freevars, cellvars, filename,
-                                     name, firstlineno, lnotab);
-}
-
-int
-_PyCode_InitOpcache(PyCodeObject *co)
-{
-    Py_ssize_t co_size = PyBytes_Size(co->co_code) / sizeof(_Py_CODEUNIT);
-    co->co_opcache_map = (unsigned char *)PyMem_Calloc(co_size, 1);
-    if (co->co_opcache_map == NULL) {
-        return -1;
-    }
-
-    _Py_CODEUNIT *opcodes = (_Py_CODEUNIT*)PyBytes_AS_STRING(co->co_code);
-    Py_ssize_t opts = 0;
-
-    for (Py_ssize_t i = 0; i < co_size;) {
-        unsigned char opcode = _Py_OPCODE(opcodes[i]);
-        i++;  // 'i' is now aligned to (next_instr - first_instr)
-
-        // TODO: LOAD_METHOD, LOAD_ATTR
-        if (opcode == LOAD_GLOBAL) {
-            opts++;
-            co->co_opcache_map[i] = (unsigned char)opts;
-            if (opts > 254) {
-                break;
-            }
-        }
-    }
-
-    if (opts) {
-        co->co_opcache = (_PyOpcache *)PyMem_Calloc(opts, sizeof(_PyOpcache));
-        if (co->co_opcache == NULL) {
-            PyMem_FREE(co->co_opcache_map);
-            return -1;
-        }
-    }
-    else {
-        PyMem_FREE(co->co_opcache_map);
-        co->co_opcache_map = NULL;
-        co->co_opcache = NULL;
-    }
-
-    co->co_opcache_size = (unsigned char)opts;
-    return 0;
-}
-
-PyCodeObject *
+PyCode_New(int argcount, 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) 
+{ 
+    return PyCode_NewWithPosOnlyArgs(argcount, 0, kwonlyargcount, nlocals, 
+                                     stacksize, flags, code, consts, names, 
+                                     varnames, freevars, cellvars, filename, 
+                                     name, firstlineno, lnotab); 
+} 
+ 
+int 
+_PyCode_InitOpcache(PyCodeObject *co) 
+{ 
+    Py_ssize_t co_size = PyBytes_Size(co->co_code) / sizeof(_Py_CODEUNIT); 
+    co->co_opcache_map = (unsigned char *)PyMem_Calloc(co_size, 1); 
+    if (co->co_opcache_map == NULL) { 
+        return -1; 
+    } 
+ 
+    _Py_CODEUNIT *opcodes = (_Py_CODEUNIT*)PyBytes_AS_STRING(co->co_code); 
+    Py_ssize_t opts = 0; 
+ 
+    for (Py_ssize_t i = 0; i < co_size;) { 
+        unsigned char opcode = _Py_OPCODE(opcodes[i]); 
+        i++;  // 'i' is now aligned to (next_instr - first_instr) 
+ 
+        // TODO: LOAD_METHOD, LOAD_ATTR 
+        if (opcode == LOAD_GLOBAL) { 
+            opts++; 
+            co->co_opcache_map[i] = (unsigned char)opts; 
+            if (opts > 254) { 
+                break; 
+            } 
+        } 
+    } 
+ 
+    if (opts) { 
+        co->co_opcache = (_PyOpcache *)PyMem_Calloc(opts, sizeof(_PyOpcache)); 
+        if (co->co_opcache == NULL) { 
+            PyMem_FREE(co->co_opcache_map); 
+            return -1; 
+        } 
+    } 
+    else { 
+        PyMem_FREE(co->co_opcache_map); 
+        co->co_opcache_map = NULL; 
+        co->co_opcache = NULL; 
+    } 
+ 
+    co->co_opcache_size = (unsigned char)opts; 
+    return 0; 
+} 
+ 
+PyCodeObject * 
 PyCode_NewEmpty(const char *filename, const char *funcname, int firstlineno)
 {
     static PyObject *emptystring = NULL;
@@ -353,9 +353,9 @@ PyCode_NewEmpty(const char *filename, const char *funcname, int firstlineno)
     if (filename_ob == NULL)
         goto failed;
 
-    result = PyCode_NewWithPosOnlyArgs(
-                0,                    /* argcount */
-                0,                              /* posonlyargcount */
+    result = PyCode_NewWithPosOnlyArgs( 
+                0,                    /* argcount */ 
+                0,                              /* posonlyargcount */ 
                 0,                              /* kwonlyargcount */
                 0,                              /* nlocals */
                 0,                              /* stacksize */
@@ -381,22 +381,22 @@ failed:
 #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},
-    {"co_nlocals",      T_INT,          OFF(co_nlocals),         READONLY},
-    {"co_stacksize",T_INT,              OFF(co_stacksize),       READONLY},
-    {"co_flags",        T_INT,          OFF(co_flags),           READONLY},
-    {"co_code",         T_OBJECT,       OFF(co_code),            READONLY},
-    {"co_consts",       T_OBJECT,       OFF(co_consts),          READONLY},
-    {"co_names",        T_OBJECT,       OFF(co_names),           READONLY},
-    {"co_varnames",     T_OBJECT,       OFF(co_varnames),        READONLY},
-    {"co_freevars",     T_OBJECT,       OFF(co_freevars),        READONLY},
-    {"co_cellvars",     T_OBJECT,       OFF(co_cellvars),        READONLY},
-    {"co_filename",     T_OBJECT,       OFF(co_filename),        READONLY},
-    {"co_name",         T_OBJECT,       OFF(co_name),            READONLY},
-    {"co_firstlineno", T_INT,           OFF(co_firstlineno),     READONLY},
-    {"co_lnotab",       T_OBJECT,       OFF(co_lnotab),          READONLY},
+    {"co_argcount",     T_INT,          OFF(co_argcount),        READONLY}, 
+    {"co_posonlyargcount",      T_INT,  OFF(co_posonlyargcount), READONLY}, 
+    {"co_kwonlyargcount",       T_INT,  OFF(co_kwonlyargcount),  READONLY}, 
+    {"co_nlocals",      T_INT,          OFF(co_nlocals),         READONLY}, 
+    {"co_stacksize",T_INT,              OFF(co_stacksize),       READONLY}, 
+    {"co_flags",        T_INT,          OFF(co_flags),           READONLY}, 
+    {"co_code",         T_OBJECT,       OFF(co_code),            READONLY}, 
+    {"co_consts",       T_OBJECT,       OFF(co_consts),          READONLY}, 
+    {"co_names",        T_OBJECT,       OFF(co_names),           READONLY}, 
+    {"co_varnames",     T_OBJECT,       OFF(co_varnames),        READONLY}, 
+    {"co_freevars",     T_OBJECT,       OFF(co_freevars),        READONLY}, 
+    {"co_cellvars",     T_OBJECT,       OFF(co_cellvars),        READONLY}, 
+    {"co_filename",     T_OBJECT,       OFF(co_filename),        READONLY}, 
+    {"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 */
 };
 
@@ -425,7 +425,7 @@ validate_and_copy_tuple(PyObject *tup)
                 PyExc_TypeError,
                 "name tuples must contain only "
                 "strings, not '%.500s'",
-                Py_TYPE(item)->tp_name);
+                Py_TYPE(item)->tp_name); 
             Py_DECREF(newtuple);
             return NULL;
         }
@@ -443,9 +443,9 @@ validate_and_copy_tuple(PyObject *tup)
 }
 
 PyDoc_STRVAR(code_doc,
-"code(argcount, posonlyargcount, kwonlyargcount, nlocals, stacksize,\n\
-      flags, codestring, constants, names, varnames, filename, name,\n\
-      firstlineno, lnotab[, freevars[, cellvars]])\n\
+"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.");
 
@@ -453,7 +453,7 @@ static PyObject *
 code_new(PyTypeObject *type, PyObject *args, PyObject *kw)
 {
     int argcount;
-    int posonlyargcount;
+    int posonlyargcount; 
     int kwonlyargcount;
     int nlocals;
     int stacksize;
@@ -470,8 +470,8 @@ code_new(PyTypeObject *type, PyObject *args, PyObject *kw)
     int firstlineno;
     PyObject *lnotab;
 
-    if (!PyArg_ParseTuple(args, "iiiiiiSO!O!O!UUiS|O!O!:code",
-                          &argcount, &posonlyargcount, &kwonlyargcount,
+    if (!PyArg_ParseTuple(args, "iiiiiiSO!O!O!UUiS|O!O!:code", 
+                          &argcount, &posonlyargcount, &kwonlyargcount, 
                               &nlocals, &stacksize, &flags,
                           &code,
                           &PyTuple_Type, &consts,
@@ -483,12 +483,12 @@ code_new(PyTypeObject *type, PyObject *args, PyObject *kw)
                           &PyTuple_Type, &cellvars))
         return NULL;
 
-    if (PySys_Audit("code.__new__", "OOOiiiiii",
-                    code, filename, name, argcount, posonlyargcount,
-                    kwonlyargcount, nlocals, stacksize, flags) < 0) {
-        goto cleanup;
-    }
-
+    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,
@@ -496,13 +496,13 @@ code_new(PyTypeObject *type, PyObject *args, PyObject *kw)
         goto cleanup;
     }
 
-    if (posonlyargcount < 0) {
-        PyErr_SetString(
-            PyExc_ValueError,
-            "code: posonlyargcount must not be negative");
-        goto cleanup;
-    }
-
+    if (posonlyargcount < 0) { 
+        PyErr_SetString( 
+            PyExc_ValueError, 
+            "code: posonlyargcount must not be negative"); 
+        goto cleanup; 
+    } 
+ 
     if (kwonlyargcount < 0) {
         PyErr_SetString(
             PyExc_ValueError,
@@ -535,14 +535,14 @@ code_new(PyTypeObject *type, PyObject *args, PyObject *kw)
     if (ourcellvars == NULL)
         goto cleanup;
 
-    co = (PyObject *)PyCode_NewWithPosOnlyArgs(argcount, posonlyargcount,
-                                               kwonlyargcount,
-                                               nlocals, stacksize, flags,
-                                               code, consts, ournames,
-                                               ourvarnames, ourfreevars,
-                                               ourcellvars, filename,
-                                               name, firstlineno, lnotab);
-  cleanup:
+    co = (PyObject *)PyCode_NewWithPosOnlyArgs(argcount, posonlyargcount, 
+                                               kwonlyargcount, 
+                                               nlocals, stacksize, flags, 
+                                               code, consts, ournames, 
+                                               ourvarnames, ourfreevars, 
+                                               ourcellvars, filename, 
+                                               name, firstlineno, lnotab); 
+  cleanup: 
     Py_XDECREF(ournames);
     Py_XDECREF(ourvarnames);
     Py_XDECREF(ourfreevars);
@@ -553,17 +553,17 @@ code_new(PyTypeObject *type, PyObject *args, PyObject *kw)
 static void
 code_dealloc(PyCodeObject *co)
 {
-    if (co->co_opcache != NULL) {
-        PyMem_FREE(co->co_opcache);
-    }
-    if (co->co_opcache_map != NULL) {
-        PyMem_FREE(co->co_opcache_map);
-    }
-    co->co_opcache_flag = 0;
-    co->co_opcache_size = 0;
-
+    if (co->co_opcache != NULL) { 
+        PyMem_FREE(co->co_opcache); 
+    } 
+    if (co->co_opcache_map != NULL) { 
+        PyMem_FREE(co->co_opcache_map); 
+    } 
+    co->co_opcache_flag = 0; 
+    co->co_opcache_size = 0; 
+ 
     if (co->co_extra != NULL) {
-        PyInterpreterState *interp = _PyInterpreterState_GET();
+        PyInterpreterState *interp = _PyInterpreterState_GET(); 
         _PyCodeObjectExtra *co_extra = co->co_extra;
 
         for (Py_ssize_t i = 0; i < co_extra->ce_size; i++) {
@@ -596,7 +596,7 @@ code_dealloc(PyCodeObject *co)
 }
 
 static PyObject *
-code_sizeof(PyCodeObject *co, PyObject *Py_UNUSED(args))
+code_sizeof(PyCodeObject *co, PyObject *Py_UNUSED(args)) 
 {
     Py_ssize_t res = _PyObject_SIZE(Py_TYPE(co));
     _PyCodeObjectExtra *co_extra = (_PyCodeObjectExtra*) co->co_extra;
@@ -608,83 +608,83 @@ code_sizeof(PyCodeObject *co, PyObject *Py_UNUSED(args))
         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
-        res += PyBytes_GET_SIZE(co->co_code) / sizeof(_Py_CODEUNIT);
-        // co_opcache
-        res += co->co_opcache_size * sizeof(_PyOpcache);
-    }
+    if (co->co_opcache != NULL) { 
+        assert(co->co_opcache_map != NULL); 
+        // co_opcache_map 
+        res += PyBytes_GET_SIZE(co->co_code) / sizeof(_Py_CODEUNIT); 
+        // co_opcache 
+        res += co->co_opcache_size * sizeof(_PyOpcache); 
+    } 
     return PyLong_FromSsize_t(res);
 }
 
-/*[clinic input]
-code.replace
-
-    *
-    co_argcount: int(c_default="self->co_argcount") = -1
-    co_posonlyargcount: int(c_default="self->co_posonlyargcount") = -1
-    co_kwonlyargcount: int(c_default="self->co_kwonlyargcount") = -1
-    co_nlocals: int(c_default="self->co_nlocals") = -1
-    co_stacksize: int(c_default="self->co_stacksize") = -1
-    co_flags: int(c_default="self->co_flags") = -1
-    co_firstlineno: int(c_default="self->co_firstlineno") = -1
-    co_code: PyBytesObject(c_default="(PyBytesObject *)self->co_code") = None
-    co_consts: object(subclass_of="&PyTuple_Type", c_default="self->co_consts") = None
-    co_names: object(subclass_of="&PyTuple_Type", c_default="self->co_names") = None
-    co_varnames: object(subclass_of="&PyTuple_Type", c_default="self->co_varnames") = None
-    co_freevars: object(subclass_of="&PyTuple_Type", c_default="self->co_freevars") = None
-    co_cellvars: object(subclass_of="&PyTuple_Type", c_default="self->co_cellvars") = None
-    co_filename: unicode(c_default="self->co_filename") = None
-    co_name: unicode(c_default="self->co_name") = None
-    co_lnotab: PyBytesObject(c_default="(PyBytesObject *)self->co_lnotab") = None
-
-Return a copy of the code object with new values for the specified fields.
-[clinic start generated code]*/
-
-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,
-                  int co_firstlineno, PyBytesObject *co_code,
-                  PyObject *co_consts, PyObject *co_names,
-                  PyObject *co_varnames, PyObject *co_freevars,
-                  PyObject *co_cellvars, PyObject *co_filename,
-                  PyObject *co_name, PyBytesObject *co_lnotab)
-/*[clinic end generated code: output=25c8e303913bcace input=d9051bc8f24e6b28]*/
-{
-#define CHECK_INT_ARG(ARG) \
-        if (ARG < 0) { \
-            PyErr_SetString(PyExc_ValueError, \
-                            #ARG " must be a positive integer"); \
-            return NULL; \
-        }
-
-    CHECK_INT_ARG(co_argcount);
-    CHECK_INT_ARG(co_posonlyargcount);
-    CHECK_INT_ARG(co_kwonlyargcount);
-    CHECK_INT_ARG(co_nlocals);
-    CHECK_INT_ARG(co_stacksize);
-    CHECK_INT_ARG(co_flags);
-    CHECK_INT_ARG(co_firstlineno);
-
-#undef CHECK_INT_ARG
-
-    if (PySys_Audit("code.__new__", "OOOiiiiii",
-                    co_code, co_filename, co_name, co_argcount,
-                    co_posonlyargcount, co_kwonlyargcount, co_nlocals,
-                    co_stacksize, co_flags) < 0) {
-        return NULL;
-    }
-
-    return (PyObject *)PyCode_NewWithPosOnlyArgs(
-        co_argcount, co_posonlyargcount, co_kwonlyargcount, co_nlocals,
-        co_stacksize, co_flags, (PyObject*)co_code, co_consts, co_names,
-        co_varnames, co_freevars, co_cellvars, co_filename, co_name,
-        co_firstlineno, (PyObject*)co_lnotab);
-}
-
+/*[clinic input] 
+code.replace 
+ 
+    * 
+    co_argcount: int(c_default="self->co_argcount") = -1 
+    co_posonlyargcount: int(c_default="self->co_posonlyargcount") = -1 
+    co_kwonlyargcount: int(c_default="self->co_kwonlyargcount") = -1 
+    co_nlocals: int(c_default="self->co_nlocals") = -1 
+    co_stacksize: int(c_default="self->co_stacksize") = -1 
+    co_flags: int(c_default="self->co_flags") = -1 
+    co_firstlineno: int(c_default="self->co_firstlineno") = -1 
+    co_code: PyBytesObject(c_default="(PyBytesObject *)self->co_code") = None 
+    co_consts: object(subclass_of="&PyTuple_Type", c_default="self->co_consts") = None 
+    co_names: object(subclass_of="&PyTuple_Type", c_default="self->co_names") = None 
+    co_varnames: object(subclass_of="&PyTuple_Type", c_default="self->co_varnames") = None 
+    co_freevars: object(subclass_of="&PyTuple_Type", c_default="self->co_freevars") = None 
+    co_cellvars: object(subclass_of="&PyTuple_Type", c_default="self->co_cellvars") = None 
+    co_filename: unicode(c_default="self->co_filename") = None 
+    co_name: unicode(c_default="self->co_name") = None 
+    co_lnotab: PyBytesObject(c_default="(PyBytesObject *)self->co_lnotab") = None 
+ 
+Return a copy of the code object with new values for the specified fields. 
+[clinic start generated code]*/ 
+ 
 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, 
+                  int co_firstlineno, PyBytesObject *co_code, 
+                  PyObject *co_consts, PyObject *co_names, 
+                  PyObject *co_varnames, PyObject *co_freevars, 
+                  PyObject *co_cellvars, PyObject *co_filename, 
+                  PyObject *co_name, PyBytesObject *co_lnotab) 
+/*[clinic end generated code: output=25c8e303913bcace input=d9051bc8f24e6b28]*/ 
+{ 
+#define CHECK_INT_ARG(ARG) \ 
+        if (ARG < 0) { \ 
+            PyErr_SetString(PyExc_ValueError, \ 
+                            #ARG " must be a positive integer"); \ 
+            return NULL; \ 
+        } 
+ 
+    CHECK_INT_ARG(co_argcount); 
+    CHECK_INT_ARG(co_posonlyargcount); 
+    CHECK_INT_ARG(co_kwonlyargcount); 
+    CHECK_INT_ARG(co_nlocals); 
+    CHECK_INT_ARG(co_stacksize); 
+    CHECK_INT_ARG(co_flags); 
+    CHECK_INT_ARG(co_firstlineno); 
+ 
+#undef CHECK_INT_ARG 
+ 
+    if (PySys_Audit("code.__new__", "OOOiiiiii", 
+                    co_code, co_filename, co_name, co_argcount, 
+                    co_posonlyargcount, co_kwonlyargcount, co_nlocals, 
+                    co_stacksize, co_flags) < 0) { 
+        return NULL; 
+    } 
+ 
+    return (PyObject *)PyCode_NewWithPosOnlyArgs( 
+        co_argcount, co_posonlyargcount, co_kwonlyargcount, co_nlocals, 
+        co_stacksize, co_flags, (PyObject*)co_code, co_consts, co_names, 
+        co_varnames, co_freevars, co_cellvars, co_filename, co_name, 
+        co_firstlineno, (PyObject*)co_lnotab); 
+} 
+ 
+static PyObject * 
 code_repr(PyCodeObject *co)
 {
     int lineno;
@@ -708,21 +708,21 @@ _PyCode_ConstantKey(PyObject *op)
 {
     PyObject *key;
 
-    /* Py_None and Py_Ellipsis are singletons. */
+    /* 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 */
-       || PyCode_Check(op))
-    {
-        /* Objects of these types are always different from object of other
-         * type and from tuples. */
-        Py_INCREF(op);
-        key = op;
-    }
-    else if (PyBool_Check(op) || PyBytes_CheckExact(op)) {
-        /* Make booleans different from integers 0 and 1.
-         * Avoid BytesWarning from comparing bytes with strings. */
+       || PyCode_Check(op)) 
+    { 
+        /* Objects of these types are always different from object of other 
+         * type and from tuples. */ 
+        Py_INCREF(op); 
+        key = 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)) {
@@ -851,11 +851,11 @@ code_richcompare(PyObject *self, PyObject *other, int op)
     cp = (PyCodeObject *)other;
 
     eq = PyObject_RichCompareBool(co->co_name, cp->co_name, Py_EQ);
-    if (!eq) goto unequal;
+    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_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;
@@ -928,7 +928,7 @@ code_hash(PyCodeObject *co)
     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_argcount ^ co->co_posonlyargcount ^ co->co_kwonlyargcount ^ 
         co->co_nlocals ^ co->co_flags;
     if (h == -1) h = -2;
     return h;
@@ -938,7 +938,7 @@ code_hash(PyCodeObject *co)
 
 static struct PyMethodDef code_methods[] = {
     {"__sizeof__", (PyCFunction)code_sizeof, METH_NOARGS},
-    CODE_REPLACE_METHODDEF
+    CODE_REPLACE_METHODDEF 
     {NULL, NULL}                /* sentinel */
 };
 
@@ -948,10 +948,10 @@ PyTypeObject PyCode_Type = {
     sizeof(PyCodeObject),
     0,
     (destructor)code_dealloc,           /* tp_dealloc */
-    0,                                  /* tp_vectorcall_offset */
+    0,                                  /* tp_vectorcall_offset */ 
     0,                                  /* tp_getattr */
     0,                                  /* tp_setattr */
-    0,                                  /* tp_as_async */
+    0,                                  /* tp_as_async */ 
     (reprfunc)code_repr,                /* tp_repr */
     0,                                  /* tp_as_number */
     0,                                  /* tp_as_sequence */
@@ -1082,7 +1082,7 @@ _PyCode_GetExtra(PyObject *code, Py_ssize_t index, void **extra)
 int
 _PyCode_SetExtra(PyObject *code, Py_ssize_t index, void *extra)
 {
-    PyInterpreterState *interp = _PyInterpreterState_GET();
+    PyInterpreterState *interp = _PyInterpreterState_GET(); 
 
     if (!PyCode_Check(code) || index < 0 ||
             index >= interp->co_extra_user_count) {