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

1 files changed, 1375 insertions, 1375 deletions

diff --git a/contrib/tools/python3/src/Modules/_tracemalloc.c b/contrib/tools/python3/src/Modules/_tracemalloc.c
index 4c8f3c4cd83..0078f0fde90 100644
--- a/contrib/tools/python3/src/Modules/_tracemalloc.c
+++ b/contrib/tools/python3/src/Modules/_tracemalloc.c
@@ -1,221 +1,221 @@
-#include "Python.h"
+#include "Python.h" 
 #include "pycore_gc.h"            // PyGC_Head
 #include "pycore_pymem.h"         // _Py_tracemalloc_config
 #include "pycore_traceback.h"
 #include "pycore_hashtable.h"
 #include "frameobject.h"          // PyFrame_GetBack()
-
-#include "clinic/_tracemalloc.c.h"
-/*[clinic input]
-module _tracemalloc
-[clinic start generated code]*/
-/*[clinic end generated code: output=da39a3ee5e6b4b0d input=708a98302fc46e5f]*/
-
-/* Trace memory blocks allocated by PyMem_RawMalloc() */
-#define TRACE_RAW_MALLOC
-
-/* Forward declaration */
-static void tracemalloc_stop(void);
-static void* raw_malloc(size_t size);
-static void raw_free(void *ptr);
-
-#ifdef Py_DEBUG
-#  define TRACE_DEBUG
-#endif
-
+ 
+#include "clinic/_tracemalloc.c.h" 
+/*[clinic input] 
+module _tracemalloc 
+[clinic start generated code]*/ 
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=708a98302fc46e5f]*/ 
+ 
+/* Trace memory blocks allocated by PyMem_RawMalloc() */ 
+#define TRACE_RAW_MALLOC 
+ 
+/* Forward declaration */ 
+static void tracemalloc_stop(void); 
+static void* raw_malloc(size_t size); 
+static void raw_free(void *ptr); 
+ 
+#ifdef Py_DEBUG 
+#  define TRACE_DEBUG 
+#endif 
+ 
 #define TO_PTR(key) ((const void *)(uintptr_t)(key))
 #define FROM_PTR(key) ((uintptr_t)(key))
 
-/* Protected by the GIL */
-static struct {
-    PyMemAllocatorEx mem;
-    PyMemAllocatorEx raw;
-    PyMemAllocatorEx obj;
-} allocators;
-
-
-#if defined(TRACE_RAW_MALLOC)
-/* This lock is needed because tracemalloc_free() is called without
-   the GIL held from PyMem_RawFree(). It cannot acquire the lock because it
+/* Protected by the GIL */ 
+static struct { 
+    PyMemAllocatorEx mem; 
+    PyMemAllocatorEx raw; 
+    PyMemAllocatorEx obj; 
+} allocators; 
+ 
+ 
+#if defined(TRACE_RAW_MALLOC) 
+/* This lock is needed because tracemalloc_free() is called without 
+   the GIL held from PyMem_RawFree(). It cannot acquire the lock because it 
    would introduce a deadlock in _PyThreadState_DeleteCurrent(). */
-static PyThread_type_lock tables_lock;
-#  define TABLES_LOCK() PyThread_acquire_lock(tables_lock, 1)
-#  define TABLES_UNLOCK() PyThread_release_lock(tables_lock)
-#else
-   /* variables are protected by the GIL */
-#  define TABLES_LOCK()
-#  define TABLES_UNLOCK()
-#endif
-
-
-#define DEFAULT_DOMAIN 0
-
-/* Pack the frame_t structure to reduce the memory footprint on 64-bit
-   architectures: 12 bytes instead of 16. */
-typedef struct
+static PyThread_type_lock tables_lock; 
+#  define TABLES_LOCK() PyThread_acquire_lock(tables_lock, 1) 
+#  define TABLES_UNLOCK() PyThread_release_lock(tables_lock) 
+#else 
+   /* variables are protected by the GIL */ 
+#  define TABLES_LOCK() 
+#  define TABLES_UNLOCK() 
+#endif 
+ 
+ 
+#define DEFAULT_DOMAIN 0 
+ 
+/* Pack the frame_t structure to reduce the memory footprint on 64-bit 
+   architectures: 12 bytes instead of 16. */ 
+typedef struct 
 #if defined(__GNUC__) || defined(__clang__)
-__attribute__((packed))
-#elif defined(_MSC_VER)
-#pragma pack(push, 4)
-#endif
-{
-    /* filename cannot be NULL: "<unknown>" is used if the Python frame
-       filename is NULL */
-    PyObject *filename;
-    unsigned int lineno;
-} frame_t;
+__attribute__((packed)) 
+#elif defined(_MSC_VER) 
+#pragma pack(push, 4) 
+#endif 
+{ 
+    /* filename cannot be NULL: "<unknown>" is used if the Python frame 
+       filename is NULL */ 
+    PyObject *filename; 
+    unsigned int lineno; 
+} frame_t; 
 #if defined(_MSC_VER) && !defined(__clang__)
-#pragma pack(pop)
-#endif
-
-
-typedef struct {
-    Py_uhash_t hash;
+#pragma pack(pop) 
+#endif 
+ 
+ 
+typedef struct { 
+    Py_uhash_t hash; 
     /* Number of frames stored */
     uint16_t nframe;
     /* Total number of frames the traceback had */
     uint16_t total_nframe;
-    frame_t frames[1];
-} traceback_t;
-
-#define TRACEBACK_SIZE(NFRAME) \
-        (sizeof(traceback_t) + sizeof(frame_t) * (NFRAME - 1))
-
+    frame_t frames[1]; 
+} traceback_t; 
+ 
+#define TRACEBACK_SIZE(NFRAME) \ 
+        (sizeof(traceback_t) + sizeof(frame_t) * (NFRAME - 1)) 
+ 
 /* The maximum number of frames is either:
  - The maximum number of frames we can store in `traceback_t.nframe`
  - The maximum memory size_t we can allocate */
 static const unsigned long MAX_NFRAME = Py_MIN(UINT16_MAX, ((SIZE_MAX - sizeof(traceback_t)) / sizeof(frame_t) + 1));
-
-
-static PyObject *unknown_filename = NULL;
-static traceback_t tracemalloc_empty_traceback;
-
-/* Trace of a memory block */
-typedef struct {
-    /* Size of the memory block in bytes */
-    size_t size;
-
-    /* Traceback where the memory block was allocated */
-    traceback_t *traceback;
-} trace_t;
-
-
-/* Size in bytes of currently traced memory.
-   Protected by TABLES_LOCK(). */
-static size_t tracemalloc_traced_memory = 0;
-
-/* Peak size in bytes of traced memory.
-   Protected by TABLES_LOCK(). */
-static size_t tracemalloc_peak_traced_memory = 0;
-
-/* Hash table used as a set to intern filenames:
-   PyObject* => PyObject*.
-   Protected by the GIL */
-static _Py_hashtable_t *tracemalloc_filenames = NULL;
-
-/* Buffer to store a new traceback in traceback_new().
-   Protected by the GIL. */
-static traceback_t *tracemalloc_traceback = NULL;
-
-/* Hash table used as a set to intern tracebacks:
-   traceback_t* => traceback_t*
-   Protected by the GIL */
-static _Py_hashtable_t *tracemalloc_tracebacks = NULL;
-
+ 
+ 
+static PyObject *unknown_filename = NULL; 
+static traceback_t tracemalloc_empty_traceback; 
+ 
+/* Trace of a memory block */ 
+typedef struct { 
+    /* Size of the memory block in bytes */ 
+    size_t size; 
+ 
+    /* Traceback where the memory block was allocated */ 
+    traceback_t *traceback; 
+} trace_t; 
+ 
+ 
+/* Size in bytes of currently traced memory. 
+   Protected by TABLES_LOCK(). */ 
+static size_t tracemalloc_traced_memory = 0; 
+ 
+/* Peak size in bytes of traced memory. 
+   Protected by TABLES_LOCK(). */ 
+static size_t tracemalloc_peak_traced_memory = 0; 
+ 
+/* Hash table used as a set to intern filenames: 
+   PyObject* => PyObject*. 
+   Protected by the GIL */ 
+static _Py_hashtable_t *tracemalloc_filenames = NULL; 
+ 
+/* Buffer to store a new traceback in traceback_new(). 
+   Protected by the GIL. */ 
+static traceback_t *tracemalloc_traceback = NULL; 
+ 
+/* Hash table used as a set to intern tracebacks: 
+   traceback_t* => traceback_t* 
+   Protected by the GIL */ 
+static _Py_hashtable_t *tracemalloc_tracebacks = NULL; 
+ 
 /* pointer (void*) => trace (trace_t*).
-   Protected by TABLES_LOCK(). */
-static _Py_hashtable_t *tracemalloc_traces = NULL;
-
+   Protected by TABLES_LOCK(). */ 
+static _Py_hashtable_t *tracemalloc_traces = NULL; 
+ 
 /* domain (unsigned int) => traces (_Py_hashtable_t).
    Protected by TABLES_LOCK(). */
 static _Py_hashtable_t *tracemalloc_domains = NULL;
+ 
 
-
-#ifdef TRACE_DEBUG
-static void
-tracemalloc_error(const char *format, ...)
-{
-    va_list ap;
-    fprintf(stderr, "tracemalloc: ");
-    va_start(ap, format);
-    vfprintf(stderr, format, ap);
-    va_end(ap);
-    fprintf(stderr, "\n");
-    fflush(stderr);
-}
-#endif
-
-
-#if defined(TRACE_RAW_MALLOC)
-#define REENTRANT_THREADLOCAL
-
-static Py_tss_t tracemalloc_reentrant_key = Py_tss_NEEDS_INIT;
-
-/* Any non-NULL pointer can be used */
-#define REENTRANT Py_True
-
-static int
-get_reentrant(void)
-{
-    void *ptr;
-
-    assert(PyThread_tss_is_created(&tracemalloc_reentrant_key));
-    ptr = PyThread_tss_get(&tracemalloc_reentrant_key);
-    if (ptr != NULL) {
-        assert(ptr == REENTRANT);
-        return 1;
-    }
-    else
-        return 0;
-}
-
-static void
-set_reentrant(int reentrant)
-{
-    assert(reentrant == 0 || reentrant == 1);
-    assert(PyThread_tss_is_created(&tracemalloc_reentrant_key));
-
-    if (reentrant) {
-        assert(!get_reentrant());
-        PyThread_tss_set(&tracemalloc_reentrant_key, REENTRANT);
-    }
-    else {
-        assert(get_reentrant());
-        PyThread_tss_set(&tracemalloc_reentrant_key, NULL);
-    }
-}
-
-#else
-
-/* TRACE_RAW_MALLOC not defined: variable protected by the GIL */
-static int tracemalloc_reentrant = 0;
-
-static int
-get_reentrant(void)
-{
-    return tracemalloc_reentrant;
-}
-
-static void
-set_reentrant(int reentrant)
-{
-    assert(reentrant != tracemalloc_reentrant);
-    tracemalloc_reentrant = reentrant;
-}
-#endif
-
-
-static Py_uhash_t
+#ifdef TRACE_DEBUG 
+static void 
+tracemalloc_error(const char *format, ...) 
+{ 
+    va_list ap; 
+    fprintf(stderr, "tracemalloc: "); 
+    va_start(ap, format); 
+    vfprintf(stderr, format, ap); 
+    va_end(ap); 
+    fprintf(stderr, "\n"); 
+    fflush(stderr); 
+} 
+#endif 
+ 
+ 
+#if defined(TRACE_RAW_MALLOC) 
+#define REENTRANT_THREADLOCAL 
+ 
+static Py_tss_t tracemalloc_reentrant_key = Py_tss_NEEDS_INIT; 
+ 
+/* Any non-NULL pointer can be used */ 
+#define REENTRANT Py_True 
+ 
+static int 
+get_reentrant(void) 
+{ 
+    void *ptr; 
+ 
+    assert(PyThread_tss_is_created(&tracemalloc_reentrant_key)); 
+    ptr = PyThread_tss_get(&tracemalloc_reentrant_key); 
+    if (ptr != NULL) { 
+        assert(ptr == REENTRANT); 
+        return 1; 
+    } 
+    else 
+        return 0; 
+} 
+ 
+static void 
+set_reentrant(int reentrant) 
+{ 
+    assert(reentrant == 0 || reentrant == 1); 
+    assert(PyThread_tss_is_created(&tracemalloc_reentrant_key)); 
+ 
+    if (reentrant) { 
+        assert(!get_reentrant()); 
+        PyThread_tss_set(&tracemalloc_reentrant_key, REENTRANT); 
+    } 
+    else { 
+        assert(get_reentrant()); 
+        PyThread_tss_set(&tracemalloc_reentrant_key, NULL); 
+    } 
+} 
+ 
+#else 
+ 
+/* TRACE_RAW_MALLOC not defined: variable protected by the GIL */ 
+static int tracemalloc_reentrant = 0; 
+ 
+static int 
+get_reentrant(void) 
+{ 
+    return tracemalloc_reentrant; 
+} 
+ 
+static void 
+set_reentrant(int reentrant) 
+{ 
+    assert(reentrant != tracemalloc_reentrant); 
+    tracemalloc_reentrant = reentrant; 
+} 
+#endif 
+ 
+ 
+static Py_uhash_t 
 hashtable_hash_pyobject(const void *key)
-{
+{ 
     PyObject *obj = (PyObject *)key;
-    return PyObject_Hash(obj);
-}
-
-
-static int
+    return PyObject_Hash(obj); 
+} 
+ 
+ 
+static int 
 hashtable_compare_unicode(const void *key1, const void *key2)
-{
+{ 
     PyObject *obj1 = (PyObject *)key1;
     PyObject *obj2 = (PyObject *)key2;
     if (obj1 != NULL && obj2 != NULL) {
@@ -224,177 +224,177 @@ hashtable_compare_unicode(const void *key1, const void *key2)
     else {
         return obj1 == obj2;
     }
-}
-
-
-static Py_uhash_t
+} 
+ 
+ 
+static Py_uhash_t 
 hashtable_hash_uint(const void *key_raw)
-{
+{ 
     unsigned int key = (unsigned int)FROM_PTR(key_raw);
     return (Py_uhash_t)key;
-}
-
-
-static _Py_hashtable_t *
+} 
+ 
+ 
+static _Py_hashtable_t * 
 hashtable_new(_Py_hashtable_hash_func hash_func,
               _Py_hashtable_compare_func compare_func,
               _Py_hashtable_destroy_func key_destroy_func,
               _Py_hashtable_destroy_func value_destroy_func)
-{
-    _Py_hashtable_allocator_t hashtable_alloc = {malloc, free};
+{ 
+    _Py_hashtable_allocator_t hashtable_alloc = {malloc, free}; 
     return _Py_hashtable_new_full(hash_func, compare_func,
                                   key_destroy_func, value_destroy_func,
-                                  &hashtable_alloc);
-}
-
-
-static void*
-raw_malloc(size_t size)
-{
-    return allocators.raw.malloc(allocators.raw.ctx, size);
-}
-
-static void
-raw_free(void *ptr)
-{
-    allocators.raw.free(allocators.raw.ctx, ptr);
-}
-
-
-static Py_uhash_t
+                                  &hashtable_alloc); 
+} 
+ 
+ 
+static void* 
+raw_malloc(size_t size) 
+{ 
+    return allocators.raw.malloc(allocators.raw.ctx, size); 
+} 
+ 
+static void 
+raw_free(void *ptr) 
+{ 
+    allocators.raw.free(allocators.raw.ctx, ptr); 
+} 
+ 
+ 
+static Py_uhash_t 
 hashtable_hash_traceback(const void *key)
-{
+{ 
     const traceback_t *traceback = (const traceback_t *)key;
-    return traceback->hash;
-}
-
-
-static int
+    return traceback->hash; 
+} 
+ 
+ 
+static int 
 hashtable_compare_traceback(const void *key1, const void *key2)
-{
+{ 
     const traceback_t *traceback1 = (const traceback_t *)key1;
     const traceback_t *traceback2 = (const traceback_t *)key2;
-
+ 
     if (traceback1->nframe != traceback2->nframe) {
-        return 0;
+        return 0; 
     }
     if (traceback1->total_nframe != traceback2->total_nframe) {
         return 0;
     }
-
+ 
     for (int i=0; i < traceback1->nframe; i++) {
         const frame_t *frame1 = &traceback1->frames[i];
         const frame_t *frame2 = &traceback2->frames[i];
-
+ 
         if (frame1->lineno != frame2->lineno) {
-            return 0;
-        }
-        if (frame1->filename != frame2->filename) {
-            assert(PyUnicode_Compare(frame1->filename, frame2->filename) != 0);
-            return 0;
+            return 0; 
         }
-    }
-    return 1;
-}
-
-
-static void
-tracemalloc_get_frame(PyFrameObject *pyframe, frame_t *frame)
-{
-    frame->filename = unknown_filename;
+        if (frame1->filename != frame2->filename) { 
+            assert(PyUnicode_Compare(frame1->filename, frame2->filename) != 0); 
+            return 0; 
+        } 
+    } 
+    return 1; 
+} 
+ 
+ 
+static void 
+tracemalloc_get_frame(PyFrameObject *pyframe, frame_t *frame) 
+{ 
+    frame->filename = unknown_filename; 
     int lineno = PyFrame_GetLineNumber(pyframe);
     if (lineno < 0) {
-        lineno = 0;
+        lineno = 0; 
     }
-    frame->lineno = (unsigned int)lineno;
-
+    frame->lineno = (unsigned int)lineno; 
+ 
     PyCodeObject *code = PyFrame_GetCode(pyframe);
     PyObject *filename = code->co_filename;
     Py_DECREF(code);
-
+ 
     if (filename == NULL) {
-#ifdef TRACE_DEBUG
-        tracemalloc_error("failed to get the filename of the code object");
-#endif
-        return;
-    }
-
-    if (!PyUnicode_Check(filename)) {
-#ifdef TRACE_DEBUG
-        tracemalloc_error("filename is not a unicode string");
-#endif
-        return;
-    }
-    if (!PyUnicode_IS_READY(filename)) {
-        /* Don't make a Unicode string ready to avoid reentrant calls
-           to tracemalloc_malloc() or tracemalloc_realloc() */
-#ifdef TRACE_DEBUG
-        tracemalloc_error("filename is not a ready unicode string");
-#endif
-        return;
-    }
-
-    /* intern the filename */
+#ifdef TRACE_DEBUG 
+        tracemalloc_error("failed to get the filename of the code object"); 
+#endif 
+        return; 
+    } 
+ 
+    if (!PyUnicode_Check(filename)) { 
+#ifdef TRACE_DEBUG 
+        tracemalloc_error("filename is not a unicode string"); 
+#endif 
+        return; 
+    } 
+    if (!PyUnicode_IS_READY(filename)) { 
+        /* Don't make a Unicode string ready to avoid reentrant calls 
+           to tracemalloc_malloc() or tracemalloc_realloc() */ 
+#ifdef TRACE_DEBUG 
+        tracemalloc_error("filename is not a ready unicode string"); 
+#endif 
+        return; 
+    } 
+ 
+    /* intern the filename */ 
     _Py_hashtable_entry_t *entry;
     entry = _Py_hashtable_get_entry(tracemalloc_filenames, filename);
-    if (entry != NULL) {
+    if (entry != NULL) { 
         filename = (PyObject *)entry->key;
-    }
-    else {
-        /* tracemalloc_filenames is responsible to keep a reference
-           to the filename */
-        Py_INCREF(filename);
+    } 
+    else { 
+        /* tracemalloc_filenames is responsible to keep a reference 
+           to the filename */ 
+        Py_INCREF(filename); 
         if (_Py_hashtable_set(tracemalloc_filenames, filename, NULL) < 0) {
-            Py_DECREF(filename);
-#ifdef TRACE_DEBUG
-            tracemalloc_error("failed to intern the filename");
-#endif
-            return;
-        }
-    }
-
-    /* the tracemalloc_filenames table keeps a reference to the filename */
-    frame->filename = filename;
-}
-
-
-static Py_uhash_t
-traceback_hash(traceback_t *traceback)
-{
-    /* code based on tuplehash() of Objects/tupleobject.c */
-    Py_uhash_t x, y;  /* Unsigned for defined overflow behavior. */
-    int len = traceback->nframe;
-    Py_uhash_t mult = _PyHASH_MULTIPLIER;
-    frame_t *frame;
-
-    x = 0x345678UL;
-    frame = traceback->frames;
-    while (--len >= 0) {
-        y = (Py_uhash_t)PyObject_Hash(frame->filename);
-        y ^= (Py_uhash_t)frame->lineno;
-        frame++;
-
-        x = (x ^ y) * mult;
-        /* the cast might truncate len; that doesn't change hash stability */
-        mult += (Py_uhash_t)(82520UL + len + len);
-    }
+            Py_DECREF(filename); 
+#ifdef TRACE_DEBUG 
+            tracemalloc_error("failed to intern the filename"); 
+#endif 
+            return; 
+        } 
+    } 
+ 
+    /* the tracemalloc_filenames table keeps a reference to the filename */ 
+    frame->filename = filename; 
+} 
+ 
+ 
+static Py_uhash_t 
+traceback_hash(traceback_t *traceback) 
+{ 
+    /* code based on tuplehash() of Objects/tupleobject.c */ 
+    Py_uhash_t x, y;  /* Unsigned for defined overflow behavior. */ 
+    int len = traceback->nframe; 
+    Py_uhash_t mult = _PyHASH_MULTIPLIER; 
+    frame_t *frame; 
+ 
+    x = 0x345678UL; 
+    frame = traceback->frames; 
+    while (--len >= 0) { 
+        y = (Py_uhash_t)PyObject_Hash(frame->filename); 
+        y ^= (Py_uhash_t)frame->lineno; 
+        frame++; 
+ 
+        x = (x ^ y) * mult; 
+        /* the cast might truncate len; that doesn't change hash stability */ 
+        mult += (Py_uhash_t)(82520UL + len + len); 
+    } 
     x ^= traceback->total_nframe;
-    x += 97531UL;
-    return x;
-}
-
-
-static void
-traceback_get_frames(traceback_t *traceback)
-{
+    x += 97531UL; 
+    return x; 
+} 
+ 
+ 
+static void 
+traceback_get_frames(traceback_t *traceback) 
+{ 
     PyThreadState *tstate = PyGILState_GetThisThreadState();
-    if (tstate == NULL) {
-#ifdef TRACE_DEBUG
-        tracemalloc_error("failed to get the current thread state");
-#endif
-        return;
-    }
-
+    if (tstate == NULL) { 
+#ifdef TRACE_DEBUG 
+        tracemalloc_error("failed to get the current thread state"); 
+#endif 
+        return; 
+    } 
+ 
     PyFrameObject *pyframe = PyThreadState_GetFrame(tstate);
     for (; pyframe != NULL;) {
         if (traceback->nframe < _Py_tracemalloc_config.max_nframe) {
@@ -409,69 +409,69 @@ traceback_get_frames(traceback_t *traceback)
         PyFrameObject *back = PyFrame_GetBack(pyframe);
         Py_DECREF(pyframe);
         pyframe = back;
-    }
-}
-
-
-static traceback_t *
-traceback_new(void)
-{
-    traceback_t *traceback;
-    _Py_hashtable_entry_t *entry;
-
-    assert(PyGILState_Check());
-
-    /* get frames */
-    traceback = tracemalloc_traceback;
-    traceback->nframe = 0;
+    } 
+} 
+ 
+ 
+static traceback_t * 
+traceback_new(void) 
+{ 
+    traceback_t *traceback; 
+    _Py_hashtable_entry_t *entry; 
+ 
+    assert(PyGILState_Check()); 
+ 
+    /* get frames */ 
+    traceback = tracemalloc_traceback; 
+    traceback->nframe = 0; 
     traceback->total_nframe = 0;
-    traceback_get_frames(traceback);
-    if (traceback->nframe == 0)
-        return &tracemalloc_empty_traceback;
-    traceback->hash = traceback_hash(traceback);
-
-    /* intern the traceback */
+    traceback_get_frames(traceback); 
+    if (traceback->nframe == 0) 
+        return &tracemalloc_empty_traceback; 
+    traceback->hash = traceback_hash(traceback); 
+ 
+    /* intern the traceback */ 
     entry = _Py_hashtable_get_entry(tracemalloc_tracebacks, traceback);
-    if (entry != NULL) {
+    if (entry != NULL) { 
         traceback = (traceback_t *)entry->key;
-    }
-    else {
-        traceback_t *copy;
-        size_t traceback_size;
-
-        traceback_size = TRACEBACK_SIZE(traceback->nframe);
-
-        copy = raw_malloc(traceback_size);
-        if (copy == NULL) {
-#ifdef TRACE_DEBUG
-            tracemalloc_error("failed to intern the traceback: malloc failed");
-#endif
-            return NULL;
-        }
-        memcpy(copy, traceback, traceback_size);
-
+    } 
+    else { 
+        traceback_t *copy; 
+        size_t traceback_size; 
+ 
+        traceback_size = TRACEBACK_SIZE(traceback->nframe); 
+ 
+        copy = raw_malloc(traceback_size); 
+        if (copy == NULL) { 
+#ifdef TRACE_DEBUG 
+            tracemalloc_error("failed to intern the traceback: malloc failed"); 
+#endif 
+            return NULL; 
+        } 
+        memcpy(copy, traceback, traceback_size); 
+ 
         if (_Py_hashtable_set(tracemalloc_tracebacks, copy, NULL) < 0) {
-            raw_free(copy);
-#ifdef TRACE_DEBUG
-            tracemalloc_error("failed to intern the traceback: putdata failed");
-#endif
-            return NULL;
-        }
-        traceback = copy;
-    }
-    return traceback;
-}
-
-
+            raw_free(copy); 
+#ifdef TRACE_DEBUG 
+            tracemalloc_error("failed to intern the traceback: putdata failed"); 
+#endif 
+            return NULL; 
+        } 
+        traceback = copy; 
+    } 
+    return traceback; 
+} 
+ 
+ 
 static _Py_hashtable_t*
 tracemalloc_create_traces_table(void)
-{
+{ 
     return hashtable_new(_Py_hashtable_hash_ptr,
                          _Py_hashtable_compare_direct,
                          NULL, raw_free);
 }
-
-
+ 
+ 
 static _Py_hashtable_t*
 tracemalloc_create_domains_table(void)
 {
@@ -479,696 +479,696 @@ tracemalloc_create_domains_table(void)
                          _Py_hashtable_compare_direct,
                          NULL,
                          (_Py_hashtable_destroy_func)_Py_hashtable_destroy);
-}
-
-
+} 
+ 
+ 
 static _Py_hashtable_t*
 tracemalloc_get_traces_table(unsigned int domain)
-{
+{ 
     if (domain == DEFAULT_DOMAIN) {
         return tracemalloc_traces;
-    }
+    } 
     else {
         return _Py_hashtable_get(tracemalloc_domains, TO_PTR(domain));
-    }
-}
-
-
-static void
-tracemalloc_remove_trace(unsigned int domain, uintptr_t ptr)
-{
+    } 
+} 
+ 
+ 
+static void 
+tracemalloc_remove_trace(unsigned int domain, uintptr_t ptr) 
+{ 
     assert(_Py_tracemalloc_config.tracing);
-
+ 
     _Py_hashtable_t *traces = tracemalloc_get_traces_table(domain);
     if (!traces) {
         return;
-    }
+    } 
 
     trace_t *trace = _Py_hashtable_steal(traces, TO_PTR(ptr));
     if (!trace) {
-        return;
-    }
+        return; 
+    } 
     assert(tracemalloc_traced_memory >= trace->size);
     tracemalloc_traced_memory -= trace->size;
     raw_free(trace);
-}
-
-#define REMOVE_TRACE(ptr) \
-            tracemalloc_remove_trace(DEFAULT_DOMAIN, (uintptr_t)(ptr))
-
-
-static int
-tracemalloc_add_trace(unsigned int domain, uintptr_t ptr,
-                      size_t size)
-{
+} 
+ 
+#define REMOVE_TRACE(ptr) \ 
+            tracemalloc_remove_trace(DEFAULT_DOMAIN, (uintptr_t)(ptr)) 
+ 
+ 
+static int 
+tracemalloc_add_trace(unsigned int domain, uintptr_t ptr, 
+                      size_t size) 
+{ 
     assert(_Py_tracemalloc_config.tracing);
-
+ 
     traceback_t *traceback = traceback_new();
-    if (traceback == NULL) {
-        return -1;
-    }
-
+    if (traceback == NULL) { 
+        return -1; 
+    } 
+ 
     _Py_hashtable_t *traces = tracemalloc_get_traces_table(domain);
     if (traces == NULL) {
         traces = tracemalloc_create_traces_table();
         if (traces == NULL) {
-            return -1;
-        }
-
+            return -1; 
+        } 
+ 
         if (_Py_hashtable_set(tracemalloc_domains, TO_PTR(domain), traces) < 0) {
             _Py_hashtable_destroy(traces);
             return -1;
         }
-    }
-
+    } 
+ 
     trace_t *trace = _Py_hashtable_get(traces, TO_PTR(ptr));
     if (trace != NULL) {
-        /* the memory block is already tracked */
+        /* the memory block is already tracked */ 
         assert(tracemalloc_traced_memory >= trace->size);
         tracemalloc_traced_memory -= trace->size;
-
+ 
         trace->size = size;
         trace->traceback = traceback;
-    }
-    else {
+    } 
+    else { 
         trace = raw_malloc(sizeof(trace_t));
         if (trace == NULL) {
             return -1;
         }
         trace->size = size;
         trace->traceback = traceback;
-
+ 
         int res = _Py_hashtable_set(traces, TO_PTR(ptr), trace);
-        if (res != 0) {
+        if (res != 0) { 
             raw_free(trace);
-            return res;
-        }
-    }
-
-    assert(tracemalloc_traced_memory <= SIZE_MAX - size);
-    tracemalloc_traced_memory += size;
+            return res; 
+        } 
+    } 
+ 
+    assert(tracemalloc_traced_memory <= SIZE_MAX - size); 
+    tracemalloc_traced_memory += size; 
     if (tracemalloc_traced_memory > tracemalloc_peak_traced_memory) {
-        tracemalloc_peak_traced_memory = tracemalloc_traced_memory;
+        tracemalloc_peak_traced_memory = tracemalloc_traced_memory; 
     }
-    return 0;
-}
-
-#define ADD_TRACE(ptr, size) \
-            tracemalloc_add_trace(DEFAULT_DOMAIN, (uintptr_t)(ptr), size)
-
-
-static void*
-tracemalloc_alloc(int use_calloc, void *ctx, size_t nelem, size_t elsize)
-{
-    PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
-    void *ptr;
-
-    assert(elsize == 0 || nelem <= SIZE_MAX / elsize);
-
-    if (use_calloc)
-        ptr = alloc->calloc(alloc->ctx, nelem, elsize);
-    else
-        ptr = alloc->malloc(alloc->ctx, nelem * elsize);
-    if (ptr == NULL)
-        return NULL;
-
-    TABLES_LOCK();
-    if (ADD_TRACE(ptr, nelem * elsize) < 0) {
-        /* Failed to allocate a trace for the new memory block */
-        TABLES_UNLOCK();
-        alloc->free(alloc->ctx, ptr);
-        return NULL;
-    }
-    TABLES_UNLOCK();
-    return ptr;
-}
-
-
-static void*
-tracemalloc_realloc(void *ctx, void *ptr, size_t new_size)
-{
-    PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
-    void *ptr2;
-
-    ptr2 = alloc->realloc(alloc->ctx, ptr, new_size);
-    if (ptr2 == NULL)
-        return NULL;
-
-    if (ptr != NULL) {
-        /* an existing memory block has been resized */
-
-        TABLES_LOCK();
-
-        /* tracemalloc_add_trace() updates the trace if there is already
+    return 0; 
+} 
+ 
+#define ADD_TRACE(ptr, size) \ 
+            tracemalloc_add_trace(DEFAULT_DOMAIN, (uintptr_t)(ptr), size) 
+ 
+ 
+static void* 
+tracemalloc_alloc(int use_calloc, void *ctx, size_t nelem, size_t elsize) 
+{ 
+    PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx; 
+    void *ptr; 
+ 
+    assert(elsize == 0 || nelem <= SIZE_MAX / elsize); 
+ 
+    if (use_calloc) 
+        ptr = alloc->calloc(alloc->ctx, nelem, elsize); 
+    else 
+        ptr = alloc->malloc(alloc->ctx, nelem * elsize); 
+    if (ptr == NULL) 
+        return NULL; 
+ 
+    TABLES_LOCK(); 
+    if (ADD_TRACE(ptr, nelem * elsize) < 0) { 
+        /* Failed to allocate a trace for the new memory block */ 
+        TABLES_UNLOCK(); 
+        alloc->free(alloc->ctx, ptr); 
+        return NULL; 
+    } 
+    TABLES_UNLOCK(); 
+    return ptr; 
+} 
+ 
+ 
+static void* 
+tracemalloc_realloc(void *ctx, void *ptr, size_t new_size) 
+{ 
+    PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx; 
+    void *ptr2; 
+ 
+    ptr2 = alloc->realloc(alloc->ctx, ptr, new_size); 
+    if (ptr2 == NULL) 
+        return NULL; 
+ 
+    if (ptr != NULL) { 
+        /* an existing memory block has been resized */ 
+ 
+        TABLES_LOCK(); 
+ 
+        /* tracemalloc_add_trace() updates the trace if there is already 
            a trace at address ptr2 */
-        if (ptr2 != ptr) {
-            REMOVE_TRACE(ptr);
-        }
-
-        if (ADD_TRACE(ptr2, new_size) < 0) {
-            /* Memory allocation failed. The error cannot be reported to
-               the caller, because realloc() may already have shrunk the
-               memory block and so removed bytes.
-
-               This case is very unlikely: a hash entry has just been
-               released, so the hash table should have at least one free entry.
-
-               The GIL and the table lock ensures that only one thread is
-               allocating memory. */
+        if (ptr2 != ptr) { 
+            REMOVE_TRACE(ptr); 
+        } 
+ 
+        if (ADD_TRACE(ptr2, new_size) < 0) { 
+            /* Memory allocation failed. The error cannot be reported to 
+               the caller, because realloc() may already have shrunk the 
+               memory block and so removed bytes. 
+ 
+               This case is very unlikely: a hash entry has just been 
+               released, so the hash table should have at least one free entry. 
+ 
+               The GIL and the table lock ensures that only one thread is 
+               allocating memory. */ 
             Py_FatalError("tracemalloc_realloc() failed to allocate a trace");
-        }
-        TABLES_UNLOCK();
-    }
-    else {
-        /* new allocation */
-
-        TABLES_LOCK();
-        if (ADD_TRACE(ptr2, new_size) < 0) {
-            /* Failed to allocate a trace for the new memory block */
-            TABLES_UNLOCK();
-            alloc->free(alloc->ctx, ptr2);
-            return NULL;
-        }
-        TABLES_UNLOCK();
-    }
-    return ptr2;
-}
-
-
-static void
-tracemalloc_free(void *ctx, void *ptr)
-{
-    PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
-
-    if (ptr == NULL)
-        return;
-
-     /* GIL cannot be locked in PyMem_RawFree() because it would introduce
+        } 
+        TABLES_UNLOCK(); 
+    } 
+    else { 
+        /* new allocation */ 
+ 
+        TABLES_LOCK(); 
+        if (ADD_TRACE(ptr2, new_size) < 0) { 
+            /* Failed to allocate a trace for the new memory block */ 
+            TABLES_UNLOCK(); 
+            alloc->free(alloc->ctx, ptr2); 
+            return NULL; 
+        } 
+        TABLES_UNLOCK(); 
+    } 
+    return ptr2; 
+} 
+ 
+ 
+static void 
+tracemalloc_free(void *ctx, void *ptr) 
+{ 
+    PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx; 
+ 
+    if (ptr == NULL) 
+        return; 
+ 
+     /* GIL cannot be locked in PyMem_RawFree() because it would introduce 
         a deadlock in _PyThreadState_DeleteCurrent(). */
-
-    alloc->free(alloc->ctx, ptr);
-
-    TABLES_LOCK();
-    REMOVE_TRACE(ptr);
-    TABLES_UNLOCK();
-}
-
-
-static void*
-tracemalloc_alloc_gil(int use_calloc, void *ctx, size_t nelem, size_t elsize)
-{
-    void *ptr;
-
-    if (get_reentrant()) {
-        PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
-        if (use_calloc)
-            return alloc->calloc(alloc->ctx, nelem, elsize);
-        else
-            return alloc->malloc(alloc->ctx, nelem * elsize);
-    }
-
-    /* Ignore reentrant call. PyObjet_Malloc() calls PyMem_Malloc() for
-       allocations larger than 512 bytes, don't trace the same memory
-       allocation twice. */
-    set_reentrant(1);
-
-    ptr = tracemalloc_alloc(use_calloc, ctx, nelem, elsize);
-
-    set_reentrant(0);
-    return ptr;
-}
-
-
-static void*
-tracemalloc_malloc_gil(void *ctx, size_t size)
-{
-    return tracemalloc_alloc_gil(0, ctx, 1, size);
-}
-
-
-static void*
-tracemalloc_calloc_gil(void *ctx, size_t nelem, size_t elsize)
-{
-    return tracemalloc_alloc_gil(1, ctx, nelem, elsize);
-}
-
-
-static void*
-tracemalloc_realloc_gil(void *ctx, void *ptr, size_t new_size)
-{
-    void *ptr2;
-
-    if (get_reentrant()) {
-        /* Reentrant call to PyMem_Realloc() and PyMem_RawRealloc().
-           Example: PyMem_RawRealloc() is called internally by pymalloc
-           (_PyObject_Malloc() and  _PyObject_Realloc()) to allocate a new
-           arena (new_arena()). */
-        PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
-
-        ptr2 = alloc->realloc(alloc->ctx, ptr, new_size);
-        if (ptr2 != NULL && ptr != NULL) {
-            TABLES_LOCK();
-            REMOVE_TRACE(ptr);
-            TABLES_UNLOCK();
-        }
-        return ptr2;
-    }
-
-    /* Ignore reentrant call. PyObjet_Realloc() calls PyMem_Realloc() for
-       allocations larger than 512 bytes. Don't trace the same memory
-       allocation twice. */
-    set_reentrant(1);
-
-    ptr2 = tracemalloc_realloc(ctx, ptr, new_size);
-
-    set_reentrant(0);
-    return ptr2;
-}
-
-
-#ifdef TRACE_RAW_MALLOC
-static void*
-tracemalloc_raw_alloc(int use_calloc, void *ctx, size_t nelem, size_t elsize)
-{
-    PyGILState_STATE gil_state;
-    void *ptr;
-
-    if (get_reentrant()) {
-        PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
-        if (use_calloc)
-            return alloc->calloc(alloc->ctx, nelem, elsize);
-        else
-            return alloc->malloc(alloc->ctx, nelem * elsize);
-    }
-
-    /* Ignore reentrant call. PyGILState_Ensure() may call PyMem_RawMalloc()
-       indirectly which would call PyGILState_Ensure() if reentrant are not
-       disabled. */
-    set_reentrant(1);
-
-    gil_state = PyGILState_Ensure();
-    ptr = tracemalloc_alloc(use_calloc, ctx, nelem, elsize);
-    PyGILState_Release(gil_state);
-
-    set_reentrant(0);
-    return ptr;
-}
-
-
-static void*
-tracemalloc_raw_malloc(void *ctx, size_t size)
-{
-    return tracemalloc_raw_alloc(0, ctx, 1, size);
-}
-
-
-static void*
-tracemalloc_raw_calloc(void *ctx, size_t nelem, size_t elsize)
-{
-    return tracemalloc_raw_alloc(1, ctx, nelem, elsize);
-}
-
-
-static void*
-tracemalloc_raw_realloc(void *ctx, void *ptr, size_t new_size)
-{
-    PyGILState_STATE gil_state;
-    void *ptr2;
-
-    if (get_reentrant()) {
-        /* Reentrant call to PyMem_RawRealloc(). */
-        PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
-
-        ptr2 = alloc->realloc(alloc->ctx, ptr, new_size);
-
-        if (ptr2 != NULL && ptr != NULL) {
-            TABLES_LOCK();
-            REMOVE_TRACE(ptr);
-            TABLES_UNLOCK();
-        }
-        return ptr2;
-    }
-
-    /* Ignore reentrant call. PyGILState_Ensure() may call PyMem_RawMalloc()
-       indirectly which would call PyGILState_Ensure() if reentrant calls are
-       not disabled. */
-    set_reentrant(1);
-
-    gil_state = PyGILState_Ensure();
-    ptr2 = tracemalloc_realloc(ctx, ptr, new_size);
-    PyGILState_Release(gil_state);
-
-    set_reentrant(0);
-    return ptr2;
-}
-#endif   /* TRACE_RAW_MALLOC */
-
-
+ 
+    alloc->free(alloc->ctx, ptr); 
+ 
+    TABLES_LOCK(); 
+    REMOVE_TRACE(ptr); 
+    TABLES_UNLOCK(); 
+} 
+ 
+ 
+static void* 
+tracemalloc_alloc_gil(int use_calloc, void *ctx, size_t nelem, size_t elsize) 
+{ 
+    void *ptr; 
+ 
+    if (get_reentrant()) { 
+        PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx; 
+        if (use_calloc) 
+            return alloc->calloc(alloc->ctx, nelem, elsize); 
+        else 
+            return alloc->malloc(alloc->ctx, nelem * elsize); 
+    } 
+ 
+    /* Ignore reentrant call. PyObjet_Malloc() calls PyMem_Malloc() for 
+       allocations larger than 512 bytes, don't trace the same memory 
+       allocation twice. */ 
+    set_reentrant(1); 
+ 
+    ptr = tracemalloc_alloc(use_calloc, ctx, nelem, elsize); 
+ 
+    set_reentrant(0); 
+    return ptr; 
+} 
+ 
+ 
+static void* 
+tracemalloc_malloc_gil(void *ctx, size_t size) 
+{ 
+    return tracemalloc_alloc_gil(0, ctx, 1, size); 
+} 
+ 
+ 
+static void* 
+tracemalloc_calloc_gil(void *ctx, size_t nelem, size_t elsize) 
+{ 
+    return tracemalloc_alloc_gil(1, ctx, nelem, elsize); 
+} 
+ 
+ 
+static void* 
+tracemalloc_realloc_gil(void *ctx, void *ptr, size_t new_size) 
+{ 
+    void *ptr2; 
+ 
+    if (get_reentrant()) { 
+        /* Reentrant call to PyMem_Realloc() and PyMem_RawRealloc(). 
+           Example: PyMem_RawRealloc() is called internally by pymalloc 
+           (_PyObject_Malloc() and  _PyObject_Realloc()) to allocate a new 
+           arena (new_arena()). */ 
+        PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx; 
+ 
+        ptr2 = alloc->realloc(alloc->ctx, ptr, new_size); 
+        if (ptr2 != NULL && ptr != NULL) { 
+            TABLES_LOCK(); 
+            REMOVE_TRACE(ptr); 
+            TABLES_UNLOCK(); 
+        } 
+        return ptr2; 
+    } 
+ 
+    /* Ignore reentrant call. PyObjet_Realloc() calls PyMem_Realloc() for 
+       allocations larger than 512 bytes. Don't trace the same memory 
+       allocation twice. */ 
+    set_reentrant(1); 
+ 
+    ptr2 = tracemalloc_realloc(ctx, ptr, new_size); 
+ 
+    set_reentrant(0); 
+    return ptr2; 
+} 
+ 
+ 
+#ifdef TRACE_RAW_MALLOC 
+static void* 
+tracemalloc_raw_alloc(int use_calloc, void *ctx, size_t nelem, size_t elsize) 
+{ 
+    PyGILState_STATE gil_state; 
+    void *ptr; 
+ 
+    if (get_reentrant()) { 
+        PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx; 
+        if (use_calloc) 
+            return alloc->calloc(alloc->ctx, nelem, elsize); 
+        else 
+            return alloc->malloc(alloc->ctx, nelem * elsize); 
+    } 
+ 
+    /* Ignore reentrant call. PyGILState_Ensure() may call PyMem_RawMalloc() 
+       indirectly which would call PyGILState_Ensure() if reentrant are not 
+       disabled. */ 
+    set_reentrant(1); 
+ 
+    gil_state = PyGILState_Ensure(); 
+    ptr = tracemalloc_alloc(use_calloc, ctx, nelem, elsize); 
+    PyGILState_Release(gil_state); 
+ 
+    set_reentrant(0); 
+    return ptr; 
+} 
+ 
+ 
+static void* 
+tracemalloc_raw_malloc(void *ctx, size_t size) 
+{ 
+    return tracemalloc_raw_alloc(0, ctx, 1, size); 
+} 
+ 
+ 
+static void* 
+tracemalloc_raw_calloc(void *ctx, size_t nelem, size_t elsize) 
+{ 
+    return tracemalloc_raw_alloc(1, ctx, nelem, elsize); 
+} 
+ 
+ 
+static void* 
+tracemalloc_raw_realloc(void *ctx, void *ptr, size_t new_size) 
+{ 
+    PyGILState_STATE gil_state; 
+    void *ptr2; 
+ 
+    if (get_reentrant()) { 
+        /* Reentrant call to PyMem_RawRealloc(). */ 
+        PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx; 
+ 
+        ptr2 = alloc->realloc(alloc->ctx, ptr, new_size); 
+ 
+        if (ptr2 != NULL && ptr != NULL) { 
+            TABLES_LOCK(); 
+            REMOVE_TRACE(ptr); 
+            TABLES_UNLOCK(); 
+        } 
+        return ptr2; 
+    } 
+ 
+    /* Ignore reentrant call. PyGILState_Ensure() may call PyMem_RawMalloc() 
+       indirectly which would call PyGILState_Ensure() if reentrant calls are 
+       not disabled. */ 
+    set_reentrant(1); 
+ 
+    gil_state = PyGILState_Ensure(); 
+    ptr2 = tracemalloc_realloc(ctx, ptr, new_size); 
+    PyGILState_Release(gil_state); 
+ 
+    set_reentrant(0); 
+    return ptr2; 
+} 
+#endif   /* TRACE_RAW_MALLOC */ 
+ 
+ 
 static void
 tracemalloc_clear_filename(void *value)
-{
+{ 
     PyObject *filename = (PyObject *)value;
-    Py_DECREF(filename);
-}
-
-
-/* reentrant flag must be set to call this function and GIL must be held */
-static void
-tracemalloc_clear_traces(void)
-{
+    Py_DECREF(filename); 
+} 
+ 
+ 
+/* reentrant flag must be set to call this function and GIL must be held */ 
+static void 
+tracemalloc_clear_traces(void) 
+{ 
     /* The GIL protects variables against concurrent access */
-    assert(PyGILState_Check());
-
-    TABLES_LOCK();
-    _Py_hashtable_clear(tracemalloc_traces);
+    assert(PyGILState_Check()); 
+ 
+    TABLES_LOCK(); 
+    _Py_hashtable_clear(tracemalloc_traces); 
     _Py_hashtable_clear(tracemalloc_domains);
-    tracemalloc_traced_memory = 0;
-    tracemalloc_peak_traced_memory = 0;
-    TABLES_UNLOCK();
-
-    _Py_hashtable_clear(tracemalloc_tracebacks);
-
-    _Py_hashtable_clear(tracemalloc_filenames);
-}
-
-
-static int
-tracemalloc_init(void)
-{
+    tracemalloc_traced_memory = 0; 
+    tracemalloc_peak_traced_memory = 0; 
+    TABLES_UNLOCK(); 
+ 
+    _Py_hashtable_clear(tracemalloc_tracebacks); 
+ 
+    _Py_hashtable_clear(tracemalloc_filenames); 
+} 
+ 
+ 
+static int 
+tracemalloc_init(void) 
+{ 
     if (_Py_tracemalloc_config.initialized == TRACEMALLOC_FINALIZED) {
-        PyErr_SetString(PyExc_RuntimeError,
-                        "the tracemalloc module has been unloaded");
-        return -1;
-    }
-
+        PyErr_SetString(PyExc_RuntimeError, 
+                        "the tracemalloc module has been unloaded"); 
+        return -1; 
+    } 
+ 
     if (_Py_tracemalloc_config.initialized == TRACEMALLOC_INITIALIZED)
-        return 0;
-
-    PyMem_GetAllocator(PYMEM_DOMAIN_RAW, &allocators.raw);
-
-#ifdef REENTRANT_THREADLOCAL
-    if (PyThread_tss_create(&tracemalloc_reentrant_key) != 0) {
-#ifdef MS_WINDOWS
-        PyErr_SetFromWindowsErr(0);
-#else
-        PyErr_SetFromErrno(PyExc_OSError);
-#endif
-        return -1;
-    }
-#endif
-
-#if defined(TRACE_RAW_MALLOC)
-    if (tables_lock == NULL) {
-        tables_lock = PyThread_allocate_lock();
-        if (tables_lock == NULL) {
-            PyErr_SetString(PyExc_RuntimeError, "cannot allocate lock");
-            return -1;
-        }
-    }
-#endif
-
+        return 0; 
+ 
+    PyMem_GetAllocator(PYMEM_DOMAIN_RAW, &allocators.raw); 
+ 
+#ifdef REENTRANT_THREADLOCAL 
+    if (PyThread_tss_create(&tracemalloc_reentrant_key) != 0) { 
+#ifdef MS_WINDOWS 
+        PyErr_SetFromWindowsErr(0); 
+#else 
+        PyErr_SetFromErrno(PyExc_OSError); 
+#endif 
+        return -1; 
+    } 
+#endif 
+ 
+#if defined(TRACE_RAW_MALLOC) 
+    if (tables_lock == NULL) { 
+        tables_lock = PyThread_allocate_lock(); 
+        if (tables_lock == NULL) { 
+            PyErr_SetString(PyExc_RuntimeError, "cannot allocate lock"); 
+            return -1; 
+        } 
+    } 
+#endif 
+ 
     tracemalloc_filenames = hashtable_new(hashtable_hash_pyobject,
                                           hashtable_compare_unicode,
                                           tracemalloc_clear_filename, NULL);
-
+ 
     tracemalloc_tracebacks = hashtable_new(hashtable_hash_traceback,
                                            hashtable_compare_traceback,
                                            NULL, raw_free);
-
+ 
     tracemalloc_traces = tracemalloc_create_traces_table();
     tracemalloc_domains = tracemalloc_create_domains_table();
-
-    if (tracemalloc_filenames == NULL || tracemalloc_tracebacks == NULL
+ 
+    if (tracemalloc_filenames == NULL || tracemalloc_tracebacks == NULL 
        || tracemalloc_traces == NULL || tracemalloc_domains == NULL) {
-        PyErr_NoMemory();
-        return -1;
-    }
-
-    unknown_filename = PyUnicode_FromString("<unknown>");
-    if (unknown_filename == NULL)
-        return -1;
-    PyUnicode_InternInPlace(&unknown_filename);
-
-    tracemalloc_empty_traceback.nframe = 1;
+        PyErr_NoMemory(); 
+        return -1; 
+    } 
+ 
+    unknown_filename = PyUnicode_FromString("<unknown>"); 
+    if (unknown_filename == NULL) 
+        return -1; 
+    PyUnicode_InternInPlace(&unknown_filename); 
+ 
+    tracemalloc_empty_traceback.nframe = 1; 
     tracemalloc_empty_traceback.total_nframe = 1;
-    /* borrowed reference */
-    tracemalloc_empty_traceback.frames[0].filename = unknown_filename;
-    tracemalloc_empty_traceback.frames[0].lineno = 0;
-    tracemalloc_empty_traceback.hash = traceback_hash(&tracemalloc_empty_traceback);
-
+    /* borrowed reference */ 
+    tracemalloc_empty_traceback.frames[0].filename = unknown_filename; 
+    tracemalloc_empty_traceback.frames[0].lineno = 0; 
+    tracemalloc_empty_traceback.hash = traceback_hash(&tracemalloc_empty_traceback); 
+ 
     _Py_tracemalloc_config.initialized = TRACEMALLOC_INITIALIZED;
-    return 0;
-}
-
-
-static void
-tracemalloc_deinit(void)
-{
+    return 0; 
+} 
+ 
+ 
+static void 
+tracemalloc_deinit(void) 
+{ 
     if (_Py_tracemalloc_config.initialized != TRACEMALLOC_INITIALIZED)
-        return;
+        return; 
     _Py_tracemalloc_config.initialized = TRACEMALLOC_FINALIZED;
-
-    tracemalloc_stop();
-
-    /* destroy hash tables */
+ 
+    tracemalloc_stop(); 
+ 
+    /* destroy hash tables */ 
     _Py_hashtable_destroy(tracemalloc_domains);
     _Py_hashtable_destroy(tracemalloc_traces);
-    _Py_hashtable_destroy(tracemalloc_tracebacks);
-    _Py_hashtable_destroy(tracemalloc_filenames);
-
-#if defined(TRACE_RAW_MALLOC)
-    if (tables_lock != NULL) {
-        PyThread_free_lock(tables_lock);
-        tables_lock = NULL;
-    }
-#endif
-
-#ifdef REENTRANT_THREADLOCAL
-    PyThread_tss_delete(&tracemalloc_reentrant_key);
-#endif
-
-    Py_XDECREF(unknown_filename);
-}
-
-
-static int
-tracemalloc_start(int max_nframe)
-{
-    PyMemAllocatorEx alloc;
-    size_t size;
-
+    _Py_hashtable_destroy(tracemalloc_tracebacks); 
+    _Py_hashtable_destroy(tracemalloc_filenames); 
+ 
+#if defined(TRACE_RAW_MALLOC) 
+    if (tables_lock != NULL) { 
+        PyThread_free_lock(tables_lock); 
+        tables_lock = NULL; 
+    } 
+#endif 
+ 
+#ifdef REENTRANT_THREADLOCAL 
+    PyThread_tss_delete(&tracemalloc_reentrant_key); 
+#endif 
+ 
+    Py_XDECREF(unknown_filename); 
+} 
+ 
+ 
+static int 
+tracemalloc_start(int max_nframe) 
+{ 
+    PyMemAllocatorEx alloc; 
+    size_t size; 
+ 
     if (max_nframe < 1 || (unsigned long) max_nframe > MAX_NFRAME) {
-        PyErr_Format(PyExc_ValueError,
+        PyErr_Format(PyExc_ValueError, 
                      "the number of frames must be in range [1; %lu]",
                      MAX_NFRAME);
-        return -1;
-    }
-
-    if (tracemalloc_init() < 0) {
-        return -1;
-    }
-
+        return -1; 
+    } 
+ 
+    if (tracemalloc_init() < 0) { 
+        return -1; 
+    } 
+ 
     if (_Py_tracemalloc_config.tracing) {
-        /* hook already installed: do nothing */
-        return 0;
-    }
-
+        /* hook already installed: do nothing */ 
+        return 0; 
+    } 
+ 
     _Py_tracemalloc_config.max_nframe = max_nframe;
-
-    /* allocate a buffer to store a new traceback */
-    size = TRACEBACK_SIZE(max_nframe);
-    assert(tracemalloc_traceback == NULL);
-    tracemalloc_traceback = raw_malloc(size);
-    if (tracemalloc_traceback == NULL) {
-        PyErr_NoMemory();
-        return -1;
-    }
-
-#ifdef TRACE_RAW_MALLOC
-    alloc.malloc = tracemalloc_raw_malloc;
-    alloc.calloc = tracemalloc_raw_calloc;
-    alloc.realloc = tracemalloc_raw_realloc;
-    alloc.free = tracemalloc_free;
-
-    alloc.ctx = &allocators.raw;
-    PyMem_GetAllocator(PYMEM_DOMAIN_RAW, &allocators.raw);
-    PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &alloc);
-#endif
-
-    alloc.malloc = tracemalloc_malloc_gil;
-    alloc.calloc = tracemalloc_calloc_gil;
-    alloc.realloc = tracemalloc_realloc_gil;
-    alloc.free = tracemalloc_free;
-
-    alloc.ctx = &allocators.mem;
-    PyMem_GetAllocator(PYMEM_DOMAIN_MEM, &allocators.mem);
-    PyMem_SetAllocator(PYMEM_DOMAIN_MEM, &alloc);
-
-    alloc.ctx = &allocators.obj;
-    PyMem_GetAllocator(PYMEM_DOMAIN_OBJ, &allocators.obj);
-    PyMem_SetAllocator(PYMEM_DOMAIN_OBJ, &alloc);
-
-    /* everything is ready: start tracing Python memory allocations */
+ 
+    /* allocate a buffer to store a new traceback */ 
+    size = TRACEBACK_SIZE(max_nframe); 
+    assert(tracemalloc_traceback == NULL); 
+    tracemalloc_traceback = raw_malloc(size); 
+    if (tracemalloc_traceback == NULL) { 
+        PyErr_NoMemory(); 
+        return -1; 
+    } 
+ 
+#ifdef TRACE_RAW_MALLOC 
+    alloc.malloc = tracemalloc_raw_malloc; 
+    alloc.calloc = tracemalloc_raw_calloc; 
+    alloc.realloc = tracemalloc_raw_realloc; 
+    alloc.free = tracemalloc_free; 
+ 
+    alloc.ctx = &allocators.raw; 
+    PyMem_GetAllocator(PYMEM_DOMAIN_RAW, &allocators.raw); 
+    PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &alloc); 
+#endif 
+ 
+    alloc.malloc = tracemalloc_malloc_gil; 
+    alloc.calloc = tracemalloc_calloc_gil; 
+    alloc.realloc = tracemalloc_realloc_gil; 
+    alloc.free = tracemalloc_free; 
+ 
+    alloc.ctx = &allocators.mem; 
+    PyMem_GetAllocator(PYMEM_DOMAIN_MEM, &allocators.mem); 
+    PyMem_SetAllocator(PYMEM_DOMAIN_MEM, &alloc); 
+ 
+    alloc.ctx = &allocators.obj; 
+    PyMem_GetAllocator(PYMEM_DOMAIN_OBJ, &allocators.obj); 
+    PyMem_SetAllocator(PYMEM_DOMAIN_OBJ, &alloc); 
+ 
+    /* everything is ready: start tracing Python memory allocations */ 
     _Py_tracemalloc_config.tracing = 1;
-
-    return 0;
-}
-
-
-static void
-tracemalloc_stop(void)
-{
+ 
+    return 0; 
+} 
+ 
+ 
+static void 
+tracemalloc_stop(void) 
+{ 
     if (!_Py_tracemalloc_config.tracing)
-        return;
-
-    /* stop tracing Python memory allocations */
+        return; 
+ 
+    /* stop tracing Python memory allocations */ 
     _Py_tracemalloc_config.tracing = 0;
-
-    /* unregister the hook on memory allocators */
-#ifdef TRACE_RAW_MALLOC
-    PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &allocators.raw);
-#endif
-    PyMem_SetAllocator(PYMEM_DOMAIN_MEM, &allocators.mem);
-    PyMem_SetAllocator(PYMEM_DOMAIN_OBJ, &allocators.obj);
-
-    tracemalloc_clear_traces();
-
-    /* release memory */
-    raw_free(tracemalloc_traceback);
-    tracemalloc_traceback = NULL;
-}
-
-
-
-/*[clinic input]
-_tracemalloc.is_tracing
-
-Return True if the tracemalloc module is tracing Python memory allocations.
-[clinic start generated code]*/
-
-static PyObject *
-_tracemalloc_is_tracing_impl(PyObject *module)
-/*[clinic end generated code: output=2d763b42601cd3ef input=af104b0a00192f63]*/
-{
+ 
+    /* unregister the hook on memory allocators */ 
+#ifdef TRACE_RAW_MALLOC 
+    PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &allocators.raw); 
+#endif 
+    PyMem_SetAllocator(PYMEM_DOMAIN_MEM, &allocators.mem); 
+    PyMem_SetAllocator(PYMEM_DOMAIN_OBJ, &allocators.obj); 
+ 
+    tracemalloc_clear_traces(); 
+ 
+    /* release memory */ 
+    raw_free(tracemalloc_traceback); 
+    tracemalloc_traceback = NULL; 
+} 
+ 
+ 
+ 
+/*[clinic input] 
+_tracemalloc.is_tracing 
+ 
+Return True if the tracemalloc module is tracing Python memory allocations. 
+[clinic start generated code]*/ 
+ 
+static PyObject * 
+_tracemalloc_is_tracing_impl(PyObject *module) 
+/*[clinic end generated code: output=2d763b42601cd3ef input=af104b0a00192f63]*/ 
+{ 
     return PyBool_FromLong(_Py_tracemalloc_config.tracing);
-}
-
-
-/*[clinic input]
-_tracemalloc.clear_traces
-
-Clear traces of memory blocks allocated by Python.
-[clinic start generated code]*/
-
-static PyObject *
-_tracemalloc_clear_traces_impl(PyObject *module)
-/*[clinic end generated code: output=a86080ee41b84197 input=0dab5b6c785183a5]*/
-{
+} 
+ 
+ 
+/*[clinic input] 
+_tracemalloc.clear_traces 
+ 
+Clear traces of memory blocks allocated by Python. 
+[clinic start generated code]*/ 
+ 
+static PyObject * 
+_tracemalloc_clear_traces_impl(PyObject *module) 
+/*[clinic end generated code: output=a86080ee41b84197 input=0dab5b6c785183a5]*/ 
+{ 
     if (!_Py_tracemalloc_config.tracing)
-        Py_RETURN_NONE;
-
-    set_reentrant(1);
-    tracemalloc_clear_traces();
-    set_reentrant(0);
-
-    Py_RETURN_NONE;
-}
-
-
-static PyObject*
-frame_to_pyobject(frame_t *frame)
-{
-    PyObject *frame_obj, *lineno_obj;
-
-    frame_obj = PyTuple_New(2);
-    if (frame_obj == NULL)
-        return NULL;
-
-    Py_INCREF(frame->filename);
-    PyTuple_SET_ITEM(frame_obj, 0, frame->filename);
-
-    lineno_obj = PyLong_FromUnsignedLong(frame->lineno);
-    if (lineno_obj == NULL) {
-        Py_DECREF(frame_obj);
-        return NULL;
-    }
-    PyTuple_SET_ITEM(frame_obj, 1, lineno_obj);
-
-    return frame_obj;
-}
-
-
-static PyObject*
-traceback_to_pyobject(traceback_t *traceback, _Py_hashtable_t *intern_table)
-{
+        Py_RETURN_NONE; 
+ 
+    set_reentrant(1); 
+    tracemalloc_clear_traces(); 
+    set_reentrant(0); 
+ 
+    Py_RETURN_NONE; 
+} 
+ 
+ 
+static PyObject* 
+frame_to_pyobject(frame_t *frame) 
+{ 
+    PyObject *frame_obj, *lineno_obj; 
+ 
+    frame_obj = PyTuple_New(2); 
+    if (frame_obj == NULL) 
+        return NULL; 
+ 
+    Py_INCREF(frame->filename); 
+    PyTuple_SET_ITEM(frame_obj, 0, frame->filename); 
+ 
+    lineno_obj = PyLong_FromUnsignedLong(frame->lineno); 
+    if (lineno_obj == NULL) { 
+        Py_DECREF(frame_obj); 
+        return NULL; 
+    } 
+    PyTuple_SET_ITEM(frame_obj, 1, lineno_obj); 
+ 
+    return frame_obj; 
+} 
+ 
+ 
+static PyObject* 
+traceback_to_pyobject(traceback_t *traceback, _Py_hashtable_t *intern_table) 
+{ 
     PyObject *frames;
-
-    if (intern_table != NULL) {
+ 
+    if (intern_table != NULL) { 
         frames = _Py_hashtable_get(intern_table, (const void *)traceback);
         if (frames) {
-            Py_INCREF(frames);
-            return frames;
-        }
-    }
-
-    frames = PyTuple_New(traceback->nframe);
-    if (frames == NULL)
-        return NULL;
-
+            Py_INCREF(frames); 
+            return frames; 
+        } 
+    } 
+ 
+    frames = PyTuple_New(traceback->nframe); 
+    if (frames == NULL) 
+        return NULL; 
+ 
     for (int i=0; i < traceback->nframe; i++) {
         PyObject *frame = frame_to_pyobject(&traceback->frames[i]);
-        if (frame == NULL) {
-            Py_DECREF(frames);
-            return NULL;
-        }
-        PyTuple_SET_ITEM(frames, i, frame);
-    }
-
-    if (intern_table != NULL) {
+        if (frame == NULL) { 
+            Py_DECREF(frames); 
+            return NULL; 
+        } 
+        PyTuple_SET_ITEM(frames, i, frame); 
+    } 
+ 
+    if (intern_table != NULL) { 
         if (_Py_hashtable_set(intern_table, traceback, frames) < 0) {
-            Py_DECREF(frames);
-            PyErr_NoMemory();
-            return NULL;
-        }
-        /* intern_table keeps a new reference to frames */
-        Py_INCREF(frames);
-    }
-    return frames;
-}
-
-
-static PyObject*
+            Py_DECREF(frames); 
+            PyErr_NoMemory(); 
+            return NULL; 
+        } 
+        /* intern_table keeps a new reference to frames */ 
+        Py_INCREF(frames); 
+    } 
+    return frames; 
+} 
+ 
+ 
+static PyObject* 
 trace_to_pyobject(unsigned int domain, const trace_t *trace,
-                  _Py_hashtable_t *intern_tracebacks)
-{
-    PyObject *trace_obj = NULL;
-    PyObject *obj;
-
+                  _Py_hashtable_t *intern_tracebacks) 
+{ 
+    PyObject *trace_obj = NULL; 
+    PyObject *obj; 
+ 
     trace_obj = PyTuple_New(4);
-    if (trace_obj == NULL)
-        return NULL;
-
-    obj = PyLong_FromSize_t(domain);
-    if (obj == NULL) {
-        Py_DECREF(trace_obj);
-        return NULL;
-    }
-    PyTuple_SET_ITEM(trace_obj, 0, obj);
-
-    obj = PyLong_FromSize_t(trace->size);
-    if (obj == NULL) {
-        Py_DECREF(trace_obj);
-        return NULL;
-    }
-    PyTuple_SET_ITEM(trace_obj, 1, obj);
-
-    obj = traceback_to_pyobject(trace->traceback, intern_tracebacks);
-    if (obj == NULL) {
-        Py_DECREF(trace_obj);
-        return NULL;
-    }
-    PyTuple_SET_ITEM(trace_obj, 2, obj);
-
+    if (trace_obj == NULL) 
+        return NULL; 
+ 
+    obj = PyLong_FromSize_t(domain); 
+    if (obj == NULL) { 
+        Py_DECREF(trace_obj); 
+        return NULL; 
+    } 
+    PyTuple_SET_ITEM(trace_obj, 0, obj); 
+ 
+    obj = PyLong_FromSize_t(trace->size); 
+    if (obj == NULL) { 
+        Py_DECREF(trace_obj); 
+        return NULL; 
+    } 
+    PyTuple_SET_ITEM(trace_obj, 1, obj); 
+ 
+    obj = traceback_to_pyobject(trace->traceback, intern_tracebacks); 
+    if (obj == NULL) { 
+        Py_DECREF(trace_obj); 
+        return NULL; 
+    } 
+    PyTuple_SET_ITEM(trace_obj, 2, obj); 
+ 
     obj = PyLong_FromUnsignedLong(trace->traceback->total_nframe);
     if (obj == NULL) {
         Py_DECREF(trace_obj);
@@ -1176,40 +1176,40 @@ trace_to_pyobject(unsigned int domain, const trace_t *trace,
     }
     PyTuple_SET_ITEM(trace_obj, 3, obj);
 
-    return trace_obj;
-}
-
-
-typedef struct {
-    _Py_hashtable_t *traces;
+    return trace_obj; 
+} 
+ 
+ 
+typedef struct { 
+    _Py_hashtable_t *traces; 
     _Py_hashtable_t *domains;
-    _Py_hashtable_t *tracebacks;
-    PyObject *list;
+    _Py_hashtable_t *tracebacks; 
+    PyObject *list; 
     unsigned int domain;
-} get_traces_t;
-
+} get_traces_t; 
+ 
 
-static int
+static int 
 tracemalloc_copy_trace(_Py_hashtable_t *traces,
                        const void *key, const void *value,
                        void *user_data)
-{
+{ 
     _Py_hashtable_t *traces2 = (_Py_hashtable_t *)user_data;
-
+ 
     trace_t *trace = (trace_t *)value;
 
     trace_t *trace2 = raw_malloc(sizeof(trace_t));
     if (trace2 == NULL) {
         return -1;
-    }
+    } 
     *trace2 = *trace;
     if (_Py_hashtable_set(traces2, key, trace2) < 0) {
         raw_free(trace2);
         return -1;
-    }
+    } 
     return 0;
 }
-
+ 
 
 static _Py_hashtable_t*
 tracemalloc_copy_traces(_Py_hashtable_t *traces)
@@ -1280,24 +1280,24 @@ tracemalloc_get_traces_fill(_Py_hashtable_t *traces,
     PyObject *tuple = trace_to_pyobject(get_traces->domain, trace,
                                         get_traces->tracebacks);
     if (tuple == NULL) {
-        return 1;
+        return 1; 
     }
-
+ 
     int res = PyList_Append(get_traces->list, tuple);
     Py_DECREF(tuple);
     if (res < 0) {
-        return 1;
+        return 1; 
     }
-
-    return 0;
-}
-
-
-static int
+ 
+    return 0; 
+} 
+ 
+ 
+static int 
 tracemalloc_get_traces_domain(_Py_hashtable_t *domains,
                               const void *key, const void *value,
                               void *user_data)
-{
+{ 
     get_traces_t *get_traces = user_data;
 
     unsigned int domain = (unsigned int)FROM_PTR(key);
@@ -1314,58 +1314,58 @@ static void
 tracemalloc_pyobject_decref(void *value)
 {
     PyObject *obj = (PyObject *)value;
-    Py_DECREF(obj);
-}
-
-
-
-/*[clinic input]
-_tracemalloc._get_traces
-
-Get traces of all memory blocks allocated by Python.
-
-Return a list of (size: int, traceback: tuple) tuples.
-traceback is a tuple of (filename: str, lineno: int) tuples.
-
-Return an empty list if the tracemalloc module is disabled.
-[clinic start generated code]*/
-
-static PyObject *
-_tracemalloc__get_traces_impl(PyObject *module)
-/*[clinic end generated code: output=e9929876ced4b5cc input=6c7d2230b24255aa]*/
-{
-    get_traces_t get_traces;
+    Py_DECREF(obj); 
+} 
+ 
+ 
+ 
+/*[clinic input] 
+_tracemalloc._get_traces 
+ 
+Get traces of all memory blocks allocated by Python. 
+ 
+Return a list of (size: int, traceback: tuple) tuples. 
+traceback is a tuple of (filename: str, lineno: int) tuples. 
+ 
+Return an empty list if the tracemalloc module is disabled. 
+[clinic start generated code]*/ 
+ 
+static PyObject * 
+_tracemalloc__get_traces_impl(PyObject *module) 
+/*[clinic end generated code: output=e9929876ced4b5cc input=6c7d2230b24255aa]*/ 
+{ 
+    get_traces_t get_traces; 
     get_traces.domain = DEFAULT_DOMAIN;
-    get_traces.traces = NULL;
+    get_traces.traces = NULL; 
     get_traces.domains = NULL;
-    get_traces.tracebacks = NULL;
-    get_traces.list = PyList_New(0);
-    if (get_traces.list == NULL)
-        goto error;
-
+    get_traces.tracebacks = NULL; 
+    get_traces.list = PyList_New(0); 
+    if (get_traces.list == NULL) 
+        goto error; 
+ 
     if (!_Py_tracemalloc_config.tracing)
-        return get_traces.list;
-
-    /* the traceback hash table is used temporarily to intern traceback tuple
-       of (filename, lineno) tuples */
+        return get_traces.list; 
+ 
+    /* the traceback hash table is used temporarily to intern traceback tuple 
+       of (filename, lineno) tuples */ 
     get_traces.tracebacks = hashtable_new(_Py_hashtable_hash_ptr,
                                           _Py_hashtable_compare_direct,
                                           NULL, tracemalloc_pyobject_decref);
-    if (get_traces.tracebacks == NULL) {
+    if (get_traces.tracebacks == NULL) { 
         goto no_memory;
-    }
-
+    } 
+ 
     // Copy all traces so tracemalloc_get_traces_fill() doesn't have to disable
     // temporarily tracemalloc which would impact other threads and so would
     // miss allocations while get_traces() is called.
-    TABLES_LOCK();
+    TABLES_LOCK(); 
     get_traces.traces = tracemalloc_copy_traces(tracemalloc_traces);
-    TABLES_UNLOCK();
-
-    if (get_traces.traces == NULL) {
+    TABLES_UNLOCK(); 
+ 
+    if (get_traces.traces == NULL) { 
         goto no_memory;
-    }
-
+    } 
+ 
     TABLES_LOCK();
     get_traces.domains = tracemalloc_copy_domains(tracemalloc_domains);
     TABLES_UNLOCK();
@@ -1375,7 +1375,7 @@ _tracemalloc__get_traces_impl(PyObject *module)
     }
 
     // Convert traces to a list of tuples
-    set_reentrant(1);
+    set_reentrant(1); 
     int err = _Py_hashtable_foreach(get_traces.traces,
                                     tracemalloc_get_traces_fill,
                                     &get_traces);
@@ -1384,196 +1384,196 @@ _tracemalloc__get_traces_impl(PyObject *module)
                                     tracemalloc_get_traces_domain,
                                     &get_traces);
     }
-    set_reentrant(0);
+    set_reentrant(0); 
     if (err) {
-        goto error;
+        goto error; 
     }
-
-    goto finally;
-
+ 
+    goto finally; 
+ 
 no_memory:
     PyErr_NoMemory();
 
-error:
-    Py_CLEAR(get_traces.list);
-
-finally:
-    if (get_traces.tracebacks != NULL) {
-        _Py_hashtable_destroy(get_traces.tracebacks);
-    }
-    if (get_traces.traces != NULL) {
-        _Py_hashtable_destroy(get_traces.traces);
-    }
+error: 
+    Py_CLEAR(get_traces.list); 
+ 
+finally: 
+    if (get_traces.tracebacks != NULL) { 
+        _Py_hashtable_destroy(get_traces.tracebacks); 
+    } 
+    if (get_traces.traces != NULL) { 
+        _Py_hashtable_destroy(get_traces.traces); 
+    } 
     if (get_traces.domains != NULL) {
         _Py_hashtable_destroy(get_traces.domains);
     }
-
-    return get_traces.list;
-}
-
-
-static traceback_t*
-tracemalloc_get_traceback(unsigned int domain, uintptr_t ptr)
-{
-
+ 
+    return get_traces.list; 
+} 
+ 
+ 
+static traceback_t* 
+tracemalloc_get_traceback(unsigned int domain, uintptr_t ptr) 
+{ 
+ 
     if (!_Py_tracemalloc_config.tracing)
-        return NULL;
-
+        return NULL; 
+ 
     trace_t *trace;
-    TABLES_LOCK();
+    TABLES_LOCK(); 
     _Py_hashtable_t *traces = tracemalloc_get_traces_table(domain);
     if (traces) {
         trace = _Py_hashtable_get(traces, TO_PTR(ptr));
-    }
-    else {
+    } 
+    else { 
         trace = NULL;
-    }
-    TABLES_UNLOCK();
-
+    } 
+    TABLES_UNLOCK(); 
+ 
     if (!trace) {
-        return NULL;
+        return NULL; 
     }
-
+ 
     return trace->traceback;
-}
-
-
-
-/*[clinic input]
-_tracemalloc._get_object_traceback
-
-    obj: object
-    /
-
-Get the traceback where the Python object obj was allocated.
-
-Return a tuple of (filename: str, lineno: int) tuples.
-Return None if the tracemalloc module is disabled or did not
-trace the allocation of the object.
-[clinic start generated code]*/
-
-static PyObject *
-_tracemalloc__get_object_traceback(PyObject *module, PyObject *obj)
-/*[clinic end generated code: output=41ee0553a658b0aa input=29495f1b21c53212]*/
-{
-    PyTypeObject *type;
-    void *ptr;
-    traceback_t *traceback;
-
-    type = Py_TYPE(obj);
+} 
+ 
+ 
+ 
+/*[clinic input] 
+_tracemalloc._get_object_traceback 
+ 
+    obj: object 
+    / 
+ 
+Get the traceback where the Python object obj was allocated. 
+ 
+Return a tuple of (filename: str, lineno: int) tuples. 
+Return None if the tracemalloc module is disabled or did not 
+trace the allocation of the object. 
+[clinic start generated code]*/ 
+ 
+static PyObject * 
+_tracemalloc__get_object_traceback(PyObject *module, PyObject *obj) 
+/*[clinic end generated code: output=41ee0553a658b0aa input=29495f1b21c53212]*/ 
+{ 
+    PyTypeObject *type; 
+    void *ptr; 
+    traceback_t *traceback; 
+ 
+    type = Py_TYPE(obj); 
     if (PyType_IS_GC(type)) {
-        ptr = (void *)((char *)obj - sizeof(PyGC_Head));
+        ptr = (void *)((char *)obj - sizeof(PyGC_Head)); 
     }
     else {
-        ptr = (void *)obj;
+        ptr = (void *)obj; 
     }
-
-    traceback = tracemalloc_get_traceback(DEFAULT_DOMAIN, (uintptr_t)ptr);
-    if (traceback == NULL)
-        Py_RETURN_NONE;
-
-    return traceback_to_pyobject(traceback, NULL);
-}
-
-
-#define PUTS(fd, str) _Py_write_noraise(fd, str, (int)strlen(str))
-
-static void
-_PyMem_DumpFrame(int fd, frame_t * frame)
-{
-    PUTS(fd, "  File \"");
-    _Py_DumpASCII(fd, frame->filename);
-    PUTS(fd, "\", line ");
-    _Py_DumpDecimal(fd, frame->lineno);
-    PUTS(fd, "\n");
-}
-
-/* Dump the traceback where a memory block was allocated into file descriptor
-   fd. The function may block on TABLES_LOCK() but it is unlikely. */
-void
-_PyMem_DumpTraceback(int fd, const void *ptr)
-{
-    traceback_t *traceback;
-    int i;
-
+ 
+    traceback = tracemalloc_get_traceback(DEFAULT_DOMAIN, (uintptr_t)ptr); 
+    if (traceback == NULL) 
+        Py_RETURN_NONE; 
+ 
+    return traceback_to_pyobject(traceback, NULL); 
+} 
+ 
+ 
+#define PUTS(fd, str) _Py_write_noraise(fd, str, (int)strlen(str)) 
+ 
+static void 
+_PyMem_DumpFrame(int fd, frame_t * frame) 
+{ 
+    PUTS(fd, "  File \""); 
+    _Py_DumpASCII(fd, frame->filename); 
+    PUTS(fd, "\", line "); 
+    _Py_DumpDecimal(fd, frame->lineno); 
+    PUTS(fd, "\n"); 
+} 
+ 
+/* Dump the traceback where a memory block was allocated into file descriptor 
+   fd. The function may block on TABLES_LOCK() but it is unlikely. */ 
+void 
+_PyMem_DumpTraceback(int fd, const void *ptr) 
+{ 
+    traceback_t *traceback; 
+    int i; 
+ 
     if (!_Py_tracemalloc_config.tracing) {
-        PUTS(fd, "Enable tracemalloc to get the memory block "
-                 "allocation traceback\n\n");
-        return;
-    }
-
-    traceback = tracemalloc_get_traceback(DEFAULT_DOMAIN, (uintptr_t)ptr);
-    if (traceback == NULL)
-        return;
-
-    PUTS(fd, "Memory block allocated at (most recent call first):\n");
-    for (i=0; i < traceback->nframe; i++) {
-        _PyMem_DumpFrame(fd, &traceback->frames[i]);
-    }
-    PUTS(fd, "\n");
-}
-
-#undef PUTS
-
-
-
-/*[clinic input]
-_tracemalloc.start
-
-    nframe: int = 1
-    /
-
-Start tracing Python memory allocations.
-
-Also set the maximum number of frames stored in the traceback of a
-trace to nframe.
-[clinic start generated code]*/
-
-static PyObject *
-_tracemalloc_start_impl(PyObject *module, int nframe)
-/*[clinic end generated code: output=caae05c23c159d3c input=40d849b5b29d1933]*/
-{
-    if (tracemalloc_start(nframe) < 0) {
-        return NULL;
-    }
-    Py_RETURN_NONE;
-}
-
-
-/*[clinic input]
-_tracemalloc.stop
-
-Stop tracing Python memory allocations.
-
-Also clear traces of memory blocks allocated by Python.
-[clinic start generated code]*/
-
-static PyObject *
-_tracemalloc_stop_impl(PyObject *module)
-/*[clinic end generated code: output=c3c42ae03e3955cd input=7478f075e51dae18]*/
-{
-    tracemalloc_stop();
-    Py_RETURN_NONE;
-}
-
-
-/*[clinic input]
-_tracemalloc.get_traceback_limit
-
-Get the maximum number of frames stored in the traceback of a trace.
-
-By default, a trace of an allocated memory block only stores
-the most recent frame: the limit is 1.
-[clinic start generated code]*/
-
-static PyObject *
-_tracemalloc_get_traceback_limit_impl(PyObject *module)
-/*[clinic end generated code: output=d556d9306ba95567 input=da3cd977fc68ae3b]*/
-{
+        PUTS(fd, "Enable tracemalloc to get the memory block " 
+                 "allocation traceback\n\n"); 
+        return; 
+    } 
+ 
+    traceback = tracemalloc_get_traceback(DEFAULT_DOMAIN, (uintptr_t)ptr); 
+    if (traceback == NULL) 
+        return; 
+ 
+    PUTS(fd, "Memory block allocated at (most recent call first):\n"); 
+    for (i=0; i < traceback->nframe; i++) { 
+        _PyMem_DumpFrame(fd, &traceback->frames[i]); 
+    } 
+    PUTS(fd, "\n"); 
+} 
+ 
+#undef PUTS 
+ 
+ 
+ 
+/*[clinic input] 
+_tracemalloc.start 
+ 
+    nframe: int = 1 
+    / 
+ 
+Start tracing Python memory allocations. 
+ 
+Also set the maximum number of frames stored in the traceback of a 
+trace to nframe. 
+[clinic start generated code]*/ 
+ 
+static PyObject * 
+_tracemalloc_start_impl(PyObject *module, int nframe) 
+/*[clinic end generated code: output=caae05c23c159d3c input=40d849b5b29d1933]*/ 
+{ 
+    if (tracemalloc_start(nframe) < 0) { 
+        return NULL; 
+    } 
+    Py_RETURN_NONE; 
+} 
+ 
+ 
+/*[clinic input] 
+_tracemalloc.stop 
+ 
+Stop tracing Python memory allocations. 
+ 
+Also clear traces of memory blocks allocated by Python. 
+[clinic start generated code]*/ 
+ 
+static PyObject * 
+_tracemalloc_stop_impl(PyObject *module) 
+/*[clinic end generated code: output=c3c42ae03e3955cd input=7478f075e51dae18]*/ 
+{ 
+    tracemalloc_stop(); 
+    Py_RETURN_NONE; 
+} 
+ 
+ 
+/*[clinic input] 
+_tracemalloc.get_traceback_limit 
+ 
+Get the maximum number of frames stored in the traceback of a trace. 
+ 
+By default, a trace of an allocated memory block only stores 
+the most recent frame: the limit is 1. 
+[clinic start generated code]*/ 
+ 
+static PyObject * 
+_tracemalloc_get_traceback_limit_impl(PyObject *module) 
+/*[clinic end generated code: output=d556d9306ba95567 input=da3cd977fc68ae3b]*/ 
+{ 
     return PyLong_FromLong(_Py_tracemalloc_config.max_nframe);
-}
-
-
+} 
+ 
+ 
 static int
 tracemalloc_get_tracemalloc_memory_cb(_Py_hashtable_t *domains,
                                       const void *key, const void *value,
@@ -1584,64 +1584,64 @@ tracemalloc_get_tracemalloc_memory_cb(_Py_hashtable_t *domains,
     *size += _Py_hashtable_size(traces);
     return 0;
 }
+ 
 
-
-/*[clinic input]
-_tracemalloc.get_tracemalloc_memory
-
-Get the memory usage in bytes of the tracemalloc module.
-
-This memory is used internally to trace memory allocations.
-[clinic start generated code]*/
-
-static PyObject *
-_tracemalloc_get_tracemalloc_memory_impl(PyObject *module)
-/*[clinic end generated code: output=e3f14e280a55f5aa input=5d919c0f4d5132ad]*/
-{
-    size_t size;
-
-    size = _Py_hashtable_size(tracemalloc_tracebacks);
-    size += _Py_hashtable_size(tracemalloc_filenames);
-
-    TABLES_LOCK();
-    size += _Py_hashtable_size(tracemalloc_traces);
+/*[clinic input] 
+_tracemalloc.get_tracemalloc_memory 
+ 
+Get the memory usage in bytes of the tracemalloc module. 
+ 
+This memory is used internally to trace memory allocations. 
+[clinic start generated code]*/ 
+ 
+static PyObject * 
+_tracemalloc_get_tracemalloc_memory_impl(PyObject *module) 
+/*[clinic end generated code: output=e3f14e280a55f5aa input=5d919c0f4d5132ad]*/ 
+{ 
+    size_t size; 
+ 
+    size = _Py_hashtable_size(tracemalloc_tracebacks); 
+    size += _Py_hashtable_size(tracemalloc_filenames); 
+ 
+    TABLES_LOCK(); 
+    size += _Py_hashtable_size(tracemalloc_traces); 
     _Py_hashtable_foreach(tracemalloc_domains,
                           tracemalloc_get_tracemalloc_memory_cb, &size);
-    TABLES_UNLOCK();
-
-    return PyLong_FromSize_t(size);
-}
-
-
-
-/*[clinic input]
-_tracemalloc.get_traced_memory
-
-Get the current size and peak size of memory blocks traced by tracemalloc.
-
-Returns a tuple: (current: int, peak: int).
-[clinic start generated code]*/
-
-static PyObject *
-_tracemalloc_get_traced_memory_impl(PyObject *module)
-/*[clinic end generated code: output=5b167189adb9e782 input=61ddb5478400ff66]*/
-{
-    Py_ssize_t size, peak_size;
-
+    TABLES_UNLOCK(); 
+ 
+    return PyLong_FromSize_t(size); 
+} 
+ 
+ 
+ 
+/*[clinic input] 
+_tracemalloc.get_traced_memory 
+ 
+Get the current size and peak size of memory blocks traced by tracemalloc. 
+ 
+Returns a tuple: (current: int, peak: int). 
+[clinic start generated code]*/ 
+ 
+static PyObject * 
+_tracemalloc_get_traced_memory_impl(PyObject *module) 
+/*[clinic end generated code: output=5b167189adb9e782 input=61ddb5478400ff66]*/ 
+{ 
+    Py_ssize_t size, peak_size; 
+ 
     if (!_Py_tracemalloc_config.tracing)
-        return Py_BuildValue("ii", 0, 0);
-
-    TABLES_LOCK();
-    size = tracemalloc_traced_memory;
-    peak_size = tracemalloc_peak_traced_memory;
-    TABLES_UNLOCK();
-
-    return Py_BuildValue("nn", size, peak_size);
-}
-
+        return Py_BuildValue("ii", 0, 0); 
+ 
+    TABLES_LOCK(); 
+    size = tracemalloc_traced_memory; 
+    peak_size = tracemalloc_peak_traced_memory; 
+    TABLES_UNLOCK(); 
+ 
+    return Py_BuildValue("nn", size, peak_size); 
+} 
+ 
 /*[clinic input]
 _tracemalloc.reset_peak
-
+ 
 Set the peak size of memory blocks traced by tracemalloc to the current size.
 
 Do nothing if the tracemalloc module is not tracing memory allocations.
@@ -1664,107 +1664,107 @@ _tracemalloc_reset_peak_impl(PyObject *module)
 }
 
 
-static PyMethodDef module_methods[] = {
-    _TRACEMALLOC_IS_TRACING_METHODDEF
-    _TRACEMALLOC_CLEAR_TRACES_METHODDEF
-    _TRACEMALLOC__GET_TRACES_METHODDEF
-    _TRACEMALLOC__GET_OBJECT_TRACEBACK_METHODDEF
-    _TRACEMALLOC_START_METHODDEF
-    _TRACEMALLOC_STOP_METHODDEF
-    _TRACEMALLOC_GET_TRACEBACK_LIMIT_METHODDEF
-    _TRACEMALLOC_GET_TRACEMALLOC_MEMORY_METHODDEF
-    _TRACEMALLOC_GET_TRACED_MEMORY_METHODDEF
+static PyMethodDef module_methods[] = { 
+    _TRACEMALLOC_IS_TRACING_METHODDEF 
+    _TRACEMALLOC_CLEAR_TRACES_METHODDEF 
+    _TRACEMALLOC__GET_TRACES_METHODDEF 
+    _TRACEMALLOC__GET_OBJECT_TRACEBACK_METHODDEF 
+    _TRACEMALLOC_START_METHODDEF 
+    _TRACEMALLOC_STOP_METHODDEF 
+    _TRACEMALLOC_GET_TRACEBACK_LIMIT_METHODDEF 
+    _TRACEMALLOC_GET_TRACEMALLOC_MEMORY_METHODDEF 
+    _TRACEMALLOC_GET_TRACED_MEMORY_METHODDEF 
     _TRACEMALLOC_RESET_PEAK_METHODDEF
-    /* sentinel */
-    {NULL, NULL}
-};
-
-PyDoc_STRVAR(module_doc,
-"Debug module to trace memory blocks allocated by Python.");
-
-static struct PyModuleDef module_def = {
-    PyModuleDef_HEAD_INIT,
-    "_tracemalloc",
-    module_doc,
-    0, /* non-negative size to be able to unload the module */
-    module_methods,
-    NULL,
-};
-
-PyMODINIT_FUNC
-PyInit__tracemalloc(void)
-{
-    PyObject *m;
-    m = PyModule_Create(&module_def);
-    if (m == NULL)
-        return NULL;
-
+    /* sentinel */ 
+    {NULL, NULL} 
+}; 
+ 
+PyDoc_STRVAR(module_doc, 
+"Debug module to trace memory blocks allocated by Python."); 
+ 
+static struct PyModuleDef module_def = { 
+    PyModuleDef_HEAD_INIT, 
+    "_tracemalloc", 
+    module_doc, 
+    0, /* non-negative size to be able to unload the module */ 
+    module_methods, 
+    NULL, 
+}; 
+ 
+PyMODINIT_FUNC 
+PyInit__tracemalloc(void) 
+{ 
+    PyObject *m; 
+    m = PyModule_Create(&module_def); 
+    if (m == NULL) 
+        return NULL; 
+ 
     if (tracemalloc_init() < 0) {
         Py_DECREF(m);
-        return NULL;
+        return NULL; 
     }
-
-    return m;
-}
-
-
-int
-_PyTraceMalloc_Init(int nframe)
-{
-    assert(PyGILState_Check());
-    if (nframe == 0) {
-        return 0;
-    }
-    return tracemalloc_start(nframe);
-}
-
-
-void
-_PyTraceMalloc_Fini(void)
-{
-    assert(PyGILState_Check());
-    tracemalloc_deinit();
-}
-
-int
-PyTraceMalloc_Track(unsigned int domain, uintptr_t ptr,
-                    size_t size)
-{
-    int res;
-    PyGILState_STATE gil_state;
-
+ 
+    return m; 
+} 
+ 
+ 
+int 
+_PyTraceMalloc_Init(int nframe) 
+{ 
+    assert(PyGILState_Check()); 
+    if (nframe == 0) { 
+        return 0; 
+    } 
+    return tracemalloc_start(nframe); 
+} 
+ 
+ 
+void 
+_PyTraceMalloc_Fini(void) 
+{ 
+    assert(PyGILState_Check()); 
+    tracemalloc_deinit(); 
+} 
+ 
+int 
+PyTraceMalloc_Track(unsigned int domain, uintptr_t ptr, 
+                    size_t size) 
+{ 
+    int res; 
+    PyGILState_STATE gil_state; 
+ 
     if (!_Py_tracemalloc_config.tracing) {
-        /* tracemalloc is not tracing: do nothing */
-        return -2;
-    }
-
-    gil_state = PyGILState_Ensure();
-
-    TABLES_LOCK();
-    res = tracemalloc_add_trace(domain, ptr, size);
-    TABLES_UNLOCK();
-
-    PyGILState_Release(gil_state);
-    return res;
-}
-
-
-int
-PyTraceMalloc_Untrack(unsigned int domain, uintptr_t ptr)
-{
+        /* tracemalloc is not tracing: do nothing */ 
+        return -2; 
+    } 
+ 
+    gil_state = PyGILState_Ensure(); 
+ 
+    TABLES_LOCK(); 
+    res = tracemalloc_add_trace(domain, ptr, size); 
+    TABLES_UNLOCK(); 
+ 
+    PyGILState_Release(gil_state); 
+    return res; 
+} 
+ 
+ 
+int 
+PyTraceMalloc_Untrack(unsigned int domain, uintptr_t ptr) 
+{ 
     if (!_Py_tracemalloc_config.tracing) {
-        /* tracemalloc is not tracing: do nothing */
-        return -2;
-    }
-
-    TABLES_LOCK();
-    tracemalloc_remove_trace(domain, ptr);
-    TABLES_UNLOCK();
-
-    return 0;
-}
-
-
+        /* tracemalloc is not tracing: do nothing */ 
+        return -2; 
+    } 
+ 
+    TABLES_LOCK(); 
+    tracemalloc_remove_trace(domain, ptr); 
+    TABLES_UNLOCK(); 
+ 
+    return 0; 
+} 
+ 
+ 
 /* If the object memory block is already traced, update its trace
    with the current Python traceback.
 
@@ -1808,14 +1808,14 @@ _PyTraceMalloc_NewReference(PyObject *op)
 }
 
 
-PyObject*
-_PyTraceMalloc_GetTraceback(unsigned int domain, uintptr_t ptr)
-{
-    traceback_t *traceback;
-
-    traceback = tracemalloc_get_traceback(domain, ptr);
-    if (traceback == NULL)
-        Py_RETURN_NONE;
-
-    return traceback_to_pyobject(traceback, NULL);
-}
+PyObject* 
+_PyTraceMalloc_GetTraceback(unsigned int domain, uintptr_t ptr) 
+{ 
+    traceback_t *traceback; 
+ 
+    traceback = tracemalloc_get_traceback(domain, ptr); 
+    if (traceback == NULL) 
+        Py_RETURN_NONE; 
+ 
+    return traceback_to_pyobject(traceback, NULL); 
+}