diff --git a/Include/internal/pycore_pylifecycle.h b/Include/internal/pycore_pylifecycle.h index 12e1e78526db35..c4a5c9422c256b 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_SimpleStringFlagsNoPrint(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..592605130650f9 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_SimpleFileObjectNoPrint( + FILE *fp, + PyObject *filename, + int closeit, + PyCompilerFlags *flags); + extern int _PyRun_InteractiveLoopObject( FILE *fp, PyObject *filename, diff --git a/Lib/test/test_embed.py b/Lib/test/test_embed.py index 2d1533c46b98f3..1bd0558bf5fe19 100644 --- a/Lib/test/test_embed.py +++ b/Lib/test/test_embed.py @@ -417,6 +417,47 @@ def test_run_main_loop(self): self.assertEqual(out, "Py_RunMain(): sys.argv=['-c', 'arg2']\n" * nloop) self.assertEqual(err, '') + def test_run_main_system_exit_command(self): + # gh-152132: Py_RunMain() must return the SystemExit code to the + # embedding application, not call exit() directly. + out, err = self.run_embedded_interpreter( + "test_run_main_system_exit_command") + self.assertEqual(out, '') + self.assertEqual(err, '') + + def test_run_main_system_exit_file(self): + # gh-152132: same as above, but for the run_filename code path. + with tempfile.NamedTemporaryFile(mode='w', suffix='.py', + delete=False) as f: + f.write("import sys; sys.exit(42)\n") + filename = f.name + try: + out, err = self.run_embedded_interpreter( + "test_run_main_system_exit_file", filename) + self.assertEqual(out, '') + self.assertEqual(err, '') + finally: + os.unlink(filename) + + def test_run_main_system_exit_module(self): + # gh-152132: same as above, but for the run_module code path. + with tempfile.TemporaryDirectory() as tmpdir: + mod = os.path.join(tmpdir, "exit_mod.py") + with open(mod, "w", encoding="utf-8") as f: + f.write("import sys; sys.exit(42)\n") + env = dict(os.environ, PYTHONPATH=tmpdir) + out, err = self.run_embedded_interpreter( + "test_run_main_system_exit_module", env=env) + self.assertEqual(out, '') + self.assertEqual(err, '') + + def test_run_main_system_exit_command_message(self): + # gh-152132: same as above, but with a string exit message. + out, err = self.run_embedded_interpreter( + "test_run_main_system_exit_command_message") + self.assertEqual(out, '') + self.assertIn('error message', err) + def test_finalize_structseq(self): # bpo-46417: Py_Finalize() clears structseq static types. Check that # sys attributes using struct types still work when diff --git a/Lib/test/test_runpy.py b/Lib/test/test_runpy.py index 55b9673ef6c91c..7f0162c56acedd 100644 --- a/Lib/test/test_runpy.py +++ b/Lib/test/test_runpy.py @@ -916,6 +916,47 @@ def test_pymain_run_module(self): ham = self.ham self.assertSigInt(["-m", ham.stem], cwd=ham.parent) + # Tests for sys.exit() handling (gh-152132) + # These only exercise the standard command-line path; the embedding API + # path is tested in Lib/test/test_embed.py. + @requires_subprocess() + def test_sys_exit_run_command(self): + cmd = [sys.executable, '-c', 'import sys; sys.exit(42)'] + proc = subprocess.run(cmd, text=True, stderr=subprocess.PIPE) + self.assertEqual(proc.returncode, 42) + + @requires_subprocess() + def test_sys_exit_run_command_default(self): + cmd = [sys.executable, '-c', 'import sys; sys.exit()'] + proc = subprocess.run(cmd, text=True, stderr=subprocess.PIPE) + self.assertEqual(proc.returncode, 0) + + @requires_subprocess() + def test_sys_exit_run_command_message(self): + cmd = [sys.executable, '-c', "import sys; sys.exit('error message')"] + proc = subprocess.run(cmd, text=True, stdout=subprocess.PIPE, + stderr=subprocess.PIPE) + self.assertEqual(proc.returncode, 1) + self.assertIn('error message', proc.stderr) + + @requires_subprocess() + def test_sys_exit_run_file(self): + with self.tmp_path() as tmp: + script = tmp / "exit_script.py" + script.write_text("import sys; sys.exit(42)") + cmd = [sys.executable, str(script)] + proc = subprocess.run(cmd, text=True, stderr=subprocess.PIPE) + self.assertEqual(proc.returncode, 42) + + @requires_subprocess() + def test_sys_exit_run_module(self): + with self.tmp_path() as tmp: + script = tmp / "exit_mod.py" + script.write_text("import sys; sys.exit(42)") + cmd = [sys.executable, '-m', 'exit_mod'] + proc = subprocess.run(cmd, cwd=tmp, text=True, stderr=subprocess.PIPE) + self.assertEqual(proc.returncode, 42) + if __name__ == "__main__": unittest.main() 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..5c603dc50e74f6 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_SimpleFileObjectNoPrint() #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 *result = _PyRun_SimpleStringFlagsNoPrint(PyBytes_AsString(bytes), "", &cf); Py_DECREF(bytes); - return (ret != 0); + if (result == NULL) { + return pymain_exit_err_print(); + } + Py_DECREF(result); + return 0; error: PySys_WriteStderr("Unable to decode the command from the command line:\n"); @@ -406,10 +409,24 @@ pymain_run_file_obj(PyObject *program_name, PyObject *filename, return pymain_exit_err_print(); } - /* PyRun_AnyFileExFlags(closeit=1) calls fclose(fp) before running code */ PyCompilerFlags cf = _PyCompilerFlags_INIT; - int run = _PyRun_AnyFileObject(fp, filename, 1, &cf); - return (run != 0); + + if (_Py_FdIsInteractive(fp, filename)) { + // Preserve the interactive REPL behavior for TTY inputs + // (e.g., "python3 /dev/stdin" when stdin is a terminal). + int run = _PyRun_InteractiveLoopObject(fp, filename, &cf); + fclose(fp); + return (run != 0); + } + + /* Use _PyRun_SimpleFileObjectNoPrint which returns PyObject* without calling + PyErr_Print(), so we can handle SystemExit properly via pymain_exit_err_print. */ + PyObject *result = _PyRun_SimpleFileObjectNoPrint(fp, filename, 1, &cf); + if (result == NULL) { + return pymain_exit_err_print(); + } + Py_DECREF(result); + return 0; } static int diff --git a/Programs/_testembed.c b/Programs/_testembed.c index 74d0fe37ddaead..daaa0fdb0ccb4f 100644 --- a/Programs/_testembed.c +++ b/Programs/_testembed.c @@ -2057,6 +2057,105 @@ static int test_run_main_loop(void) } +static int test_run_main_system_exit_command(void) +{ + // gh-152132: Py_RunMain() must return the SystemExit code instead of + // calling exit() directly. + PyConfig config; + PyConfig_InitPythonConfig(&config); + + wchar_t *argv[] = {L"python3", L"-c", L"import sys; sys.exit(42)"}; + config_set_argv(&config, Py_ARRAY_LENGTH(argv), argv); + config_set_string(&config, &config.program_name, L"./python3"); + init_from_config_clear(&config); + + int exitcode = Py_RunMain(); + if (exitcode != 42) { + fprintf(stderr, "expected exit code 42, got %d\n", exitcode); + return 1; + } + return 0; +} + + +static int test_run_main_system_exit_file(void) +{ + // gh-152132: Py_RunMain() must return the SystemExit code instead of + // calling exit() directly. + if (main_argc < 3) { + fprintf(stderr, "usage: %s test_run_main_system_exit_file SCRIPT\n", + PROGRAM); + return 1; + } + const char *filename = main_argv[2]; + wchar_t *wfilename = Py_DecodeLocale(filename, NULL); + if (wfilename == NULL) { + fprintf(stderr, "unable to decode filename\n"); + return 1; + } + + PyConfig config; + PyConfig_InitPythonConfig(&config); + + wchar_t *argv[] = {L"python3", wfilename}; + config_set_argv(&config, Py_ARRAY_LENGTH(argv), argv); + config_set_string(&config, &config.program_name, L"./python3"); + init_from_config_clear(&config); + + int exitcode = Py_RunMain(); + PyMem_RawFree(wfilename); + if (exitcode != 42) { + fprintf(stderr, "expected exit code 42, got %d\n", exitcode); + return 1; + } + return 0; +} + + +static int test_run_main_system_exit_module(void) +{ + // gh-152132: Py_RunMain() must return the SystemExit code instead of + // calling exit() directly. The module under -m is resolved from PYTHONPATH + // set by the test harness. + PyConfig config; + PyConfig_InitPythonConfig(&config); + + wchar_t *argv[] = {L"python3", L"-m", L"exit_mod"}; + config_set_argv(&config, Py_ARRAY_LENGTH(argv), argv); + config_set_string(&config, &config.program_name, L"./python3"); + init_from_config_clear(&config); + + int exitcode = Py_RunMain(); + if (exitcode != 42) { + fprintf(stderr, "expected exit code 42, got %d\n", exitcode); + return 1; + } + return 0; +} + + +static int test_run_main_system_exit_command_message(void) +{ + // gh-152132: Py_RunMain() must return the SystemExit code instead of + // calling exit() directly. + PyConfig config; + PyConfig_InitPythonConfig(&config); + + wchar_t *argv[] = {L"python3", L"-c", + L"import sys; sys.exit('error message')"}; + config_set_argv(&config, Py_ARRAY_LENGTH(argv), argv); + config_set_string(&config, &config.program_name, L"./python3"); + init_from_config_clear(&config); + + int exitcode = Py_RunMain(); + if (exitcode != 1) { + fprintf(stderr, "expected exit code 1, got %d\n", exitcode); + return 1; + } + return 0; +} + + static int test_get_argc_argv(void) { PyConfig config; @@ -2951,6 +3050,10 @@ static struct TestCase TestCases[] = { {"test_initconfig_module", test_initconfig_module}, {"test_run_main", test_run_main}, {"test_run_main_loop", test_run_main_loop}, + {"test_run_main_system_exit_command", test_run_main_system_exit_command}, + {"test_run_main_system_exit_file", test_run_main_system_exit_file}, + {"test_run_main_system_exit_module", test_run_main_system_exit_module}, + {"test_run_main_system_exit_command_message", test_run_main_system_exit_command_message}, {"test_get_argc_argv", test_get_argc_argv}, {"test_init_use_frozen_modules", test_init_use_frozen_modules}, {"test_init_main_interpreter_settings", test_init_main_interpreter_settings}, diff --git a/Python/pythonrun.c b/Python/pythonrun.c index 971ab064777a41..9c8dbcacf8da48 100644 --- a/Python/pythonrun.c +++ b/Python/pythonrun.c @@ -458,15 +458,19 @@ set_main_loader(PyObject *d, PyObject *filename, const char *loader_name) } -int -_PyRun_SimpleFileObject(FILE *fp, PyObject *filename, int closeit, - PyCompilerFlags *flags) +/* Run a simple file object. Returns the result PyObject* on success, + or NULL on failure. Does NOT call PyErr_Print(); the caller must + handle the error (e.g. with PyErr_Print() or + _Py_HandleSystemExitAndKeyboardInterrupt()). */ +PyObject * +_PyRun_SimpleFileObjectNoPrint(FILE *fp, PyObject *filename, int closeit, + PyCompilerFlags *flags) { - int ret = -1; + PyObject *result = NULL; PyObject *main_module = PyImport_AddModuleRef("__main__"); if (main_module == NULL) - return -1; + return NULL; PyObject *dict = PyModule_GetDict(main_module); // borrowed ref int set_file_name = 0; @@ -486,12 +490,12 @@ _PyRun_SimpleFileObject(FILE *fp, PyObject *filename, int closeit, goto done; } - PyObject *v; 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"); @@ -502,39 +506,58 @@ _PyRun_SimpleFileObject(FILE *fp, PyObject *filename, int closeit, if (set_main_loader(dict, filename, "SourcelessFileLoader") < 0) { fprintf(stderr, "python: failed to set __main__.__loader__\n"); - ret = -1; fclose(pyc_fp); goto done; } - v = run_pyc_file(pyc_fp, dict, dict, flags); + result = 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"); - ret = -1; goto done; } - v = pyrun_file(fp, filename, Py_file_input, dict, dict, - closeit, flags); + result = pyrun_file(fp, filename, Py_file_input, dict, dict, + closeit, flags); } flush_io(); - if (v == NULL) { - Py_CLEAR(main_module); - PyErr_Print(); - goto done; - } - Py_DECREF(v); - ret = 0; - done: +done: if (set_file_name) { - if (PyDict_PopString(dict, "__file__", NULL) < 0) { - PyErr_Print(); + if (result == 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 ret; + return result; +} + + +int +_PyRun_SimpleFileObject(FILE *fp, PyObject *filename, int closeit, + PyCompilerFlags *flags) +{ + PyObject *result = _PyRun_SimpleFileObjectNoPrint(fp, filename, closeit, + flags); + if (result == NULL) { + PyErr_Print(); + return -1; + } + Py_DECREF(result); + return 0; } @@ -552,37 +575,52 @@ PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit, } -int -_PyRun_SimpleStringFlagsWithName(const char *command, const char* name, PyCompilerFlags *flags) { +/* Run a simple string. Returns the result PyObject* on success, + or NULL on failure. Does NOT call PyErr_Print(); the caller must + handle the error (e.g. with PyErr_Print() or + _Py_HandleSystemExitAndKeyboardInterrupt()). */ +PyObject * +_PyRun_SimpleStringFlagsNoPrint(const char *command, const char* name, + PyCompilerFlags *flags) +{ PyObject *main_module = PyImport_AddModuleRef("__main__"); if (main_module == NULL) { - return -1; + return NULL; } PyObject *dict = PyModule_GetDict(main_module); // borrowed ref - PyObject *res = NULL; + PyObject *result = NULL; if (name == NULL) { - res = PyRun_StringFlags(command, Py_file_input, dict, dict, flags); + result = PyRun_StringFlags(command, Py_file_input, dict, dict, flags); } else { PyObject* the_name = PyUnicode_FromString(name); if (!the_name) { - PyErr_Print(); Py_DECREF(main_module); - return -1; + return NULL; } - res = _PyRun_StringFlagsWithName(command, the_name, Py_file_input, dict, dict, flags, 0); + result = _PyRun_StringFlagsWithName(command, the_name, Py_file_input, + dict, dict, flags, 0); Py_DECREF(the_name); } Py_DECREF(main_module); - if (res == NULL) { + return result; +} + + +int +_PyRun_SimpleStringFlagsWithName(const char *command, const char* name, + PyCompilerFlags *flags) +{ + PyObject *result = _PyRun_SimpleStringFlagsNoPrint(command, name, flags); + if (result == NULL) { PyErr_Print(); return -1; } - - Py_DECREF(res); + Py_DECREF(result); return 0; } + int PyRun_SimpleStringFlags(const char *command, PyCompilerFlags *flags) {