churchyard / rpms / python3

Forked from rpms/python3 3 years ago
Clone

Blame 00262-pep538_coerce_legacy_c_locale.patch

3b36b49
diff --git a/Doc/using/cmdline.rst b/Doc/using/cmdline.rst
51bb7c4
index 08dc311..c6ec147 100644
3b36b49
--- a/Doc/using/cmdline.rst
3b36b49
+++ b/Doc/using/cmdline.rst
31fe33b
@@ -713,6 +713,40 @@ conflict.
3b36b49
 
3b36b49
    .. versionadded:: 3.6
3b36b49
 
3b36b49
+
3b36b49
+.. envvar:: PYTHONCOERCECLOCALE
3b36b49
+
31fe33b
+   If set to the value ``0``, causes the main Python command line application
3b36b49
+   to skip coercing the legacy ASCII-based C locale to a more capable UTF-8
3b36b49
+   based alternative. Note that this setting is checked even when the
3b36b49
+   :option:`-E` or :option:`-I` options are used, as it is handled prior to
3b36b49
+   the processing of command line options.
3b36b49
+
31fe33b
+   If this variable is *not* set, or is set to a value other than ``0``, and
31fe33b
+   the current locale reported for the ``LC_CTYPE`` category is the default
31fe33b
+   ``C`` locale, then the Python CLI will attempt to configure one of the
31fe33b
+   following locales for the given locale categories before loading the
31fe33b
+   interpreter runtime:
3b36b49
+
31fe33b
+   * ``C.UTF-8`` (``LC_ALL``)
31fe33b
+   * ``C.utf8`` (``LC_ALL``)
31fe33b
+   * ``UTF-8`` (``LC_CTYPE``)
3b36b49
+
3b36b49
+   If setting one of these locale categories succeeds, then the matching
31fe33b
+   environment variables will be set (both ``LC_ALL`` and ``LANG`` for the
31fe33b
+   ``LC_ALL`` category, and ``LC_CTYPE`` for the ``LC_CTYPE`` category) in
31fe33b
+   the current process environment before the Python runtime is initialized.
31fe33b
+
31fe33b
+   Configuring one of these locales (either explicitly or via the above
31fe33b
+   implicit locale coercion) will automatically set the error handler for
31fe33b
+   :data:`sys.stdin` and :data:`sys.stdout` to ``surrogateescape``. This
31fe33b
+   behavior can be overridden using :envvar:`PYTHONIOENCODING` as usual.
3b36b49
+
3b36b49
+   Availability: \*nix
3b36b49
+
3b36b49
+   .. versionadded:: 3.7
3b36b49
+      See :pep:`538` for more details.
3b36b49
+
3b36b49
 Debug-mode variables
3b36b49
 ~~~~~~~~~~~~~~~~~~~~
3b36b49
 
3b36b49
diff --git a/Lib/test/support/script_helper.py b/Lib/test/support/script_helper.py
51bb7c4
index 1e74647..b3ac848 100644
3b36b49
--- a/Lib/test/support/script_helper.py
3b36b49
+++ b/Lib/test/support/script_helper.py
51bb7c4
@@ -48,8 +48,35 @@ def interpreter_requires_environment():
3b36b49
     return __cached_interp_requires_environment
3b36b49
 
3b36b49
 
3b36b49
-_PythonRunResult = collections.namedtuple("_PythonRunResult",
3b36b49
-                                          ("rc", "out", "err"))
3b36b49
+class _PythonRunResult(collections.namedtuple("_PythonRunResult",
3b36b49
+                                          ("rc", "out", "err"))):
3b36b49
+    """Helper for reporting Python subprocess run results"""
3b36b49
+    def fail(self, cmd_line):
3b36b49
+        """Provide helpful details about failed subcommand runs"""
3b36b49
+        # Limit to 80 lines to ASCII characters
3b36b49
+        maxlen = 80 * 100
3b36b49
+        out, err = self.out, self.err
3b36b49
+        if len(out) > maxlen:
3b36b49
+            out = b'(... truncated stdout ...)' + out[-maxlen:]
3b36b49
+        if len(err) > maxlen:
3b36b49
+            err = b'(... truncated stderr ...)' + err[-maxlen:]
3b36b49
+        out = out.decode('ascii', 'replace').rstrip()
3b36b49
+        err = err.decode('ascii', 'replace').rstrip()
3b36b49
+        raise AssertionError("Process return code is %d\n"
3b36b49
+                             "command line: %r\n"
3b36b49
+                             "\n"
3b36b49
+                             "stdout:\n"
3b36b49
+                             "---\n"
3b36b49
+                             "%s\n"
3b36b49
+                             "---\n"
3b36b49
+                             "\n"
3b36b49
+                             "stderr:\n"
3b36b49
+                             "---\n"
3b36b49
+                             "%s\n"
3b36b49
+                             "---"
3b36b49
+                             % (self.rc, cmd_line,
3b36b49
+                                out,
3b36b49
+                                err))
3b36b49
 
3b36b49
 
3b36b49
 # Executing the interpreter in a subprocess
51bb7c4
@@ -107,30 +134,7 @@ def run_python_until_end(*args, **env_vars):
3b36b49
 def _assert_python(expected_success, *args, **env_vars):
3b36b49
     res, cmd_line = run_python_until_end(*args, **env_vars)
3b36b49
     if (res.rc and expected_success) or (not res.rc and not expected_success):
3b36b49
-        # Limit to 80 lines to ASCII characters
3b36b49
-        maxlen = 80 * 100
3b36b49
-        out, err = res.out, res.err
3b36b49
-        if len(out) > maxlen:
3b36b49
-            out = b'(... truncated stdout ...)' + out[-maxlen:]
3b36b49
-        if len(err) > maxlen:
3b36b49
-            err = b'(... truncated stderr ...)' + err[-maxlen:]
3b36b49
-        out = out.decode('ascii', 'replace').rstrip()
3b36b49
-        err = err.decode('ascii', 'replace').rstrip()
3b36b49
-        raise AssertionError("Process return code is %d\n"
3b36b49
-                             "command line: %r\n"
3b36b49
-                             "\n"
3b36b49
-                             "stdout:\n"
3b36b49
-                             "---\n"
3b36b49
-                             "%s\n"
3b36b49
-                             "---\n"
3b36b49
-                             "\n"
3b36b49
-                             "stderr:\n"
3b36b49
-                             "---\n"
3b36b49
-                             "%s\n"
3b36b49
-                             "---"
3b36b49
-                             % (res.rc, cmd_line,
3b36b49
-                                out,
3b36b49
-                                err))
3b36b49
+        res.fail(cmd_line)
3b36b49
     return res
3b36b49
 
3b36b49
 def assert_python_ok(*args, **env_vars):
51bb7c4
diff --git a/Lib/test/test_c_locale_coercion.py b/Lib/test/test_c_locale_coercion.py
51bb7c4
new file mode 100644
51bb7c4
index 0000000..ad6ecac
51bb7c4
--- /dev/null
51bb7c4
+++ b/Lib/test/test_c_locale_coercion.py
51bb7c4
@@ -0,0 +1,269 @@
51bb7c4
+# Tests the attempted automatic coercion of the C locale to a UTF-8 locale
51bb7c4
+
51bb7c4
+import unittest
51bb7c4
+import os
51bb7c4
+import sys
51bb7c4
+import sysconfig
51bb7c4
+import shutil
51bb7c4
+import subprocess
51bb7c4
+from collections import namedtuple
51bb7c4
+
51bb7c4
+import test.support
51bb7c4
+from test.support.script_helper import (
51bb7c4
+    run_python_until_end,
51bb7c4
+    interpreter_requires_environment,
51bb7c4
+)
51bb7c4
+
51bb7c4
+# In order to get the warning messages to match up as expected, the candidate
51bb7c4
+# order here must much the target locale order in Python/pylifecycle.c
51bb7c4
+_C_UTF8_LOCALES = (
51bb7c4
+    # Entries: (Target locale, expected env var updates)
51bb7c4
+    ("C.UTF-8", "LC_CTYPE & LANG"),
51bb7c4
+    ("C.utf8", "LC_CTYPE & LANG"),
51bb7c4
+    ("UTF-8", "LC_CTYPE"),
51bb7c4
+)
51bb7c4
+
51bb7c4
+# There's no reliable cross-platform way of checking locale alias
51bb7c4
+# lists, so the only way of knowing which of these locales will work
51bb7c4
+# is to try them with locale.setlocale(). We do that in a subprocess
51bb7c4
+# to avoid altering the locale of the test runner.
51bb7c4
+def _set_locale_in_subprocess(locale_name):
51bb7c4
+    cmd_fmt = "import locale; print(locale.setlocale(locale.LC_CTYPE, '{}'))"
51bb7c4
+    cmd = cmd_fmt.format(locale_name)
51bb7c4
+    result, py_cmd = run_python_until_end("-c", cmd, __isolated=True)
51bb7c4
+    return result.rc == 0
51bb7c4
+
51bb7c4
+_EncodingDetails = namedtuple("EncodingDetails",
51bb7c4
+                              "fsencoding stdin_info stdout_info stderr_info")
51bb7c4
+
51bb7c4
+class EncodingDetails(_EncodingDetails):
51bb7c4
+    CHILD_PROCESS_SCRIPT = ";".join([
51bb7c4
+        "import sys",
51bb7c4
+        "print(sys.getfilesystemencoding())",
51bb7c4
+        "print(sys.stdin.encoding + ':' + sys.stdin.errors)",
51bb7c4
+        "print(sys.stdout.encoding + ':' + sys.stdout.errors)",
51bb7c4
+        "print(sys.stderr.encoding + ':' + sys.stderr.errors)",
51bb7c4
+    ])
51bb7c4
+
51bb7c4
+    @classmethod
51bb7c4
+    def get_expected_details(cls, expected_fsencoding):
51bb7c4
+        """Returns expected child process details for a given encoding"""
51bb7c4
+        _stream = expected_fsencoding + ":{}"
51bb7c4
+        # stdin and stdout should use surrogateescape either because the
51bb7c4
+        # coercion triggered, or because the C locale was detected
51bb7c4
+        stream_info = 2*[_stream.format("surrogateescape")]
51bb7c4
+        # stderr should always use backslashreplace
51bb7c4
+        stream_info.append(_stream.format("backslashreplace"))
51bb7c4
+        return dict(cls(expected_fsencoding, *stream_info)._asdict())
51bb7c4
+
51bb7c4
+    @staticmethod
51bb7c4
+    def _handle_output_variations(data):
51bb7c4
+        """Adjust the output to handle platform specific idiosyncrasies
51bb7c4
+
51bb7c4
+        * Some platforms report ASCII as ANSI_X3.4-1968
51bb7c4
+        * Some platforms report ASCII as US-ASCII
51bb7c4
+        * Some platforms report UTF-8 instead of utf-8
51bb7c4
+        """
51bb7c4
+        data = data.replace(b"ANSI_X3.4-1968", b"ascii")
51bb7c4
+        data = data.replace(b"US-ASCII", b"ascii")
51bb7c4
+        data = data.lower()
51bb7c4
+        return data
51bb7c4
+
51bb7c4
+    @classmethod
51bb7c4
+    def get_child_details(cls, env_vars):
51bb7c4
+        """Retrieves fsencoding and standard stream details from a child process
51bb7c4
+
51bb7c4
+        Returns (encoding_details, stderr_lines):
51bb7c4
+
51bb7c4
+        - encoding_details: EncodingDetails for eager decoding
51bb7c4
+        - stderr_lines: result of calling splitlines() on the stderr output
51bb7c4
+
51bb7c4
+        The child is run in isolated mode if the current interpreter supports
51bb7c4
+        that.
51bb7c4
+        """
51bb7c4
+        result, py_cmd = run_python_until_end(
51bb7c4
+            "-c", cls.CHILD_PROCESS_SCRIPT,
51bb7c4
+            __isolated=True,
51bb7c4
+            **env_vars
51bb7c4
+        )
51bb7c4
+        if not result.rc == 0:
51bb7c4
+            result.fail(py_cmd)
51bb7c4
+        # All subprocess outputs in this test case should be pure ASCII
51bb7c4
+        adjusted_output = cls._handle_output_variations(result.out)
51bb7c4
+        stdout_lines = adjusted_output.decode("ascii").rstrip().splitlines()
51bb7c4
+        child_encoding_details = dict(cls(*stdout_lines)._asdict())
51bb7c4
+        stderr_lines = result.err.decode("ascii").rstrip().splitlines()
51bb7c4
+        return child_encoding_details, stderr_lines
51bb7c4
+
51bb7c4
+
51bb7c4
+class _ChildProcessEncodingTestCase(unittest.TestCase):
51bb7c4
+    # Base class to check for expected encoding details in a child process
51bb7c4
+
51bb7c4
+    def _check_child_encoding_details(self,
51bb7c4
+                                      env_vars,
51bb7c4
+                                      expected_fsencoding,
51bb7c4
+                                      expected_warning):
51bb7c4
+        """Check the C locale handling for the given process environment
51bb7c4
+
51bb7c4
+        Parameters:
51bb7c4
+            expected_fsencoding: the encoding the child is expected to report
51bb7c4
+            allow_c_locale: setting to use for PYTHONALLOWCLOCALE
51bb7c4
+              None: don't set the variable at all
51bb7c4
+              str: the value set in the child's environment
51bb7c4
+        """
51bb7c4
+        result = EncodingDetails.get_child_details(env_vars)
51bb7c4
+        encoding_details, stderr_lines = result
51bb7c4
+        self.assertEqual(encoding_details,
51bb7c4
+                         EncodingDetails.get_expected_details(
51bb7c4
+                             expected_fsencoding))
51bb7c4
+        self.assertEqual(stderr_lines, expected_warning)
51bb7c4
+
51bb7c4
+# Details of the shared library warning emitted at runtime
51bb7c4
+LIBRARY_C_LOCALE_WARNING = (
51bb7c4
+    "Python runtime initialized with LC_CTYPE=C (a locale with default ASCII "
51bb7c4
+    "encoding), which may cause Unicode compatibility problems. Using C.UTF-8, "
51bb7c4
+    "C.utf8, or UTF-8 (if available) as alternative Unicode-compatible "
51bb7c4
+    "locales is recommended."
51bb7c4
+)
51bb7c4
+
51bb7c4
+@unittest.skipUnless(sysconfig.get_config_var("PY_WARN_ON_C_LOCALE"),
51bb7c4
+                     "C locale runtime warning disabled at build time")
51bb7c4
+class LocaleWarningTests(_ChildProcessEncodingTestCase):
51bb7c4
+    # Test warning emitted when running in the C locale
51bb7c4
+
51bb7c4
+    def test_library_c_locale_warning(self):
51bb7c4
+        self.maxDiff = None
51bb7c4
+        for locale_to_set in ("C", "POSIX", "invalid.ascii"):
51bb7c4
+            var_dict = {
51bb7c4
+                "LC_ALL": locale_to_set
51bb7c4
+            }
51bb7c4
+            with self.subTest(forced_locale=locale_to_set):
51bb7c4
+                self._check_child_encoding_details(var_dict,
51bb7c4
+                                                   "ascii",
51bb7c4
+                                                   [LIBRARY_C_LOCALE_WARNING])
51bb7c4
+
51bb7c4
+# Details of the CLI locale coercion warning emitted at runtime
51bb7c4
+CLI_COERCION_WARNING_FMT = (
51bb7c4
+    "Python detected LC_CTYPE=C: {} coerced to {} (set another locale "
51bb7c4
+    "or PYTHONCOERCECLOCALE=0 to disable this locale coercion behavior)."
51bb7c4
+)
51bb7c4
+
51bb7c4
+class _LocaleCoercionTargetsTestCase(_ChildProcessEncodingTestCase):
51bb7c4
+    # Base class for test cases that rely on coercion targets being defined
51bb7c4
+
51bb7c4
+    available_targets = []
51bb7c4
+    targets_required = True
51bb7c4
+
51bb7c4
+    @classmethod
51bb7c4
+    def setUpClass(cls):
51bb7c4
+        first_target_locale = first_env_updates = None
51bb7c4
+        available_targets = cls.available_targets
51bb7c4
+        # Find the target locales available in the current system
51bb7c4
+        for target_locale, env_updates in _C_UTF8_LOCALES:
51bb7c4
+            if _set_locale_in_subprocess(target_locale):
51bb7c4
+                available_targets.append(target_locale)
51bb7c4
+                if first_target_locale is None:
51bb7c4
+                    first_target_locale = target_locale
51bb7c4
+                    first_env_updates = env_updates
51bb7c4
+        if cls.targets_required and not available_targets:
51bb7c4
+            raise unittest.SkipTest("No C-with-UTF-8 locale available")
51bb7c4
+        # Expect coercion to use the first available locale
51bb7c4
+        cls.EXPECTED_COERCION_WARNING = CLI_COERCION_WARNING_FMT.format(
51bb7c4
+            first_env_updates, first_target_locale
51bb7c4
+        )
51bb7c4
+
51bb7c4
+
51bb7c4
+class LocaleConfigurationTests(_LocaleCoercionTargetsTestCase):
51bb7c4
+    # Test explicit external configuration via the process environment
51bb7c4
+
51bb7c4
+    def test_external_target_locale_configuration(self):
51bb7c4
+        # Explicitly setting a target locale should give the same behaviour as
51bb7c4
+        # is seen when implicitly coercing to that target locale
51bb7c4
+        self.maxDiff = None
51bb7c4
+
51bb7c4
+        expected_warning = []
51bb7c4
+        expected_fsencoding = "utf-8"
51bb7c4
+
51bb7c4
+        base_var_dict = {
51bb7c4
+            "LANG": "",
51bb7c4
+            "LC_CTYPE": "",
51bb7c4
+            "LC_ALL": "",
51bb7c4
+        }
51bb7c4
+        for env_var in ("LANG", "LC_CTYPE"):
51bb7c4
+            for locale_to_set in self.available_targets:
51bb7c4
+                with self.subTest(env_var=env_var,
51bb7c4
+                                  configured_locale=locale_to_set):
51bb7c4
+                    var_dict = base_var_dict.copy()
51bb7c4
+                    var_dict[env_var] = locale_to_set
51bb7c4
+                    self._check_child_encoding_details(var_dict,
51bb7c4
+                                                       expected_fsencoding,
51bb7c4
+                                                       expected_warning)
51bb7c4
+
51bb7c4
+
51bb7c4
+
51bb7c4
+@test.support.cpython_only
51bb7c4
+@unittest.skipUnless(sysconfig.get_config_var("PY_COERCE_C_LOCALE"),
51bb7c4
+                     "C locale coercion disabled at build time")
51bb7c4
+class LocaleCoercionTests(_LocaleCoercionTargetsTestCase):
51bb7c4
+    # Test implicit reconfiguration of the environment during CLI startup
51bb7c4
+
51bb7c4
+    def _check_c_locale_coercion(self, expected_fsencoding, coerce_c_locale):
51bb7c4
+        """Check the C locale handling for various configurations
51bb7c4
+
51bb7c4
+        Parameters:
51bb7c4
+            expected_fsencoding: the encoding the child is expected to report
51bb7c4
+            allow_c_locale: setting to use for PYTHONALLOWCLOCALE
51bb7c4
+              None: don't set the variable at all
51bb7c4
+              str: the value set in the child's environment
51bb7c4
+        """
51bb7c4
+
51bb7c4
+        # Check for expected warning on stderr if C locale is coerced
51bb7c4
+        self.maxDiff = None
51bb7c4
+
51bb7c4
+        expected_warning = []
51bb7c4
+        if coerce_c_locale != "0":
51bb7c4
+            expected_warning.append(self.EXPECTED_COERCION_WARNING)
51bb7c4
+
51bb7c4
+        base_var_dict = {
51bb7c4
+            "LANG": "",
51bb7c4
+            "LC_CTYPE": "",
51bb7c4
+            "LC_ALL": "",
51bb7c4
+        }
51bb7c4
+        for env_var in ("LANG", "LC_CTYPE"):
51bb7c4
+            for locale_to_set in ("", "C", "POSIX", "invalid.ascii"):
51bb7c4
+                with self.subTest(env_var=env_var,
51bb7c4
+                                  nominal_locale=locale_to_set,
51bb7c4
+                                  PYTHONCOERCECLOCALE=coerce_c_locale):
51bb7c4
+                    var_dict = base_var_dict.copy()
51bb7c4
+                    var_dict[env_var] = locale_to_set
51bb7c4
+                    if coerce_c_locale is not None:
51bb7c4
+                        var_dict["PYTHONCOERCECLOCALE"] = coerce_c_locale
51bb7c4
+                    self._check_child_encoding_details(var_dict,
51bb7c4
+                                                       expected_fsencoding,
51bb7c4
+                                                       expected_warning)
51bb7c4
+
51bb7c4
+    def test_test_PYTHONCOERCECLOCALE_not_set(self):
51bb7c4
+        # This should coerce to the first available target locale by default
51bb7c4
+        self._check_c_locale_coercion("utf-8", coerce_c_locale=None)
51bb7c4
+
51bb7c4
+    def test_PYTHONCOERCECLOCALE_not_zero(self):
51bb7c4
+        # *Any* string other that "0" is considered "set" for our purposes
51bb7c4
+        # and hence should result in the locale coercion being enabled
51bb7c4
+        for setting in ("", "1", "true", "false"):
51bb7c4
+            self._check_c_locale_coercion("utf-8", coerce_c_locale=setting)
51bb7c4
+
51bb7c4
+    def test_PYTHONCOERCECLOCALE_set_to_zero(self):
51bb7c4
+        # The setting "0" should result in the locale coercion being disabled
51bb7c4
+        self._check_c_locale_coercion("ascii", coerce_c_locale="0")
51bb7c4
+
51bb7c4
+
51bb7c4
+def test_main():
51bb7c4
+    test.support.run_unittest(
51bb7c4
+        LocaleConfigurationTests,
51bb7c4
+        LocaleCoercionTests,
51bb7c4
+        LocaleWarningTests
51bb7c4
+    )
51bb7c4
+    test.support.reap_children()
51bb7c4
+
51bb7c4
+if __name__ == "__main__":
51bb7c4
+    test_main()
3b36b49
diff --git a/Lib/test/test_capi.py b/Lib/test/test_capi.py
51bb7c4
index eb3e2c5..f677d88 100644
3b36b49
--- a/Lib/test/test_capi.py
3b36b49
+++ b/Lib/test/test_capi.py
51bb7c4
@@ -369,14 +369,15 @@ def setUp(self):
31fe33b
     def tearDown(self):
31fe33b
         os.chdir(self.oldcwd)
31fe33b
 
31fe33b
-    def run_embedded_interpreter(self, *args):
31fe33b
+    def run_embedded_interpreter(self, *args, env=None):
31fe33b
         """Runs a test in the embedded interpreter"""
31fe33b
         cmd = [self.test_exe]
31fe33b
         cmd.extend(args)
31fe33b
         p = subprocess.Popen(cmd,
31fe33b
                              stdout=subprocess.PIPE,
31fe33b
                              stderr=subprocess.PIPE,
31fe33b
-                             universal_newlines=True)
31fe33b
+                             universal_newlines=True,
31fe33b
+                             env=env)
31fe33b
         (out, err) = p.communicate()
31fe33b
         self.assertEqual(p.returncode, 0,
31fe33b
                          "bad returncode %d, stderr is %r" %
51bb7c4
@@ -386,7 +387,7 @@ def run_embedded_interpreter(self, *args):
3b36b49
     def test_subinterps(self):
3b36b49
         # This is just a "don't crash" test
3b36b49
         out, err = self.run_embedded_interpreter("repeated_init_and_subinterpreters")
3b36b49
-        if support.verbose:
3b36b49
+        if support.verbose > 1:
3b36b49
             print()
3b36b49
             print(out)
3b36b49
             print(err)
51bb7c4
@@ -403,13 +404,14 @@ def _get_default_pipe_encoding():
31fe33b
 
3b36b49
     def test_forced_io_encoding(self):
3b36b49
         # Checks forced configuration of embedded interpreter IO streams
31fe33b
-        out, err = self.run_embedded_interpreter("forced_io_encoding")
3b36b49
-        if support.verbose:
31fe33b
+        env = {"PYTHONIOENCODING": "UTF-8:surrogateescape"}
31fe33b
+        out, err = self.run_embedded_interpreter("forced_io_encoding", env=env)
3b36b49
+        if support.verbose > 1:
3b36b49
             print()
3b36b49
             print(out)
3b36b49
             print(err)
3b36b49
-        expected_errors = sys.__stdout__.errors
3b36b49
-        expected_stdin_encoding = sys.__stdin__.encoding
3b36b49
+        expected_errors = "surrogateescape"
3b36b49
+        expected_stdin_encoding = "UTF-8"
3b36b49
         expected_pipe_encoding = self._get_default_pipe_encoding()
3b36b49
         expected_output = '\n'.join([
3b36b49
         "--- Use defaults ---",
3b36b49
diff --git a/Lib/test/test_cmd_line.py b/Lib/test/test_cmd_line.py
51bb7c4
index 958d282..c4c6850 100644
3b36b49
--- a/Lib/test/test_cmd_line.py
3b36b49
+++ b/Lib/test/test_cmd_line.py
51bb7c4
@@ -8,8 +8,9 @@
3b36b49
 import subprocess
3b36b49
 import tempfile
Iryna Shcherbina aba719b
 from test.support import script_helper, is_android
3b36b49
-from test.support.script_helper import (spawn_python, kill_python, assert_python_ok,
3b36b49
-    assert_python_failure)
3b36b49
+from test.support.script_helper import (
3b36b49
+    spawn_python, kill_python, assert_python_ok, assert_python_failure
3b36b49
+)
3b36b49
 
3b36b49
 
3b36b49
 # XXX (ncoghlan): Move to script_helper and make consistent with run_python
51bb7c4
@@ -150,6 +151,7 @@ def test_undecodable_code(self):
3b36b49
         env = os.environ.copy()
3b36b49
         # Use C locale to get ascii for the locale encoding
3b36b49
         env['LC_ALL'] = 'C'
3b36b49
+        env['PYTHONCOERCECLOCALE'] = '0'
3b36b49
         code = (
3b36b49
             b'import locale; '
3b36b49
             b'print(ascii("' + undecodable + b'"), '
3b36b49
diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
51bb7c4
index ed78e2a..3844812 100644
3b36b49
--- a/Lib/test/test_sys.py
3b36b49
+++ b/Lib/test/test_sys.py
51bb7c4
@@ -682,6 +682,7 @@ def c_locale_get_error_handler(self, isolated=False, encoding=None):
3b36b49
         # Force the POSIX locale
3b36b49
         env = os.environ.copy()
3b36b49
         env["LC_ALL"] = "C"
3b36b49
+        env["PYTHONCOERCECLOCALE"] = "0"
3b36b49
         code = '\n'.join((
3b36b49
             'import sys',
3b36b49
             'def dump(name):',
3b36b49
diff --git a/Programs/_testembed.c b/Programs/_testembed.c
51bb7c4
index a68d4fa..280bf50 100644
3b36b49
--- a/Programs/_testembed.c
3b36b49
+++ b/Programs/_testembed.c
3b36b49
@@ -1,4 +1,5 @@
3b36b49
-#include <Python.h>
3b36b49
+#include "Python.h"
3b36b49
+#include "pyconfig.h"
3b36b49
 #include <stdio.h>
3b36b49
 
3b36b49
 /*********************************************************
3b36b49
diff --git a/Programs/python.c b/Programs/python.c
31fe33b
index a7afbc7..03f8295 100644
3b36b49
--- a/Programs/python.c
3b36b49
+++ b/Programs/python.c
31fe33b
@@ -15,6 +15,21 @@ wmain(int argc, wchar_t **argv)
3b36b49
 }
3b36b49
 #else
3b36b49
 
31fe33b
+/* Access private pylifecycle helper API to better handle the legacy C locale
3b36b49
+ *
3b36b49
+ * The legacy C locale assumes ASCII as the default text encoding, which
3b36b49
+ * causes problems not only for the CPython runtime, but also other
3b36b49
+ * components like GNU readline.
3b36b49
+ *
3b36b49
+ * Accordingly, when the CLI detects it, it attempts to coerce it to a
3b36b49
+ * more capable UTF-8 based alternative.
3b36b49
+ *
3b36b49
+ * See the documentation of the PYTHONCOERCECLOCALE setting for more details.
3b36b49
+ *
3b36b49
+ */
31fe33b
+extern int _Py_LegacyLocaleDetected(void);
31fe33b
+extern void _Py_CoerceLegacyLocale(void);
3b36b49
+
31fe33b
 int
31fe33b
 main(int argc, char **argv)
31fe33b
 {
31fe33b
@@ -25,7 +40,11 @@ main(int argc, char **argv)
31fe33b
     char *oldloc;
31fe33b
 
31fe33b
     /* Force malloc() allocator to bootstrap Python */
31fe33b
+#ifdef Py_DEBUG
31fe33b
+    (void)_PyMem_SetupAllocators("malloc_debug");
31fe33b
+#  else
31fe33b
     (void)_PyMem_SetupAllocators("malloc");
31fe33b
+#  endif
31fe33b
 
31fe33b
     argv_copy = (wchar_t **)PyMem_RawMalloc(sizeof(wchar_t*) * (argc+1));
31fe33b
     argv_copy2 = (wchar_t **)PyMem_RawMalloc(sizeof(wchar_t*) * (argc+1));
31fe33b
@@ -49,7 +68,21 @@ main(int argc, char **argv)
31fe33b
         return 1;
31fe33b
     }
31fe33b
 
31fe33b
+#ifdef __ANDROID__
31fe33b
+    /* Passing "" to setlocale() on Android requests the C locale rather
31fe33b
+     * than checking environment variables, so request C.UTF-8 explicitly
31fe33b
+     */
31fe33b
+    setlocale(LC_ALL, "C.UTF-8");
31fe33b
+#else
31fe33b
+    /* Reconfigure the locale to the default for this process */
31fe33b
     setlocale(LC_ALL, "");
31fe33b
+#endif
31fe33b
+
31fe33b
+    if (_Py_LegacyLocaleDetected()) {
31fe33b
+        _Py_CoerceLegacyLocale();
31fe33b
+    }
31fe33b
+
31fe33b
+    /* Convert from char to wchar_t based on the locale settings */
31fe33b
     for (i = 0; i < argc; i++) {
31fe33b
         argv_copy[i] = Py_DecodeLocale(argv[i], NULL);
31fe33b
         if (!argv_copy[i]) {
31fe33b
@@ -70,7 +103,11 @@ main(int argc, char **argv)
31fe33b
 
31fe33b
     /* Force again malloc() allocator to release memory blocks allocated
31fe33b
        before Py_Main() */
31fe33b
+#ifdef Py_DEBUG
31fe33b
+    (void)_PyMem_SetupAllocators("malloc_debug");
31fe33b
+#  else
31fe33b
     (void)_PyMem_SetupAllocators("malloc");
31fe33b
+#  endif
31fe33b
 
31fe33b
     for (i = 0; i < argc; i++) {
31fe33b
         PyMem_RawFree(argv_copy2[i]);
31fe33b
diff --git a/Python/pylifecycle.c b/Python/pylifecycle.c
51bb7c4
index c0f41b3..278a5af 100644
31fe33b
--- a/Python/pylifecycle.c
31fe33b
+++ b/Python/pylifecycle.c
31fe33b
@@ -167,6 +167,7 @@ Py_SetStandardStreamEncoding(const char *encoding, const char *errors)
31fe33b
     return 0;
31fe33b
 }
31fe33b
 
31fe33b
+
31fe33b
 /* Global initializations.  Can be undone by Py_FinalizeEx().  Don't
31fe33b
    call this twice without an intervening Py_FinalizeEx() call.  When
31fe33b
    initializations fail, a fatal error is issued and the function does
51bb7c4
@@ -302,6 +303,167 @@ import_init(PyInterpreterState *interp, PyObject *sysmod)
31fe33b
 }
31fe33b
 
31fe33b
 
31fe33b
+/* Helper functions to better handle the legacy C locale
31fe33b
+ *
31fe33b
+ * The legacy C locale assumes ASCII as the default text encoding, which
31fe33b
+ * causes problems not only for the CPython runtime, but also other
31fe33b
+ * components like GNU readline.
31fe33b
+ *
31fe33b
+ * Accordingly, when the CLI detects it, it attempts to coerce it to a
31fe33b
+ * more capable UTF-8 based alternative as follows:
31fe33b
+ *
31fe33b
+ *     if (_Py_LegacyLocaleDetected()) {
31fe33b
+ *         _Py_CoerceLegacyLocale();
31fe33b
+ *     }
31fe33b
+ *
31fe33b
+ * See the documentation of the PYTHONCOERCECLOCALE setting for more details.
31fe33b
+ *
31fe33b
+ * Locale coercion also impacts the default error handler for the standard
31fe33b
+ * streams: while the usual default is "strict", the default for the legacy
31fe33b
+ * C locale and for any of the coercion target locales is "surrogateescape".
31fe33b
+ */
31fe33b
+
31fe33b
+int
31fe33b
+_Py_LegacyLocaleDetected(void)
31fe33b
+{
31fe33b
+    const char *ctype_loc = setlocale(LC_CTYPE, NULL);
31fe33b
+    return ctype_loc != NULL && strcmp(ctype_loc, "C") == 0;
31fe33b
+}
3b36b49
+
3b36b49
+typedef struct _CandidateLocale {
51bb7c4
+    const char *locale_name; /* The locale to try as a coercion target */
51bb7c4
+    int set_LANG;            /* Whether to set LANG in addition to LC_CTYPE */
3b36b49
+} _LocaleCoercionTarget;
3b36b49
+
3b36b49
+static _LocaleCoercionTarget _TARGET_LOCALES[] = {
51bb7c4
+    { "C.UTF-8", 1 },
51bb7c4
+    { "C.utf8",  1},
51bb7c4
+    { "UTF-8", 0 },
3b36b49
+    { NULL, 0 }
3b36b49
+};
3b36b49
+
31fe33b
+static char *
31fe33b
+get_default_standard_stream_error_handler(void)
31fe33b
+{
31fe33b
+    const char *ctype_loc = setlocale(LC_CTYPE, NULL);
31fe33b
+    if (ctype_loc != NULL) {
31fe33b
+        /* "surrogateescape" is the default in the legacy C locale */
31fe33b
+        if (strcmp(ctype_loc, "C") == 0) {
31fe33b
+            return "surrogateescape";
31fe33b
+        }
31fe33b
+
31fe33b
+        /* "surrogateescape" is the default in locale coercion target locales */
31fe33b
+        const _LocaleCoercionTarget *target = NULL;
31fe33b
+        for (target = _TARGET_LOCALES; target->locale_name; target++) {
31fe33b
+            if (strcmp(ctype_loc, target->locale_name) == 0) {
31fe33b
+                return "surrogateescape";
31fe33b
+            }
31fe33b
+        }
31fe33b
+   }
31fe33b
+
31fe33b
+   /* Otherwise return NULL to request the typical default error handler */
31fe33b
+   return NULL;
31fe33b
+}
31fe33b
+
31fe33b
+#ifdef PY_COERCE_C_LOCALE
31fe33b
+static const char *_C_LOCALE_COERCION_WARNING =
31fe33b
+    "Python detected LC_CTYPE=C: %.20s coerced to %.20s (set another locale "
31fe33b
+    "or PYTHONCOERCECLOCALE=0 to disable this locale coercion behavior).\n";
31fe33b
+
31fe33b
+static void
3b36b49
+_coerce_default_locale_settings(const _LocaleCoercionTarget *target)
3b36b49
+{
51bb7c4
+    const char *env_vars_updated = "LC_CTYPE";
3b36b49
+    const char *newloc = target->locale_name;
3b36b49
+
3b36b49
+    /* Reset locale back to currently configured defaults */
3b36b49
+    setlocale(LC_ALL, "");
3b36b49
+
3b36b49
+    /* Set the relevant locale environment variables */
51bb7c4
+    if (setenv("LC_CTYPE", newloc, 1)) {
51bb7c4
+        fprintf(stderr,
51bb7c4
+                "Error setting LC_CTYPE, skipping C locale coercion\n");
51bb7c4
+        return;
51bb7c4
+    }
51bb7c4
+    if (target->set_LANG) {
51bb7c4
+        if (setenv("LANG", newloc, 1) == 0) {
51bb7c4
+            env_vars_updated = "LC_CTYPE & LANG";
51bb7c4
+        } else {
3b36b49
+            fprintf(stderr,
3b36b49
+                    "Error setting LANG during C locale coercion\n");
3b36b49
+        }
3b36b49
+    }
51bb7c4
+    fprintf(stderr, _C_LOCALE_COERCION_WARNING, env_vars_updated, newloc);
3b36b49
+
3b36b49
+    /* Reconfigure with the overridden environment variables */
3b36b49
+    setlocale(LC_ALL, "");
3b36b49
+}
3b36b49
+
31fe33b
+static int
31fe33b
+c_locale_coercion_is_expected(void)
3b36b49
+{
31fe33b
+    /* This may be called prior to Py_Initialize, so we don't call any other
31fe33b
+     * Python APIs, and we ignore the -E and -I flags
31fe33b
+     */
3b36b49
+    const char *coerce_c_locale = getenv("PYTHONCOERCECLOCALE");
31fe33b
+    if (coerce_c_locale == NULL || strncmp(coerce_c_locale, "0", 2) != 0) {
31fe33b
+        return 1;
31fe33b
+    }
31fe33b
+    return 0;
31fe33b
+}
31fe33b
+#endif
31fe33b
+
31fe33b
+void
31fe33b
+_Py_CoerceLegacyLocale(void)
31fe33b
+{
31fe33b
+#ifdef PY_COERCE_C_LOCALE
31fe33b
+    /* We ignore the Python -E and -I flags here, as the CLI needs to sort out
3b36b49
+     * the locale settings *before* we try to do anything with the command
3b36b49
+     * line arguments. For cross-platform debugging purposes, we also need
3b36b49
+     * to give end users a way to force even scripts that are otherwise
3b36b49
+     * isolated from their environment to use the legacy ASCII-centric C
3b36b49
+     * locale.
3b36b49
+    */
31fe33b
+    if (c_locale_coercion_is_expected()) {
3b36b49
+        /* PYTHONCOERCECLOCALE is not set, or is not set to exactly "0" */
51bb7c4
+        const char *locale_override = getenv("LC_ALL");
51bb7c4
+        if (locale_override == NULL || *locale_override == '\0') {
51bb7c4
+            /* LC_ALL is also not set (or is set to an empty string) */
51bb7c4
+            const _LocaleCoercionTarget *target = NULL;
51bb7c4
+            for (target = _TARGET_LOCALES; target->locale_name; target++) {
51bb7c4
+                const char *new_locale = setlocale(LC_CTYPE,
51bb7c4
+                                                   target->locale_name);
51bb7c4
+                if (new_locale != NULL) {
51bb7c4
+                    /* Successfully configured locale, so make it the default */
51bb7c4
+                    _coerce_default_locale_settings(target);
51bb7c4
+                    return;
51bb7c4
+                }
3b36b49
+            }
3b36b49
+        }
3b36b49
+    }
3b36b49
+    /* No C locale warning here, as Py_Initialize will emit one later */
3b36b49
+#endif
31fe33b
+}
3b36b49
+
3b36b49
+
3b36b49
+#ifdef PY_WARN_ON_C_LOCALE
3b36b49
+static const char *_C_LOCALE_WARNING =
3b36b49
+    "Python runtime initialized with LC_CTYPE=C (a locale with default ASCII "
3b36b49
+    "encoding), which may cause Unicode compatibility problems. Using C.UTF-8, "
3b36b49
+    "C.utf8, or UTF-8 (if available) as alternative Unicode-compatible "
3b36b49
+    "locales is recommended.\n";
3b36b49
+
3b36b49
+static void
3b36b49
+_emit_stderr_warning_for_c_locale(void)
3b36b49
+{
31fe33b
+    if (c_locale_coercion_is_expected()) {
31fe33b
+        if (_Py_LegacyLocaleDetected()) {
3b36b49
+            fprintf(stderr, "%s", _C_LOCALE_WARNING);
3b36b49
+        }
3b36b49
+    }
3b36b49
+}
3b36b49
+#endif
3b36b49
+
3b36b49
 void
3b36b49
 _Py_InitializeEx_Private(int install_sigs, int install_importlib)
3b36b49
 {
51bb7c4
@@ -316,11 +478,19 @@ _Py_InitializeEx_Private(int install_sigs, int install_importlib)
3b36b49
     initialized = 1;
3b36b49
     _Py_Finalizing = NULL;
3b36b49
 
3b36b49
-#ifdef HAVE_SETLOCALE
3b36b49
+#ifdef __ANDROID__
3b36b49
+    /* Passing "" to setlocale() on Android requests the C locale rather
3b36b49
+     * than checking environment variables, so request C.UTF-8 explicitly
3b36b49
+     */
3b36b49
+    setlocale(LC_CTYPE, "C.UTF-8");
3b36b49
+#else
3b36b49
     /* Set up the LC_CTYPE locale, so we can obtain
3b36b49
        the locale's charset without having to switch
3b36b49
        locales. */
3b36b49
     setlocale(LC_CTYPE, "");
3b36b49
+#ifdef PY_WARN_ON_C_LOCALE
3b36b49
+    _emit_stderr_warning_for_c_locale();
3b36b49
+#endif
3b36b49
 #endif
3b36b49
 
3b36b49
     if ((p = Py_GETENV("PYTHONDEBUG")) && *p != '\0')
51bb7c4
@@ -1252,12 +1422,8 @@ initstdio(void)
31fe33b
             }
31fe33b
         }
31fe33b
         if (!errors && !(pythonioencoding && *pythonioencoding)) {
31fe33b
-            /* When the LC_CTYPE locale is the POSIX locale ("C locale"),
31fe33b
-               stdin and stdout use the surrogateescape error handler by
31fe33b
-               default, instead of the strict error handler. */
31fe33b
-            char *loc = setlocale(LC_CTYPE, NULL);
31fe33b
-            if (loc != NULL && strcmp(loc, "C") == 0)
31fe33b
-                errors = "surrogateescape";
31fe33b
+            /* Choose the default error handler based on the current locale */
31fe33b
+            errors = get_default_standard_stream_error_handler();
31fe33b
         }
31fe33b
     }
31fe33b
 
3b36b49
diff --git a/configure b/configure
51bb7c4
index c9340c6..8b1bd5b 100755
3b36b49
--- a/configure
3b36b49
+++ b/configure
3b36b49
@@ -834,6 +834,8 @@ with_thread
3b36b49
 enable_ipv6
3b36b49
 with_doc_strings
3b36b49
 with_pymalloc
3b36b49
+with_c_locale_coercion
3b36b49
+with_c_locale_warning
3b36b49
 with_valgrind
3b36b49
 with_dtrace
3b36b49
 with_fpectl
51bb7c4
@@ -1538,6 +1540,12 @@ Optional Packages:
3b36b49
                           deprecated; use --with(out)-threads
3b36b49
   --with(out)-doc-strings disable/enable documentation strings
3b36b49
   --with(out)-pymalloc    disable/enable specialized mallocs
3b36b49
+  --with(out)-c-locale-coercion
3b36b49
+                          disable/enable C locale coercion to a UTF-8 based
3b36b49
+                          locale
3b36b49
+  --with(out)-c-locale-warning
3b36b49
+                          disable/enable locale compatibility warning in the C
3b36b49
+                          locale
3b36b49
   --with-valgrind         Enable Valgrind support
3b36b49
   --with(out)-dtrace      disable/enable DTrace support
3b36b49
   --with-fpectl           enable SIGFPE catching
51bb7c4
@@ -11030,6 +11038,52 @@ fi
3b36b49
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_pymalloc" >&5
3b36b49
 $as_echo "$with_pymalloc" >&6; }
3b36b49
 
3b36b49
+# Check for --with-c-locale-coercion
3b36b49
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for --with-c-locale-coercion" >&5
3b36b49
+$as_echo_n "checking for --with-c-locale-coercion... " >&6; }
3b36b49
+
3b36b49
+# Check whether --with-c-locale-coercion was given.
3b36b49
+if test "${with_c_locale_coercion+set}" = set; then :
3b36b49
+  withval=$with_c_locale_coercion;
3b36b49
+fi
3b36b49
+
3b36b49
+
3b36b49
+if test -z "$with_c_locale_coercion"
3b36b49
+then
3b36b49
+    with_c_locale_coercion="yes"
3b36b49
+fi
3b36b49
+if test "$with_c_locale_coercion" != "no"
3b36b49
+then
3b36b49
+
3b36b49
+$as_echo "#define PY_COERCE_C_LOCALE 1" >>confdefs.h
3b36b49
+
3b36b49
+fi
3b36b49
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_c_locale_coercion" >&5
3b36b49
+$as_echo "$with_c_locale_coercion" >&6; }
3b36b49
+
3b36b49
+# Check for --with-c-locale-warning
3b36b49
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for --with-c-locale-warning" >&5
3b36b49
+$as_echo_n "checking for --with-c-locale-warning... " >&6; }
3b36b49
+
3b36b49
+# Check whether --with-c-locale-warning was given.
3b36b49
+if test "${with_c_locale_warning+set}" = set; then :
3b36b49
+  withval=$with_c_locale_warning;
3b36b49
+fi
3b36b49
+
3b36b49
+
3b36b49
+if test -z "$with_c_locale_warning"
3b36b49
+then
3b36b49
+    with_c_locale_warning="yes"
3b36b49
+fi
3b36b49
+if test "$with_c_locale_warning" != "no"
3b36b49
+then
3b36b49
+
3b36b49
+$as_echo "#define PY_WARN_ON_C_LOCALE 1" >>confdefs.h
3b36b49
+
3b36b49
+fi
3b36b49
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_c_locale_warning" >&5
3b36b49
+$as_echo "$with_c_locale_warning" >&6; }
3b36b49
+
3b36b49
 # Check for Valgrind support
3b36b49
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for --with-valgrind" >&5
3b36b49
 $as_echo_n "checking for --with-valgrind... " >&6; }
3b36b49
diff --git a/configure.ac b/configure.ac
51bb7c4
index e065ce5..c455ebd 100644
3b36b49
--- a/configure.ac
3b36b49
+++ b/configure.ac
51bb7c4
@@ -3304,6 +3304,40 @@ then
3b36b49
 fi
3b36b49
 AC_MSG_RESULT($with_pymalloc)
3b36b49
 
3b36b49
+# Check for --with-c-locale-coercion
3b36b49
+AC_MSG_CHECKING(for --with-c-locale-coercion)
3b36b49
+AC_ARG_WITH(c-locale-coercion,
3b36b49
+            AS_HELP_STRING([--with(out)-c-locale-coercion],
3b36b49
+              [disable/enable C locale coercion to a UTF-8 based locale]))
3b36b49
+
3b36b49
+if test -z "$with_c_locale_coercion"
3b36b49
+then
3b36b49
+    with_c_locale_coercion="yes"
3b36b49
+fi
3b36b49
+if test "$with_c_locale_coercion" != "no"
3b36b49
+then
3b36b49
+    AC_DEFINE(PY_COERCE_C_LOCALE, 1,
3b36b49
+      [Define if you want to coerce the C locale to a UTF-8 based locale])
3b36b49
+fi
3b36b49
+AC_MSG_RESULT($with_c_locale_coercion)
3b36b49
+
3b36b49
+# Check for --with-c-locale-warning
3b36b49
+AC_MSG_CHECKING(for --with-c-locale-warning)
3b36b49
+AC_ARG_WITH(c-locale-warning,
3b36b49
+            AS_HELP_STRING([--with(out)-c-locale-warning],
3b36b49
+              [disable/enable locale compatibility warning in the C locale]))
3b36b49
+
3b36b49
+if test -z "$with_c_locale_warning"
3b36b49
+then
3b36b49
+    with_c_locale_warning="yes"
3b36b49
+fi
3b36b49
+if test "$with_c_locale_warning" != "no"
3b36b49
+then
3b36b49
+    AC_DEFINE(PY_WARN_ON_C_LOCALE, 1,
3b36b49
+      [Define to emit a locale compatibility warning in the C locale])
3b36b49
+fi
3b36b49
+AC_MSG_RESULT($with_c_locale_warning)
3b36b49
+
3b36b49
 # Check for Valgrind support
3b36b49
 AC_MSG_CHECKING([for --with-valgrind])
3b36b49
 AC_ARG_WITH([valgrind],
3b36b49
diff --git a/pyconfig.h.in b/pyconfig.h.in
51bb7c4
index 0a3d59e..fa2792b 100644
3b36b49
--- a/pyconfig.h.in
3b36b49
+++ b/pyconfig.h.in
51bb7c4
@@ -1247,9 +1247,15 @@
3b36b49
 /* Define as the preferred size in bits of long digits */
3b36b49
 #undef PYLONG_BITS_IN_DIGIT
3b36b49
 
3b36b49
+/* Define if you want to coerce the C locale to a UTF-8 based locale */
3b36b49
+#undef PY_COERCE_C_LOCALE
3b36b49
+
3b36b49
 /* Define to printf format modifier for Py_ssize_t */
3b36b49
 #undef PY_FORMAT_SIZE_T
3b36b49
 
3b36b49
+/* Define to emit a locale compatibility warning in the C locale */
3b36b49
+#undef PY_WARN_ON_C_LOCALE
3b36b49
+
3b36b49
 /* Define if you want to build an interpreter with many run-time checks. */
3b36b49
 #undef Py_DEBUG
3b36b49