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/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/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. diff --git a/Modules/main.c b/Modules/main.c index a4dfddd98e257e..658937d8e93949 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,13 @@ pymain_run_command(wchar_t *command) PyCompilerFlags cf = _PyCompilerFlags_INIT; cf.cf_flags |= PyCF_IGNORE_COOKIE; - ret = _PyRun_SimpleStringFlagsWithName(PyBytes_AsString(bytes), "", &cf); + PyObject *res = _PyRun_SimpleStringFlagsEx(PyBytes_AsString(bytes), "", &cf); 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 +409,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..94ed7e79caa1ff 100644 --- a/Python/pythonrun.c +++ b/Python/pythonrun.c @@ -538,6 +538,94 @@ _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 (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); + return v; +} + + int PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit, PyCompilerFlags *flags) @@ -583,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) {