Changeset 388 for python/vendor/current/Python/pythonrun.c

Timestamp:

Mar 19, 2014, 11:11:30 AM (11 years ago)

Author:

dmik

Message:

python: Update vendor to 2.7.6.

File:

• python/vendor/current/Python/pythonrun.c (modified) (62 diffs)

python/vendor/current/Python/pythonrun.c

@@ -41 +41 @@
 #define PRINT_TOTAL_REFS()
 #else /* Py_REF_DEBUG */
-#define PRINT_TOTAL_REFS() fprintf(stderr,                              \
-                                   "[%" PY_FORMAT_SIZE_T "d refs]\n",   \
-                                   _Py_GetRefTotal())
+#define PRINT_TOTAL_REFS() fprintf(stderr,                              \
+                   "[%" PY_FORMAT_SIZE_T "d refs]\n",                   \
+                   _Py_GetRefTotal())
 #endif
 
@@ -58 +58 @@
 static void initsite(void);
 static PyObject *run_mod(mod_ty, const char *, PyObject *, PyObject *,
-                          PyCompilerFlags *, PyArena *);
+                          PyCompilerFlags *, PyArena *);
 static PyObject *run_pyc_file(FILE *, const char *, PyObject *, PyObject *,
-                              PyCompilerFlags *);
+                              PyCompilerFlags *);
 static void err_input(perrdetail *);
 static void initsigs(void);
@@ -77 +77 @@
 int Py_VerboseFlag; /* Needed by import.c */
 int Py_InteractiveFlag; /* Needed by Py_FdIsInteractive() below */
-int Py_InspectFlag; /* Needed to determine whether to exit at SystemError */
+int Py_InspectFlag; /* Needed to determine whether to exit at SystemExit */
 int Py_NoSiteFlag; /* Suppress 'import site' */
 int Py_BytesWarningFlag; /* Warn on str(bytes) and str(buffer) */
@@ -90 +90 @@
 int _Py_QnewFlag = 0;
 int Py_NoUserSiteDirectory = 0; /* for -s and site.py */
+int Py_HashRandomizationFlag = 0; /* for -R and PYTHONHASHSEED */
+
+
+/* Hack to force loading of object files */
+int (*_PyOS_mystrnicmp_hack)(const char *, const char *, Py_ssize_t) = \
+    PyOS_mystrnicmp; /* Python/pystrcmp.o */
 
 /* PyModule_GetWarningsModule is no longer necessary as of 2.6
@@ -96 +102 @@
 PyModule_GetWarningsModule(void)
 {
-        return PyImport_ImportModule("warnings");
+    return PyImport_ImportModule("warnings");
 }
 
@@ -106 +112 @@
 Py_IsInitialized(void)
 {
-        return initialized;
+    return initialized;
 }
 
@@ -124 +130 @@
 add_flag(int flag, const char *envs)
 {
-        int env = atoi(envs);
-        if (flag < env)
-                flag = env;
-        if (flag < 1)
-                flag = 1;
-        return flag;
+    int env = atoi(envs);
+    if (flag < env)
+        flag = env;
+    if (flag < 1)
+        flag = 1;
+    return flag;
 }
 
@@ -135 +141 @@
 Py_InitializeEx(int install_sigs)
 {
-        PyInterpreterState *interp;
-        PyThreadState *tstate;
-        PyObject *bimod, *sysmod;
-        char *p;
-        char *icodeset = NULL; /* On Windows, input codeset may theoretically 
-                                  differ from output codeset. */
-        char *codeset = NULL;
-        char *errors = NULL;
-        int free_codeset = 0;
-        int overridden = 0;
-        PyObject *sys_stream, *sys_isatty;
+    PyInterpreterState *interp;
+    PyThreadState *tstate;
+    PyObject *bimod, *sysmod;
+    char *p;
+    char *icodeset = NULL; /* On Windows, input codeset may theoretically
+                              differ from output codeset. */
+    char *codeset = NULL;
+    char *errors = NULL;
+    int free_codeset = 0;
+    int overridden = 0;
+    PyObject *sys_stream, *sys_isatty;
 #if defined(Py_USING_UNICODE) && defined(HAVE_LANGINFO_H) && defined(CODESET)
-        char *saved_locale, *loc_codeset;
+    char *saved_locale, *loc_codeset;
 #endif
 #ifdef MS_WINDOWS
-        char ibuf[128];
-        char buf[128];
-#endif
-        extern void _Py_ReadyTypes(void);
-
-        if (initialized)
-                return;
-        initialized = 1;
-
-        if ((p = Py_GETENV("PYTHONDEBUG")) && *p != '\0')
-                Py_DebugFlag = add_flag(Py_DebugFlag, p);
-        if ((p = Py_GETENV("PYTHONVERBOSE")) && *p != '\0')
-                Py_VerboseFlag = add_flag(Py_VerboseFlag, p);
-        if ((p = Py_GETENV("PYTHONOPTIMIZE")) && *p != '\0')
-                Py_OptimizeFlag = add_flag(Py_OptimizeFlag, p);
-        if ((p = Py_GETENV("PYTHONDONTWRITEBYTECODE")) && *p != '\0')
-                Py_DontWriteBytecodeFlag = add_flag(Py_DontWriteBytecodeFlag, p);
-
-        interp = PyInterpreterState_New();
-        if (interp == NULL)
-                Py_FatalError("Py_Initialize: can't make first interpreter");
-
-        tstate = PyThreadState_New(interp);
-        if (tstate == NULL)
-                Py_FatalError("Py_Initialize: can't make first thread");
-        (void) PyThreadState_Swap(tstate);
-
-        _Py_ReadyTypes();
-
-        if (!_PyFrame_Init())
-                Py_FatalError("Py_Initialize: can't init frames");
-
-        if (!_PyInt_Init())
-                Py_FatalError("Py_Initialize: can't init ints");
-
-        if (!PyByteArray_Init())
-                Py_FatalError("Py_Initialize: can't init bytearray");
-
-        _PyFloat_Init();
-
-        interp->modules = PyDict_New();
-        if (interp->modules == NULL)
-                Py_FatalError("Py_Initialize: can't make modules dictionary");
-        interp->modules_reloading = PyDict_New();
-        if (interp->modules_reloading == NULL)
-                Py_FatalError("Py_Initialize: can't make modules_reloading dictionary");
+    char ibuf[128];
+    char buf[128];
+#endif
+    extern void _Py_ReadyTypes(void);
+
+    if (initialized)
+        return;
+    initialized = 1;
+
+    if ((p = Py_GETENV("PYTHONDEBUG")) && *p != '\0')
+        Py_DebugFlag = add_flag(Py_DebugFlag, p);
+    if ((p = Py_GETENV("PYTHONVERBOSE")) && *p != '\0')
+        Py_VerboseFlag = add_flag(Py_VerboseFlag, p);
+    if ((p = Py_GETENV("PYTHONOPTIMIZE")) && *p != '\0')
+        Py_OptimizeFlag = add_flag(Py_OptimizeFlag, p);
+    if ((p = Py_GETENV("PYTHONDONTWRITEBYTECODE")) && *p != '\0')
+        Py_DontWriteBytecodeFlag = add_flag(Py_DontWriteBytecodeFlag, p);
+    /* The variable is only tested for existence here; _PyRandom_Init will
+       check its value further. */
+    if ((p = Py_GETENV("PYTHONHASHSEED")) && *p != '\0')
+        Py_HashRandomizationFlag = add_flag(Py_HashRandomizationFlag, p);
+
+    _PyRandom_Init();
+
+    interp = PyInterpreterState_New();
+    if (interp == NULL)
+        Py_FatalError("Py_Initialize: can't make first interpreter");
+
+    tstate = PyThreadState_New(interp);
+    if (tstate == NULL)
+        Py_FatalError("Py_Initialize: can't make first thread");
+    (void) PyThreadState_Swap(tstate);
+
+    _Py_ReadyTypes();
+
+    if (!_PyFrame_Init())
+        Py_FatalError("Py_Initialize: can't init frames");
+
+    if (!_PyInt_Init())
+        Py_FatalError("Py_Initialize: can't init ints");
+
+    if (!_PyLong_Init())
+        Py_FatalError("Py_Initialize: can't init longs");
+
+    if (!PyByteArray_Init())
+        Py_FatalError("Py_Initialize: can't init bytearray");
+
+    _PyFloat_Init();
+
+    interp->modules = PyDict_New();
+    if (interp->modules == NULL)
+        Py_FatalError("Py_Initialize: can't make modules dictionary");
+    interp->modules_reloading = PyDict_New();
+    if (interp->modules_reloading == NULL)
+        Py_FatalError("Py_Initialize: can't make modules_reloading dictionary");
 
 #ifdef Py_USING_UNICODE
-        /* Init Unicode implementation; relies on the codec registry */
-        _PyUnicode_Init();
-#endif
-
-        bimod = _PyBuiltin_Init();
-        if (bimod == NULL)
-                Py_FatalError("Py_Initialize: can't initialize __builtin__");
-        interp->builtins = PyModule_GetDict(bimod);
-        if (interp->builtins == NULL)
-                Py_FatalError("Py_Initialize: can't initialize builtins dict");
-        Py_INCREF(interp->builtins);
-
-        sysmod = _PySys_Init();
-        if (sysmod == NULL)
-                Py_FatalError("Py_Initialize: can't initialize sys");
-        interp->sysdict = PyModule_GetDict(sysmod);
-        if (interp->sysdict == NULL)
-                Py_FatalError("Py_Initialize: can't initialize sys dict");
-        Py_INCREF(interp->sysdict);
-        _PyImport_FixupExtension("sys", "sys");
-        PySys_SetPath(Py_GetPath());
-        PyDict_SetItemString(interp->sysdict, "modules",
-                             interp->modules);
-
-        _PyImport_Init();
-
-        /* initialize builtin exceptions */
-        _PyExc_Init();
-        _PyImport_FixupExtension("exceptions", "exceptions");
-
-        /* phase 2 of builtins */
-        _PyImport_FixupExtension("__builtin__", "__builtin__");
-
-        _PyImportHooks_Init();
-
-        if (install_sigs)
-                initsigs(); /* Signal handling stuff, including initintr() */
-                
-        /* Initialize warnings. */
-        _PyWarnings_Init();
-        if (PySys_HasWarnOptions()) {
-                PyObject *warnings_module = PyImport_ImportModule("warnings");
-                if (!warnings_module)
-                        PyErr_Clear();
-                Py_XDECREF(warnings_module);
-        }
-
-        initmain(); /* Module __main__ */
-        if (!Py_NoSiteFlag)
-                initsite(); /* Module site */
-
-        /* auto-thread-state API, if available */
+    /* Init Unicode implementation; relies on the codec registry */
+    _PyUnicode_Init();
+#endif
+
+    bimod = _PyBuiltin_Init();
+    if (bimod == NULL)
+        Py_FatalError("Py_Initialize: can't initialize __builtin__");
+    interp->builtins = PyModule_GetDict(bimod);
+    if (interp->builtins == NULL)
+        Py_FatalError("Py_Initialize: can't initialize builtins dict");
+    Py_INCREF(interp->builtins);
+
+    sysmod = _PySys_Init();
+    if (sysmod == NULL)
+        Py_FatalError("Py_Initialize: can't initialize sys");
+    interp->sysdict = PyModule_GetDict(sysmod);
+    if (interp->sysdict == NULL)
+        Py_FatalError("Py_Initialize: can't initialize sys dict");
+    Py_INCREF(interp->sysdict);
+    _PyImport_FixupExtension("sys", "sys");
+    PySys_SetPath(Py_GetPath());
+    PyDict_SetItemString(interp->sysdict, "modules",
+                         interp->modules);
+
+    _PyImport_Init();
+
+    /* initialize builtin exceptions */
+    _PyExc_Init();
+    _PyImport_FixupExtension("exceptions", "exceptions");
+
+    /* phase 2 of builtins */
+    _PyImport_FixupExtension("__builtin__", "__builtin__");
+
+    _PyImportHooks_Init();
+
+    if (install_sigs)
+        initsigs(); /* Signal handling stuff, including initintr() */
+
+    /* Initialize warnings. */
+    _PyWarnings_Init();
+    if (PySys_HasWarnOptions()) {
+        PyObject *warnings_module = PyImport_ImportModule("warnings");
+        if (!warnings_module)
+            PyErr_Clear();
+        Py_XDECREF(warnings_module);
+    }
+
+    initmain(); /* Module __main__ */
+
+    /* auto-thread-state API, if available */
 #ifdef WITH_THREAD
-        _PyGILState_Init(interp, tstate);
+    _PyGILState_Init(interp, tstate);
 #endif /* WITH_THREAD */
 
-        if ((p = Py_GETENV("PYTHONIOENCODING")) && *p != '\0') {
-                p = icodeset = codeset = strdup(p);
-                free_codeset = 1;
-                errors = strchr(p, ':');
-                if (errors) {
-                        *errors = '\0';
-                        errors++;
-                }
-                overridden = 1;
-        }
+    if (!Py_NoSiteFlag)
+        initsite(); /* Module site */
+
+    if ((p = Py_GETENV("PYTHONIOENCODING")) && *p != '\0') {
+        p = icodeset = codeset = strdup(p);
+        free_codeset = 1;
+        errors = strchr(p, ':');
+        if (errors) {
+            *errors = '\0';
+            errors++;
+        }
+        overridden = 1;
+    }
 
 #if defined(Py_USING_UNICODE) && defined(HAVE_LANGINFO_H) && defined(CODESET)
-        /* On Unix, set the file system encoding according to the
-           user's preference, if the CODESET names a well-known
-           Python codec, and Py_FileSystemDefaultEncoding isn't
-           initialized by other means. Also set the encoding of
-           stdin and stdout if these are terminals, unless overridden.  */
-
-        if (!overridden || !Py_FileSystemDefaultEncoding) {
-                saved_locale = strdup(setlocale(LC_CTYPE, NULL));
-                setlocale(LC_CTYPE, "");
-                loc_codeset = nl_langinfo(CODESET);
-                if (loc_codeset && *loc_codeset) {
-                        PyObject *enc = PyCodec_Encoder(loc_codeset);
-                        if (enc) {
-                                loc_codeset = strdup(loc_codeset);
-                                Py_DECREF(enc);
-                        } else {
-                                loc_codeset = NULL;
-                                PyErr_Clear();
-                        }
-                } else
-                        loc_codeset = NULL;
-                setlocale(LC_CTYPE, saved_locale);
-                free(saved_locale);
-
-                if (!overridden) {
-                        codeset = icodeset = loc_codeset;
-                        free_codeset = 1;
-                }
-
-                /* Initialize Py_FileSystemDefaultEncoding from
-                   locale even if PYTHONIOENCODING is set. */
-                if (!Py_FileSystemDefaultEncoding) {
-                        Py_FileSystemDefaultEncoding = loc_codeset;
-                        if (!overridden)
-                                free_codeset = 0;
-                }
-        }
+    /* On Unix, set the file system encoding according to the
+       user's preference, if the CODESET names a well-known
+       Python codec, and Py_FileSystemDefaultEncoding isn't
+       initialized by other means. Also set the encoding of
+       stdin and stdout if these are terminals, unless overridden.  */
+
+    if (!overridden || !Py_FileSystemDefaultEncoding) {
+        saved_locale = strdup(setlocale(LC_CTYPE, NULL));
+        setlocale(LC_CTYPE, "");
+        loc_codeset = nl_langinfo(CODESET);
+        if (loc_codeset && *loc_codeset) {
+            PyObject *enc = PyCodec_Encoder(loc_codeset);
+            if (enc) {
+                loc_codeset = strdup(loc_codeset);
+                Py_DECREF(enc);
+            } else {
+                if (PyErr_ExceptionMatches(PyExc_LookupError)) {
+                    PyErr_Clear();
+                    loc_codeset = NULL;
+                } else {
+                    PyErr_Print();
+                    exit(1);
+                }
+            }
+        } else
+            loc_codeset = NULL;
+        setlocale(LC_CTYPE, saved_locale);
+        free(saved_locale);
+
+        if (!overridden) {
+            codeset = icodeset = loc_codeset;
+            free_codeset = 1;
+        }
+
+        /* Initialize Py_FileSystemDefaultEncoding from
+           locale even if PYTHONIOENCODING is set. */
+        if (!Py_FileSystemDefaultEncoding) {
+            Py_FileSystemDefaultEncoding = loc_codeset;
+            if (!overridden)
+                free_codeset = 0;
+        }
+    }
 #endif
 
 #ifdef MS_WINDOWS
-        if (!overridden) {
-                icodeset = ibuf;
-                codeset = buf;
-                sprintf(ibuf, "cp%d", GetConsoleCP());
-                sprintf(buf, "cp%d", GetConsoleOutputCP());
-        }
-#endif
-
-        if (codeset) {
-                sys_stream = PySys_GetObject("stdin");
-                sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");
-                if (!sys_isatty)
-                        PyErr_Clear();
-                if ((overridden ||
-                     (sys_isatty && PyObject_IsTrue(sys_isatty))) &&
-                   PyFile_Check(sys_stream)) {
-                        if (!PyFile_SetEncodingAndErrors(sys_stream, icodeset, errors))
-                                Py_FatalError("Cannot set codeset of stdin");
-                }
-                Py_XDECREF(sys_isatty);
-
-                sys_stream = PySys_GetObject("stdout");
-                sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");
-                if (!sys_isatty)
-                        PyErr_Clear();
-                if ((overridden || 
-                     (sys_isatty && PyObject_IsTrue(sys_isatty))) &&
-                   PyFile_Check(sys_stream)) {
-                        if (!PyFile_SetEncodingAndErrors(sys_stream, codeset, errors))
-                                Py_FatalError("Cannot set codeset of stdout");
-                }
-                Py_XDECREF(sys_isatty);
-
-                sys_stream = PySys_GetObject("stderr");
-                sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");
-                if (!sys_isatty)
-                        PyErr_Clear();
-                if((overridden || 
-                    (sys_isatty && PyObject_IsTrue(sys_isatty))) &&
-                   PyFile_Check(sys_stream)) {
-                        if (!PyFile_SetEncodingAndErrors(sys_stream, codeset, errors))
-                                Py_FatalError("Cannot set codeset of stderr");
-                }
-                Py_XDECREF(sys_isatty);
-
-                if (free_codeset)
-                        free(codeset);
-        }
+    if (!overridden) {
+        icodeset = ibuf;
+        codeset = buf;
+        sprintf(ibuf, "cp%d", GetConsoleCP());
+        sprintf(buf, "cp%d", GetConsoleOutputCP());
+    }
+#endif
+
+    if (codeset) {
+        sys_stream = PySys_GetObject("stdin");
+        sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");
+        if (!sys_isatty)
+            PyErr_Clear();
+        if ((overridden ||
+             (sys_isatty && PyObject_IsTrue(sys_isatty))) &&
+           PyFile_Check(sys_stream)) {
+            if (!PyFile_SetEncodingAndErrors(sys_stream, icodeset, errors))
+                Py_FatalError("Cannot set codeset of stdin");
+        }
+        Py_XDECREF(sys_isatty);
+
+        sys_stream = PySys_GetObject("stdout");
+        sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");
+        if (!sys_isatty)
+            PyErr_Clear();
+        if ((overridden ||
+             (sys_isatty && PyObject_IsTrue(sys_isatty))) &&
+           PyFile_Check(sys_stream)) {
+            if (!PyFile_SetEncodingAndErrors(sys_stream, codeset, errors))
+                Py_FatalError("Cannot set codeset of stdout");
+        }
+        Py_XDECREF(sys_isatty);
+
+        sys_stream = PySys_GetObject("stderr");
+        sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");
+        if (!sys_isatty)
+            PyErr_Clear();
+        if((overridden ||
+            (sys_isatty && PyObject_IsTrue(sys_isatty))) &&
+           PyFile_Check(sys_stream)) {
+            if (!PyFile_SetEncodingAndErrors(sys_stream, codeset, errors))
+                Py_FatalError("Cannot set codeset of stderr");
+        }
+        Py_XDECREF(sys_isatty);
+
+        if (free_codeset)
+            free(codeset);
+    }
 }
 
@@ -359 +380 @@
 Py_Initialize(void)
 {
-        Py_InitializeEx(1);
+    Py_InitializeEx(1);
 }
 
@@ -384 +405 @@
 Py_Finalize(void)
 {
-        PyInterpreterState *interp;
-        PyThreadState *tstate;
-
-        if (!initialized)
-                return;
-
-        wait_for_thread_shutdown();
-
-        /* The interpreter is still entirely intact at this point, and the
-         * exit funcs may be relying on that.  In particular, if some thread
-         * or exit func is still waiting to do an import, the import machinery
-         * expects Py_IsInitialized() to return true.  So don't say the
-         * interpreter is uninitialized until after the exit funcs have run.
-         * Note that Threading.py uses an exit func to do a join on all the
-         * threads created thru it, so this also protects pending imports in
-         * the threads created via Threading.
-         */
-        call_sys_exitfunc();
-        initialized = 0;
-
-        /* Get current thread state and interpreter pointer */
-        tstate = PyThreadState_GET();
-        interp = tstate->interp;
-
-        /* Disable signal handling */
-        PyOS_FiniInterrupts();
-
-        /* Clear type lookup cache */
-        PyType_ClearCache();
-
-        /* Collect garbage.  This may call finalizers; it's nice to call these
-         * before all modules are destroyed.
-         * XXX If a __del__ or weakref callback is triggered here, and tries to
-         * XXX import a module, bad things can happen, because Python no
-         * XXX longer believes it's initialized.
-         * XXX     Fatal Python error: Interpreter not initialized (version mismatch?)
-         * XXX is easy to provoke that way.  I've also seen, e.g.,
-         * XXX     Exception exceptions.ImportError: 'No module named sha'
-         * XXX         in <function callback at 0x008F5718> ignored
-         * XXX but I'm unclear on exactly how that one happens.  In any case,
-         * XXX I haven't seen a real-life report of either of these.
-         */
-        PyGC_Collect();
+    PyInterpreterState *interp;
+    PyThreadState *tstate;
+
+    if (!initialized)
+        return;
+
+    wait_for_thread_shutdown();
+
+    /* The interpreter is still entirely intact at this point, and the
+     * exit funcs may be relying on that.  In particular, if some thread
+     * or exit func is still waiting to do an import, the import machinery
+     * expects Py_IsInitialized() to return true.  So don't say the
+     * interpreter is uninitialized until after the exit funcs have run.
+     * Note that Threading.py uses an exit func to do a join on all the
+     * threads created thru it, so this also protects pending imports in
+     * the threads created via Threading.
+     */
+    call_sys_exitfunc();
+    initialized = 0;
+
+    /* Get current thread state and interpreter pointer */
+    tstate = PyThreadState_GET();
+    interp = tstate->interp;
+
+    /* Disable signal handling */
+    PyOS_FiniInterrupts();
+
+    /* Clear type lookup cache */
+    PyType_ClearCache();
+
+    /* Collect garbage.  This may call finalizers; it's nice to call these
+     * before all modules are destroyed.
+     * XXX If a __del__ or weakref callback is triggered here, and tries to
+     * XXX import a module, bad things can happen, because Python no
+     * XXX longer believes it's initialized.
+     * XXX     Fatal Python error: Interpreter not initialized (version mismatch?)
+     * XXX is easy to provoke that way.  I've also seen, e.g.,
+     * XXX     Exception exceptions.ImportError: 'No module named sha'
+     * XXX         in <function callback at 0x008F5718> ignored
+     * XXX but I'm unclear on exactly how that one happens.  In any case,
+     * XXX I haven't seen a real-life report of either of these.
+     */
+    PyGC_Collect();
 #ifdef COUNT_ALLOCS
-        /* With COUNT_ALLOCS, it helps to run GC multiple times:
-           each collection might release some types from the type
-           list, so they become garbage. */
-        while (PyGC_Collect() > 0)
-                /* nothing */;
-#endif
-
-        /* Destroy all modules */
-        PyImport_Cleanup();
-
-        /* Collect final garbage.  This disposes of cycles created by
-         * new-style class definitions, for example.
-         * XXX This is disabled because it caused too many problems.  If
-         * XXX a __del__ or weakref callback triggers here, Python code has
-         * XXX a hard time running, because even the sys module has been
-         * XXX cleared out (sys.stdout is gone, sys.excepthook is gone, etc).
-         * XXX One symptom is a sequence of information-free messages
-         * XXX coming from threads (if a __del__ or callback is invoked,
-         * XXX other threads can execute too, and any exception they encounter
-         * XXX triggers a comedy of errors as subsystem after subsystem
-         * XXX fails to find what it *expects* to find in sys to help report
-         * XXX the exception and consequent unexpected failures).  I've also
-         * XXX seen segfaults then, after adding print statements to the
-         * XXX Python code getting called.
-         */
+    /* With COUNT_ALLOCS, it helps to run GC multiple times:
+       each collection might release some types from the type
+       list, so they become garbage. */
+    while (PyGC_Collect() > 0)
+        /* nothing */;
+#endif
+
+    /* Destroy all modules */
+    PyImport_Cleanup();
+
+    /* Collect final garbage.  This disposes of cycles created by
+     * new-style class definitions, for example.
+     * XXX This is disabled because it caused too many problems.  If
+     * XXX a __del__ or weakref callback triggers here, Python code has
+     * XXX a hard time running, because even the sys module has been
+     * XXX cleared out (sys.stdout is gone, sys.excepthook is gone, etc).
+     * XXX One symptom is a sequence of information-free messages
+     * XXX coming from threads (if a __del__ or callback is invoked,
+     * XXX other threads can execute too, and any exception they encounter
+     * XXX triggers a comedy of errors as subsystem after subsystem
+     * XXX fails to find what it *expects* to find in sys to help report
+     * XXX the exception and consequent unexpected failures).  I've also
+     * XXX seen segfaults then, after adding print statements to the
+     * XXX Python code getting called.
+     */
 #if 0
-        PyGC_Collect();
-#endif
-
-        /* Destroy the database used by _PyImport_{Fixup,Find}Extension */
-        _PyImport_Fini();
-
-        /* Debugging stuff */
+    PyGC_Collect();
+#endif
+
+    /* Destroy the database used by _PyImport_{Fixup,Find}Extension */
+    _PyImport_Fini();
+
+    /* Debugging stuff */
 #ifdef COUNT_ALLOCS
-        dump_counts(stdout);
-#endif
-
-        PRINT_TOTAL_REFS();
+    dump_counts(stdout);
+#endif
+
+    PRINT_TOTAL_REFS();
 
 #ifdef Py_TRACE_REFS
-        /* Display all objects still alive -- this can invoke arbitrary
-         * __repr__ overrides, so requires a mostly-intact interpreter.
-         * Alas, a lot of stuff may still be alive now that will be cleaned
-         * up later.
-         */
-        if (Py_GETENV("PYTHONDUMPREFS"))
-                _Py_PrintReferences(stderr);
+    /* Display all objects still alive -- this can invoke arbitrary
+     * __repr__ overrides, so requires a mostly-intact interpreter.
+     * Alas, a lot of stuff may still be alive now that will be cleaned
+     * up later.
+     */
+    if (Py_GETENV("PYTHONDUMPREFS"))
+        _Py_PrintReferences(stderr);
 #endif /* Py_TRACE_REFS */
 
-        /* Clear interpreter state */
-        PyInterpreterState_Clear(interp);
-
-        /* Now we decref the exception classes.  After this point nothing
-           can raise an exception.  That's okay, because each Fini() method
-           below has been checked to make sure no exceptions are ever
-           raised.
-        */
-
-        _PyExc_Fini();
-
-        /* Cleanup auto-thread-state */
+    /* Clear interpreter state */
+    PyInterpreterState_Clear(interp);
+
+    /* Now we decref the exception classes.  After this point nothing
+       can raise an exception.  That's okay, because each Fini() method
+       below has been checked to make sure no exceptions are ever
+       raised.
+    */
+
+    _PyExc_Fini();
+
+    /* Cleanup auto-thread-state */
 #ifdef WITH_THREAD
-        _PyGILState_Fini();
+    _PyGILState_Fini();
 #endif /* WITH_THREAD */
 
-        /* Delete current thread */
-        PyThreadState_Swap(NULL);
-        PyInterpreterState_Delete(interp);
-
-        /* Sundry finalizers */
-        PyMethod_Fini();
-        PyFrame_Fini();
-        PyCFunction_Fini();
-        PyTuple_Fini();
-        PyList_Fini();
-        PySet_Fini();
-        PyString_Fini();
-        PyByteArray_Fini();
-        PyInt_Fini();
-        PyFloat_Fini();
-        PyDict_Fini();
+    /* Delete current thread */
+    PyThreadState_Swap(NULL);
+    PyInterpreterState_Delete(interp);
+
+    /* Sundry finalizers */
+    PyMethod_Fini();
+    PyFrame_Fini();
+    PyCFunction_Fini();
+    PyTuple_Fini();
+    PyList_Fini();
+    PySet_Fini();
+    PyString_Fini();
+    PyByteArray_Fini();
+    PyInt_Fini();
+    PyFloat_Fini();
+    PyDict_Fini();
 
 #ifdef Py_USING_UNICODE
-        /* Cleanup Unicode implementation */
-        _PyUnicode_Fini();
-#endif
-
-        /* XXX Still allocated:
-           - various static ad-hoc pointers to interned strings
-           - int and float free list blocks
-           - whatever various modules and libraries allocate
-        */
-
-        PyGrammar_RemoveAccelerators(&_PyParser_Grammar);
+    /* Cleanup Unicode implementation */
+    _PyUnicode_Fini();
+#endif
+
+    /* XXX Still allocated:
+       - various static ad-hoc pointers to interned strings
+       - int and float free list blocks
+       - whatever various modules and libraries allocate
+    */
+
+    PyGrammar_RemoveAccelerators(&_PyParser_Grammar);
 
 #ifdef Py_TRACE_REFS
-        /* Display addresses (& refcnts) of all objects still alive.
-         * An address can be used to find the repr of the object, printed
-         * above by _Py_PrintReferences.
-         */
-        if (Py_GETENV("PYTHONDUMPREFS"))
-                _Py_PrintReferenceAddresses(stderr);
+    /* Display addresses (& refcnts) of all objects still alive.
+     * An address can be used to find the repr of the object, printed
+     * above by _Py_PrintReferences.
+     */
+    if (Py_GETENV("PYTHONDUMPREFS"))
+        _Py_PrintReferenceAddresses(stderr);
 #endif /* Py_TRACE_REFS */
 #ifdef PYMALLOC_DEBUG
-        if (Py_GETENV("PYTHONMALLOCSTATS"))
-                _PyObject_DebugMallocStats();
-#endif
-
-        call_ll_exitfuncs();
+    if (Py_GETENV("PYTHONMALLOCSTATS"))
+        _PyObject_DebugMallocStats();
+#endif
+
+    call_ll_exitfuncs();
 }
 
@@ -555 +576 @@
 Py_NewInterpreter(void)
 {
-        PyInterpreterState *interp;
-        PyThreadState *tstate, *save_tstate;
-        PyObject *bimod, *sysmod;
-
-        if (!initialized)
-                Py_FatalError("Py_NewInterpreter: call Py_Initialize first");
-
-        interp = PyInterpreterState_New();
-        if (interp == NULL)
-                return NULL;
-
-        tstate = PyThreadState_New(interp);
-        if (tstate == NULL) {
-                PyInterpreterState_Delete(interp);
-                return NULL;
-        }
-
-        save_tstate = PyThreadState_Swap(tstate);
-
-        /* XXX The following is lax in error checking */
-
-        interp->modules = PyDict_New();
-        interp->modules_reloading = PyDict_New();
-
-        bimod = _PyImport_FindExtension("__builtin__", "__builtin__");
-        if (bimod != NULL) {
-                interp->builtins = PyModule_GetDict(bimod);
-                if (interp->builtins == NULL)
-                        goto handle_error;
-                Py_INCREF(interp->builtins);
-        }
-        sysmod = _PyImport_FindExtension("sys", "sys");
-        if (bimod != NULL && sysmod != NULL) {
-                interp->sysdict = PyModule_GetDict(sysmod);
-                if (interp->sysdict == NULL)
-                        goto handle_error;
-                Py_INCREF(interp->sysdict);
-                PySys_SetPath(Py_GetPath());
-                PyDict_SetItemString(interp->sysdict, "modules",
-                                     interp->modules);
-                _PyImportHooks_Init();
-                initmain();
-                if (!Py_NoSiteFlag)
-                        initsite();
-        }
-
-        if (!PyErr_Occurred())
-                return tstate;
+    PyInterpreterState *interp;
+    PyThreadState *tstate, *save_tstate;
+    PyObject *bimod, *sysmod;
+
+    if (!initialized)
+        Py_FatalError("Py_NewInterpreter: call Py_Initialize first");
+
+    interp = PyInterpreterState_New();
+    if (interp == NULL)
+        return NULL;
+
+    tstate = PyThreadState_New(interp);
+    if (tstate == NULL) {
+        PyInterpreterState_Delete(interp);
+        return NULL;
+    }
+
+    save_tstate = PyThreadState_Swap(tstate);
+
+    /* XXX The following is lax in error checking */
+
+    interp->modules = PyDict_New();
+    interp->modules_reloading = PyDict_New();
+
+    bimod = _PyImport_FindExtension("__builtin__", "__builtin__");
+    if (bimod != NULL) {
+        interp->builtins = PyModule_GetDict(bimod);
+        if (interp->builtins == NULL)
+            goto handle_error;
+        Py_INCREF(interp->builtins);
+    }
+    sysmod = _PyImport_FindExtension("sys", "sys");
+    if (bimod != NULL && sysmod != NULL) {
+        interp->sysdict = PyModule_GetDict(sysmod);
+        if (interp->sysdict == NULL)
+            goto handle_error;
+        Py_INCREF(interp->sysdict);
+        PySys_SetPath(Py_GetPath());
+        PyDict_SetItemString(interp->sysdict, "modules",
+                             interp->modules);
+        _PyImportHooks_Init();
+        initmain();
+        if (!Py_NoSiteFlag)
+            initsite();
+    }
+
+    if (!PyErr_Occurred())
+        return tstate;
 
 handle_error:
-        /* Oops, it didn't work.  Undo it all. */
-
-        PyErr_Print();
-        PyThreadState_Clear(tstate);
-        PyThreadState_Swap(save_tstate);
-        PyThreadState_Delete(tstate);
-        PyInterpreterState_Delete(interp);
-
-        return NULL;
+    /* Oops, it didn't work.  Undo it all. */
+
+    PyErr_Print();
+    PyThreadState_Clear(tstate);
+    PyThreadState_Swap(save_tstate);
+    PyThreadState_Delete(tstate);
+    PyInterpreterState_Delete(interp);
+
+    return NULL;
 }
 
@@ -631 +652 @@
 Py_EndInterpreter(PyThreadState *tstate)
 {
-        PyInterpreterState *interp = tstate->interp;
-
-        if (tstate != PyThreadState_GET())
-                Py_FatalError("Py_EndInterpreter: thread is not current");
-        if (tstate->frame != NULL)
-                Py_FatalError("Py_EndInterpreter: thread still has a frame");
-        if (tstate != interp->tstate_head || tstate->next != NULL)
-                Py_FatalError("Py_EndInterpreter: not the last thread");
-
-        PyImport_Cleanup();
-        PyInterpreterState_Clear(interp);
-        PyThreadState_Swap(NULL);
-        PyInterpreterState_Delete(interp);
+    PyInterpreterState *interp = tstate->interp;
+
+    if (tstate != PyThreadState_GET())
+        Py_FatalError("Py_EndInterpreter: thread is not current");
+    if (tstate->frame != NULL)
+        Py_FatalError("Py_EndInterpreter: thread still has a frame");
+    if (tstate != interp->tstate_head || tstate->next != NULL)
+        Py_FatalError("Py_EndInterpreter: not the last thread");
+
+    PyImport_Cleanup();
+    PyInterpreterState_Clear(interp);
+    PyThreadState_Swap(NULL);
+    PyInterpreterState_Delete(interp);
 }
 
@@ -651 +672 @@
 Py_SetProgramName(char *pn)
 {
-        if (pn && *pn)
-                progname = pn;
+    if (pn && *pn)
+        progname = pn;
 }
 
@@ -658 +679 @@
 Py_GetProgramName(void)
 {
-        return progname;
+    return progname;
 }
 
@@ -666 +687 @@
 Py_SetPythonHome(char *home)
 {
-        default_home = home;
+    default_home = home;
 }
 
@@ -672 +693 @@
 Py_GetPythonHome(void)
 {
-        char *home = default_home;
-        if (home == NULL && !Py_IgnoreEnvironmentFlag)
-                home = Py_GETENV("PYTHONHOME");
-        return home;
+    char *home = default_home;
+    if (home == NULL && !Py_IgnoreEnvironmentFlag)
+        home = Py_GETENV("PYTHONHOME");
+    return home;
 }
 
@@ -683 +704 @@
 initmain(void)
 {
-        PyObject *m, *d;
-        m = PyImport_AddModule("__main__");
-        if (m == NULL)
-                Py_FatalError("can't create __main__ module");
-        d = PyModule_GetDict(m);
-        if (PyDict_GetItemString(d, "__builtins__") == NULL) {
-                PyObject *bimod = PyImport_ImportModule("__builtin__");
-                if (bimod == NULL ||
-                    PyDict_SetItemString(d, "__builtins__", bimod) != 0)
-                        Py_FatalError("can't add __builtins__ to __main__");
-                Py_DECREF(bimod);
-        }
+    PyObject *m, *d;
+    m = PyImport_AddModule("__main__");
+    if (m == NULL)
+        Py_FatalError("can't create __main__ module");
+    d = PyModule_GetDict(m);
+    if (PyDict_GetItemString(d, "__builtins__") == NULL) {
+        PyObject *bimod = PyImport_ImportModule("__builtin__");
+        if (bimod == NULL ||
+            PyDict_SetItemString(d, "__builtins__", bimod) != 0)
+            Py_FatalError("can't add __builtins__ to __main__");
+        Py_XDECREF(bimod);
+    }
 }
 
@@ -702 +723 @@
 initsite(void)
 {
-        PyObject *m, *f;
-        m = PyImport_ImportModule("site");
-        if (m == NULL) {
-                f = PySys_GetObject("stderr");
-                if (Py_VerboseFlag) {
-                        PyFile_WriteString(
-                                "'import site' failed; traceback:\n", f);
-                        PyErr_Print();
-                }
-                else {
-                        PyFile_WriteString(
-                          "'import site' failed; use -v for traceback\n", f);
-                        PyErr_Clear();
-                }
-        }
-        else {
-                Py_DECREF(m);
-        }
+    PyObject *m;
+    m = PyImport_ImportModule("site");
+    if (m == NULL) {
+        PyErr_Print();
+        Py_Finalize();
+        exit(1);
+    }
+    else {
+        Py_DECREF(m);
+    }
 }
 
@@ -726 +739 @@
 int
 PyRun_AnyFileExFlags(FILE *fp, const char *filename, int closeit,
-                     PyCompilerFlags *flags)
-{
-        if (filename == NULL)
-                filename = "???";
-        if (Py_FdIsInteractive(fp, filename)) {
-                int err = PyRun_InteractiveLoopFlags(fp, filename, flags);
-                if (closeit)
-                        fclose(fp);
-                return err;
-        }
-        else
-                return PyRun_SimpleFileExFlags(fp, filename, closeit, flags);
+                     PyCompilerFlags *flags)
+{
+    if (filename == NULL)
+        filename = "???";
+    if (Py_FdIsInteractive(fp, filename)) {
+        int err = PyRun_InteractiveLoopFlags(fp, filename, flags);
+        if (closeit)
+            fclose(fp);
+        return err;
+    }
+    else
+        return PyRun_SimpleFileExFlags(fp, filename, closeit, flags);
 }
 
@@ -743 +756 @@
 PyRun_InteractiveLoopFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
 {
-        PyObject *v;
-        int ret;
-        PyCompilerFlags local_flags;
-
-        if (flags == NULL) {
-                flags = &local_flags;
-                local_flags.cf_flags = 0;
-        }
-        v = PySys_GetObject("ps1");
-        if (v == NULL) {
-                PySys_SetObject("ps1", v = PyString_FromString(">>> "));
-                Py_XDECREF(v);
-        }
-        v = PySys_GetObject("ps2");
-        if (v == NULL) {
-                PySys_SetObject("ps2", v = PyString_FromString("... "));
-                Py_XDECREF(v);
-        }
-        for (;;) {
-                ret = PyRun_InteractiveOneFlags(fp, filename, flags);
-                PRINT_TOTAL_REFS();
-                if (ret == E_EOF)
-                        return 0;
-                /*
-                if (ret == E_NOMEM)
-                        return -1;
-                */
-        }
+    PyObject *v;
+    int ret;
+    PyCompilerFlags local_flags;
+
+    if (flags == NULL) {
+        flags = &local_flags;
+        local_flags.cf_flags = 0;
+    }
+    v = PySys_GetObject("ps1");
+    if (v == NULL) {
+        PySys_SetObject("ps1", v = PyString_FromString(">>> "));
+        Py_XDECREF(v);
+    }
+    v = PySys_GetObject("ps2");
+    if (v == NULL) {
+        PySys_SetObject("ps2", v = PyString_FromString("... "));
+        Py_XDECREF(v);
+    }
+    for (;;) {
+        ret = PyRun_InteractiveOneFlags(fp, filename, flags);
+        PRINT_TOTAL_REFS();
+        if (ret == E_EOF)
+            return 0;
+        /*
+        if (ret == E_NOMEM)
+            return -1;
+        */
+    }
 }
 
@@ -776 +789 @@
 /* compute parser flags based on compiler flags */
 #define PARSER_FLAGS(flags) \
-        ((flags) ? ((((flags)->cf_flags & PyCF_DONT_IMPLY_DEDENT) ? \
-                      PyPARSE_DONT_IMPLY_DEDENT : 0)) : 0)
+    ((flags) ? ((((flags)->cf_flags & PyCF_DONT_IMPLY_DEDENT) ? \
+                  PyPARSE_DONT_IMPLY_DEDENT : 0)) : 0)
 #endif
 #if 1
 /* Keep an example of flags with future keyword support. */
 #define PARSER_FLAGS(flags) \
-        ((flags) ? ((((flags)->cf_flags & PyCF_DONT_IMPLY_DEDENT) ? \
-                      PyPARSE_DONT_IMPLY_DEDENT : 0) \
-                    | (((flags)->cf_flags & CO_FUTURE_PRINT_FUNCTION) ? \
-                       PyPARSE_PRINT_IS_FUNCTION : 0) \
-                    | (((flags)->cf_flags & CO_FUTURE_UNICODE_LITERALS) ? \
-                       PyPARSE_UNICODE_LITERALS : 0) \
-                    ) : 0)
+    ((flags) ? ((((flags)->cf_flags & PyCF_DONT_IMPLY_DEDENT) ? \
+                  PyPARSE_DONT_IMPLY_DEDENT : 0) \
+                | (((flags)->cf_flags & CO_FUTURE_PRINT_FUNCTION) ? \
+                   PyPARSE_PRINT_IS_FUNCTION : 0) \
+                | (((flags)->cf_flags & CO_FUTURE_UNICODE_LITERALS) ? \
+                   PyPARSE_UNICODE_LITERALS : 0) \
+                ) : 0)
 #endif
 
@@ -794 +807 @@
 PyRun_InteractiveOneFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
 {
-        PyObject *m, *d, *v, *w;
-        mod_ty mod;
-        PyArena *arena;
-        char *ps1 = "", *ps2 = "";
-        int errcode = 0;
-
-        v = PySys_GetObject("ps1");
-        if (v != NULL) {
-                v = PyObject_Str(v);
-                if (v == NULL)
-                        PyErr_Clear();
-                else if (PyString_Check(v))
-                        ps1 = PyString_AsString(v);
-        }
-        w = PySys_GetObject("ps2");
-        if (w != NULL) {
-                w = PyObject_Str(w);
-                if (w == NULL)
-                        PyErr_Clear();
-                else if (PyString_Check(w))
-                        ps2 = PyString_AsString(w);
-        }
-        arena = PyArena_New();
-        if (arena == NULL) {
-                Py_XDECREF(v);
-                Py_XDECREF(w);
-                return -1;
-        }
-        mod = PyParser_ASTFromFile(fp, filename,
-                                   Py_single_input, ps1, ps2,
-                                   flags, &errcode, arena);
-        Py_XDECREF(v);
-        Py_XDECREF(w);
-        if (mod == NULL) {
-                PyArena_Free(arena);
-                if (errcode == E_EOF) {
-                        PyErr_Clear();
-                        return E_EOF;
-                }
-                PyErr_Print();
-                return -1;
-        }
-        m = PyImport_AddModule("__main__");
-        if (m == NULL) {
-                PyArena_Free(arena);
-                return -1;
-        }
-        d = PyModule_GetDict(m);
-        v = run_mod(mod, filename, d, d, flags, arena);
-        PyArena_Free(arena);
-        if (v == NULL) {
-                PyErr_Print();
-                return -1;
-        }
-        Py_DECREF(v);
-        if (Py_FlushLine())
-                PyErr_Clear();
-        return 0;
+    PyObject *m, *d, *v, *w;
+    mod_ty mod;
+    PyArena *arena;
+    char *ps1 = "", *ps2 = "";
+    int errcode = 0;
+
+    v = PySys_GetObject("ps1");
+    if (v != NULL) {
+        v = PyObject_Str(v);
+        if (v == NULL)
+            PyErr_Clear();
+        else if (PyString_Check(v))
+            ps1 = PyString_AsString(v);
+    }
+    w = PySys_GetObject("ps2");
+    if (w != NULL) {
+        w = PyObject_Str(w);
+        if (w == NULL)
+            PyErr_Clear();
+        else if (PyString_Check(w))
+            ps2 = PyString_AsString(w);
+    }
+    arena = PyArena_New();
+    if (arena == NULL) {
+        Py_XDECREF(v);
+        Py_XDECREF(w);
+        return -1;
+    }
+    mod = PyParser_ASTFromFile(fp, filename,
+                               Py_single_input, ps1, ps2,
+                               flags, &errcode, arena);
+    Py_XDECREF(v);
+    Py_XDECREF(w);
+    if (mod == NULL) {
+        PyArena_Free(arena);
+        if (errcode == E_EOF) {
+            PyErr_Clear();
+            return E_EOF;
+        }
+        PyErr_Print();
+        return -1;
+    }
+    m = PyImport_AddModule("__main__");
+    if (m == NULL) {
+        PyArena_Free(arena);
+        return -1;
+    }
+    d = PyModule_GetDict(m);
+    v = run_mod(mod, filename, d, d, flags, arena);
+    PyArena_Free(arena);
+    if (v == NULL) {
+        PyErr_Print();
+        return -1;
+    }
+    Py_DECREF(v);
+    if (Py_FlushLine())
+        PyErr_Clear();
+    return 0;
 }
 
@@ -860 +873 @@
 maybe_pyc_file(FILE *fp, const char* filename, const char* ext, int closeit)
 {
-        if (strcmp(ext, ".pyc") == 0 || strcmp(ext, ".pyo") == 0)
-                return 1;
-
-        /* Only look into the file if we are allowed to close it, since
-           it then should also be seekable. */
-        if (closeit) {
-                /* Read only two bytes of the magic. If the file was opened in
-                   text mode, the bytes 3 and 4 of the magic (\r\n) might not
-                   be read as they are on disk. */
-                unsigned int halfmagic = PyImport_GetMagicNumber() & 0xFFFF;
-                unsigned char buf[2];
-                /* Mess:  In case of -x, the stream is NOT at its start now,
-                   and ungetc() was used to push back the first newline,
-                   which makes the current stream position formally undefined,
-                   and a x-platform nightmare.
-                   Unfortunately, we have no direct way to know whether -x
-                   was specified.  So we use a terrible hack:  if the current
-                   stream position is not 0, we assume -x was specified, and
-                   give up.  Bug 132850 on SourceForge spells out the
-                   hopelessness of trying anything else (fseek and ftell
-                   don't work predictably x-platform for text-mode files).
-                */
-                int ispyc = 0;
-                if (ftell(fp) == 0) {
-                        if (fread(buf, 1, 2, fp) == 2 &&
-                            ((unsigned int)buf[1]<<8 | buf[0]) == halfmagic)
-                                ispyc = 1;
-                        rewind(fp);
-                }
-                return ispyc;
-        }
-        return 0;
+    if (strcmp(ext, ".pyc") == 0 || strcmp(ext, ".pyo") == 0)
+        return 1;
+
+    /* Only look into the file if we are allowed to close it, since
+       it then should also be seekable. */
+    if (closeit) {
+        /* Read only two bytes of the magic. If the file was opened in
+           text mode, the bytes 3 and 4 of the magic (\r\n) might not
+           be read as they are on disk. */
+        unsigned int halfmagic = PyImport_GetMagicNumber() & 0xFFFF;
+        unsigned char buf[2];
+        /* Mess:  In case of -x, the stream is NOT at its start now,
+           and ungetc() was used to push back the first newline,
+           which makes the current stream position formally undefined,
+           and a x-platform nightmare.
+           Unfortunately, we have no direct way to know whether -x
+           was specified.  So we use a terrible hack:  if the current
+           stream position is not 0, we assume -x was specified, and
+           give up.  Bug 132850 on SourceForge spells out the
+           hopelessness of trying anything else (fseek and ftell
+           don't work predictably x-platform for text-mode files).
+        */
+        int ispyc = 0;
+        if (ftell(fp) == 0) {
+            if (fread(buf, 1, 2, fp) == 2 &&
+                ((unsigned int)buf[1]<<8 | buf[0]) == halfmagic)
+                ispyc = 1;
+            rewind(fp);
+        }
+        return ispyc;
+    }
+    return 0;
 }
 
 int
 PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit,
-                        PyCompilerFlags *flags)
-{
-        PyObject *m, *d, *v;
-        const char *ext;
-        int set_file_name = 0, ret, len;
-
-        m = PyImport_AddModule("__main__");
-        if (m == NULL)
-                return -1;
-        d = PyModule_GetDict(m);
-        if (PyDict_GetItemString(d, "__file__") == NULL) {
-                PyObject *f = PyString_FromString(filename);
-                if (f == NULL)
-                        return -1;
-                if (PyDict_SetItemString(d, "__file__", f) < 0) {
-                        Py_DECREF(f);
-                        return -1;
-                }
-                set_file_name = 1;
-                Py_DECREF(f);
-        }
-        len = strlen(filename);
-        ext = filename + len - (len > 4 ? 4 : 0);
-        if (maybe_pyc_file(fp, filename, ext, closeit)) {
-                /* Try to run a pyc file. First, re-open in binary */
-                if (closeit)
-                        fclose(fp);
-                if ((fp = fopen(filename, "rb")) == NULL) {
-                        fprintf(stderr, "python: Can't reopen .pyc file\n");
-                        ret = -1;
-                        goto done;
-                }
-                /* Turn on optimization if a .pyo file is given */
-                if (strcmp(ext, ".pyo") == 0)
-                        Py_OptimizeFlag = 1;
-                v = run_pyc_file(fp, filename, d, d, flags);
-        } else {
-                v = PyRun_FileExFlags(fp, filename, Py_file_input, d, d,
-                                      closeit, flags);
-        }
-        if (v == NULL) {
-                PyErr_Print();
-                ret = -1;
-                goto done;
-        }
-        Py_DECREF(v);
-        if (Py_FlushLine())
-                PyErr_Clear();
-        ret = 0;
+                        PyCompilerFlags *flags)
+{
+    PyObject *m, *d, *v;
+    const char *ext;
+    int set_file_name = 0, len, ret = -1;
+
+    m = PyImport_AddModule("__main__");
+    if (m == NULL)
+        return -1;
+    Py_INCREF(m);
+    d = PyModule_GetDict(m);
+    if (PyDict_GetItemString(d, "__file__") == NULL) {
+        PyObject *f = PyString_FromString(filename);
+        if (f == NULL)
+            goto done;
+        if (PyDict_SetItemString(d, "__file__", f) < 0) {
+            Py_DECREF(f);
+            goto done;
+        }
+        set_file_name = 1;
+        Py_DECREF(f);
+    }
+    len = strlen(filename);
+    ext = filename + len - (len > 4 ? 4 : 0);
+    if (maybe_pyc_file(fp, filename, ext, closeit)) {
+        /* Try to run a pyc file. First, re-open in binary */
+        if (closeit)
+            fclose(fp);
+        if ((fp = fopen(filename, "rb")) == NULL) {
+            fprintf(stderr, "python: Can't reopen .pyc file\n");
+            goto done;
+        }
+        /* Turn on optimization if a .pyo file is given */
+        if (strcmp(ext, ".pyo") == 0)
+            Py_OptimizeFlag = 1;
+        v = run_pyc_file(fp, filename, d, d, flags);
+    } else {
+        v = PyRun_FileExFlags(fp, filename, Py_file_input, d, d,
+                              closeit, flags);
+    }
+    if (v == NULL) {
+        PyErr_Print();
+        goto done;
+    }
+    Py_DECREF(v);
+    if (Py_FlushLine())
+        PyErr_Clear();
+    ret = 0;
   done:
-        if (set_file_name && PyDict_DelItemString(d, "__file__"))
-                PyErr_Clear();
-        return ret;
+    if (set_file_name && PyDict_DelItemString(d, "__file__"))
+        PyErr_Clear();
+    Py_DECREF(m);
+    return ret;
 }
 
@@ -954 +967 @@
 PyRun_SimpleStringFlags(const char *command, PyCompilerFlags *flags)
 {
-        PyObject *m, *d, *v;
-        m = PyImport_AddModule("__main__");
-        if (m == NULL)
-                return -1;
-        d = PyModule_GetDict(m);
-        v = PyRun_StringFlags(command, Py_file_input, d, d, flags);
-        if (v == NULL) {
-                PyErr_Print();
-                return -1;
-        }
-        Py_DECREF(v);
-        if (Py_FlushLine())
-                PyErr_Clear();
-        return 0;
+    PyObject *m, *d, *v;
+    m = PyImport_AddModule("__main__");
+    if (m == NULL)
+        return -1;
+    d = PyModule_GetDict(m);
+    v = PyRun_StringFlags(command, Py_file_input, d, d, flags);
+    if (v == NULL) {
+        PyErr_Print();
+        return -1;
+    }
+    Py_DECREF(v);
+    if (Py_FlushLine())
+        PyErr_Clear();
+    return 0;
 }
 
 static int
 parse_syntax_error(PyObject *err, PyObject **message, const char **filename,
-                   int *lineno, int *offset, const char **text)
-{
-        long hold;
-        PyObject *v;
-
-        /* old style errors */
-        if (PyTuple_Check(err))
-                return PyArg_ParseTuple(err, "O(ziiz)", message, filename,
-                                        lineno, offset, text);
-
-        /* new style errors.  `err' is an instance */
-
-        if (! (v = PyObject_GetAttrString(err, "msg")))
-                goto finally;
-        *message = v;
-
-        if (!(v = PyObject_GetAttrString(err, "filename")))
-                goto finally;
-        if (v == Py_None)
-                *filename = NULL;
-        else if (! (*filename = PyString_AsString(v)))
-                goto finally;
-
-        Py_DECREF(v);
-        if (!(v = PyObject_GetAttrString(err, "lineno")))
-                goto finally;
-        hold = PyInt_AsLong(v);
-        Py_DECREF(v);
-        v = NULL;
-        if (hold < 0 && PyErr_Occurred())
-                goto finally;
-        *lineno = (int)hold;
-
-        if (!(v = PyObject_GetAttrString(err, "offset")))
-                goto finally;
-        if (v == Py_None) {
-                *offset = -1;
-                Py_DECREF(v);
-                v = NULL;
-        } else {
-                hold = PyInt_AsLong(v);
-                Py_DECREF(v);
-                v = NULL;
-                if (hold < 0 && PyErr_Occurred())
-                        goto finally;
-                *offset = (int)hold;
-        }
-
-        if (!(v = PyObject_GetAttrString(err, "text")))
-                goto finally;
-        if (v == Py_None)
-                *text = NULL;
-        else if (! (*text = PyString_AsString(v)))
-                goto finally;
-        Py_DECREF(v);
-        return 1;
+                   int *lineno, int *offset, const char **text)
+{
+    long hold;
+    PyObject *v;
+
+    /* old style errors */
+    if (PyTuple_Check(err))
+        return PyArg_ParseTuple(err, "O(ziiz)", message, filename,
+                                lineno, offset, text);
+
+    *message = NULL;
+
+    /* new style errors.  `err' is an instance */
+    *message = PyObject_GetAttrString(err, "msg");
+    if (!*message)
+        goto finally;
+
+    v = PyObject_GetAttrString(err, "filename");
+    if (!v)
+        goto finally;
+    if (v == Py_None) {
+        Py_DECREF(v);
+        *filename = NULL;
+    }
+    else {
+        *filename = PyString_AsString(v);
+        Py_DECREF(v);
+        if (!*filename)
+            goto finally;
+    }
+
+    v = PyObject_GetAttrString(err, "lineno");
+    if (!v)
+        goto finally;
+    hold = PyInt_AsLong(v);
+    Py_DECREF(v);
+    if (hold < 0 && PyErr_Occurred())
+        goto finally;
+    *lineno = (int)hold;
+
+    v = PyObject_GetAttrString(err, "offset");
+    if (!v)
+        goto finally;
+    if (v == Py_None) {
+        *offset = -1;
+        Py_DECREF(v);
+    } else {
+        hold = PyInt_AsLong(v);
+        Py_DECREF(v);
+        if (hold < 0 && PyErr_Occurred())
+            goto finally;
+        *offset = (int)hold;
+    }
+
+    v = PyObject_GetAttrString(err, "text");
+    if (!v)
+        goto finally;
+    if (v == Py_None) {
+        Py_DECREF(v);
+        *text = NULL;
+    }
+    else {
+        *text = PyString_AsString(v);
+        Py_DECREF(v);
+        if (!*text)
+            goto finally;
+    }
+    return 1;
 
 finally:
-        Py_XDECREF(v);
-        return 0;
+    Py_XDECREF(*message);
+    return 0;
 }
 
@@ -1037 +1062 @@
 PyErr_Print(void)
 {
-        PyErr_PrintEx(1);
+    PyErr_PrintEx(1);
 }
 
@@ -1043 +1068 @@
 print_error_text(PyObject *f, int offset, const char *text)
 {
-        char *nl;
-        if (offset >= 0) {
-                if (offset > 0 && offset == (int)strlen(text))
-                        offset--;
-                for (;;) {
-                        nl = strchr(text, '\n');
-                        if (nl == NULL || nl-text >= offset)
-                                break;
-                        offset -= (int)(nl+1-text);
-                        text = nl+1;
-                }
-                while (*text == ' ' || *text == '\t') {
-                        text++;
-                        offset--;
-                }
-        }
-        PyFile_WriteString("    ", f);
-        PyFile_WriteString(text, f);
-        if (*text == '\0' || text[strlen(text)-1] != '\n')
-                PyFile_WriteString("\n", f);
-        if (offset == -1)
-                return;
-        PyFile_WriteString("    ", f);
-        offset--;
-        while (offset > 0) {
-                PyFile_WriteString(" ", f);
-                offset--;
-        }
-        PyFile_WriteString("^\n", f);
+    char *nl;
+    if (offset >= 0) {
+        if (offset > 0 && offset == strlen(text) && text[offset - 1] == '\n')
+            offset--;
+        for (;;) {
+            nl = strchr(text, '\n');
+            if (nl == NULL || nl-text >= offset)
+                break;
+            offset -= (int)(nl+1-text);
+            text = nl+1;
+        }
+        while (*text == ' ' || *text == '\t') {
+            text++;
+            offset--;
+        }
+    }
+    PyFile_WriteString("    ", f);
+    PyFile_WriteString(text, f);
+    if (*text == '\0' || text[strlen(text)-1] != '\n')
+        PyFile_WriteString("\n", f);
+    if (offset == -1)
+        return;
+    PyFile_WriteString("    ", f);
+    offset--;
+    while (offset > 0) {
+        PyFile_WriteString(" ", f);
+        offset--;
+    }
+    PyFile_WriteString("^\n", f);
 }
 
@@ -1077 +1102 @@
 handle_system_exit(void)
 {
-        PyObject *exception, *value, *tb;
-        int exitcode = 0;
-
-        if (Py_InspectFlag)
-                /* Don't exit if -i flag was given. This flag is set to 0
-                 * when entering interactive mode for inspecting. */
-                return;
-
-        PyErr_Fetch(&exception, &value, &tb);
-        if (Py_FlushLine())
-                PyErr_Clear();
-        fflush(stdout);
-        if (value == NULL || value == Py_None)
-                goto done;
-        if (PyExceptionInstance_Check(value)) {
-                /* The error code should be in the `code' attribute. */
-                PyObject *code = PyObject_GetAttrString(value, "code");
-                if (code) {
-                        Py_DECREF(value);
-                        value = code;
-                        if (value == Py_None)
-                                goto done;
-                }
-                /* If we failed to dig out the 'code' attribute,
-                   just let the else clause below print the error. */
-        }
-        if (PyInt_Check(value))
-                exitcode = (int)PyInt_AsLong(value);
-        else {
-                PyObject_Print(value, stderr, Py_PRINT_RAW);
-                PySys_WriteStderr("\n");
-                exitcode = 1;
-        }
+    PyObject *exception, *value, *tb;
+    int exitcode = 0;
+
+    if (Py_InspectFlag)
+        /* Don't exit if -i flag was given. This flag is set to 0
+         * when entering interactive mode for inspecting. */
+        return;
+
+    PyErr_Fetch(&exception, &value, &tb);
+    if (Py_FlushLine())
+        PyErr_Clear();
+    fflush(stdout);
+    if (value == NULL || value == Py_None)
+        goto done;
+    if (PyExceptionInstance_Check(value)) {
+        /* The error code should be in the `code' attribute. */
+        PyObject *code = PyObject_GetAttrString(value, "code");
+        if (code) {
+            Py_DECREF(value);
+            value = code;
+            if (value == Py_None)
+                goto done;
+        }
+        /* If we failed to dig out the 'code' attribute,
+           just let the else clause below print the error. */
+    }
+    if (PyInt_Check(value))
+        exitcode = (int)PyInt_AsLong(value);
+    else {
+        PyObject *sys_stderr = PySys_GetObject("stderr");
+        if (sys_stderr != NULL && sys_stderr != Py_None) {
+            PyFile_WriteObject(value, sys_stderr, Py_PRINT_RAW);
+        } else {
+            PyObject_Print(value, stderr, Py_PRINT_RAW);
+            fflush(stderr);
+        }
+        PySys_WriteStderr("\n");
+        exitcode = 1;
+    }
  done:
-        /* Restore and clear the exception info, in order to properly decref
-         * the exception, value, and traceback.  If we just exit instead,
-         * these leak, which confuses PYTHONDUMPREFS output, and may prevent
-         * some finalizers from running.
-         */
-        PyErr_Restore(exception, value, tb);
-        PyErr_Clear();
-        Py_Exit(exitcode);
-        /* NOTREACHED */
+    /* Restore and clear the exception info, in order to properly decref
+     * the exception, value, and traceback.      If we just exit instead,
+     * these leak, which confuses PYTHONDUMPREFS output, and may prevent
+     * some finalizers from running.
+     */
+    PyErr_Restore(exception, value, tb);
+    PyErr_Clear();
+    Py_Exit(exitcode);
+    /* NOTREACHED */
 }
 
@@ -1125 +1156 @@
 PyErr_PrintEx(int set_sys_last_vars)
 {
-        PyObject *exception, *v, *tb, *hook;
-
-        if (PyErr_ExceptionMatches(PyExc_SystemExit)) {
-                handle_system_exit();
-        }
-        PyErr_Fetch(&exception, &v, &tb);
-        if (exception == NULL)
-                return;
-        PyErr_NormalizeException(&exception, &v, &tb);
-        if (exception == NULL)
-                return;
-        /* Now we know v != NULL too */
-        if (set_sys_last_vars) {
-                PySys_SetObject("last_type", exception);
-                PySys_SetObject("last_value", v);
-                PySys_SetObject("last_traceback", tb);
-        }
-        hook = PySys_GetObject("excepthook");
-        if (hook) {
-                PyObject *args = PyTuple_Pack(3,
-                    exception, v, tb ? tb : Py_None);
-                PyObject *result = PyEval_CallObject(hook, args);
-                if (result == NULL) {
-                        PyObject *exception2, *v2, *tb2;
-                        if (PyErr_ExceptionMatches(PyExc_SystemExit)) {
-                                handle_system_exit();
-                        }
-                        PyErr_Fetch(&exception2, &v2, &tb2);
-                        PyErr_NormalizeException(&exception2, &v2, &tb2);
-                        /* It should not be possible for exception2 or v2
-                           to be NULL. However PyErr_Display() can't
-                           tolerate NULLs, so just be safe. */
-                        if (exception2 == NULL) {
-                                exception2 = Py_None;
-                                Py_INCREF(exception2);
-                        }
-                        if (v2 == NULL) {
-                                v2 = Py_None;
-                                Py_INCREF(v2);
-                        }
-                        if (Py_FlushLine())
-                                PyErr_Clear();
-                        fflush(stdout);
-                        PySys_WriteStderr("Error in sys.excepthook:\n");
-                        PyErr_Display(exception2, v2, tb2);
-                        PySys_WriteStderr("\nOriginal exception was:\n");
-                        PyErr_Display(exception, v, tb);
-                        Py_DECREF(exception2);
-                        Py_DECREF(v2);
-                        Py_XDECREF(tb2);
-                }
-                Py_XDECREF(result);
-                Py_XDECREF(args);
-        } else {
-                PySys_WriteStderr("sys.excepthook is missing\n");
-                PyErr_Display(exception, v, tb);
-        }
-        Py_XDECREF(exception);
-        Py_XDECREF(v);
-        Py_XDECREF(tb);
+    PyObject *exception, *v, *tb, *hook;
+
+    if (PyErr_ExceptionMatches(PyExc_SystemExit)) {
+        handle_system_exit();
+    }
+    PyErr_Fetch(&exception, &v, &tb);
+    if (exception == NULL)
+        return;
+    PyErr_NormalizeException(&exception, &v, &tb);
+    if (exception == NULL)
+        return;
+    /* Now we know v != NULL too */
+    if (set_sys_last_vars) {
+        PySys_SetObject("last_type", exception);
+        PySys_SetObject("last_value", v);
+        PySys_SetObject("last_traceback", tb);
+    }
+    hook = PySys_GetObject("excepthook");
+    if (hook && hook != Py_None) {
+        PyObject *args = PyTuple_Pack(3,
+            exception, v, tb ? tb : Py_None);
+        PyObject *result = PyEval_CallObject(hook, args);
+        if (result == NULL) {
+            PyObject *exception2, *v2, *tb2;
+            if (PyErr_ExceptionMatches(PyExc_SystemExit)) {
+                handle_system_exit();
+            }
+            PyErr_Fetch(&exception2, &v2, &tb2);
+            PyErr_NormalizeException(&exception2, &v2, &tb2);
+            /* It should not be possible for exception2 or v2
+               to be NULL. However PyErr_Display() can't
+               tolerate NULLs, so just be safe. */
+            if (exception2 == NULL) {
+                exception2 = Py_None;
+                Py_INCREF(exception2);
+            }
+            if (v2 == NULL) {
+                v2 = Py_None;
+                Py_INCREF(v2);
+            }
+            if (Py_FlushLine())
+                PyErr_Clear();
+            fflush(stdout);
+            PySys_WriteStderr("Error in sys.excepthook:\n");
+            PyErr_Display(exception2, v2, tb2);
+            PySys_WriteStderr("\nOriginal exception was:\n");
+            PyErr_Display(exception, v, tb);
+            Py_DECREF(exception2);
+            Py_DECREF(v2);
+            Py_XDECREF(tb2);
+        }
+        Py_XDECREF(result);
+        Py_XDECREF(args);
+    } else {
+        PySys_WriteStderr("sys.excepthook is missing\n");
+        PyErr_Display(exception, v, tb);
+    }
+    Py_XDECREF(exception);
+    Py_XDECREF(v);
+    Py_XDECREF(tb);
 }
 
@@ -1190 +1221 @@
 PyErr_Display(PyObject *exception, PyObject *value, PyObject *tb)
 {
-        int err = 0;
-        PyObject *f = PySys_GetObject("stderr");
-        Py_INCREF(value);
-        if (f == NULL)
-                fprintf(stderr, "lost sys.stderr\n");
-        else {
-                if (Py_FlushLine())
-                        PyErr_Clear();
-                fflush(stdout);
-                if (tb && tb != Py_None)
-                        err = PyTraceBack_Print(tb, f);
-                if (err == 0 &&
-                    PyObject_HasAttrString(value, "print_file_and_line"))
-                {
-                        PyObject *message;
-                        const char *filename, *text;
-                        int lineno, offset;
-                        if (!parse_syntax_error(value, &message, &filename,
-                                                &lineno, &offset, &text))
-                                PyErr_Clear();
-                        else {
-                                char buf[10];
-                                PyFile_WriteString("  File \"", f);
-                                if (filename == NULL)
-                                        PyFile_WriteString("<string>", f);
-                                else
-                                        PyFile_WriteString(filename, f);
-                                PyFile_WriteString("\", line ", f);
-                                PyOS_snprintf(buf, sizeof(buf), "%d", lineno);
-                                PyFile_WriteString(buf, f);
-                                PyFile_WriteString("\n", f);
-                                if (text != NULL)
-                                        print_error_text(f, offset, text);
-                                Py_DECREF(value);
-                                value = message;
-                                /* Can't be bothered to check all those
-                                   PyFile_WriteString() calls */
-                                if (PyErr_Occurred())
-                                        err = -1;
-                        }
-                }
-                if (err) {
-                        /* Don't do anything else */
-                }
-                else if (PyExceptionClass_Check(exception)) {
-                        PyObject* moduleName;
-                        char* className = PyExceptionClass_Name(exception);
-                        if (className != NULL) {
-                                char *dot = strrchr(className, '.');
-                                if (dot != NULL)
-                                        className = dot+1;
-                        }
-
-                        moduleName = PyObject_GetAttrString(exception, "__module__");
-                        if (moduleName == NULL)
-                                err = PyFile_WriteString("<unknown>", f);
-                        else {
-                                char* modstr = PyString_AsString(moduleName);
-                                if (modstr && strcmp(modstr, "exceptions"))
-                                {
-                                        err = PyFile_WriteString(modstr, f);
-                                        err += PyFile_WriteString(".", f);
-                                }
-                                Py_DECREF(moduleName);
-                        }
-                        if (err == 0) {
-                                if (className == NULL)
-                                      err = PyFile_WriteString("<unknown>", f);
-                                else
-                                      err = PyFile_WriteString(className, f);
-                        }
-                }
-                else
-                        err = PyFile_WriteObject(exception, f, Py_PRINT_RAW);
-                if (err == 0 && (value != Py_None)) {
-                        PyObject *s = PyObject_Str(value);
-                        /* only print colon if the str() of the
-                           object is not the empty string
-                        */
-                        if (s == NULL)
-                                err = -1;
-                        else if (!PyString_Check(s) ||
-                                 PyString_GET_SIZE(s) != 0)
-                                err = PyFile_WriteString(": ", f);
-                        if (err == 0)
-                          err = PyFile_WriteObject(s, f, Py_PRINT_RAW);
-                        Py_XDECREF(s);
-                }
-                /* try to write a newline in any case */
-                err += PyFile_WriteString("\n", f);
-        }
-        Py_DECREF(value);
-        /* If an error happened here, don't show it.
-           XXX This is wrong, but too many callers rely on this behavior. */
-        if (err != 0)
-                PyErr_Clear();
+    int err = 0;
+    PyObject *f = PySys_GetObject("stderr");
+    Py_INCREF(value);
+    if (f == NULL || f == Py_None)
+        fprintf(stderr, "lost sys.stderr\n");
+    else {
+        if (Py_FlushLine())
+            PyErr_Clear();
+        fflush(stdout);
+        if (tb && tb != Py_None)
+            err = PyTraceBack_Print(tb, f);
+        if (err == 0 &&
+            PyObject_HasAttrString(value, "print_file_and_line"))
+        {
+            PyObject *message;
+            const char *filename, *text;
+            int lineno, offset;
+            if (!parse_syntax_error(value, &message, &filename,
+                                    &lineno, &offset, &text))
+                PyErr_Clear();
+            else {
+                char buf[10];
+                PyFile_WriteString("  File \"", f);
+                if (filename == NULL)
+                    PyFile_WriteString("<string>", f);
+                else
+                    PyFile_WriteString(filename, f);
+                PyFile_WriteString("\", line ", f);
+                PyOS_snprintf(buf, sizeof(buf), "%d", lineno);
+                PyFile_WriteString(buf, f);
+                PyFile_WriteString("\n", f);
+                if (text != NULL)
+                    print_error_text(f, offset, text);
+                Py_DECREF(value);
+                value = message;
+                /* Can't be bothered to check all those
+                   PyFile_WriteString() calls */
+                if (PyErr_Occurred())
+                    err = -1;
+            }
+        }
+        if (err) {
+            /* Don't do anything else */
+        }
+        else if (PyExceptionClass_Check(exception)) {
+            PyObject* moduleName;
+            char* className = PyExceptionClass_Name(exception);
+            if (className != NULL) {
+                char *dot = strrchr(className, '.');
+                if (dot != NULL)
+                    className = dot+1;
+            }
+
+            moduleName = PyObject_GetAttrString(exception, "__module__");
+            if (moduleName == NULL)
+                err = PyFile_WriteString("<unknown>", f);
+            else {
+                char* modstr = PyString_AsString(moduleName);
+                if (modstr && strcmp(modstr, "exceptions"))
+                {
+                    err = PyFile_WriteString(modstr, f);
+                    err += PyFile_WriteString(".", f);
+                }
+                Py_DECREF(moduleName);
+            }
+            if (err == 0) {
+                if (className == NULL)
+                      err = PyFile_WriteString("<unknown>", f);
+                else
+                      err = PyFile_WriteString(className, f);
+            }
+        }
+        else
+            err = PyFile_WriteObject(exception, f, Py_PRINT_RAW);
+        if (err == 0 && (value != Py_None)) {
+            PyObject *s = PyObject_Str(value);
+            /* only print colon if the str() of the
+               object is not the empty string
+            */
+            if (s == NULL)
+                err = -1;
+            else if (!PyString_Check(s) ||
+                     PyString_GET_SIZE(s) != 0)
+                err = PyFile_WriteString(": ", f);
+            if (err == 0)
+              err = PyFile_WriteObject(s, f, Py_PRINT_RAW);
+            Py_XDECREF(s);
+        }
+        /* try to write a newline in any case */
+        err += PyFile_WriteString("\n", f);
+    }
+    Py_DECREF(value);
+    /* If an error happened here, don't show it.
+       XXX This is wrong, but too many callers rely on this behavior. */
+    if (err != 0)
+        PyErr_Clear();
 }
 
 PyObject *
 PyRun_StringFlags(const char *str, int start, PyObject *globals,
-                  PyObject *locals, PyCompilerFlags *flags)
-{
-        PyObject *ret = NULL;
-        mod_ty mod;
-        PyArena *arena = PyArena_New();
-        if (arena == NULL)
-                return NULL;
-        
-        mod = PyParser_ASTFromString(str, "<string>", start, flags, arena);
-        if (mod != NULL)
-                ret = run_mod(mod, "<string>", globals, locals, flags, arena);
-        PyArena_Free(arena);
-        return ret;
+                  PyObject *locals, PyCompilerFlags *flags)
+{
+    PyObject *ret = NULL;
+    mod_ty mod;
+    PyArena *arena = PyArena_New();
+    if (arena == NULL)
+        return NULL;
+
+    mod = PyParser_ASTFromString(str, "<string>", start, flags, arena);
+    if (mod != NULL)
+        ret = run_mod(mod, "<string>", globals, locals, flags, arena);
+    PyArena_Free(arena);
+    return ret;
 }
 
 PyObject *
 PyRun_FileExFlags(FILE *fp, const char *filename, int start, PyObject *globals,
-                  PyObject *locals, int closeit, PyCompilerFlags *flags)
-{
-        PyObject *ret;
-        mod_ty mod;
-        PyArena *arena = PyArena_New();
-        if (arena == NULL)
-                return NULL;
-        
-        mod = PyParser_ASTFromFile(fp, filename, start, 0, 0,
-                                   flags, NULL, arena);
-        if (closeit)
-                fclose(fp);
-        if (mod == NULL) {
-                PyArena_Free(arena);
-                return NULL;
-        }
-        ret = run_mod(mod, filename, globals, locals, flags, arena);
-        PyArena_Free(arena);
-        return ret;
+                  PyObject *locals, int closeit, PyCompilerFlags *flags)
+{
+    PyObject *ret;
+    mod_ty mod;
+    PyArena *arena = PyArena_New();
+    if (arena == NULL)
+        return NULL;
+
+    mod = PyParser_ASTFromFile(fp, filename, start, 0, 0,
+                               flags, NULL, arena);
+    if (closeit)
+        fclose(fp);
+    if (mod == NULL) {
+        PyArena_Free(arena);
+        return NULL;
+    }
+    ret = run_mod(mod, filename, globals, locals, flags, arena);
+    PyArena_Free(arena);
+    return ret;
 }
 
 static PyObject *
 run_mod(mod_ty mod, const char *filename, PyObject *globals, PyObject *locals,
-         PyCompilerFlags *flags, PyArena *arena)
-{
-        PyCodeObject *co;
-        PyObject *v;
-        co = PyAST_Compile(mod, filename, flags, arena);
-        if (co == NULL)
-                return NULL;
-        v = PyEval_EvalCode(co, globals, locals);
-        Py_DECREF(co);
-        return v;
+         PyCompilerFlags *flags, PyArena *arena)
+{
+    PyCodeObject *co;
+    PyObject *v;
+    co = PyAST_Compile(mod, filename, flags, arena);
+    if (co == NULL)
+        return NULL;
+    v = PyEval_EvalCode(co, globals, locals);
+    Py_DECREF(co);
+    return v;
 }
 
 static PyObject *
 run_pyc_file(FILE *fp, const char *filename, PyObject *globals,
-             PyObject *locals, PyCompilerFlags *flags)
-{
-        PyCodeObject *co;
-        PyObject *v;
-        long magic;
-        long PyImport_GetMagicNumber(void);
-
-        magic = PyMarshal_ReadLongFromFile(fp);
-        if (magic != PyImport_GetMagicNumber()) {
-                PyErr_SetString(PyExc_RuntimeError,
-                           "Bad magic number in .pyc file");
-                return NULL;
-        }
-        (void) PyMarshal_ReadLongFromFile(fp);
-        v = PyMarshal_ReadLastObjectFromFile(fp);
-        fclose(fp);
-        if (v == NULL || !PyCode_Check(v)) {
-                Py_XDECREF(v);
-                PyErr_SetString(PyExc_RuntimeError,
-                           "Bad code object in .pyc file");
-                return NULL;
-        }
-        co = (PyCodeObject *)v;
-        v = PyEval_EvalCode(co, globals, locals);
-        if (v && flags)
-                flags->cf_flags |= (co->co_flags & PyCF_MASK);
-        Py_DECREF(co);
-        return v;
+             PyObject *locals, PyCompilerFlags *flags)
+{
+    PyCodeObject *co;
+    PyObject *v;
+    long magic;
+    long PyImport_GetMagicNumber(void);
+
+    magic = PyMarshal_ReadLongFromFile(fp);
+    if (magic != PyImport_GetMagicNumber()) {
+        PyErr_SetString(PyExc_RuntimeError,
+                   "Bad magic number in .pyc file");
+        return NULL;
+    }
+    (void) PyMarshal_ReadLongFromFile(fp);
+    v = PyMarshal_ReadLastObjectFromFile(fp);
+    fclose(fp);
+    if (v == NULL || !PyCode_Check(v)) {
+        Py_XDECREF(v);
+        PyErr_SetString(PyExc_RuntimeError,
+                   "Bad code object in .pyc file");
+        return NULL;
+    }
+    co = (PyCodeObject *)v;
+    v = PyEval_EvalCode(co, globals, locals);
+    if (v && flags)
+        flags->cf_flags |= (co->co_flags & PyCF_MASK);
+    Py_DECREF(co);
+    return v;
 }
 
 PyObject *
 Py_CompileStringFlags(const char *str, const char *filename, int start,
-                      PyCompilerFlags *flags)
-{
-        PyCodeObject *co;
-        mod_ty mod;
-        PyArena *arena = PyArena_New();
-        if (arena == NULL)
-                return NULL;
-
-        mod = PyParser_ASTFromString(str, filename, start, flags, arena);
-        if (mod == NULL) {
-                PyArena_Free(arena);
-                return NULL;
-        }
-        if (flags && (flags->cf_flags & PyCF_ONLY_AST)) {
-                PyObject *result = PyAST_mod2obj(mod);
-                PyArena_Free(arena);
-                return result;
-        }
-        co = PyAST_Compile(mod, filename, flags, arena);
-        PyArena_Free(arena);
-        return (PyObject *)co;
+                      PyCompilerFlags *flags)
+{
+    PyCodeObject *co;
+    mod_ty mod;
+    PyArena *arena = PyArena_New();
+    if (arena == NULL)
+        return NULL;
+
+    mod = PyParser_ASTFromString(str, filename, start, flags, arena);
+    if (mod == NULL) {
+        PyArena_Free(arena);
+        return NULL;
+    }
+    if (flags && (flags->cf_flags & PyCF_ONLY_AST)) {
+        PyObject *result = PyAST_mod2obj(mod);
+        PyArena_Free(arena);
+        return result;
+    }
+    co = PyAST_Compile(mod, filename, flags, arena);
+    PyArena_Free(arena);
+    return (PyObject *)co;
 }
 
@@ -1402 +1433 @@
 Py_SymtableString(const char *str, const char *filename, int start)
 {
-        struct symtable *st;
-        mod_ty mod;
-        PyCompilerFlags flags;
-        PyArena *arena = PyArena_New();
-        if (arena == NULL)
-                return NULL;
-
-        flags.cf_flags = 0;
-
-        mod = PyParser_ASTFromString(str, filename, start, &flags, arena);
-        if (mod == NULL) {
-                PyArena_Free(arena);
-                return NULL;
-        }
-        st = PySymtable_Build(mod, filename, 0);
-        PyArena_Free(arena);
-        return st;
+    struct symtable *st;
+    mod_ty mod;
+    PyCompilerFlags flags;
+    PyArena *arena = PyArena_New();
+    if (arena == NULL)
+        return NULL;
+
+    flags.cf_flags = 0;
+
+    mod = PyParser_ASTFromString(str, filename, start, &flags, arena);
+    if (mod == NULL) {
+        PyArena_Free(arena);
+        return NULL;
+    }
+    st = PySymtable_Build(mod, filename, 0);
+    PyArena_Free(arena);
+    return st;
 }
 
@@ -1424 +1455 @@
 mod_ty
 PyParser_ASTFromString(const char *s, const char *filename, int start,
-                       PyCompilerFlags *flags, PyArena *arena)
-{
-        mod_ty mod;
-        PyCompilerFlags localflags;
-        perrdetail err;
-        int iflags = PARSER_FLAGS(flags);
-
-        node *n = PyParser_ParseStringFlagsFilenameEx(s, filename,
-                                        &_PyParser_Grammar, start, &err,
-                                        &iflags);
-        if (flags == NULL) {
-                localflags.cf_flags = 0;
-                flags = &localflags;
-        }
-        if (n) {
-                flags->cf_flags |= iflags & PyCF_MASK;
-                mod = PyAST_FromNode(n, flags, filename, arena);
-                PyNode_Free(n);
-                return mod;
-        }
-        else {
-                err_input(&err);
-                return NULL;
-        }
+                       PyCompilerFlags *flags, PyArena *arena)
+{
+    mod_ty mod;
+    PyCompilerFlags localflags;
+    perrdetail err;
+    int iflags = PARSER_FLAGS(flags);
+
+    node *n = PyParser_ParseStringFlagsFilenameEx(s, filename,
+                                    &_PyParser_Grammar, start, &err,
+                                    &iflags);
+    if (flags == NULL) {
+        localflags.cf_flags = 0;
+        flags = &localflags;
+    }
+    if (n) {
+        flags->cf_flags |= iflags & PyCF_MASK;
+        mod = PyAST_FromNode(n, flags, filename, arena);
+        PyNode_Free(n);
+        return mod;
+    }
+    else {
+        err_input(&err);
+        return NULL;
+    }
 }
 
 mod_ty
 PyParser_ASTFromFile(FILE *fp, const char *filename, int start, char *ps1,
-                     char *ps2, PyCompilerFlags *flags, int *errcode,
-                     PyArena *arena)
-{
-        mod_ty mod;
-        PyCompilerFlags localflags;
-        perrdetail err;
-        int iflags = PARSER_FLAGS(flags);
-
-        node *n = PyParser_ParseFileFlagsEx(fp, filename, &_PyParser_Grammar,
-                                start, ps1, ps2, &err, &iflags);
-        if (flags == NULL) {
-                localflags.cf_flags = 0;
-                flags = &localflags;
-        }
-        if (n) {
-                flags->cf_flags |= iflags & PyCF_MASK;
-                mod = PyAST_FromNode(n, flags, filename, arena);
-                PyNode_Free(n);
-                return mod;
-        }
-        else {
-                err_input(&err);
-                if (errcode)
-                        *errcode = err.error;
-                return NULL;
-        }
+                     char *ps2, PyCompilerFlags *flags, int *errcode,
+                     PyArena *arena)
+{
+    mod_ty mod;
+    PyCompilerFlags localflags;
+    perrdetail err;
+    int iflags = PARSER_FLAGS(flags);
+
+    node *n = PyParser_ParseFileFlagsEx(fp, filename, &_PyParser_Grammar,
+                            start, ps1, ps2, &err, &iflags);
+    if (flags == NULL) {
+        localflags.cf_flags = 0;
+        flags = &localflags;
+    }
+    if (n) {
+        flags->cf_flags |= iflags & PyCF_MASK;
+        mod = PyAST_FromNode(n, flags, filename, arena);
+        PyNode_Free(n);
+        return mod;
+    }
+    else {
+        err_input(&err);
+        if (errcode)
+            *errcode = err.error;
+        return NULL;
+    }
 }
 
@@ -1485 +1516 @@
 PyParser_SimpleParseFileFlags(FILE *fp, const char *filename, int start, int flags)
 {
-        perrdetail err;
-        node *n = PyParser_ParseFileFlags(fp, filename, &_PyParser_Grammar,
-                                          start, NULL, NULL, &err, flags);
-        if (n == NULL)
-                err_input(&err);
-
-        return n;
+    perrdetail err;
+    node *n = PyParser_ParseFileFlags(fp, filename, &_PyParser_Grammar,
+                                      start, NULL, NULL, &err, flags);
+    if (n == NULL)
+        err_input(&err);
+
+    return n;
 }
 
@@ -1499 +1530 @@
 PyParser_SimpleParseStringFlags(const char *str, int start, int flags)
 {
-        perrdetail err;
-        node *n = PyParser_ParseStringFlags(str, &_PyParser_Grammar,
-                                            start, &err, flags);
-        if (n == NULL)
-                err_input(&err);
-        return n;
+    perrdetail err;
+    node *n = PyParser_ParseStringFlags(str, &_PyParser_Grammar,
+                                        start, &err, flags);
+    if (n == NULL)
+        err_input(&err);
+    return n;
 }
 
 node *
 PyParser_SimpleParseStringFlagsFilename(const char *str, const char *filename,
-                                        int start, int flags)
-{
-        perrdetail err;
-        node *n = PyParser_ParseStringFlagsFilename(str, filename,
-                                &_PyParser_Grammar, start, &err, flags);
-        if (n == NULL)
-                err_input(&err);
-        return n;
+                                        int start, int flags)
+{
+    perrdetail err;
+    node *n = PyParser_ParseStringFlagsFilename(str, filename,
+                            &_PyParser_Grammar, start, &err, flags);
+    if (n == NULL)
+        err_input(&err);
+    return n;
 }
 
@@ -1522 +1553 @@
 PyParser_SimpleParseStringFilename(const char *str, const char *filename, int start)
 {
-        return PyParser_SimpleParseStringFlagsFilename(str, filename, start, 0);
+    return PyParser_SimpleParseStringFlagsFilename(str, filename, start, 0);
 }
 
@@ -1531 +1562 @@
 PyParser_SetError(perrdetail *err)
 {
-        err_input(err);
+    err_input(err);
 }
 
@@ -1539 +1570 @@
 err_input(perrdetail *err)
 {
-        PyObject *v, *w, *errtype;
-        PyObject* u = NULL;
-        char *msg = NULL;
-        errtype = PyExc_SyntaxError;
-        switch (err->error) {
-        case E_SYNTAX:
-                errtype = PyExc_IndentationError;
-                if (err->expected == INDENT)
-                        msg = "expected an indented block";
-                else if (err->token == INDENT)
-                        msg = "unexpected indent";
-                else if (err->token == DEDENT)
-                        msg = "unexpected unindent";
-                else {
-                        errtype = PyExc_SyntaxError;
-                        msg = "invalid syntax";
-                }
-                break;
-        case E_TOKEN:
-                msg = "invalid token";
-                break;
-        case E_EOFS:
-                msg = "EOF while scanning triple-quoted string literal";
-                break;
-        case E_EOLS:
-                msg = "EOL while scanning string literal";
-                break;
-        case E_INTR:
-                if (!PyErr_Occurred())
-                        PyErr_SetNone(PyExc_KeyboardInterrupt);
-                goto cleanup;
-        case E_NOMEM:
-                PyErr_NoMemory();
-                goto cleanup;
-        case E_EOF:
-                msg = "unexpected EOF while parsing";
-                break;
-        case E_TABSPACE:
-                errtype = PyExc_TabError;
-                msg = "inconsistent use of tabs and spaces in indentation";
-                break;
-        case E_OVERFLOW:
-                msg = "expression too long";
-                break;
-        case E_DEDENT:
-                errtype = PyExc_IndentationError;
-                msg = "unindent does not match any outer indentation level";
-                break;
-        case E_TOODEEP:
-                errtype = PyExc_IndentationError;
-                msg = "too many levels of indentation";
-                break;
-        case E_DECODE: {
-                PyObject *type, *value, *tb;
-                PyErr_Fetch(&type, &value, &tb);
-                if (value != NULL) {
-                        u = PyObject_Str(value);
-                        if (u != NULL) {
-                                msg = PyString_AsString(u);
-                        }
-                }
-                if (msg == NULL)
-                        msg = "unknown decode error";
-                Py_XDECREF(type);
-                Py_XDECREF(value);
-                Py_XDECREF(tb);
-                break;
-        }
-        case E_LINECONT:
-                msg = "unexpected character after line continuation character";
-                break;
-        default:
-                fprintf(stderr, "error=%d\n", err->error);
-                msg = "unknown parsing error";
-                break;
-        }
-        v = Py_BuildValue("(ziiz)", err->filename,
-                          err->lineno, err->offset, err->text);
-        w = NULL;
-        if (v != NULL)
-                w = Py_BuildValue("(sO)", msg, v);
-        Py_XDECREF(u);
-        Py_XDECREF(v);
-        PyErr_SetObject(errtype, w);
-        Py_XDECREF(w);
+    PyObject *v, *w, *errtype;
+    PyObject* u = NULL;
+    char *msg = NULL;
+    errtype = PyExc_SyntaxError;
+    switch (err->error) {
+    case E_ERROR:
+        return;
+    case E_SYNTAX:
+        errtype = PyExc_IndentationError;
+        if (err->expected == INDENT)
+            msg = "expected an indented block";
+        else if (err->token == INDENT)
+            msg = "unexpected indent";
+        else if (err->token == DEDENT)
+            msg = "unexpected unindent";
+        else {
+            errtype = PyExc_SyntaxError;
+            msg = "invalid syntax";
+        }
+        break;
+    case E_TOKEN:
+        msg = "invalid token";
+        break;
+    case E_EOFS:
+        msg = "EOF while scanning triple-quoted string literal";
+        break;
+    case E_EOLS:
+        msg = "EOL while scanning string literal";
+        break;
+    case E_INTR:
+        if (!PyErr_Occurred())
+            PyErr_SetNone(PyExc_KeyboardInterrupt);
+        goto cleanup;
+    case E_NOMEM:
+        PyErr_NoMemory();
+        goto cleanup;
+    case E_EOF:
+        msg = "unexpected EOF while parsing";
+        break;
+    case E_TABSPACE:
+        errtype = PyExc_TabError;
+        msg = "inconsistent use of tabs and spaces in indentation";
+        break;
+    case E_OVERFLOW:
+        msg = "expression too long";
+        break;
+    case E_DEDENT:
+        errtype = PyExc_IndentationError;
+        msg = "unindent does not match any outer indentation level";
+        break;
+    case E_TOODEEP:
+        errtype = PyExc_IndentationError;
+        msg = "too many levels of indentation";
+        break;
+    case E_DECODE: {
+        PyObject *type, *value, *tb;
+        PyErr_Fetch(&type, &value, &tb);
+        if (value != NULL) {
+            u = PyObject_Str(value);
+            if (u != NULL) {
+                msg = PyString_AsString(u);
+            }
+        }
+        if (msg == NULL)
+            msg = "unknown decode error";
+        Py_XDECREF(type);
+        Py_XDECREF(value);
+        Py_XDECREF(tb);
+        break;
+    }
+    case E_LINECONT:
+        msg = "unexpected character after line continuation character";
+        break;
+    default:
+        fprintf(stderr, "error=%d\n", err->error);
+        msg = "unknown parsing error";
+        break;
+    }
+    v = Py_BuildValue("(ziiz)", err->filename,
+                      err->lineno, err->offset, err->text);
+    w = NULL;
+    if (v != NULL)
+        w = Py_BuildValue("(sO)", msg, v);
+    Py_XDECREF(u);
+    Py_XDECREF(v);
+    PyErr_SetObject(errtype, w);
+    Py_XDECREF(w);
 cleanup:
-        if (err->text != NULL) {
-                PyObject_FREE(err->text);
-                err->text = NULL;
-        }
+    if (err->text != NULL) {
+        PyObject_FREE(err->text);
+        err->text = NULL;
+    }
 }
 
@@ -1636 +1669 @@
 Py_FatalError(const char *msg)
 {
-        fprintf(stderr, "Fatal Python error: %s\n", msg);
-        fflush(stderr); /* it helps in Windows debug build */
+    fprintf(stderr, "Fatal Python error: %s\n", msg);
+    fflush(stderr); /* it helps in Windows debug build */
 
 #ifdef MS_WINDOWS
-        {
-                size_t len = strlen(msg);
-                WCHAR* buffer;
-                size_t i;
-
-                /* Convert the message to wchar_t. This uses a simple one-to-one
-                conversion, assuming that the this error message actually uses ASCII
-                only. If this ceases to be true, we will have to convert. */
-                buffer = alloca( (len+1) * (sizeof *buffer));
-                for( i=0; i<=len; ++i)
-                        buffer[i] = msg[i];
-                OutputDebugStringW(L"Fatal Python error: ");
-                OutputDebugStringW(buffer);
-                OutputDebugStringW(L"\n");
-        }
+    {
+        size_t len = strlen(msg);
+        WCHAR* buffer;
+        size_t i;
+
+        /* Convert the message to wchar_t. This uses a simple one-to-one
+        conversion, assuming that the this error message actually uses ASCII
+        only. If this ceases to be true, we will have to convert. */
+        buffer = alloca( (len+1) * (sizeof *buffer));
+        for( i=0; i<=len; ++i)
+            buffer[i] = msg[i];
+        OutputDebugStringW(L"Fatal Python error: ");
+        OutputDebugStringW(buffer);
+        OutputDebugStringW(L"\n");
+    }
 #ifdef _DEBUG
-        DebugBreak();
+    DebugBreak();
 #endif
 #endif /* MS_WINDOWS */
-        abort();
+    abort();
 }
 
@@ -1676 +1709 @@
 {
 #ifdef WITH_THREAD
-        PyObject *result;
-        PyThreadState *tstate = PyThreadState_GET();
-        PyObject *threading = PyMapping_GetItemString(tstate->interp->modules,
-                                                      "threading");
-        if (threading == NULL) {
-                /* threading not imported */
-                PyErr_Clear();
-                return;
-        }
-        result = PyObject_CallMethod(threading, "_shutdown", "");
-        if (result == NULL)
-                PyErr_WriteUnraisable(threading);
-        else
-                Py_DECREF(result);
-        Py_DECREF(threading);
+    PyObject *result;
+    PyThreadState *tstate = PyThreadState_GET();
+    PyObject *threading = PyMapping_GetItemString(tstate->interp->modules,
+                                                  "threading");
+    if (threading == NULL) {
+        /* threading not imported */
+        PyErr_Clear();
+        return;
+    }
+    result = PyObject_CallMethod(threading, "_shutdown", "");
+    if (result == NULL)
+        PyErr_WriteUnraisable(threading);
+    else
+        Py_DECREF(result);
+    Py_DECREF(threading);
 #endif
 }
@@ -1700 +1733 @@
 int Py_AtExit(void (*func)(void))
 {
-        if (nexitfuncs >= NEXITFUNCS)
-                return -1;
-        exitfuncs[nexitfuncs++] = func;
-        return 0;
+    if (nexitfuncs >= NEXITFUNCS)
+        return -1;
+    exitfuncs[nexitfuncs++] = func;
+    return 0;
 }
 
@@ -1709 +1742 @@
 call_sys_exitfunc(void)
 {
-        PyObject *exitfunc = PySys_GetObject("exitfunc");
-
-        if (exitfunc) {
-                PyObject *res;
-                Py_INCREF(exitfunc);
-                PySys_SetObject("exitfunc", (PyObject *)NULL);
-                res = PyEval_CallObject(exitfunc, (PyObject *)NULL);
-                if (res == NULL) {
-                        if (!PyErr_ExceptionMatches(PyExc_SystemExit)) {
-                                PySys_WriteStderr("Error in sys.exitfunc:\n");
-                        }
-                        PyErr_Print();
-                }
-                Py_DECREF(exitfunc);
-        }
-
-        if (Py_FlushLine())
-                PyErr_Clear();
+    PyObject *exitfunc = PySys_GetObject("exitfunc");
+
+    if (exitfunc) {
+        PyObject *res;
+        Py_INCREF(exitfunc);
+        PySys_SetObject("exitfunc", (PyObject *)NULL);
+        res = PyEval_CallObject(exitfunc, (PyObject *)NULL);
+        if (res == NULL) {
+            if (!PyErr_ExceptionMatches(PyExc_SystemExit)) {
+                PySys_WriteStderr("Error in sys.exitfunc:\n");
+            }
+            PyErr_Print();
+        }
+        Py_DECREF(exitfunc);
+    }
+
+    if (Py_FlushLine())
+        PyErr_Clear();
 }
 
@@ -1732 +1765 @@
 call_ll_exitfuncs(void)
 {
-        while (nexitfuncs > 0)
-                (*exitfuncs[--nexitfuncs])();
-
-        fflush(stdout);
-        fflush(stderr);
+    while (nexitfuncs > 0)
+        (*exitfuncs[--nexitfuncs])();
+
+    fflush(stdout);
+    fflush(stderr);
 }
 
@@ -1742 +1775 @@
 Py_Exit(int sts)
 {
-        Py_Finalize();
-
-        exit(sts);
+    Py_Finalize();
+
+    exit(sts);
 }
 
@@ -1751 +1784 @@
 {
 #ifdef SIGPIPE
-        PyOS_setsig(SIGPIPE, SIG_IGN);
+    PyOS_setsig(SIGPIPE, SIG_IGN);
 #endif
 #ifdef SIGXFZ
-        PyOS_setsig(SIGXFZ, SIG_IGN);
+    PyOS_setsig(SIGXFZ, SIG_IGN);
 #endif
 #ifdef SIGXFSZ
-        PyOS_setsig(SIGXFSZ, SIG_IGN);
-#endif
-        PyOS_InitInterrupts(); /* May imply initsignal() */
+    PyOS_setsig(SIGXFSZ, SIG_IGN);
+#endif
+    PyOS_InitInterrupts(); /* May imply initsignal() */
 }
 
@@ -1772 +1805 @@
 Py_FdIsInteractive(FILE *fp, const char *filename)
 {
-        if (isatty((int)fileno(fp)))
-                return 1;
-        if (!Py_InteractiveFlag)
-                return 0;
-        return (filename == NULL) ||
-               (strcmp(filename, "<stdin>") == 0) ||
-               (strcmp(filename, "???") == 0);
+    if (isatty((int)fileno(fp)))
+        return 1;
+    if (!Py_InteractiveFlag)
+        return 0;
+    return (filename == NULL) ||
+           (strcmp(filename, "<stdin>") == 0) ||
+           (strcmp(filename, "???") == 0);
 }
 
@@ -1796 +1829 @@
 PyOS_CheckStack(void)
 {
-        __try {
-                /* alloca throws a stack overflow exception if there's
-                   not enough space left on the stack */
-                alloca(PYOS_STACK_MARGIN * sizeof(void*));
-                return 0;
-        } __except (GetExceptionCode() == STATUS_STACK_OVERFLOW ?
-                        EXCEPTION_EXECUTE_HANDLER : 
-                        EXCEPTION_CONTINUE_SEARCH) {
-                int errcode = _resetstkoflw();
-                if (errcode == 0)
-                {
-                        Py_FatalError("Could not reset the stack!");
-                }
-        }
-        return 1;
+    __try {
+        /* alloca throws a stack overflow exception if there's
+           not enough space left on the stack */
+        alloca(PYOS_STACK_MARGIN * sizeof(void*));
+        return 0;
+    } __except (GetExceptionCode() == STATUS_STACK_OVERFLOW ?
+                    EXCEPTION_EXECUTE_HANDLER :
+            EXCEPTION_CONTINUE_SEARCH) {
+        int errcode = _resetstkoflw();
+        if (errcode == 0)
+        {
+            Py_FatalError("Could not reset the stack!");
+        }
+    }
+    return 1;
 }
 
@@ -1826 +1859 @@
 {
 #ifdef HAVE_SIGACTION
-        struct sigaction context;
-        if (sigaction(sig, NULL, &context) == -1)
-                return SIG_ERR;
-        return context.sa_handler;
+    struct sigaction context;
+    if (sigaction(sig, NULL, &context) == -1)
+        return SIG_ERR;
+    return context.sa_handler;
 #else
-        PyOS_sighandler_t handler;
+    PyOS_sighandler_t handler;
 /* Special signal handling for the secure CRT in Visual Studio 2005 */
 #if defined(_MSC_VER) && _MSC_VER >= 1400
-        switch (sig) {
-        /* Only these signals are valid */
-        case SIGINT:
-        case SIGILL:
-        case SIGFPE:
-        case SIGSEGV:
-        case SIGTERM:
-        case SIGBREAK:
-        case SIGABRT:
-                break;
-        /* Don't call signal() with other values or it will assert */
-        default:
-                return SIG_ERR;
-        }
+    switch (sig) {
+    /* Only these signals are valid */
+    case SIGINT:
+    case SIGILL:
+    case SIGFPE:
+    case SIGSEGV:
+    case SIGTERM:
+    case SIGBREAK:
+    case SIGABRT:
+        break;
+    /* Don't call signal() with other values or it will assert */
+    default:
+        return SIG_ERR;
+    }
 #endif /* _MSC_VER && _MSC_VER >= 1400 */
-        handler = signal(sig, SIG_IGN);
-        if (handler != SIG_ERR)
-                signal(sig, handler);
-        return handler;
+    handler = signal(sig, SIG_IGN);
+    if (handler != SIG_ERR)
+        signal(sig, handler);
+    return handler;
 #endif
 }
@@ -1860 +1893 @@
 {
 #ifdef HAVE_SIGACTION
-        struct sigaction context, ocontext;
-        context.sa_handler = handler;
-        sigemptyset(&context.sa_mask);
-        context.sa_flags = 0;
-        if (sigaction(sig, &context, &ocontext) == -1)
-                return SIG_ERR;
-        return ocontext.sa_handler;
+    /* Some code in Modules/signalmodule.c depends on sigaction() being
+     * used here if HAVE_SIGACTION is defined.  Fix that if this code
+     * changes to invalidate that assumption.
+     */
+    struct sigaction context, ocontext;
+    context.sa_handler = handler;
+    sigemptyset(&context.sa_mask);
+    context.sa_flags = 0;
+    if (sigaction(sig, &context, &ocontext) == -1)
+        return SIG_ERR;
+    return ocontext.sa_handler;
 #else
-        PyOS_sighandler_t oldhandler;
-        oldhandler = signal(sig, handler);
+    PyOS_sighandler_t oldhandler;
+    oldhandler = signal(sig, handler);
 #ifdef HAVE_SIGINTERRUPT
-        siginterrupt(sig, 1);
-#endif
-        return oldhandler;
+    siginterrupt(sig, 1);
+#endif
+    return oldhandler;
 #endif
 }
@@ -1883 +1920 @@
 PyParser_SimpleParseFile(FILE *fp, const char *filename, int start)
 {
-        return PyParser_SimpleParseFileFlags(fp, filename, start, 0);
+    return PyParser_SimpleParseFileFlags(fp, filename, start, 0);
 }
 
@@ -1890 +1927 @@
 PyParser_SimpleParseString(const char *str, int start)
 {
-        return PyParser_SimpleParseStringFlags(str, start, 0);
+    return PyParser_SimpleParseStringFlags(str, start, 0);
 }
 
@@ -1897 +1934 @@
 PyRun_AnyFile(FILE *fp, const char *name)
 {
-        return PyRun_AnyFileExFlags(fp, name, 0, NULL);
+    return PyRun_AnyFileExFlags(fp, name, 0, NULL);
 }
 
@@ -1904 +1941 @@
 PyRun_AnyFileEx(FILE *fp, const char *name, int closeit)
 {
-        return PyRun_AnyFileExFlags(fp, name, closeit, NULL);
+    return PyRun_AnyFileExFlags(fp, name, closeit, NULL);
 }
 
@@ -1911 +1948 @@
 PyRun_AnyFileFlags(FILE *fp, const char *name, PyCompilerFlags *flags)
 {
-        return PyRun_AnyFileExFlags(fp, name, 0, flags);
+    return PyRun_AnyFileExFlags(fp, name, 0, flags);
 }
 
@@ -1918 +1955 @@
 PyRun_File(FILE *fp, const char *p, int s, PyObject *g, PyObject *l)
 {
-        return PyRun_FileExFlags(fp, p, s, g, l, 0, NULL);
+    return PyRun_FileExFlags(fp, p, s, g, l, 0, NULL);
 }
 
@@ -1925 +1962 @@
 PyRun_FileEx(FILE *fp, const char *p, int s, PyObject *g, PyObject *l, int c)
 {
-        return PyRun_FileExFlags(fp, p, s, g, l, c, NULL);
+    return PyRun_FileExFlags(fp, p, s, g, l, c, NULL);
 }
 
@@ -1931 +1968 @@
 PyAPI_FUNC(PyObject *)
 PyRun_FileFlags(FILE *fp, const char *p, int s, PyObject *g, PyObject *l,
-                PyCompilerFlags *flags)
-{
-        return PyRun_FileExFlags(fp, p, s, g, l, 0, flags);
+                PyCompilerFlags *flags)
+{
+    return PyRun_FileExFlags(fp, p, s, g, l, 0, flags);
 }
 
@@ -1940 +1977 @@
 PyRun_SimpleFile(FILE *f, const char *p)
 {
-        return PyRun_SimpleFileExFlags(f, p, 0, NULL);
+    return PyRun_SimpleFileExFlags(f, p, 0, NULL);
 }
 
@@ -1947 +1984 @@
 PyRun_SimpleFileEx(FILE *f, const char *p, int c)
 {
-        return PyRun_SimpleFileExFlags(f, p, c, NULL);
+    return PyRun_SimpleFileExFlags(f, p, c, NULL);
 }
 
@@ -1955 +1992 @@
 PyRun_String(const char *str, int s, PyObject *g, PyObject *l)
 {
-        return PyRun_StringFlags(str, s, g, l, NULL);
+    return PyRun_StringFlags(str, s, g, l, NULL);
 }
 
@@ -1962 +1999 @@
 PyRun_SimpleString(const char *s)
 {
-        return PyRun_SimpleStringFlags(s, NULL);
+    return PyRun_SimpleStringFlags(s, NULL);
 }
 
@@ -1969 +2006 @@
 Py_CompileString(const char *str, const char *p, int s)
 {
-        return Py_CompileStringFlags(str, p, s, NULL);
+    return Py_CompileStringFlags(str, p, s, NULL);
 }
 
@@ -1976 +2013 @@
 PyRun_InteractiveOne(FILE *f, const char *p)
 {
-        return PyRun_InteractiveOneFlags(f, p, NULL);
+    return PyRun_InteractiveOneFlags(f, p, NULL);
 }
 
@@ -1983 +2020 @@
 PyRun_InteractiveLoop(FILE *f, const char *p)
 {
-        return PyRun_InteractiveLoopFlags(f, p, NULL);
+    return PyRun_InteractiveLoopFlags(f, p, NULL);
 }