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

1 files changed, 757 insertions, 757 deletions

diff --git a/contrib/tools/python3/src/Python/errors.c b/contrib/tools/python3/src/Python/errors.c
index 79278764cc5..313702e4d1f 100644
--- a/contrib/tools/python3/src/Python/errors.c
+++ b/contrib/tools/python3/src/Python/errors.c
@@ -2,12 +2,12 @@
 /* Error handling */
 
 #include "Python.h"
-#include "pycore_initconfig.h"
-#include "pycore_object.h"        // _PyType_GetQualName
-#include "pycore_pyerrors.h"
-#include "pycore_pystate.h"    // _PyThreadState_GET()
-#include "pycore_sysmodule.h"
-#include "pycore_traceback.h"
+#include "pycore_initconfig.h" 
+#include "pycore_object.h"        // _PyType_GetQualName 
+#include "pycore_pyerrors.h" 
+#include "pycore_pystate.h"    // _PyThreadState_GET() 
+#include "pycore_sysmodule.h" 
+#include "pycore_traceback.h" 
 
 #ifndef __STDC__
 #ifndef MS_WINDOWS
@@ -26,20 +26,20 @@ extern char *strerror(int);
 extern "C" {
 #endif
 
-_Py_IDENTIFIER(__module__);
+_Py_IDENTIFIER(__module__); 
 _Py_IDENTIFIER(builtins);
 _Py_IDENTIFIER(stderr);
-_Py_IDENTIFIER(flush);
-
-/* Forward declarations */
-static PyObject *
-_PyErr_FormatV(PyThreadState *tstate, PyObject *exception,
-               const char *format, va_list vargs);
-
-
+_Py_IDENTIFIER(flush); 
+
+/* Forward declarations */ 
+static PyObject * 
+_PyErr_FormatV(PyThreadState *tstate, PyObject *exception, 
+               const char *format, va_list vargs); 
+ 
+ 
 void
-_PyErr_Restore(PyThreadState *tstate, PyObject *type, PyObject *value,
-               PyObject *traceback)
+_PyErr_Restore(PyThreadState *tstate, PyObject *type, PyObject *value, 
+               PyObject *traceback) 
 {
     PyObject *oldtype, *oldvalue, *oldtraceback;
 
@@ -65,14 +65,14 @@ _PyErr_Restore(PyThreadState *tstate, PyObject *type, PyObject *value,
     Py_XDECREF(oldtraceback);
 }
 
-void
-PyErr_Restore(PyObject *type, PyObject *value, PyObject *traceback)
-{
-    PyThreadState *tstate = _PyThreadState_GET();
-    _PyErr_Restore(tstate, type, value, traceback);
-}
-
-
+void 
+PyErr_Restore(PyObject *type, PyObject *value, PyObject *traceback) 
+{ 
+    PyThreadState *tstate = _PyThreadState_GET(); 
+    _PyErr_Restore(tstate, type, value, traceback); 
+} 
+ 
+ 
 _PyErr_StackItem *
 _PyErr_GetTopmostException(PyThreadState *tstate)
 {
@@ -86,43 +86,43 @@ _PyErr_GetTopmostException(PyThreadState *tstate)
 }
 
 static PyObject*
-_PyErr_CreateException(PyObject *exception_type, PyObject *value)
+_PyErr_CreateException(PyObject *exception_type, PyObject *value) 
 {
-    PyObject *exc;
-
+    PyObject *exc; 
+ 
     if (value == NULL || value == Py_None) {
-        exc = _PyObject_CallNoArg(exception_type);
+        exc = _PyObject_CallNoArg(exception_type); 
     }
     else if (PyTuple_Check(value)) {
-        exc = PyObject_Call(exception_type, value, NULL);
+        exc = PyObject_Call(exception_type, value, NULL); 
     }
     else {
-        exc = PyObject_CallOneArg(exception_type, value);
-    }
-
-    if (exc != NULL && !PyExceptionInstance_Check(exc)) {
-        PyErr_Format(PyExc_TypeError,
-                     "calling %R should have returned an instance of "
-                     "BaseException, not %s",
-                     exception_type, Py_TYPE(exc)->tp_name);
-        Py_CLEAR(exc);
+        exc = PyObject_CallOneArg(exception_type, value); 
     }
-
-    return exc;
+ 
+    if (exc != NULL && !PyExceptionInstance_Check(exc)) { 
+        PyErr_Format(PyExc_TypeError, 
+                     "calling %R should have returned an instance of " 
+                     "BaseException, not %s", 
+                     exception_type, Py_TYPE(exc)->tp_name); 
+        Py_CLEAR(exc); 
+    } 
+ 
+    return exc; 
 }
 
 void
-_PyErr_SetObject(PyThreadState *tstate, PyObject *exception, PyObject *value)
+_PyErr_SetObject(PyThreadState *tstate, PyObject *exception, PyObject *value) 
 {
     PyObject *exc_value;
     PyObject *tb = NULL;
 
     if (exception != NULL &&
         !PyExceptionClass_Check(exception)) {
-        _PyErr_Format(tstate, PyExc_SystemError,
-                      "_PyErr_SetObject: "
-                      "exception %R is not a BaseException subclass",
-                      exception);
+        _PyErr_Format(tstate, PyExc_SystemError, 
+                      "_PyErr_SetObject: " 
+                      "exception %R is not a BaseException subclass", 
+                      exception); 
         return;
     }
 
@@ -137,7 +137,7 @@ _PyErr_SetObject(PyThreadState *tstate, PyObject *exception, PyObject *value)
 
             /* Issue #23571: functions must not be called with an
                exception set */
-            _PyErr_Clear(tstate);
+            _PyErr_Clear(tstate); 
 
             fixed_value = _PyErr_CreateException(exception, value);
             Py_XDECREF(value);
@@ -149,16 +149,16 @@ _PyErr_SetObject(PyThreadState *tstate, PyObject *exception, PyObject *value)
             value = fixed_value;
         }
 
-        /* Avoid creating new reference cycles through the
-           context chain, while taking care not to hang on
-           pre-existing ones.
+        /* Avoid creating new reference cycles through the 
+           context chain, while taking care not to hang on 
+           pre-existing ones. 
            This is O(chain length) but context chains are
            usually very short. Sensitive readers may try
            to inline the call to PyException_GetContext. */
         if (exc_value != value) {
             PyObject *o = exc_value, *context;
-            PyObject *slow_o = o;  /* Floyd's cycle detection algo */
-            int slow_update_toggle = 0;
+            PyObject *slow_o = o;  /* Floyd's cycle detection algo */ 
+            int slow_update_toggle = 0; 
             while ((context = PyException_GetContext(o))) {
                 Py_DECREF(context);
                 if (context == value) {
@@ -166,16 +166,16 @@ _PyErr_SetObject(PyThreadState *tstate, PyObject *exception, PyObject *value)
                     break;
                 }
                 o = context;
-                if (o == slow_o) {
-                    /* pre-existing cycle - all exceptions on the
-                       path were visited and checked.  */
-                    break;
-                }
-                if (slow_update_toggle) {
-                    slow_o = PyException_GetContext(slow_o);
-                    Py_DECREF(slow_o);
-                }
-                slow_update_toggle = !slow_update_toggle;
+                if (o == slow_o) { 
+                    /* pre-existing cycle - all exceptions on the 
+                       path were visited and checked.  */ 
+                    break; 
+                } 
+                if (slow_update_toggle) { 
+                    slow_o = PyException_GetContext(slow_o); 
+                    Py_DECREF(slow_o); 
+                } 
+                slow_update_toggle = !slow_update_toggle; 
             }
             PyException_SetContext(value, exc_value);
         }
@@ -186,72 +186,72 @@ _PyErr_SetObject(PyThreadState *tstate, PyObject *exception, PyObject *value)
     if (value != NULL && PyExceptionInstance_Check(value))
         tb = PyException_GetTraceback(value);
     Py_XINCREF(exception);
-    _PyErr_Restore(tstate, exception, value, tb);
-}
-
-void
-PyErr_SetObject(PyObject *exception, PyObject *value)
-{
-    PyThreadState *tstate = _PyThreadState_GET();
-    _PyErr_SetObject(tstate, exception, value);
+    _PyErr_Restore(tstate, exception, value, tb); 
 }
 
+void 
+PyErr_SetObject(PyObject *exception, PyObject *value) 
+{ 
+    PyThreadState *tstate = _PyThreadState_GET(); 
+    _PyErr_SetObject(tstate, exception, value); 
+} 
+ 
 /* Set a key error with the specified argument, wrapping it in a
  * tuple automatically so that tuple keys are not unpacked as the
  * exception arguments. */
 void
 _PyErr_SetKeyError(PyObject *arg)
 {
-    PyThreadState *tstate = _PyThreadState_GET();
-    PyObject *tup = PyTuple_Pack(1, arg);
-    if (!tup) {
-        /* caller will expect error to be set anyway */
-        return;
-    }
-    _PyErr_SetObject(tstate, PyExc_KeyError, tup);
+    PyThreadState *tstate = _PyThreadState_GET(); 
+    PyObject *tup = PyTuple_Pack(1, arg); 
+    if (!tup) { 
+        /* caller will expect error to be set anyway */ 
+        return; 
+    } 
+    _PyErr_SetObject(tstate, PyExc_KeyError, tup); 
     Py_DECREF(tup);
 }
 
 void
-_PyErr_SetNone(PyThreadState *tstate, PyObject *exception)
-{
-    _PyErr_SetObject(tstate, exception, (PyObject *)NULL);
-}
-
-
-void
+_PyErr_SetNone(PyThreadState *tstate, PyObject *exception) 
+{ 
+    _PyErr_SetObject(tstate, exception, (PyObject *)NULL); 
+} 
+ 
+ 
+void 
 PyErr_SetNone(PyObject *exception)
 {
-    PyThreadState *tstate = _PyThreadState_GET();
-    _PyErr_SetNone(tstate, exception);
+    PyThreadState *tstate = _PyThreadState_GET(); 
+    _PyErr_SetNone(tstate, exception); 
 }
 
-
+ 
 void
-_PyErr_SetString(PyThreadState *tstate, PyObject *exception,
-                 const char *string)
+_PyErr_SetString(PyThreadState *tstate, PyObject *exception, 
+                 const char *string) 
 {
     PyObject *value = PyUnicode_FromString(string);
-    _PyErr_SetObject(tstate, exception, value);
+    _PyErr_SetObject(tstate, exception, value); 
     Py_XDECREF(value);
 }
 
-void
-PyErr_SetString(PyObject *exception, const char *string)
-{
-    PyThreadState *tstate = _PyThreadState_GET();
-    _PyErr_SetString(tstate, exception, string);
-}
-
+void 
+PyErr_SetString(PyObject *exception, const char *string) 
+{ 
+    PyThreadState *tstate = _PyThreadState_GET(); 
+    _PyErr_SetString(tstate, exception, string); 
+} 
 
+ 
 PyObject* _Py_HOT_FUNCTION
 PyErr_Occurred(void)
 {
-    /* The caller must hold the GIL. */
-    assert(PyGILState_Check());
-
-    PyThreadState *tstate = _PyThreadState_GET();
-    return _PyErr_Occurred(tstate);
+    /* The caller must hold the GIL. */ 
+    assert(PyGILState_Check()); 
+ 
+    PyThreadState *tstate = _PyThreadState_GET(); 
+    return _PyErr_Occurred(tstate); 
 }
 
 
@@ -288,17 +288,17 @@ PyErr_GivenExceptionMatches(PyObject *err, PyObject *exc)
 
 
 int
-_PyErr_ExceptionMatches(PyThreadState *tstate, PyObject *exc)
-{
-    return PyErr_GivenExceptionMatches(_PyErr_Occurred(tstate), exc);
-}
-
-
-int
+_PyErr_ExceptionMatches(PyThreadState *tstate, PyObject *exc) 
+{ 
+    return PyErr_GivenExceptionMatches(_PyErr_Occurred(tstate), exc); 
+} 
+ 
+ 
+int 
 PyErr_ExceptionMatches(PyObject *exc)
 {
-    PyThreadState *tstate = _PyThreadState_GET();
-    return _PyErr_ExceptionMatches(tstate, exc);
+    PyThreadState *tstate = _PyThreadState_GET(); 
+    return _PyErr_ExceptionMatches(tstate, exc); 
 }
 
 
@@ -313,18 +313,18 @@ PyErr_ExceptionMatches(PyObject *exc)
             PyException_SetTraceback() with the resulting value and tb?
 */
 void
-_PyErr_NormalizeException(PyThreadState *tstate, PyObject **exc,
-                          PyObject **val, PyObject **tb)
+_PyErr_NormalizeException(PyThreadState *tstate, PyObject **exc, 
+                          PyObject **val, PyObject **tb) 
 {
     int recursion_depth = 0;
-    tstate->overflowed++;
+    tstate->overflowed++; 
     PyObject *type, *value, *initial_tb;
 
   restart:
     type = *exc;
     if (type == NULL) {
         /* There was no exception, so nothing to do. */
-        tstate->overflowed--;
+        tstate->overflowed--; 
         return;
     }
 
@@ -376,7 +376,7 @@ _PyErr_NormalizeException(PyThreadState *tstate, PyObject **exc,
     }
     *exc = type;
     *val = value;
-    tstate->overflowed--;
+    tstate->overflowed--; 
     return;
 
   error:
@@ -384,16 +384,16 @@ _PyErr_NormalizeException(PyThreadState *tstate, PyObject **exc,
     Py_DECREF(value);
     recursion_depth++;
     if (recursion_depth == Py_NORMALIZE_RECURSION_LIMIT) {
-        _PyErr_SetString(tstate, PyExc_RecursionError,
-                         "maximum recursion depth exceeded "
-                         "while normalizing an exception");
+        _PyErr_SetString(tstate, PyExc_RecursionError, 
+                         "maximum recursion depth exceeded " 
+                         "while normalizing an exception"); 
     }
     /* If the new exception doesn't set a traceback and the old
        exception had a traceback, use the old traceback for the
        new exception.  It's better than nothing.
     */
     initial_tb = *tb;
-    _PyErr_Fetch(tstate, exc, val, tb);
+    _PyErr_Fetch(tstate, exc, val, tb); 
     assert(*exc != NULL);
     if (initial_tb != NULL) {
         if (*tb == NULL)
@@ -420,17 +420,17 @@ _PyErr_NormalizeException(PyThreadState *tstate, PyObject **exc,
 
 
 void
-PyErr_NormalizeException(PyObject **exc, PyObject **val, PyObject **tb)
+PyErr_NormalizeException(PyObject **exc, PyObject **val, PyObject **tb) 
 {
-    PyThreadState *tstate = _PyThreadState_GET();
-    _PyErr_NormalizeException(tstate, exc, val, tb);
-}
-
+    PyThreadState *tstate = _PyThreadState_GET(); 
+    _PyErr_NormalizeException(tstate, exc, val, tb); 
+} 
 
-void
-_PyErr_Fetch(PyThreadState *tstate, PyObject **p_type, PyObject **p_value,
-             PyObject **p_traceback)
-{
+ 
+void 
+_PyErr_Fetch(PyThreadState *tstate, PyObject **p_type, PyObject **p_value, 
+             PyObject **p_traceback) 
+{ 
     *p_type = tstate->curexc_type;
     *p_value = tstate->curexc_value;
     *p_traceback = tstate->curexc_traceback;
@@ -440,33 +440,33 @@ _PyErr_Fetch(PyThreadState *tstate, PyObject **p_type, PyObject **p_value,
     tstate->curexc_traceback = NULL;
 }
 
-
-void
-PyErr_Fetch(PyObject **p_type, PyObject **p_value, PyObject **p_traceback)
-{
-    PyThreadState *tstate = _PyThreadState_GET();
-    _PyErr_Fetch(tstate, p_type, p_value, p_traceback);
-}
-
-
-void
-_PyErr_Clear(PyThreadState *tstate)
-{
-    _PyErr_Restore(tstate, NULL, NULL, NULL);
-}
-
-
+ 
 void
+PyErr_Fetch(PyObject **p_type, PyObject **p_value, PyObject **p_traceback) 
+{ 
+    PyThreadState *tstate = _PyThreadState_GET(); 
+    _PyErr_Fetch(tstate, p_type, p_value, p_traceback); 
+} 
+ 
+ 
+void 
+_PyErr_Clear(PyThreadState *tstate) 
+{ 
+    _PyErr_Restore(tstate, NULL, NULL, NULL); 
+} 
+ 
+ 
+void 
 PyErr_Clear(void)
 {
-    PyThreadState *tstate = _PyThreadState_GET();
-    _PyErr_Clear(tstate);
+    PyThreadState *tstate = _PyThreadState_GET(); 
+    _PyErr_Clear(tstate); 
 }
 
-
+ 
 void
-_PyErr_GetExcInfo(PyThreadState *tstate,
-                  PyObject **p_type, PyObject **p_value, PyObject **p_traceback)
+_PyErr_GetExcInfo(PyThreadState *tstate, 
+                  PyObject **p_type, PyObject **p_value, PyObject **p_traceback) 
 {
     _PyErr_StackItem *exc_info = _PyErr_GetTopmostException(tstate);
     *p_type = exc_info->exc_type;
@@ -478,19 +478,19 @@ _PyErr_GetExcInfo(PyThreadState *tstate,
     Py_XINCREF(*p_traceback);
 }
 
-
-void
-PyErr_GetExcInfo(PyObject **p_type, PyObject **p_value, PyObject **p_traceback)
-{
-    PyThreadState *tstate = _PyThreadState_GET();
-    _PyErr_GetExcInfo(tstate, p_type, p_value, p_traceback);
-}
-
+ 
 void
+PyErr_GetExcInfo(PyObject **p_type, PyObject **p_value, PyObject **p_traceback) 
+{ 
+    PyThreadState *tstate = _PyThreadState_GET(); 
+    _PyErr_GetExcInfo(tstate, p_type, p_value, p_traceback); 
+} 
+ 
+void 
 PyErr_SetExcInfo(PyObject *p_type, PyObject *p_value, PyObject *p_traceback)
 {
     PyObject *oldtype, *oldvalue, *oldtraceback;
-    PyThreadState *tstate = _PyThreadState_GET();
+    PyThreadState *tstate = _PyThreadState_GET(); 
 
     oldtype = tstate->exc_info->exc_type;
     oldvalue = tstate->exc_info->exc_value;
@@ -507,153 +507,153 @@ PyErr_SetExcInfo(PyObject *p_type, PyObject *p_value, PyObject *p_traceback)
 
 /* Like PyErr_Restore(), but if an exception is already set,
    set the context associated with it.
-
-   The caller is responsible for ensuring that this call won't create
-   any cycles in the exception context chain. */
+ 
+   The caller is responsible for ensuring that this call won't create 
+   any cycles in the exception context chain. */ 
 void
 _PyErr_ChainExceptions(PyObject *exc, PyObject *val, PyObject *tb)
 {
     if (exc == NULL)
         return;
 
-    PyThreadState *tstate = _PyThreadState_GET();
-
-    if (!PyExceptionClass_Check(exc)) {
-        _PyErr_Format(tstate, PyExc_SystemError,
-                      "_PyErr_ChainExceptions: "
-                      "exception %R is not a BaseException subclass",
-                      exc);
-        return;
-    }
-
-    if (_PyErr_Occurred(tstate)) {
+    PyThreadState *tstate = _PyThreadState_GET(); 
+ 
+    if (!PyExceptionClass_Check(exc)) { 
+        _PyErr_Format(tstate, PyExc_SystemError, 
+                      "_PyErr_ChainExceptions: " 
+                      "exception %R is not a BaseException subclass", 
+                      exc); 
+        return; 
+    } 
+ 
+    if (_PyErr_Occurred(tstate)) { 
         PyObject *exc2, *val2, *tb2;
-        _PyErr_Fetch(tstate, &exc2, &val2, &tb2);
-        _PyErr_NormalizeException(tstate, &exc, &val, &tb);
+        _PyErr_Fetch(tstate, &exc2, &val2, &tb2); 
+        _PyErr_NormalizeException(tstate, &exc, &val, &tb); 
         if (tb != NULL) {
             PyException_SetTraceback(val, tb);
             Py_DECREF(tb);
         }
         Py_DECREF(exc);
-        _PyErr_NormalizeException(tstate, &exc2, &val2, &tb2);
+        _PyErr_NormalizeException(tstate, &exc2, &val2, &tb2); 
         PyException_SetContext(val2, val);
-        _PyErr_Restore(tstate, exc2, val2, tb2);
+        _PyErr_Restore(tstate, exc2, val2, tb2); 
     }
     else {
-        _PyErr_Restore(tstate, exc, val, tb);
-    }
-}
-
-/* Set the currently set exception's context to the given exception.
-
-   If the provided exc_info is NULL, then the current Python thread state's
-   exc_info will be used for the context instead.
-
-   This function can only be called when _PyErr_Occurred() is true.
-   Also, this function won't create any cycles in the exception context
-   chain to the extent that _PyErr_SetObject ensures this. */
-void
-_PyErr_ChainStackItem(_PyErr_StackItem *exc_info)
-{
-    PyThreadState *tstate = _PyThreadState_GET();
-    assert(_PyErr_Occurred(tstate));
-
-    int exc_info_given;
-    if (exc_info == NULL) {
-        exc_info_given = 0;
-        exc_info = tstate->exc_info;
-    } else {
-        exc_info_given = 1;
-    }
-    if (exc_info->exc_type == NULL || exc_info->exc_type == Py_None) {
-        return;
-    }
-
-    _PyErr_StackItem *saved_exc_info;
-    if (exc_info_given) {
-        /* Temporarily set the thread state's exc_info since this is what
-           _PyErr_SetObject uses for implicit exception chaining. */
-        saved_exc_info = tstate->exc_info;
-        tstate->exc_info = exc_info;
-    }
-
-    PyObject *exc, *val, *tb;
-    _PyErr_Fetch(tstate, &exc, &val, &tb);
-
-    PyObject *exc2, *val2, *tb2;
-    exc2 = exc_info->exc_type;
-    val2 = exc_info->exc_value;
-    tb2 = exc_info->exc_traceback;
-    _PyErr_NormalizeException(tstate, &exc2, &val2, &tb2);
-    if (tb2 != NULL) {
-        PyException_SetTraceback(val2, tb2);
-    }
-
-    /* _PyErr_SetObject sets the context from PyThreadState. */
-    _PyErr_SetObject(tstate, exc, val);
-    Py_DECREF(exc);  // since _PyErr_Occurred was true
-    Py_XDECREF(val);
-    Py_XDECREF(tb);
-
-    if (exc_info_given) {
-        tstate->exc_info = saved_exc_info;
-    }
-}
-
+        _PyErr_Restore(tstate, exc, val, tb); 
+    }
+}
+
+/* Set the currently set exception's context to the given exception. 
+ 
+   If the provided exc_info is NULL, then the current Python thread state's 
+   exc_info will be used for the context instead. 
+ 
+   This function can only be called when _PyErr_Occurred() is true. 
+   Also, this function won't create any cycles in the exception context 
+   chain to the extent that _PyErr_SetObject ensures this. */ 
+void 
+_PyErr_ChainStackItem(_PyErr_StackItem *exc_info) 
+{ 
+    PyThreadState *tstate = _PyThreadState_GET(); 
+    assert(_PyErr_Occurred(tstate)); 
+ 
+    int exc_info_given; 
+    if (exc_info == NULL) { 
+        exc_info_given = 0; 
+        exc_info = tstate->exc_info; 
+    } else { 
+        exc_info_given = 1; 
+    } 
+    if (exc_info->exc_type == NULL || exc_info->exc_type == Py_None) { 
+        return; 
+    } 
+ 
+    _PyErr_StackItem *saved_exc_info; 
+    if (exc_info_given) { 
+        /* Temporarily set the thread state's exc_info since this is what 
+           _PyErr_SetObject uses for implicit exception chaining. */ 
+        saved_exc_info = tstate->exc_info; 
+        tstate->exc_info = exc_info; 
+    } 
+ 
+    PyObject *exc, *val, *tb; 
+    _PyErr_Fetch(tstate, &exc, &val, &tb); 
+ 
+    PyObject *exc2, *val2, *tb2; 
+    exc2 = exc_info->exc_type; 
+    val2 = exc_info->exc_value; 
+    tb2 = exc_info->exc_traceback; 
+    _PyErr_NormalizeException(tstate, &exc2, &val2, &tb2); 
+    if (tb2 != NULL) { 
+        PyException_SetTraceback(val2, tb2); 
+    } 
+ 
+    /* _PyErr_SetObject sets the context from PyThreadState. */ 
+    _PyErr_SetObject(tstate, exc, val); 
+    Py_DECREF(exc);  // since _PyErr_Occurred was true 
+    Py_XDECREF(val); 
+    Py_XDECREF(tb); 
+ 
+    if (exc_info_given) { 
+        tstate->exc_info = saved_exc_info; 
+    } 
+} 
+ 
 static PyObject *
-_PyErr_FormatVFromCause(PyThreadState *tstate, PyObject *exception,
-                        const char *format, va_list vargs)
+_PyErr_FormatVFromCause(PyThreadState *tstate, PyObject *exception, 
+                        const char *format, va_list vargs) 
 {
     PyObject *exc, *val, *val2, *tb;
 
-    assert(_PyErr_Occurred(tstate));
-    _PyErr_Fetch(tstate, &exc, &val, &tb);
-    _PyErr_NormalizeException(tstate, &exc, &val, &tb);
+    assert(_PyErr_Occurred(tstate)); 
+    _PyErr_Fetch(tstate, &exc, &val, &tb); 
+    _PyErr_NormalizeException(tstate, &exc, &val, &tb); 
     if (tb != NULL) {
         PyException_SetTraceback(val, tb);
         Py_DECREF(tb);
     }
     Py_DECREF(exc);
-    assert(!_PyErr_Occurred(tstate));
+    assert(!_PyErr_Occurred(tstate)); 
 
-    _PyErr_FormatV(tstate, exception, format, vargs);
+    _PyErr_FormatV(tstate, exception, format, vargs); 
 
-    _PyErr_Fetch(tstate, &exc, &val2, &tb);
-    _PyErr_NormalizeException(tstate, &exc, &val2, &tb);
+    _PyErr_Fetch(tstate, &exc, &val2, &tb); 
+    _PyErr_NormalizeException(tstate, &exc, &val2, &tb); 
     Py_INCREF(val);
     PyException_SetCause(val2, val);
     PyException_SetContext(val2, val);
-    _PyErr_Restore(tstate, exc, val2, tb);
+    _PyErr_Restore(tstate, exc, val2, tb); 
 
     return NULL;
 }
 
 PyObject *
-_PyErr_FormatFromCauseTstate(PyThreadState *tstate, PyObject *exception,
-                             const char *format, ...)
-{
-    va_list vargs;
-#ifdef HAVE_STDARG_PROTOTYPES
-    va_start(vargs, format);
-#else
-    va_start(vargs);
-#endif
-    _PyErr_FormatVFromCause(tstate, exception, format, vargs);
-    va_end(vargs);
-    return NULL;
-}
-
-PyObject *
+_PyErr_FormatFromCauseTstate(PyThreadState *tstate, PyObject *exception, 
+                             const char *format, ...) 
+{ 
+    va_list vargs; 
+#ifdef HAVE_STDARG_PROTOTYPES 
+    va_start(vargs, format); 
+#else 
+    va_start(vargs); 
+#endif 
+    _PyErr_FormatVFromCause(tstate, exception, format, vargs); 
+    va_end(vargs); 
+    return NULL; 
+} 
+ 
+PyObject * 
 _PyErr_FormatFromCause(PyObject *exception, const char *format, ...)
 {
-    PyThreadState *tstate = _PyThreadState_GET();
+    PyThreadState *tstate = _PyThreadState_GET(); 
     va_list vargs;
 #ifdef HAVE_STDARG_PROTOTYPES
     va_start(vargs, format);
 #else
     va_start(vargs);
 #endif
-    _PyErr_FormatVFromCause(tstate, exception, format, vargs);
+    _PyErr_FormatVFromCause(tstate, exception, format, vargs); 
     va_end(vargs);
     return NULL;
 }
@@ -663,33 +663,33 @@ _PyErr_FormatFromCause(PyObject *exception, const char *format, ...)
 int
 PyErr_BadArgument(void)
 {
-    PyThreadState *tstate = _PyThreadState_GET();
-    _PyErr_SetString(tstate, PyExc_TypeError,
-                     "bad argument type for built-in operation");
+    PyThreadState *tstate = _PyThreadState_GET(); 
+    _PyErr_SetString(tstate, PyExc_TypeError, 
+                     "bad argument type for built-in operation"); 
     return 0;
 }
 
 PyObject *
-_PyErr_NoMemory(PyThreadState *tstate)
+_PyErr_NoMemory(PyThreadState *tstate) 
 {
-    if (Py_IS_TYPE(PyExc_MemoryError, NULL)) {
+    if (Py_IS_TYPE(PyExc_MemoryError, NULL)) { 
         /* PyErr_NoMemory() has been called before PyExc_MemoryError has been
            initialized by _PyExc_Init() */
         Py_FatalError("Out of memory and PyExc_MemoryError is not "
                       "initialized yet");
     }
-    _PyErr_SetNone(tstate, PyExc_MemoryError);
+    _PyErr_SetNone(tstate, PyExc_MemoryError); 
     return NULL;
 }
 
 PyObject *
-PyErr_NoMemory(void)
-{
-    PyThreadState *tstate = _PyThreadState_GET();
-    return _PyErr_NoMemory(tstate);
-}
-
-PyObject *
+PyErr_NoMemory(void) 
+{ 
+    PyThreadState *tstate = _PyThreadState_GET(); 
+    return _PyErr_NoMemory(tstate); 
+} 
+ 
+PyObject * 
 PyErr_SetFromErrnoWithFilenameObject(PyObject *exc, PyObject *filenameObject)
 {
     return PyErr_SetFromErrnoWithFilenameObjects(exc, filenameObject, NULL);
@@ -698,7 +698,7 @@ PyErr_SetFromErrnoWithFilenameObject(PyObject *exc, PyObject *filenameObject)
 PyObject *
 PyErr_SetFromErrnoWithFilenameObjects(PyObject *exc, PyObject *filenameObject, PyObject *filenameObject2)
 {
-    PyThreadState *tstate = _PyThreadState_GET();
+    PyThreadState *tstate = _PyThreadState_GET(); 
     PyObject *message;
     PyObject *v, *args;
     int i = errno;
@@ -713,7 +713,7 @@ PyErr_SetFromErrnoWithFilenameObjects(PyObject *exc, PyObject *filenameObject, P
 
 #ifndef MS_WINDOWS
     if (i != 0) {
-        const char *s = strerror(i);
+        const char *s = strerror(i); 
         message = PyUnicode_DecodeLocale(s, "surrogateescape");
     }
     else {
@@ -784,7 +784,7 @@ PyErr_SetFromErrnoWithFilenameObjects(PyObject *exc, PyObject *filenameObject, P
         v = PyObject_Call(exc, args, NULL);
         Py_DECREF(args);
         if (v != NULL) {
-            _PyErr_SetObject(tstate, (PyObject *) Py_TYPE(v), v);
+            _PyErr_SetObject(tstate, (PyObject *) Py_TYPE(v), v); 
             Py_DECREF(v);
         }
     }
@@ -837,17 +837,17 @@ PyObject *PyErr_SetExcFromWindowsErrWithFilenameObjects(
     PyObject *filenameObject,
     PyObject *filenameObject2)
 {
-    PyThreadState *tstate = _PyThreadState_GET();
+    PyThreadState *tstate = _PyThreadState_GET(); 
     int len;
     WCHAR *s_buf = NULL; /* Free via LocalFree */
     PyObject *message;
     PyObject *args, *v;
-
+ 
     DWORD err = (DWORD)ierr;
-    if (err==0) {
-        err = GetLastError();
-    }
-
+    if (err==0) { 
+        err = GetLastError(); 
+    } 
+ 
     len = FormatMessageW(
         /* Error API error */
         FORMAT_MESSAGE_ALLOCATE_BUFFER |
@@ -892,7 +892,7 @@ PyObject *PyErr_SetExcFromWindowsErrWithFilenameObjects(
         v = PyObject_Call(exc, args, NULL);
         Py_DECREF(args);
         if (v != NULL) {
-            _PyErr_SetObject(tstate, (PyObject *) Py_TYPE(v), v);
+            _PyErr_SetObject(tstate, (PyObject *) Py_TYPE(v), v); 
             Py_DECREF(v);
         }
     }
@@ -968,7 +968,7 @@ PyObject *
 PyErr_SetImportErrorSubclass(PyObject *exception, PyObject *msg,
     PyObject *name, PyObject *path)
 {
-    PyThreadState *tstate = _PyThreadState_GET();
+    PyThreadState *tstate = _PyThreadState_GET(); 
     int issubclass;
     PyObject *kwargs, *error;
 
@@ -977,14 +977,14 @@ PyErr_SetImportErrorSubclass(PyObject *exception, PyObject *msg,
         return NULL;
     }
     else if (!issubclass) {
-        _PyErr_SetString(tstate, PyExc_TypeError,
-                         "expected a subclass of ImportError");
+        _PyErr_SetString(tstate, PyExc_TypeError, 
+                         "expected a subclass of ImportError"); 
         return NULL;
     }
 
     if (msg == NULL) {
-        _PyErr_SetString(tstate, PyExc_TypeError,
-                         "expected a message argument");
+        _PyErr_SetString(tstate, PyExc_TypeError, 
+                         "expected a message argument"); 
         return NULL;
     }
 
@@ -1006,9 +1006,9 @@ PyErr_SetImportErrorSubclass(PyObject *exception, PyObject *msg,
         goto done;
     }
 
-    error = PyObject_VectorcallDict(exception, &msg, 1, kwargs);
+    error = PyObject_VectorcallDict(exception, &msg, 1, kwargs); 
     if (error != NULL) {
-        _PyErr_SetObject(tstate, (PyObject *)Py_TYPE(error), error);
+        _PyErr_SetObject(tstate, (PyObject *)Py_TYPE(error), error); 
         Py_DECREF(error);
     }
 
@@ -1026,10 +1026,10 @@ PyErr_SetImportError(PyObject *msg, PyObject *name, PyObject *path)
 void
 _PyErr_BadInternalCall(const char *filename, int lineno)
 {
-    PyThreadState *tstate = _PyThreadState_GET();
-    _PyErr_Format(tstate, PyExc_SystemError,
-                  "%s:%d: bad argument to internal function",
-                  filename, lineno);
+    PyThreadState *tstate = _PyThreadState_GET(); 
+    _PyErr_Format(tstate, PyExc_SystemError, 
+                  "%s:%d: bad argument to internal function", 
+                  filename, lineno); 
 }
 
 /* Remove the preprocessor macro for PyErr_BadInternalCall() so that we can
@@ -1039,66 +1039,66 @@ void
 PyErr_BadInternalCall(void)
 {
     assert(0 && "bad argument to internal function");
-    PyThreadState *tstate = _PyThreadState_GET();
-    _PyErr_SetString(tstate, PyExc_SystemError,
-                     "bad argument to internal function");
+    PyThreadState *tstate = _PyThreadState_GET(); 
+    _PyErr_SetString(tstate, PyExc_SystemError, 
+                     "bad argument to internal function"); 
 }
 #define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)
 
 
-static PyObject *
-_PyErr_FormatV(PyThreadState *tstate, PyObject *exception,
-               const char *format, va_list vargs)
+static PyObject * 
+_PyErr_FormatV(PyThreadState *tstate, PyObject *exception, 
+               const char *format, va_list vargs) 
 {
     PyObject* string;
 
     /* Issue #23571: PyUnicode_FromFormatV() must not be called with an
        exception set, it calls arbitrary Python code like PyObject_Repr() */
-    _PyErr_Clear(tstate);
+    _PyErr_Clear(tstate); 
 
     string = PyUnicode_FromFormatV(format, vargs);
 
-    _PyErr_SetObject(tstate, exception, string);
+    _PyErr_SetObject(tstate, exception, string); 
     Py_XDECREF(string);
     return NULL;
 }
 
 
 PyObject *
-PyErr_FormatV(PyObject *exception, const char *format, va_list vargs)
-{
-    PyThreadState *tstate = _PyThreadState_GET();
-    return _PyErr_FormatV(tstate, exception, format, vargs);
-}
-
-
-PyObject *
-_PyErr_Format(PyThreadState *tstate, PyObject *exception,
-              const char *format, ...)
-{
-    va_list vargs;
-#ifdef HAVE_STDARG_PROTOTYPES
-    va_start(vargs, format);
-#else
-    va_start(vargs);
-#endif
-    _PyErr_FormatV(tstate, exception, format, vargs);
-    va_end(vargs);
-    return NULL;
-}
-
-
-PyObject *
+PyErr_FormatV(PyObject *exception, const char *format, va_list vargs) 
+{ 
+    PyThreadState *tstate = _PyThreadState_GET(); 
+    return _PyErr_FormatV(tstate, exception, format, vargs); 
+} 
+ 
+ 
+PyObject * 
+_PyErr_Format(PyThreadState *tstate, PyObject *exception, 
+              const char *format, ...) 
+{ 
+    va_list vargs; 
+#ifdef HAVE_STDARG_PROTOTYPES 
+    va_start(vargs, format); 
+#else 
+    va_start(vargs); 
+#endif 
+    _PyErr_FormatV(tstate, exception, format, vargs); 
+    va_end(vargs); 
+    return NULL; 
+} 
+ 
+ 
+PyObject * 
 PyErr_Format(PyObject *exception, const char *format, ...)
 {
-    PyThreadState *tstate = _PyThreadState_GET();
+    PyThreadState *tstate = _PyThreadState_GET(); 
     va_list vargs;
 #ifdef HAVE_STDARG_PROTOTYPES
     va_start(vargs, format);
 #else
     va_start(vargs);
 #endif
-    _PyErr_FormatV(tstate, exception, format, vargs);
+    _PyErr_FormatV(tstate, exception, format, vargs); 
     va_end(vargs);
     return NULL;
 }
@@ -1107,37 +1107,37 @@ PyErr_Format(PyObject *exception, const char *format, ...)
 PyObject *
 PyErr_NewException(const char *name, PyObject *base, PyObject *dict)
 {
-    PyThreadState *tstate = _PyThreadState_GET();
+    PyThreadState *tstate = _PyThreadState_GET(); 
     PyObject *modulename = NULL;
     PyObject *classname = NULL;
     PyObject *mydict = NULL;
     PyObject *bases = NULL;
     PyObject *result = NULL;
-
-    const char *dot = strrchr(name, '.');
+ 
+    const char *dot = strrchr(name, '.'); 
     if (dot == NULL) {
-        _PyErr_SetString(tstate, PyExc_SystemError,
-                         "PyErr_NewException: name must be module.class");
+        _PyErr_SetString(tstate, PyExc_SystemError, 
+                         "PyErr_NewException: name must be module.class"); 
         return NULL;
     }
-    if (base == NULL) {
+    if (base == NULL) { 
         base = PyExc_Exception;
-    }
+    } 
     if (dict == NULL) {
         dict = mydict = PyDict_New();
         if (dict == NULL)
             goto failure;
     }
-
-    if (_PyDict_GetItemIdWithError(dict, &PyId___module__) == NULL) {
-        if (_PyErr_Occurred(tstate)) {
-            goto failure;
-        }
+ 
+    if (_PyDict_GetItemIdWithError(dict, &PyId___module__) == NULL) { 
+        if (_PyErr_Occurred(tstate)) { 
+            goto failure; 
+        } 
         modulename = PyUnicode_FromStringAndSize(name,
                                              (Py_ssize_t)(dot-name));
         if (modulename == NULL)
             goto failure;
-        if (_PyDict_SetItemId(dict, &PyId___module__, modulename) != 0)
+        if (_PyDict_SetItemId(dict, &PyId___module__, modulename) != 0) 
             goto failure;
     }
     if (PyTuple_Check(base)) {
@@ -1195,372 +1195,372 @@ PyErr_NewExceptionWithDoc(const char *name, const char *doc,
 }
 
 
-PyDoc_STRVAR(UnraisableHookArgs__doc__,
-"UnraisableHookArgs\n\
-\n\
-Type used to pass arguments to sys.unraisablehook.");
-
-static PyTypeObject UnraisableHookArgsType;
-
-static PyStructSequence_Field UnraisableHookArgs_fields[] = {
-    {"exc_type", "Exception type"},
-    {"exc_value", "Exception value"},
-    {"exc_traceback", "Exception traceback"},
-    {"err_msg", "Error message"},
-    {"object", "Object causing the exception"},
-    {0}
-};
-
-static PyStructSequence_Desc UnraisableHookArgs_desc = {
-    .name = "UnraisableHookArgs",
-    .doc = UnraisableHookArgs__doc__,
-    .fields = UnraisableHookArgs_fields,
-    .n_in_sequence = 5
-};
-
-
-PyStatus
-_PyErr_Init(void)
-{
-    if (UnraisableHookArgsType.tp_name == NULL) {
-        if (PyStructSequence_InitType2(&UnraisableHookArgsType,
-                                       &UnraisableHookArgs_desc) < 0) {
-            return _PyStatus_ERR("failed to initialize UnraisableHookArgs type");
-        }
-    }
-    return _PyStatus_OK();
-}
-
-
-static PyObject *
-make_unraisable_hook_args(PyThreadState *tstate, PyObject *exc_type,
-                          PyObject *exc_value, PyObject *exc_tb,
-                          PyObject *err_msg, PyObject *obj)
-{
-    PyObject *args = PyStructSequence_New(&UnraisableHookArgsType);
-    if (args == NULL) {
-        return NULL;
-    }
-
-    Py_ssize_t pos = 0;
-#define ADD_ITEM(exc_type) \
-        do { \
-            if (exc_type == NULL) { \
-                exc_type = Py_None; \
-            } \
-            Py_INCREF(exc_type); \
-            PyStructSequence_SET_ITEM(args, pos++, exc_type); \
-        } while (0)
-
-
-    ADD_ITEM(exc_type);
-    ADD_ITEM(exc_value);
-    ADD_ITEM(exc_tb);
-    ADD_ITEM(err_msg);
-    ADD_ITEM(obj);
-#undef ADD_ITEM
-
-    if (_PyErr_Occurred(tstate)) {
-        Py_DECREF(args);
-        return NULL;
-    }
-    return args;
-}
-
-
-
-/* Default implementation of sys.unraisablehook.
-
-   It can be called to log the exception of a custom sys.unraisablehook.
-
-   Do nothing if sys.stderr attribute doesn't exist or is set to None. */
-static int
-write_unraisable_exc_file(PyThreadState *tstate, PyObject *exc_type,
-                          PyObject *exc_value, PyObject *exc_tb,
-                          PyObject *err_msg, PyObject *obj, PyObject *file)
-{
-    if (obj != NULL && obj != Py_None) {
-        if (err_msg != NULL && err_msg != Py_None) {
-            if (PyFile_WriteObject(err_msg, file, Py_PRINT_RAW) < 0) {
-                return -1;
-            }
-            if (PyFile_WriteString(": ", file) < 0) {
-                return -1;
+PyDoc_STRVAR(UnraisableHookArgs__doc__, 
+"UnraisableHookArgs\n\ 
+\n\ 
+Type used to pass arguments to sys.unraisablehook."); 
+ 
+static PyTypeObject UnraisableHookArgsType; 
+ 
+static PyStructSequence_Field UnraisableHookArgs_fields[] = { 
+    {"exc_type", "Exception type"}, 
+    {"exc_value", "Exception value"}, 
+    {"exc_traceback", "Exception traceback"}, 
+    {"err_msg", "Error message"}, 
+    {"object", "Object causing the exception"}, 
+    {0} 
+}; 
+ 
+static PyStructSequence_Desc UnraisableHookArgs_desc = { 
+    .name = "UnraisableHookArgs", 
+    .doc = UnraisableHookArgs__doc__, 
+    .fields = UnraisableHookArgs_fields, 
+    .n_in_sequence = 5 
+}; 
+ 
+ 
+PyStatus 
+_PyErr_Init(void) 
+{
+    if (UnraisableHookArgsType.tp_name == NULL) { 
+        if (PyStructSequence_InitType2(&UnraisableHookArgsType, 
+                                       &UnraisableHookArgs_desc) < 0) { 
+            return _PyStatus_ERR("failed to initialize UnraisableHookArgs type"); 
+        } 
+    } 
+    return _PyStatus_OK(); 
+} 
+ 
+ 
+static PyObject * 
+make_unraisable_hook_args(PyThreadState *tstate, PyObject *exc_type, 
+                          PyObject *exc_value, PyObject *exc_tb, 
+                          PyObject *err_msg, PyObject *obj) 
+{ 
+    PyObject *args = PyStructSequence_New(&UnraisableHookArgsType); 
+    if (args == NULL) { 
+        return NULL; 
+    } 
+ 
+    Py_ssize_t pos = 0; 
+#define ADD_ITEM(exc_type) \ 
+        do { \ 
+            if (exc_type == NULL) { \ 
+                exc_type = Py_None; \ 
+            } \ 
+            Py_INCREF(exc_type); \ 
+            PyStructSequence_SET_ITEM(args, pos++, exc_type); \ 
+        } while (0) 
+ 
+ 
+    ADD_ITEM(exc_type); 
+    ADD_ITEM(exc_value); 
+    ADD_ITEM(exc_tb); 
+    ADD_ITEM(err_msg); 
+    ADD_ITEM(obj); 
+#undef ADD_ITEM 
+ 
+    if (_PyErr_Occurred(tstate)) { 
+        Py_DECREF(args); 
+        return NULL; 
+    } 
+    return args; 
+} 
+ 
+ 
+ 
+/* Default implementation of sys.unraisablehook. 
+ 
+   It can be called to log the exception of a custom sys.unraisablehook. 
+ 
+   Do nothing if sys.stderr attribute doesn't exist or is set to None. */ 
+static int 
+write_unraisable_exc_file(PyThreadState *tstate, PyObject *exc_type, 
+                          PyObject *exc_value, PyObject *exc_tb, 
+                          PyObject *err_msg, PyObject *obj, PyObject *file) 
+{ 
+    if (obj != NULL && obj != Py_None) { 
+        if (err_msg != NULL && err_msg != Py_None) { 
+            if (PyFile_WriteObject(err_msg, file, Py_PRINT_RAW) < 0) { 
+                return -1; 
+            } 
+            if (PyFile_WriteString(": ", file) < 0) { 
+                return -1; 
+            } 
+        } 
+        else { 
+            if (PyFile_WriteString("Exception ignored in: ", file) < 0) { 
+                return -1; 
+            } 
+        } 
+ 
+        if (PyFile_WriteObject(obj, file, 0) < 0) { 
+            _PyErr_Clear(tstate); 
+            if (PyFile_WriteString("<object repr() failed>", file) < 0) { 
+                return -1; 
             }
         }
-        else {
-            if (PyFile_WriteString("Exception ignored in: ", file) < 0) {
-                return -1;
-            }
-        }
-
-        if (PyFile_WriteObject(obj, file, 0) < 0) {
-            _PyErr_Clear(tstate);
-            if (PyFile_WriteString("<object repr() failed>", file) < 0) {
-                return -1;
-            }
-        }
-        if (PyFile_WriteString("\n", file) < 0) {
-            return -1;
-        }
-    }
-    else if (err_msg != NULL && err_msg != Py_None) {
-        if (PyFile_WriteObject(err_msg, file, Py_PRINT_RAW) < 0) {
-            return -1;
-        }
-        if (PyFile_WriteString(":\n", file) < 0) {
-            return -1;
-        }
-    }
-
-    if (exc_tb != NULL && exc_tb != Py_None) {
-        if (PyTraceBack_Print(exc_tb, file) < 0) {
-            /* continue even if writing the traceback failed */
-            _PyErr_Clear(tstate);
-        }
-    }
-
-    if (exc_type == NULL || exc_type == Py_None) {
-        return -1;
-    }
-
-    assert(PyExceptionClass_Check(exc_type));
-
-    PyObject *modulename = _PyObject_GetAttrId(exc_type, &PyId___module__);
-    if (modulename == NULL || !PyUnicode_Check(modulename)) {
-        Py_XDECREF(modulename);
-        _PyErr_Clear(tstate);
-        if (PyFile_WriteString("<unknown>", file) < 0) {
-            return -1;
-        }
+        if (PyFile_WriteString("\n", file) < 0) { 
+            return -1; 
+        } 
+    }
+    else if (err_msg != NULL && err_msg != Py_None) { 
+        if (PyFile_WriteObject(err_msg, file, Py_PRINT_RAW) < 0) { 
+            return -1; 
+        } 
+        if (PyFile_WriteString(":\n", file) < 0) { 
+            return -1; 
+        } 
+    } 
+
+    if (exc_tb != NULL && exc_tb != Py_None) { 
+        if (PyTraceBack_Print(exc_tb, file) < 0) { 
+            /* continue even if writing the traceback failed */ 
+            _PyErr_Clear(tstate); 
+        } 
+    } 
+
+    if (exc_type == NULL || exc_type == Py_None) { 
+        return -1; 
+    } 
+
+    assert(PyExceptionClass_Check(exc_type)); 
+
+    PyObject *modulename = _PyObject_GetAttrId(exc_type, &PyId___module__); 
+    if (modulename == NULL || !PyUnicode_Check(modulename)) { 
+        Py_XDECREF(modulename); 
+        _PyErr_Clear(tstate); 
+        if (PyFile_WriteString("<unknown>", file) < 0) { 
+            return -1; 
+        } 
     }
     else {
-        if (!_PyUnicode_EqualToASCIIId(modulename, &PyId_builtins)) {
-            if (PyFile_WriteObject(modulename, file, Py_PRINT_RAW) < 0) {
-                Py_DECREF(modulename);
-                return -1;
-            }
-            Py_DECREF(modulename);
-            if (PyFile_WriteString(".", file) < 0) {
-                return -1;
-            }
-        }
-        else {
-            Py_DECREF(modulename);
-        }
-    }
-
-    PyObject *qualname = _PyType_GetQualName((PyTypeObject *)exc_type);
-    if (qualname == NULL || !PyUnicode_Check(qualname)) {
-        Py_XDECREF(qualname);
-        _PyErr_Clear(tstate);
-        if (PyFile_WriteString("<unknown>", file) < 0) {
-            return -1;
+        if (!_PyUnicode_EqualToASCIIId(modulename, &PyId_builtins)) { 
+            if (PyFile_WriteObject(modulename, file, Py_PRINT_RAW) < 0) { 
+                Py_DECREF(modulename); 
+                return -1; 
+            } 
+            Py_DECREF(modulename); 
+            if (PyFile_WriteString(".", file) < 0) { 
+                return -1; 
+            } 
         }
+        else { 
+            Py_DECREF(modulename); 
+        } 
+    }
+ 
+    PyObject *qualname = _PyType_GetQualName((PyTypeObject *)exc_type); 
+    if (qualname == NULL || !PyUnicode_Check(qualname)) { 
+        Py_XDECREF(qualname); 
+        _PyErr_Clear(tstate); 
+        if (PyFile_WriteString("<unknown>", file) < 0) { 
+            return -1; 
+        } 
     }
     else {
-        if (PyFile_WriteObject(qualname, file, Py_PRINT_RAW) < 0) {
-            Py_DECREF(qualname);
-            return -1;
-        }
-        Py_DECREF(qualname);
-    }
-
-    if (exc_value && exc_value != Py_None) {
-        if (PyFile_WriteString(": ", file) < 0) {
-            return -1;
-        }
-        if (PyFile_WriteObject(exc_value, file, Py_PRINT_RAW) < 0) {
-            _PyErr_Clear(tstate);
-            if (PyFile_WriteString("<exception str() failed>", file) < 0) {
-                return -1;
-            }
-        }
-    }
-
-    if (PyFile_WriteString("\n", file) < 0) {
-        return -1;
-    }
-
-    /* Explicitly call file.flush() */
-    PyObject *res = _PyObject_CallMethodIdNoArgs(file, &PyId_flush);
-    if (!res) {
-        return -1;
-    }
-    Py_DECREF(res);
-
-    return 0;
-}
-
-
-static int
-write_unraisable_exc(PyThreadState *tstate, PyObject *exc_type,
-                     PyObject *exc_value, PyObject *exc_tb, PyObject *err_msg,
-                     PyObject *obj)
-{
-    PyObject *file = _PySys_GetObjectId(&PyId_stderr);
-    if (file == NULL || file == Py_None) {
-        return 0;
-    }
-
-    /* Hold a strong reference to ensure that sys.stderr doesn't go away
-       while we use it */
-    Py_INCREF(file);
-    int res = write_unraisable_exc_file(tstate, exc_type, exc_value, exc_tb,
-                                        err_msg, obj, file);
-    Py_DECREF(file);
-
-    return res;
-}
-
-
-PyObject*
-_PyErr_WriteUnraisableDefaultHook(PyObject *args)
-{
-    PyThreadState *tstate = _PyThreadState_GET();
-
-    if (!Py_IS_TYPE(args, &UnraisableHookArgsType)) {
-        _PyErr_SetString(tstate, PyExc_TypeError,
-                         "sys.unraisablehook argument type "
-                         "must be UnraisableHookArgs");
-        return NULL;
-    }
-
-    /* Borrowed references */
-    PyObject *exc_type = PyStructSequence_GET_ITEM(args, 0);
-    PyObject *exc_value = PyStructSequence_GET_ITEM(args, 1);
-    PyObject *exc_tb = PyStructSequence_GET_ITEM(args, 2);
-    PyObject *err_msg = PyStructSequence_GET_ITEM(args, 3);
-    PyObject *obj = PyStructSequence_GET_ITEM(args, 4);
-
-    if (write_unraisable_exc(tstate, exc_type, exc_value, exc_tb, err_msg, obj) < 0) {
-        return NULL;
-    }
-    Py_RETURN_NONE;
-}
-
-
-/* Call sys.unraisablehook().
-
-   This function can be used when an exception has occurred but there is no way
-   for Python to handle it. For example, when a destructor raises an exception
-   or during garbage collection (gc.collect()).
-
-   If err_msg_str is non-NULL, the error message is formatted as:
-   "Exception ignored %s" % err_msg_str. Otherwise, use "Exception ignored in"
-   error message.
-
-   An exception must be set when calling this function. */
-void
-_PyErr_WriteUnraisableMsg(const char *err_msg_str, PyObject *obj)
-{
-    PyThreadState *tstate = _PyThreadState_GET();
-    _Py_EnsureTstateNotNULL(tstate);
-
-    PyObject *err_msg = NULL;
-    PyObject *exc_type, *exc_value, *exc_tb;
-    _PyErr_Fetch(tstate, &exc_type, &exc_value, &exc_tb);
-
-    assert(exc_type != NULL);
-
-    if (exc_type == NULL) {
-        /* sys.unraisablehook requires that at least exc_type is set */
-        goto default_hook;
-    }
-
-    if (exc_tb == NULL) {
-        PyFrameObject *frame = tstate->frame;
-        if (frame != NULL) {
-            exc_tb = _PyTraceBack_FromFrame(NULL, frame);
-            if (exc_tb == NULL) {
-                _PyErr_Clear(tstate);
+        if (PyFile_WriteObject(qualname, file, Py_PRINT_RAW) < 0) { 
+            Py_DECREF(qualname); 
+            return -1; 
+        } 
+        Py_DECREF(qualname); 
+    }
+
+    if (exc_value && exc_value != Py_None) { 
+        if (PyFile_WriteString(": ", file) < 0) { 
+            return -1; 
+        } 
+        if (PyFile_WriteObject(exc_value, file, Py_PRINT_RAW) < 0) { 
+            _PyErr_Clear(tstate); 
+            if (PyFile_WriteString("<exception str() failed>", file) < 0) { 
+                return -1; 
             }
         }
     }
-
-    _PyErr_NormalizeException(tstate, &exc_type, &exc_value, &exc_tb);
-
-    if (exc_tb != NULL && exc_tb != Py_None && PyTraceBack_Check(exc_tb)) {
-        if (PyException_SetTraceback(exc_value, exc_tb) < 0) {
-            _PyErr_Clear(tstate);
-        }
-    }
-
-    if (err_msg_str != NULL) {
-        err_msg = PyUnicode_FromFormat("Exception ignored %s", err_msg_str);
-        if (err_msg == NULL) {
-            PyErr_Clear();
-        }
-    }
-
-    PyObject *hook_args = make_unraisable_hook_args(
-        tstate, exc_type, exc_value, exc_tb, err_msg, obj);
-    if (hook_args == NULL) {
-        err_msg_str = ("Exception ignored on building "
-                       "sys.unraisablehook arguments");
-        goto error;
-    }
-
-    _Py_IDENTIFIER(unraisablehook);
-    PyObject *hook = _PySys_GetObjectId(&PyId_unraisablehook);
-    if (hook == NULL) {
-        Py_DECREF(hook_args);
-        goto default_hook;
-    }
-
-    if (_PySys_Audit(tstate, "sys.unraisablehook", "OO", hook, hook_args) < 0) {
-        Py_DECREF(hook_args);
-        err_msg_str = "Exception ignored in audit hook";
-        obj = NULL;
-        goto error;
-    }
-
-    if (hook == Py_None) {
-        Py_DECREF(hook_args);
-        goto default_hook;
-    }
-
-    PyObject *res = PyObject_CallOneArg(hook, hook_args);
-    Py_DECREF(hook_args);
-    if (res != NULL) {
-        Py_DECREF(res);
-        goto done;
-    }
-
-    /* sys.unraisablehook failed: log its error using default hook */
-    obj = hook;
-    err_msg_str = NULL;
-
-error:
-    /* err_msg_str and obj have been updated and we have a new exception */
-    Py_XSETREF(err_msg, PyUnicode_FromString(err_msg_str ?
-        err_msg_str : "Exception ignored in sys.unraisablehook"));
-    Py_XDECREF(exc_type);
-    Py_XDECREF(exc_value);
-    Py_XDECREF(exc_tb);
-    _PyErr_Fetch(tstate, &exc_type, &exc_value, &exc_tb);
-
-default_hook:
-    /* Call the default unraisable hook (ignore failure) */
-    (void)write_unraisable_exc(tstate, exc_type, exc_value, exc_tb,
-                               err_msg, obj);
-
-done:
-    Py_XDECREF(exc_type);
-    Py_XDECREF(exc_value);
-    Py_XDECREF(exc_tb);
-    Py_XDECREF(err_msg);
-    _PyErr_Clear(tstate); /* Just in case */
-}
-
-
-void
-PyErr_WriteUnraisable(PyObject *obj)
-{
-    _PyErr_WriteUnraisableMsg(NULL, obj);
-}
-
-
+ 
+    if (PyFile_WriteString("\n", file) < 0) { 
+        return -1; 
+    } 
+ 
+    /* Explicitly call file.flush() */ 
+    PyObject *res = _PyObject_CallMethodIdNoArgs(file, &PyId_flush); 
+    if (!res) { 
+        return -1; 
+    } 
+    Py_DECREF(res); 
+ 
+    return 0; 
+} 
+
+ 
+static int 
+write_unraisable_exc(PyThreadState *tstate, PyObject *exc_type, 
+                     PyObject *exc_value, PyObject *exc_tb, PyObject *err_msg, 
+                     PyObject *obj) 
+{ 
+    PyObject *file = _PySys_GetObjectId(&PyId_stderr); 
+    if (file == NULL || file == Py_None) { 
+        return 0; 
+    } 
+ 
+    /* Hold a strong reference to ensure that sys.stderr doesn't go away 
+       while we use it */ 
+    Py_INCREF(file); 
+    int res = write_unraisable_exc_file(tstate, exc_type, exc_value, exc_tb, 
+                                        err_msg, obj, file); 
+    Py_DECREF(file); 
+ 
+    return res; 
+} 
+ 
+ 
+PyObject* 
+_PyErr_WriteUnraisableDefaultHook(PyObject *args) 
+{ 
+    PyThreadState *tstate = _PyThreadState_GET(); 
+ 
+    if (!Py_IS_TYPE(args, &UnraisableHookArgsType)) { 
+        _PyErr_SetString(tstate, PyExc_TypeError, 
+                         "sys.unraisablehook argument type " 
+                         "must be UnraisableHookArgs"); 
+        return NULL; 
+    } 
+ 
+    /* Borrowed references */ 
+    PyObject *exc_type = PyStructSequence_GET_ITEM(args, 0); 
+    PyObject *exc_value = PyStructSequence_GET_ITEM(args, 1); 
+    PyObject *exc_tb = PyStructSequence_GET_ITEM(args, 2); 
+    PyObject *err_msg = PyStructSequence_GET_ITEM(args, 3); 
+    PyObject *obj = PyStructSequence_GET_ITEM(args, 4); 
+ 
+    if (write_unraisable_exc(tstate, exc_type, exc_value, exc_tb, err_msg, obj) < 0) { 
+        return NULL; 
+    } 
+    Py_RETURN_NONE; 
+} 
+ 
+ 
+/* Call sys.unraisablehook(). 
+ 
+   This function can be used when an exception has occurred but there is no way 
+   for Python to handle it. For example, when a destructor raises an exception 
+   or during garbage collection (gc.collect()). 
+ 
+   If err_msg_str is non-NULL, the error message is formatted as: 
+   "Exception ignored %s" % err_msg_str. Otherwise, use "Exception ignored in" 
+   error message. 
+ 
+   An exception must be set when calling this function. */ 
+void 
+_PyErr_WriteUnraisableMsg(const char *err_msg_str, PyObject *obj) 
+{ 
+    PyThreadState *tstate = _PyThreadState_GET(); 
+    _Py_EnsureTstateNotNULL(tstate); 
+ 
+    PyObject *err_msg = NULL; 
+    PyObject *exc_type, *exc_value, *exc_tb; 
+    _PyErr_Fetch(tstate, &exc_type, &exc_value, &exc_tb); 
+ 
+    assert(exc_type != NULL); 
+ 
+    if (exc_type == NULL) { 
+        /* sys.unraisablehook requires that at least exc_type is set */ 
+        goto default_hook; 
+    } 
+ 
+    if (exc_tb == NULL) { 
+        PyFrameObject *frame = tstate->frame; 
+        if (frame != NULL) { 
+            exc_tb = _PyTraceBack_FromFrame(NULL, frame); 
+            if (exc_tb == NULL) { 
+                _PyErr_Clear(tstate); 
+            } 
+        } 
+    } 
+ 
+    _PyErr_NormalizeException(tstate, &exc_type, &exc_value, &exc_tb); 
+ 
+    if (exc_tb != NULL && exc_tb != Py_None && PyTraceBack_Check(exc_tb)) { 
+        if (PyException_SetTraceback(exc_value, exc_tb) < 0) { 
+            _PyErr_Clear(tstate); 
+        } 
+    } 
+ 
+    if (err_msg_str != NULL) { 
+        err_msg = PyUnicode_FromFormat("Exception ignored %s", err_msg_str); 
+        if (err_msg == NULL) { 
+            PyErr_Clear(); 
+        } 
+    } 
+ 
+    PyObject *hook_args = make_unraisable_hook_args( 
+        tstate, exc_type, exc_value, exc_tb, err_msg, obj); 
+    if (hook_args == NULL) { 
+        err_msg_str = ("Exception ignored on building " 
+                       "sys.unraisablehook arguments"); 
+        goto error; 
+    } 
+ 
+    _Py_IDENTIFIER(unraisablehook); 
+    PyObject *hook = _PySys_GetObjectId(&PyId_unraisablehook); 
+    if (hook == NULL) { 
+        Py_DECREF(hook_args); 
+        goto default_hook; 
+    } 
+ 
+    if (_PySys_Audit(tstate, "sys.unraisablehook", "OO", hook, hook_args) < 0) { 
+        Py_DECREF(hook_args); 
+        err_msg_str = "Exception ignored in audit hook"; 
+        obj = NULL; 
+        goto error; 
+    } 
+ 
+    if (hook == Py_None) { 
+        Py_DECREF(hook_args); 
+        goto default_hook; 
+    } 
+ 
+    PyObject *res = PyObject_CallOneArg(hook, hook_args); 
+    Py_DECREF(hook_args); 
+    if (res != NULL) { 
+        Py_DECREF(res); 
+        goto done; 
+    } 
+ 
+    /* sys.unraisablehook failed: log its error using default hook */ 
+    obj = hook; 
+    err_msg_str = NULL; 
+ 
+error: 
+    /* err_msg_str and obj have been updated and we have a new exception */ 
+    Py_XSETREF(err_msg, PyUnicode_FromString(err_msg_str ? 
+        err_msg_str : "Exception ignored in sys.unraisablehook")); 
+    Py_XDECREF(exc_type); 
+    Py_XDECREF(exc_value); 
+    Py_XDECREF(exc_tb); 
+    _PyErr_Fetch(tstate, &exc_type, &exc_value, &exc_tb); 
+ 
+default_hook: 
+    /* Call the default unraisable hook (ignore failure) */ 
+    (void)write_unraisable_exc(tstate, exc_type, exc_value, exc_tb, 
+                               err_msg, obj); 
+ 
+done: 
+    Py_XDECREF(exc_type); 
+    Py_XDECREF(exc_value); 
+    Py_XDECREF(exc_tb); 
+    Py_XDECREF(err_msg); 
+    _PyErr_Clear(tstate); /* Just in case */ 
+}
+
+ 
+void 
+PyErr_WriteUnraisable(PyObject *obj) 
+{ 
+    _PyErr_WriteUnraisableMsg(NULL, obj); 
+} 
+ 
+ 
 extern PyObject *PyModule_GetWarningsModule(void);
 
 
@@ -1585,43 +1585,43 @@ PyErr_SyntaxLocationObject(PyObject *filename, int lineno, int col_offset)
     _Py_IDENTIFIER(offset);
     _Py_IDENTIFIER(print_file_and_line);
     _Py_IDENTIFIER(text);
-    PyThreadState *tstate = _PyThreadState_GET();
+    PyThreadState *tstate = _PyThreadState_GET(); 
 
     /* add attributes for the line number and filename for the error */
-    _PyErr_Fetch(tstate, &exc, &v, &tb);
-    _PyErr_NormalizeException(tstate, &exc, &v, &tb);
+    _PyErr_Fetch(tstate, &exc, &v, &tb); 
+    _PyErr_NormalizeException(tstate, &exc, &v, &tb); 
     /* XXX check that it is, indeed, a syntax error. It might not
      * be, though. */
     tmp = PyLong_FromLong(lineno);
     if (tmp == NULL)
-        _PyErr_Clear(tstate);
+        _PyErr_Clear(tstate); 
     else {
-        if (_PyObject_SetAttrId(v, &PyId_lineno, tmp)) {
-            _PyErr_Clear(tstate);
-        }
+        if (_PyObject_SetAttrId(v, &PyId_lineno, tmp)) { 
+            _PyErr_Clear(tstate); 
+        } 
         Py_DECREF(tmp);
     }
     tmp = NULL;
     if (col_offset >= 0) {
         tmp = PyLong_FromLong(col_offset);
-        if (tmp == NULL) {
-            _PyErr_Clear(tstate);
-        }
-    }
-    if (_PyObject_SetAttrId(v, &PyId_offset, tmp ? tmp : Py_None)) {
-        _PyErr_Clear(tstate);
+        if (tmp == NULL) { 
+            _PyErr_Clear(tstate); 
+        } 
     }
+    if (_PyObject_SetAttrId(v, &PyId_offset, tmp ? tmp : Py_None)) { 
+        _PyErr_Clear(tstate); 
+    } 
     Py_XDECREF(tmp);
     if (filename != NULL) {
-        if (_PyObject_SetAttrId(v, &PyId_filename, filename)) {
-            _PyErr_Clear(tstate);
-        }
+        if (_PyObject_SetAttrId(v, &PyId_filename, filename)) { 
+            _PyErr_Clear(tstate); 
+        } 
 
         tmp = PyErr_ProgramTextObject(filename, lineno);
         if (tmp) {
-            if (_PyObject_SetAttrId(v, &PyId_text, tmp)) {
-                _PyErr_Clear(tstate);
-            }
+            if (_PyObject_SetAttrId(v, &PyId_text, tmp)) { 
+                _PyErr_Clear(tstate); 
+            } 
             Py_DECREF(tmp);
         }
     }
@@ -1629,39 +1629,39 @@ PyErr_SyntaxLocationObject(PyObject *filename, int lineno, int col_offset)
         if (!_PyObject_HasAttrId(v, &PyId_msg)) {
             tmp = PyObject_Str(v);
             if (tmp) {
-                if (_PyObject_SetAttrId(v, &PyId_msg, tmp)) {
-                    _PyErr_Clear(tstate);
-                }
+                if (_PyObject_SetAttrId(v, &PyId_msg, tmp)) { 
+                    _PyErr_Clear(tstate); 
+                } 
                 Py_DECREF(tmp);
             }
-            else {
-                _PyErr_Clear(tstate);
-            }
+            else { 
+                _PyErr_Clear(tstate); 
+            } 
         }
         if (!_PyObject_HasAttrId(v, &PyId_print_file_and_line)) {
             if (_PyObject_SetAttrId(v, &PyId_print_file_and_line,
-                                    Py_None)) {
-                _PyErr_Clear(tstate);
-            }
+                                    Py_None)) { 
+                _PyErr_Clear(tstate); 
+            } 
         }
     }
-    _PyErr_Restore(tstate, exc, v, tb);
+    _PyErr_Restore(tstate, exc, v, tb); 
 }
 
 void
 PyErr_SyntaxLocationEx(const char *filename, int lineno, int col_offset)
 {
-    PyThreadState *tstate = _PyThreadState_GET();
+    PyThreadState *tstate = _PyThreadState_GET(); 
     PyObject *fileobj;
     if (filename != NULL) {
         fileobj = PyUnicode_DecodeFSDefault(filename);
-        if (fileobj == NULL) {
-            _PyErr_Clear(tstate);
-        }
+        if (fileobj == NULL) { 
+            _PyErr_Clear(tstate); 
+        } 
     }
-    else {
+    else { 
         fileobj = NULL;
-    }
+    } 
     PyErr_SyntaxLocationObject(fileobj, lineno, col_offset);
     Py_XDECREF(fileobj);
 }
@@ -1673,22 +1673,22 @@ PyErr_SyntaxLocationEx(const char *filename, int lineno, int col_offset)
    functionality in tb_displayline() in traceback.c. */
 
 static PyObject *
-err_programtext(PyThreadState *tstate, FILE *fp, int lineno)
+err_programtext(PyThreadState *tstate, FILE *fp, int lineno) 
 {
     int i;
     char linebuf[1000];
-    if (fp == NULL) {
-        return NULL;
-    }
+    if (fp == NULL) { 
+        return NULL; 
+    } 
 
     for (i = 0; i < lineno; i++) {
         char *pLastChar = &linebuf[sizeof(linebuf) - 2];
         do {
             *pLastChar = '\0';
             if (Py_UniversalNewlineFgets(linebuf, sizeof linebuf,
-                                         fp, NULL) == NULL) {
-                goto after_loop;
-            }
+                                         fp, NULL) == NULL) { 
+                goto after_loop; 
+            } 
             /* fgets read *something*; if it didn't get as
                far as pLastChar, it must have found a newline
                or hit the end of the file; if pLastChar is \n,
@@ -1696,14 +1696,14 @@ err_programtext(PyThreadState *tstate, FILE *fp, int lineno)
                yet seen a newline, so must continue */
         } while (*pLastChar != '\0' && *pLastChar != '\n');
     }
-
-after_loop:
+ 
+after_loop: 
     fclose(fp);
     if (i == lineno) {
         PyObject *res;
         res = PyUnicode_FromString(linebuf);
         if (res == NULL)
-            _PyErr_Clear(tstate);
+            _PyErr_Clear(tstate); 
         return res;
     }
     return NULL;
@@ -1713,28 +1713,28 @@ PyObject *
 PyErr_ProgramText(const char *filename, int lineno)
 {
     FILE *fp;
-    if (filename == NULL || *filename == '\0' || lineno <= 0) {
+    if (filename == NULL || *filename == '\0' || lineno <= 0) { 
         return NULL;
-    }
-    PyThreadState *tstate = _PyThreadState_GET();
+    } 
+    PyThreadState *tstate = _PyThreadState_GET(); 
     fp = _Py_fopen(filename, "r" PY_STDIOTEXTMODE);
-    return err_programtext(tstate, fp, lineno);
+    return err_programtext(tstate, fp, lineno); 
 }
 
 PyObject *
 PyErr_ProgramTextObject(PyObject *filename, int lineno)
 {
-    if (filename == NULL || lineno <= 0) {
+    if (filename == NULL || lineno <= 0) { 
         return NULL;
-    }
-
-    PyThreadState *tstate = _PyThreadState_GET();
-    FILE *fp = _Py_fopen_obj(filename, "r" PY_STDIOTEXTMODE);
+    } 
+ 
+    PyThreadState *tstate = _PyThreadState_GET(); 
+    FILE *fp = _Py_fopen_obj(filename, "r" PY_STDIOTEXTMODE); 
     if (fp == NULL) {
-        _PyErr_Clear(tstate);
+        _PyErr_Clear(tstate); 
         return NULL;
     }
-    return err_programtext(tstate, fp, lineno);
+    return err_programtext(tstate, fp, lineno); 
 }
 
 #ifdef __cplusplus