From 88d4cd7658472c7c41ddcf78b503c7e542c3332d Mon Sep 17 00:00:00 2001 From: tangyuan0821 Date: Thu, 25 Jun 2026 20:32:06 +0800 Subject: [PATCH 1/3] Fix Py_RunMain: don't call exit() on sys.exit() in run_command/run_filename paths --- Include/internal/pycore_pythonrun.h | 6 +++ Modules/main.c | 30 +++++++++--- Python/pythonrun.c | 76 +++++++++++++++++++++++++++++ 3 files changed, 105 insertions(+), 7 deletions(-) diff --git a/Include/internal/pycore_pythonrun.h b/Include/internal/pycore_pythonrun.h index 66dd7cd843b04f..a556fc078e6e59 100644 --- a/Include/internal/pycore_pythonrun.h +++ b/Include/internal/pycore_pythonrun.h @@ -20,6 +20,12 @@ extern int _PyRun_AnyFileObject( int closeit, PyCompilerFlags *flags); +extern PyObject * _PyRun_SimpleFileObjectEx( + FILE *fp, + PyObject *filename, + int closeit, + PyCompilerFlags *flags); + extern int _PyRun_InteractiveLoopObject( FILE *fp, PyObject *filename, diff --git a/Modules/main.c b/Modules/main.c index a4dfddd98e257e..98e8811d09f465 100644 --- a/Modules/main.c +++ b/Modules/main.c @@ -10,7 +10,7 @@ #include "pycore_pathconfig.h" // _PyPathConfig_ComputeSysPath0() #include "pycore_pylifecycle.h" // _Py_PreInitializeFromPyArgv() #include "pycore_pystate.h" // _PyInterpreterState_GET() -#include "pycore_pythonrun.h" // _PyRun_AnyFileObject() +#include "pycore_pythonrun.h" // _PyRun_SimpleFileObjectEx() #include "pycore_tuple.h" // _PyTuple_FromPair #include "pycore_unicodeobject.h" // _PyUnicode_Dedent() @@ -235,7 +235,6 @@ static int pymain_run_command(wchar_t *command) { PyObject *unicode, *bytes; - int ret; unicode = PyUnicode_FromWideChar(command, -1); if (unicode == NULL) { @@ -259,9 +258,21 @@ pymain_run_command(wchar_t *command) PyCompilerFlags cf = _PyCompilerFlags_INIT; cf.cf_flags |= PyCF_IGNORE_COOKIE; - ret = _PyRun_SimpleStringFlagsWithName(PyBytes_AsString(bytes), "", &cf); + PyObject *main_module = PyImport_AddModuleRef("__main__"); + if (main_module == NULL) { + Py_DECREF(bytes); + return pymain_exit_err_print(); + } + PyObject *dict = PyModule_GetDict(main_module); + PyObject *res = PyRun_StringFlags(PyBytes_AsString(bytes), Py_file_input, + dict, dict, &cf); + Py_DECREF(main_module); Py_DECREF(bytes); - return (ret != 0); + if (res == NULL) { + return pymain_exit_err_print(); + } + Py_DECREF(res); + return 0; error: PySys_WriteStderr("Unable to decode the command from the command line:\n"); @@ -406,10 +417,15 @@ pymain_run_file_obj(PyObject *program_name, PyObject *filename, return pymain_exit_err_print(); } - /* PyRun_AnyFileExFlags(closeit=1) calls fclose(fp) before running code */ + /* Use _PyRun_SimpleFileObjectEx which returns PyObject* without calling + PyErr_Print(), so we can handle SystemExit properly via pymain_exit_err_print. */ PyCompilerFlags cf = _PyCompilerFlags_INIT; - int run = _PyRun_AnyFileObject(fp, filename, 1, &cf); - return (run != 0); + PyObject *v = _PyRun_SimpleFileObjectEx(fp, filename, 1, &cf); + if (v == NULL) { + return pymain_exit_err_print(); + } + Py_DECREF(v); + return 0; } static int diff --git a/Python/pythonrun.c b/Python/pythonrun.c index 971ab064777a41..af1ed4a629d07d 100644 --- a/Python/pythonrun.c +++ b/Python/pythonrun.c @@ -538,6 +538,82 @@ _PyRun_SimpleFileObject(FILE *fp, PyObject *filename, int closeit, } +/* Variant of _PyRun_SimpleFileObject that returns the result object + instead of calling PyErr_Print() on failure. The caller (typically + pymain_run_file_obj in Modules/main.c) should handle the error + with _Py_HandleSystemExitAndKeyboardInterrupt or pymain_exit_err_print. */ +PyObject * +_PyRun_SimpleFileObjectEx(FILE *fp, PyObject *filename, int closeit, + PyCompilerFlags *flags) +{ + PyObject *v = NULL; + + PyObject *main_module = PyImport_AddModuleRef("__main__"); + if (main_module == NULL) + return NULL; + PyObject *dict = PyModule_GetDict(main_module); // borrowed ref + + int set_file_name = 0; + int has_file = PyDict_ContainsString(dict, "__file__"); + if (has_file < 0) { + goto done; + } + if (!has_file) { + if (PyDict_SetItemString(dict, "__file__", filename) < 0) { + goto done; + } + set_file_name = 1; + } + + int pyc = maybe_pyc_file(fp, filename, closeit); + if (pyc < 0) { + goto done; + } + + if (pyc) { + FILE *pyc_fp; + /* Try to run a pyc file. First, re-open in binary */ + if (closeit) { + fclose(fp); + closeit = 0; // already closed + } + + pyc_fp = Py_fopen(filename, "rb"); + if (pyc_fp == NULL) { + fprintf(stderr, "python: Can't reopen .pyc file\n"); + goto done; + } + + if (set_main_loader(dict, filename, "SourcelessFileLoader") < 0) { + fprintf(stderr, "python: failed to set __main__.__loader__\n"); + fclose(pyc_fp); + goto done; + } + v = run_pyc_file(pyc_fp, dict, dict, flags); + } else { + /* When running from stdin, leave __main__.__loader__ alone */ + if ((!PyUnicode_Check(filename) || !PyUnicode_EqualToUTF8(filename, "")) && + set_main_loader(dict, filename, "SourceFileLoader") < 0) { + fprintf(stderr, "python: failed to set __main__.__loader__\n"); + goto done; + } + v = pyrun_file(fp, filename, Py_file_input, dict, dict, + closeit, flags); + } + flush_io(); + +done: + if (set_file_name) { + if (PyDict_PopString(dict, "__file__", NULL) < 0) { + /* Non-fatal cleanup error; just clear it */ + PyErr_Clear(); + } + } + Py_XDECREF(main_module); + return v; +} + + int PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit, PyCompilerFlags *flags) From 220349e82c3243c6e8bdfc3a9645ba4d8656ecec Mon Sep 17 00:00:00 2001 From: tangyuan0821 Date: Thu, 25 Jun 2026 20:37:21 +0800 Subject: [PATCH 2/3] Handle sys.exit() in Py_RunMain command and file paths --- .../next/C_API/2026-06-25-20-35-38.gh-issue-152132.Vj4s5T.rst | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 Misc/NEWS.d/next/C_API/2026-06-25-20-35-38.gh-issue-152132.Vj4s5T.rst diff --git a/Misc/NEWS.d/next/C_API/2026-06-25-20-35-38.gh-issue-152132.Vj4s5T.rst b/Misc/NEWS.d/next/C_API/2026-06-25-20-35-38.gh-issue-152132.Vj4s5T.rst new file mode 100644 index 00000000000000..45da4fbb83689c --- /dev/null +++ b/Misc/NEWS.d/next/C_API/2026-06-25-20-35-38.gh-issue-152132.Vj4s5T.rst @@ -0,0 +1,3 @@ +Fix :c:func:`Py_RunMain` incorrectly calling ``exit()`` on +:exc:`SystemExit` when running a command or file. The exit code +is now returned to the caller. From e88db2f1ac568c51446f0fa7606122b9d4a4c37d Mon Sep 17 00:00:00 2001 From: tangyuan0821 Date: Thu, 25 Jun 2026 21:33:12 +0800 Subject: [PATCH 3/3] gh-152132: Fix missing traceback source lines and lost exceptions Two issues introduced by the Py_RunMain SystemExit fix: 1. pymain_run_command lost traceback source lines for -c commands because PyRun_StringFlags does not register source in linecache. Add _PyRun_SimpleStringFlagsEx, which returns PyObject* without calling PyErr_Print(), and use it in pymain_run_command with the "" name so source linecache registration is preserved. 2. _PyRun_SimpleFileObjectEx could lose exceptions during cleanup when PyDict_PopString fails (e.g. under low-memory conditions). Save and restore the original exception around cleanup code when the main code failed; use PyErr_Print() for cleanup errors when the main code succeeded to match legacy behavior. --- Include/internal/pycore_pylifecycle.h | 5 +++ Modules/main.c | 10 +----- Python/pythonrun.c | 45 +++++++++++++++++++++++++-- 3 files changed, 48 insertions(+), 12 deletions(-) diff --git a/Include/internal/pycore_pylifecycle.h b/Include/internal/pycore_pylifecycle.h index 12e1e78526db35..d01ec4f540230c 100644 --- a/Include/internal/pycore_pylifecycle.h +++ b/Include/internal/pycore_pylifecycle.h @@ -111,6 +111,11 @@ PyAPI_FUNC(char*) _Py_SetLocaleFromEnv(int category); // Export for special main.c string compiling with source tracebacks int _PyRun_SimpleStringFlagsWithName(const char *command, const char* name, PyCompilerFlags *flags); +// Like _PyRun_SimpleStringFlagsWithName but returns the result object +// instead of calling PyErr_Print() on failure. The caller should handle +// the error with _Py_HandleSystemExitAndKeyboardInterrupt or PyErr_Print. +PyObject *_PyRun_SimpleStringFlagsEx(const char *command, const char* name, PyCompilerFlags *flags); + /* interpreter config */ diff --git a/Modules/main.c b/Modules/main.c index 98e8811d09f465..658937d8e93949 100644 --- a/Modules/main.c +++ b/Modules/main.c @@ -258,15 +258,7 @@ pymain_run_command(wchar_t *command) PyCompilerFlags cf = _PyCompilerFlags_INIT; cf.cf_flags |= PyCF_IGNORE_COOKIE; - PyObject *main_module = PyImport_AddModuleRef("__main__"); - if (main_module == NULL) { - Py_DECREF(bytes); - return pymain_exit_err_print(); - } - PyObject *dict = PyModule_GetDict(main_module); - PyObject *res = PyRun_StringFlags(PyBytes_AsString(bytes), Py_file_input, - dict, dict, &cf); - Py_DECREF(main_module); + PyObject *res = _PyRun_SimpleStringFlagsEx(PyBytes_AsString(bytes), "", &cf); Py_DECREF(bytes); if (res == NULL) { return pymain_exit_err_print(); diff --git a/Python/pythonrun.c b/Python/pythonrun.c index af1ed4a629d07d..94ed7e79caa1ff 100644 --- a/Python/pythonrun.c +++ b/Python/pythonrun.c @@ -604,9 +604,21 @@ _PyRun_SimpleFileObjectEx(FILE *fp, PyObject *filename, int closeit, done: if (set_file_name) { - if (PyDict_PopString(dict, "__file__", NULL) < 0) { - /* Non-fatal cleanup error; just clear it */ - PyErr_Clear(); + if (v == NULL) { + // Main code failed: save the exception before cleanup + // so PyDict_PopString doesn't overwrite it + PyObject *saved_exc = PyErr_GetRaisedException(); + if (PyDict_PopString(dict, "__file__", NULL) < 0) { + /* Non-fatal cleanup error; just clear it */ + PyErr_Clear(); + } + PyErr_SetRaisedException(saved_exc); + } else { + // Main code succeeded: if cleanup fails, print it + // to match legacy behavior + if (PyDict_PopString(dict, "__file__", NULL) < 0) { + PyErr_Print(); + } } } Py_XDECREF(main_module); @@ -659,6 +671,33 @@ _PyRun_SimpleStringFlagsWithName(const char *command, const char* name, PyCompil return 0; } +PyObject * +_PyRun_SimpleStringFlagsEx(const char *command, const char* name, PyCompilerFlags *flags) +{ + PyObject *main_module = PyImport_AddModuleRef("__main__"); + if (main_module == NULL) { + return NULL; + } + PyObject *dict = PyModule_GetDict(main_module); // borrowed ref + + PyObject *res = NULL; + if (name == NULL) { + res = PyRun_StringFlags(command, Py_file_input, dict, dict, flags); + } else { + PyObject* the_name = PyUnicode_FromString(name); + if (!the_name) { + Py_DECREF(main_module); + return NULL; + } + res = _PyRun_StringFlagsWithName(command, the_name, Py_file_input, + dict, dict, flags, 0); + Py_DECREF(the_name); + } + Py_DECREF(main_module); + return res; +} + + int PyRun_SimpleStringFlags(const char *command, PyCompilerFlags *flags) {