From 06e7608207daab9fb82d13ccf2d3664535442f11 Mon Sep 17 00:00:00 2001 From: Victor Stinner Date: Wed, 19 Sep 2018 14:56:36 -0700 Subject: Revert "bpo-34589: Add -X coerce_c_locale command line option (GH-9378)" (GH-9430) * Revert "bpo-34589: Add -X coerce_c_locale command line option (GH-9378)" This reverts commit dbdee0073cf0b88fe541980ace1f650900f455cc. * Revert "bpo-34589: C locale coercion off by default (GH-9073)" This reverts commit 7a0791b6992d420dc52536257f2f093851ed7215. * Revert "bpo-34589: Make _PyCoreConfig.coerce_c_locale private (GH-9371)" This reverts commit 188ebfa475a6f6aa2d0ea14ca8e1fbe7865b6d27. --- Doc/using/cmdline.rst | 16 +-- Doc/whatsnew/3.7.rst | 7 -- Include/coreconfig.h | 29 +---- Include/pylifecycle.h | 4 - Lib/test/test_c_locale_coercion.py | 55 ++------- Lib/test/test_cmd_line.py | 7 +- Lib/test/test_embed.py | 8 +- Lib/test/test_sys.py | 8 +- Lib/test/test_utf8_mode.py | 3 +- .../C API/2018-09-18-00-09-31.bpo-34589.C7bUpq.rst | 3 - .../2018-09-18-01-41-33.bpo-34589.lLVTYc.rst | 2 - Modules/_testcapimodule.c | 8 +- Modules/main.c | 37 ++---- Programs/_testembed.c | 9 +- Programs/python.c | 2 +- Python/coreconfig.c | 129 +++++++-------------- Python/pylifecycle.c | 2 +- 17 files changed, 87 insertions(+), 242 deletions(-) delete mode 100644 Misc/NEWS.d/next/C API/2018-09-18-00-09-31.bpo-34589.C7bUpq.rst delete mode 100644 Misc/NEWS.d/next/Core and Builtins/2018-09-18-01-41-33.bpo-34589.lLVTYc.rst diff --git a/Doc/using/cmdline.rst b/Doc/using/cmdline.rst index cd3b241..b61df8a 100644 --- a/Doc/using/cmdline.rst +++ b/Doc/using/cmdline.rst @@ -438,22 +438,13 @@ Miscellaneous options * Set the :attr:`~sys.flags.dev_mode` attribute of :attr:`sys.flags` to ``True`` - * ``-X utf8`` enables UTF-8 mode (:pep:`540`) for operating system interfaces, overriding + * ``-X utf8`` enables UTF-8 mode for operating system interfaces, overriding the default locale-aware mode. ``-X utf8=0`` explicitly disables UTF-8 mode (even when it would otherwise activate automatically). See :envvar:`PYTHONUTF8` for more details. * ``-X pycache_prefix=PATH`` enables writing ``.pyc`` files to a parallel tree rooted at the given directory instead of to the code tree. See also :envvar:`PYTHONPYCACHEPREFIX`. - * ``-X coerce_c_locale`` or ``-X coerce_c_locale=1`` tries to coerce the C - locale (:pep:`538`). - ``-X coerce_c_locale=0`` skips coercing the legacy ASCII-based C and POSIX - locales to a more capable UTF-8 based alternative. - ``-X coerce_c_locale=warn`` will cause Python to emit warning messages on - ``stderr`` if either the locale coercion activates, or else if a locale - that *would* have triggered coercion is still active when the Python - runtime is initialized. - See :envvar:`PYTHONCOERCECLOCALE` for more details. It also allows passing arbitrary values and retrieving them through the :data:`sys._xoptions` dictionary. @@ -473,9 +464,6 @@ Miscellaneous options .. versionadded:: 3.7 The ``-X importtime``, ``-X dev`` and ``-X utf8`` options. - .. versionadded:: 3.7.1 - The ``-X coerce_c_locale`` option. - .. versionadded:: 3.8 The ``-X pycache_prefix`` option. @@ -862,8 +850,6 @@ conflict. order to force the interpreter to use ``ASCII`` instead of ``UTF-8`` for system interfaces. - Also available as the :option:`-X` ``coerce_c_locale`` option. - Availability: \*nix .. versionadded:: 3.7 diff --git a/Doc/whatsnew/3.7.rst b/Doc/whatsnew/3.7.rst index 6cd9d46..f53a026 100644 --- a/Doc/whatsnew/3.7.rst +++ b/Doc/whatsnew/3.7.rst @@ -2494,10 +2494,3 @@ versions, it respected an ill-defined subset of those environment variables, while in Python 3.7.0 it didn't read any of them due to :issue:`34247`). If this behavior is unwanted, set :c:data:`Py_IgnoreEnvironmentFlag` to 1 before calling :c:func:`Py_Initialize`. - -:c:func:`Py_Initialize` and :c:func:`Py_Main` cannot enable the C locale -coercion (:pep:`538`) anymore: it is always disabled. It can now only be -enabled by the Python program ("python3). - -New :option:`-X` ``coerce_c_locale`` command line option to control C locale -coercion (:pep:`538`). diff --git a/Include/coreconfig.h b/Include/coreconfig.h index 293d8ed..ef043ab 100644 --- a/Include/coreconfig.h +++ b/Include/coreconfig.h @@ -63,6 +63,8 @@ typedef struct { int show_alloc_count; /* -X showalloccount */ int dump_refs; /* PYTHONDUMPREFS */ int malloc_stats; /* PYTHONMALLOCSTATS */ + int coerce_c_locale; /* PYTHONCOERCECLOCALE, -1 means unknown */ + int coerce_c_locale_warn; /* PYTHONCOERCECLOCALE=warn */ /* Python filesystem encoding and error handler: sys.getfilesystemencoding() and sys.getfilesystemencodeerrors(). @@ -295,30 +297,6 @@ typedef struct { If set to -1 (default), inherit Py_FrozenFlag value. */ int _frozen; - /* C locale coercion (PEP 538). - - The option is enabled by the PYTHONCOERCECLOCALE environment - variable. The option is also enabled if the LC_CTYPE locale is "C" - and a target locale (ex: "C.UTF-8") is supported by the platform. - - Py_Initialize() and Py_Main() must not enable C locale coercion: it is - always disabled. The option can only be enabled by the Python program - ("python3). - - See also the _coerce_c_locale_warn option. */ - int _coerce_c_locale; - - /* C locale coercion warning (PEP 538). - - Enabled by the PYTHONCOERCECLOCALE=warn environment variable. - - Py_Initialize() and Py_Main() must not enable C locale coercion warning: - it is always disabled. The warning can only be enabled by the Python - program ("python3). - - See also the _coerce_c_locale option. */ - int _coerce_c_locale_warn; - } _PyCoreConfig; #ifdef MS_WINDOWS @@ -336,8 +314,7 @@ typedef struct { .use_hash_seed = -1, \ .faulthandler = -1, \ .tracemalloc = -1, \ - ._coerce_c_locale = 0, \ - ._coerce_c_locale_warn = 0, \ + .coerce_c_locale = -1, \ .utf8_mode = -1, \ .argc = -1, \ .nmodule_search_path = -1, \ diff --git a/Include/pylifecycle.h b/Include/pylifecycle.h index f64bae3..04e672e 100644 --- a/Include/pylifecycle.h +++ b/Include/pylifecycle.h @@ -83,11 +83,7 @@ PyAPI_FUNC(int) Py_FdIsInteractive(FILE *, const char *); /* Bootstrap __main__ (defined in Modules/main.c) */ PyAPI_FUNC(int) Py_Main(int argc, wchar_t **argv); #ifdef Py_BUILD_CORE -# ifdef MS_WINDOWS -PyAPI_FUNC(int) _Py_WindowsMain(int argc, wchar_t **argv); -# else PyAPI_FUNC(int) _Py_UnixMain(int argc, char **argv); -# endif #endif /* In getpath.c */ diff --git a/Lib/test/test_c_locale_coercion.py b/Lib/test/test_c_locale_coercion.py index f62208a..1db293b 100644 --- a/Lib/test/test_c_locale_coercion.py +++ b/Lib/test/test_c_locale_coercion.py @@ -139,7 +139,7 @@ class EncodingDetails(_EncodingDetails): return data @classmethod - def get_child_details(cls, env_vars, xoption=None): + def get_child_details(cls, env_vars): """Retrieves fsencoding and standard stream details from a child process Returns (encoding_details, stderr_lines): @@ -150,11 +150,10 @@ class EncodingDetails(_EncodingDetails): The child is run in isolated mode if the current interpreter supports that. """ - args = [] - if xoption: - args.extend(("-X", f"coerce_c_locale={xoption}")) - args.extend(("-X", "utf8=0", "-c", cls.CHILD_PROCESS_SCRIPT)) - result, py_cmd = run_python_until_end(*args, **env_vars) + result, py_cmd = run_python_until_end( + "-X", "utf8=0", "-c", cls.CHILD_PROCESS_SCRIPT, + **env_vars + ) if not result.rc == 0: result.fail(py_cmd) # All subprocess outputs in this test case should be pure ASCII @@ -213,8 +212,7 @@ class _LocaleHandlingTestCase(unittest.TestCase): expected_fs_encoding, expected_stream_encoding, expected_warnings, - coercion_expected, - xoption=None): + coercion_expected): """Check the C locale handling for the given process environment Parameters: @@ -222,7 +220,7 @@ class _LocaleHandlingTestCase(unittest.TestCase): expected_stream_encoding: expected encoding for standard streams expected_warning: stderr output to expect (if any) """ - result = EncodingDetails.get_child_details(env_vars, xoption) + result = EncodingDetails.get_child_details(env_vars) encoding_details, stderr_lines = result expected_details = EncodingDetails.get_expected_details( coercion_expected, @@ -292,7 +290,6 @@ class LocaleCoercionTests(_LocaleHandlingTestCase): coerce_c_locale, expected_warnings=None, coercion_expected=True, - use_xoption=False, **extra_vars): """Check the C locale handling for various configurations @@ -322,12 +319,8 @@ class LocaleCoercionTests(_LocaleHandlingTestCase): "PYTHONCOERCECLOCALE": "", } base_var_dict.update(extra_vars) - xoption = None if coerce_c_locale is not None: - if use_xoption: - xoption = coerce_c_locale - else: - base_var_dict["PYTHONCOERCECLOCALE"] = coerce_c_locale + base_var_dict["PYTHONCOERCECLOCALE"] = coerce_c_locale # Check behaviour for the default locale with self.subTest(default_locale=True, @@ -349,8 +342,7 @@ class LocaleCoercionTests(_LocaleHandlingTestCase): fs_encoding, stream_encoding, _expected_warnings, - _coercion_expected, - xoption=xoption) + _coercion_expected) # Check behaviour for explicitly configured locales for locale_to_set in EXPECTED_C_LOCALE_EQUIVALENTS: @@ -365,8 +357,7 @@ class LocaleCoercionTests(_LocaleHandlingTestCase): fs_encoding, stream_encoding, expected_warnings, - coercion_expected, - xoption=xoption) + coercion_expected) def test_PYTHONCOERCECLOCALE_not_set(self): # This should coerce to the first available target locale by default @@ -413,32 +404,6 @@ class LocaleCoercionTests(_LocaleHandlingTestCase): expected_warnings=[LEGACY_LOCALE_WARNING], coercion_expected=False) - def test_xoption_set_to_1(self): - self._check_c_locale_coercion("utf-8", "utf-8", coerce_c_locale="1", - use_xoption=True) - - def test_xoption_set_to_zero(self): - # The setting "0" should result in the locale coercion being disabled - self._check_c_locale_coercion(EXPECTED_C_LOCALE_FS_ENCODING, - EXPECTED_C_LOCALE_STREAM_ENCODING, - coerce_c_locale="0", - coercion_expected=False, - use_xoption=True) - # Setting LC_ALL=C shouldn't make any difference to the behaviour - self._check_c_locale_coercion(EXPECTED_C_LOCALE_FS_ENCODING, - EXPECTED_C_LOCALE_STREAM_ENCODING, - coerce_c_locale="0", - LC_ALL="C", - coercion_expected=False, - use_xoption=True) - - def test_xoption_set_to_warn(self): - # -X coerce_c_locale=warn enables runtime warnings for legacy locales - self._check_c_locale_coercion("utf-8", "utf-8", - coerce_c_locale="warn", - expected_warnings=[CLI_COERCION_WARNING], - use_xoption=True) - def test_main(): test.support.run_unittest( LocaleConfigurationTests, diff --git a/Lib/test/test_cmd_line.py b/Lib/test/test_cmd_line.py index 7e967b2..21511b8 100644 --- a/Lib/test/test_cmd_line.py +++ b/Lib/test/test_cmd_line.py @@ -159,16 +159,13 @@ class CmdLineTest(unittest.TestCase): env = os.environ.copy() # Use C locale to get ascii for the locale encoding env['LC_ALL'] = 'C' + env['PYTHONCOERCECLOCALE'] = '0' code = ( b'import locale; ' b'print(ascii("' + undecodable + b'"), ' b'locale.getpreferredencoding())') p = subprocess.Popen( - [sys.executable, - # Disable C locale coercion and UTF-8 Mode to not use UTF-8 - "-X", "coerce_c_locale=0", - "-X", "utf8=0", - "-c", code], + [sys.executable, "-c", code], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env) stdout, stderr = p.communicate() diff --git a/Lib/test/test_embed.py b/Lib/test/test_embed.py index e531fd4..80233a5 100644 --- a/Lib/test/test_embed.py +++ b/Lib/test/test_embed.py @@ -277,6 +277,8 @@ class InitConfigTests(EmbeddingTestsMixin, unittest.TestCase): 'filesystem_errors': None, 'utf8_mode': 0, + 'coerce_c_locale': 0, + 'coerce_c_locale_warn': 0, 'pycache_prefix': NULL_STR, 'program_name': './_testembed', @@ -304,8 +306,6 @@ class InitConfigTests(EmbeddingTestsMixin, unittest.TestCase): '_install_importlib': 1, '_check_hash_pycs_mode': 'default', '_frozen': 0, - '_coerce_c_locale': 0, - '_coerce_c_locale_warn': 0, } def get_stdio_encoding(self, env): @@ -324,6 +324,10 @@ class InitConfigTests(EmbeddingTestsMixin, unittest.TestCase): 'print(sys.getfilesystemencoding(), ' 'sys.getfilesystemencodeerrors())') args = (sys.executable, '-c', code) + env = dict(env) + if not isolated: + env['PYTHONCOERCECLOCALE'] = '0' + env['PYTHONUTF8'] = '0' proc = subprocess.run(args, text=True, env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE) diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py index a7f2928..b90366d 100644 --- a/Lib/test/test_sys.py +++ b/Lib/test/test_sys.py @@ -656,8 +656,9 @@ class SysModuleTest(unittest.TestCase): def c_locale_get_error_handler(self, locale, isolated=False, encoding=None): # Force the POSIX locale - env = dict(os.environ) + env = os.environ.copy() env["LC_ALL"] = locale + env["PYTHONCOERCECLOCALE"] = "0" code = '\n'.join(( 'import sys', 'def dump(name):', @@ -667,10 +668,7 @@ class SysModuleTest(unittest.TestCase): 'dump("stdout")', 'dump("stderr")', )) - args = [sys.executable, - "-X", "utf8=0", - "-X", "coerce_c_locale=0", - "-c", code] + args = [sys.executable, "-X", "utf8=0", "-c", code] if isolated: args.append("-I") if encoding is not None: diff --git a/Lib/test/test_utf8_mode.py b/Lib/test/test_utf8_mode.py index c3cbb49..7280ce7 100644 --- a/Lib/test/test_utf8_mode.py +++ b/Lib/test/test_utf8_mode.py @@ -27,8 +27,6 @@ class UTF8ModeTests(unittest.TestCase): return (loc in POSIX_LOCALES) def get_output(self, *args, failure=False, **kw): - # Always disable the C locale coercion (PEP 538) - args = ('-X', 'coerce_c_locale=0', *args) kw = dict(self.DEFAULT_ENV, **kw) if failure: out = assert_python_failure(*args, **kw) @@ -118,6 +116,7 @@ class UTF8ModeTests(unittest.TestCase): # PYTHONLEGACYWINDOWSFSENCODING disables the UTF-8 mode # and has the priority over -X utf8 and PYTHONUTF8 out = self.get_output('-X', 'utf8', '-c', code, + PYTHONUTF8='strict', PYTHONLEGACYWINDOWSFSENCODING='1') self.assertEqual(out, 'mbcs/replace') diff --git a/Misc/NEWS.d/next/C API/2018-09-18-00-09-31.bpo-34589.C7bUpq.rst b/Misc/NEWS.d/next/C API/2018-09-18-00-09-31.bpo-34589.C7bUpq.rst deleted file mode 100644 index 27b6a6e..0000000 --- a/Misc/NEWS.d/next/C API/2018-09-18-00-09-31.bpo-34589.C7bUpq.rst +++ /dev/null @@ -1,3 +0,0 @@ -Py_Initialize() and Py_Main() cannot enable the C locale coercion (PEP 538) -anymore: it is always disabled. It can now only be enabled by the Python -program ("python3). diff --git a/Misc/NEWS.d/next/Core and Builtins/2018-09-18-01-41-33.bpo-34589.lLVTYc.rst b/Misc/NEWS.d/next/Core and Builtins/2018-09-18-01-41-33.bpo-34589.lLVTYc.rst deleted file mode 100644 index 618092d..0000000 --- a/Misc/NEWS.d/next/Core and Builtins/2018-09-18-01-41-33.bpo-34589.lLVTYc.rst +++ /dev/null @@ -1,2 +0,0 @@ -Add a new :option:`-X` ``coerce_c_locale`` command line option to control C -locale coercion (:pep:`538`). diff --git a/Modules/_testcapimodule.c b/Modules/_testcapimodule.c index c21a6e3..add642f 100644 --- a/Modules/_testcapimodule.c +++ b/Modules/_testcapimodule.c @@ -4701,6 +4701,10 @@ get_coreconfig(PyObject *self, PyObject *Py_UNUSED(args)) PyLong_FromLong(config->dump_refs)); SET_ITEM("malloc_stats", PyLong_FromLong(config->malloc_stats)); + SET_ITEM("coerce_c_locale", + PyLong_FromLong(config->coerce_c_locale)); + SET_ITEM("coerce_c_locale_warn", + PyLong_FromLong(config->coerce_c_locale_warn)); SET_ITEM("filesystem_encoding", FROM_STRING(config->filesystem_encoding)); SET_ITEM("filesystem_errors", @@ -4779,10 +4783,6 @@ get_coreconfig(PyObject *self, PyObject *Py_UNUSED(args)) FROM_STRING(config->_check_hash_pycs_mode)); SET_ITEM("_frozen", PyLong_FromLong(config->_frozen)); - SET_ITEM("_coerce_c_locale", - PyLong_FromLong(config->_coerce_c_locale)); - SET_ITEM("_coerce_c_locale_warn", - PyLong_FromLong(config->_coerce_c_locale_warn)); return dict; diff --git a/Modules/main.c b/Modules/main.c index d4ae4a0..455178a 100644 --- a/Modules/main.c +++ b/Modules/main.c @@ -1342,9 +1342,9 @@ pymain_read_conf(_PyMain *pymain, _PyCoreConfig *config, * See the documentation of the PYTHONCOERCECLOCALE setting for more * details. */ - if (config->_coerce_c_locale && !locale_coerced) { + if (config->coerce_c_locale && !locale_coerced) { locale_coerced = 1; - _Py_CoerceLegacyLocale(config->_coerce_c_locale_warn); + _Py_CoerceLegacyLocale(config->coerce_c_locale_warn); encoding_changed = 1; } @@ -1367,7 +1367,7 @@ pymain_read_conf(_PyMain *pymain, _PyCoreConfig *config, /* Reset the configuration before reading again the configuration, just keep UTF-8 Mode value. */ int new_utf8_mode = config->utf8_mode; - int new_coerce_c_locale = config->_coerce_c_locale; + int new_coerce_c_locale = config->coerce_c_locale; if (_PyCoreConfig_Copy(config, &save_config) < 0) { pymain->err = _Py_INIT_NO_MEMORY(); goto done; @@ -1375,7 +1375,7 @@ pymain_read_conf(_PyMain *pymain, _PyCoreConfig *config, pymain_clear_cmdline(pymain, cmdline); memset(cmdline, 0, sizeof(*cmdline)); config->utf8_mode = new_utf8_mode; - config->_coerce_c_locale = new_coerce_c_locale; + config->coerce_c_locale = new_coerce_c_locale; /* The encoding changed: read again the configuration with the new encoding */ @@ -1700,8 +1700,7 @@ pymain_cmdline(_PyMain *pymain, _PyCoreConfig *config) static int -pymain_init(_PyMain *pymain, PyInterpreterState **interp_p, - int use_c_locale_coercion) +pymain_init(_PyMain *pymain, PyInterpreterState **interp_p) { /* 754 requires that FP exceptions run in "no stop" mode by default, * and until C vendors implement C99's ways to control FP exceptions, @@ -1714,11 +1713,6 @@ pymain_init(_PyMain *pymain, PyInterpreterState **interp_p, _PyCoreConfig local_config = _PyCoreConfig_INIT; _PyCoreConfig *config = &local_config; - if (use_c_locale_coercion) { - /* set to -1 to be able to enable the feature */ - config->_coerce_c_locale = -1; - config->_coerce_c_locale_warn = -1; - } _PyCoreConfig_GetGlobalConfig(config); @@ -1753,10 +1747,10 @@ pymain_init(_PyMain *pymain, PyInterpreterState **interp_p, static int -pymain_main(_PyMain *pymain, int use_c_locale_coercion) +pymain_main(_PyMain *pymain) { PyInterpreterState *interp; - int res = pymain_init(pymain, &interp, use_c_locale_coercion); + int res = pymain_init(pymain, &interp); if (res != 1) { if (pymain_run_python(pymain, interp) < 0) { _Py_FatalInitError(pymain->err); @@ -1783,22 +1777,10 @@ Py_Main(int argc, wchar_t **argv) pymain.argc = argc; pymain.wchar_argv = argv; - return pymain_main(&pymain, 0); + return pymain_main(&pymain); } -#ifdef MS_WINDOWS -int -_Py_WindowsMain(int argc, wchar_t **argv) -{ - _PyMain pymain = _PyMain_INIT; - pymain.use_bytes_argv = 0; - pymain.argc = argc; - pymain.wchar_argv = argv; - - return pymain_main(&pymain, 1); -} -#else int _Py_UnixMain(int argc, char **argv) { @@ -1807,9 +1789,8 @@ _Py_UnixMain(int argc, char **argv) pymain.argc = argc; pymain.bytes_argv = argv; - return pymain_main(&pymain, 1); + return pymain_main(&pymain); } -#endif /* this is gonna seem *real weird*, but if you put some other code between diff --git a/Programs/_testembed.c b/Programs/_testembed.c index b939469..99772ea 100644 --- a/Programs/_testembed.c +++ b/Programs/_testembed.c @@ -330,6 +330,8 @@ dump_config(void) printf("filesystem_encoding = %s\n", config->filesystem_encoding); printf("filesystem_errors = %s\n", config->filesystem_errors); + printf("coerce_c_locale = %i\n", config->coerce_c_locale); + printf("coerce_c_locale_warn = %i\n", config->coerce_c_locale_warn); printf("utf8_mode = %i\n", config->utf8_mode); printf("pycache_prefix = %ls\n", config->pycache_prefix); @@ -383,8 +385,6 @@ dump_config(void) printf("_install_importlib = %i\n", config->_install_importlib); printf("_check_hash_pycs_mode = %s\n", config->_check_hash_pycs_mode); printf("_frozen = %i\n", config->_frozen); - printf("_coerce_c_locale = %i\n", config->_coerce_c_locale); - printf("_coerce_c_locale_warn = %i\n", config->_coerce_c_locale_warn); #undef ASSERT_EQUAL #undef ASSERT_STR_EQUAL @@ -482,6 +482,8 @@ static int test_init_from_config(void) putenv("PYTHONMALLOCSTATS=0"); config.malloc_stats = 1; + /* FIXME: test coerce_c_locale and coerce_c_locale_warn */ + putenv("PYTHONUTF8=0"); Py_UTF8Mode = 0; config.utf8_mode = 1; @@ -604,7 +606,8 @@ static int test_init_isolated(void) /* Test _PyCoreConfig.isolated=1 */ _PyCoreConfig config = _PyCoreConfig_INIT; - /* Set utf8_mode to not depend on the locale */ + /* Set coerce_c_locale and utf8_mode to not depend on the locale */ + config.coerce_c_locale = 0; config.utf8_mode = 0; /* Use path starting with "./" avoids a search along the PATH */ config.program_name = L"./_testembed"; diff --git a/Programs/python.c b/Programs/python.c index c7697fa..78e48f8 100644 --- a/Programs/python.c +++ b/Programs/python.c @@ -6,7 +6,7 @@ int wmain(int argc, wchar_t **argv) { - return _Py_WindowsMain(argc, argv); + return Py_Main(argc, argv); } #else int diff --git a/Python/coreconfig.c b/Python/coreconfig.c index b2459dc..fae32e5 100644 --- a/Python/coreconfig.c +++ b/Python/coreconfig.c @@ -303,8 +303,8 @@ _PyCoreConfig_Copy(_PyCoreConfig *config, const _PyCoreConfig *config2) COPY_ATTR(dump_refs); COPY_ATTR(malloc_stats); - COPY_ATTR(_coerce_c_locale); - COPY_ATTR(_coerce_c_locale_warn); + COPY_ATTR(coerce_c_locale); + COPY_ATTR(coerce_c_locale_warn); COPY_ATTR(utf8_mode); COPY_WSTR_ATTR(pycache_prefix); @@ -705,17 +705,6 @@ config_init_utf8_mode(_PyCoreConfig *config) return _Py_INIT_OK(); } -#ifndef MS_WINDOWS - /* The C locale and the POSIX locale enable the UTF-8 Mode (PEP 540) */ - const char *ctype_loc = setlocale(LC_CTYPE, NULL); - if (ctype_loc != NULL - && (strcmp(ctype_loc, "C") == 0 || strcmp(ctype_loc, "POSIX") == 0)) - { - config->utf8_mode = 1; - return _Py_INIT_OK(); - } -#endif - return _Py_INIT_OK(); } @@ -819,6 +808,23 @@ config_read_env_vars(_PyCoreConfig *config) config->malloc_stats = 1; } + const char *env = _PyCoreConfig_GetEnv(config, "PYTHONCOERCECLOCALE"); + if (env) { + if (strcmp(env, "0") == 0) { + if (config->coerce_c_locale < 0) { + config->coerce_c_locale = 0; + } + } + else if (strcmp(env, "warn") == 0) { + config->coerce_c_locale_warn = 1; + } + else { + if (config->coerce_c_locale < 0) { + config->coerce_c_locale = 1; + } + } + } + wchar_t *path; int res = _PyCoreConfig_GetEnvDup(config, &path, L"PYTHONPATH", "PYTHONPATH"); @@ -958,76 +964,28 @@ config_read_complex_options(_PyCoreConfig *config) } -static _PyInitError -config_init_coerce_c_locale(_PyCoreConfig *config) +static void +config_init_locale(_PyCoreConfig *config) { - const wchar_t *xopt = config_get_xoption(config, L"coerce_c_locale"); - if (xopt) { - wchar_t *sep = wcschr(xopt, L'='); - if (sep) { - xopt = sep + 1; - if (wcscmp(xopt, L"1") == 0) { - if (config->_coerce_c_locale < 0) { - config->_coerce_c_locale = 1; - } - } - else if (wcscmp(xopt, L"0") == 0) { - if (config->_coerce_c_locale < 0) { - config->_coerce_c_locale = 0; - } - } - else if (wcscmp(xopt, L"warn") == 0) { - if (config->_coerce_c_locale_warn < 0) { - config->_coerce_c_locale_warn = 1; - } - } - else { - return _Py_INIT_USER_ERR("invalid -X coerce_c_locale option value"); - } - } - else { - if (config->_coerce_c_locale < 0) { - config->_coerce_c_locale = 1; - } - } - - if (config->_coerce_c_locale_warn < 0) { - config->_coerce_c_locale_warn = 0; - } - } - - const char *env = _PyCoreConfig_GetEnv(config, "PYTHONCOERCECLOCALE"); - if (env) { - if (strcmp(env, "0") == 0) { - if (config->_coerce_c_locale < 0) { - config->_coerce_c_locale = 0; - } - } - else if (strcmp(env, "warn") == 0) { - if (config->_coerce_c_locale_warn < 0) { - config->_coerce_c_locale_warn = 1; - } - } - else { - if (config->_coerce_c_locale < 0) { - config->_coerce_c_locale = 1; - } - } - - if (config->_coerce_c_locale_warn < 0) { - config->_coerce_c_locale_warn = 0; - } - } - - if (config->_coerce_c_locale < 0) { + if (config->coerce_c_locale < 0) { /* The C locale enables the C locale coercion (PEP 538) */ if (_Py_LegacyLocaleDetected()) { - config->_coerce_c_locale = 1; - return _Py_INIT_OK(); + config->coerce_c_locale = 1; } } - return _Py_INIT_OK(); +#ifndef MS_WINDOWS + if (config->utf8_mode < 0) { + /* The C locale and the POSIX locale enable the UTF-8 Mode (PEP 540) */ + const char *ctype_loc = setlocale(LC_CTYPE, NULL); + if (ctype_loc != NULL + && (strcmp(ctype_loc, "C") == 0 + || strcmp(ctype_loc, "POSIX") == 0)) + { + config->utf8_mode = 1; + } + } +#endif } @@ -1333,11 +1291,8 @@ _PyCoreConfig_Read(_PyCoreConfig *config) } } - if (config->_coerce_c_locale < 0 || config->_coerce_c_locale_warn < 0) { - err = config_init_coerce_c_locale(config); - if (_Py_INIT_FAILED(err)) { - return err; - } + if (config->utf8_mode < 0 || config->coerce_c_locale < 0) { + config_init_locale(config); } if (config->_install_importlib) { @@ -1366,11 +1321,8 @@ _PyCoreConfig_Read(_PyCoreConfig *config) if (config->tracemalloc < 0) { config->tracemalloc = 0; } - if (config->_coerce_c_locale < 0) { - config->_coerce_c_locale = 0; - } - if (config->_coerce_c_locale_warn < 0) { - config->_coerce_c_locale_warn = 0; + if (config->coerce_c_locale < 0) { + config->coerce_c_locale = 0; } if (config->utf8_mode < 0) { config->utf8_mode = 0; @@ -1391,8 +1343,7 @@ _PyCoreConfig_Read(_PyCoreConfig *config) return err; } - assert(config->_coerce_c_locale >= 0); - assert(config->_coerce_c_locale_warn >= 0); + assert(config->coerce_c_locale >= 0); assert(config->use_environment >= 0); assert(config->filesystem_encoding != NULL); assert(config->filesystem_errors != NULL); diff --git a/Python/pylifecycle.c b/Python/pylifecycle.c index 06ea6b4..ec39500 100644 --- a/Python/pylifecycle.c +++ b/Python/pylifecycle.c @@ -295,7 +295,7 @@ static const char *_C_LOCALE_WARNING = static void _emit_stderr_warning_for_legacy_locale(const _PyCoreConfig *core_config) { - if (core_config->_coerce_c_locale_warn && _Py_LegacyLocaleDetected()) { + if (core_config->coerce_c_locale_warn && _Py_LegacyLocaleDetected()) { PySys_FormatStderr("%s", _C_LOCALE_WARNING); } } -- cgit v0.12