text: #include "Python.h"
  #include "internal/pystate.h"
  #include <locale.h>
  #ifdef HAVE_LANGINFO_H
  #  include <langinfo.h>
  #endif
  
  #include <locale.h>     /* setlocale() */
  #ifdef HAVE_LANGINFO_H
  #include <langinfo.h>   /* nl_langinfo(CODESET) */
  #endif
  
  
  #define DECODE_LOCALE_ERR(NAME, LEN) \
      (((LEN) == -2) \
       ? _Py_INIT_USER_ERR("cannot decode " NAME) \
       : _Py_INIT_NO_MEMORY())
  
  
  /* Global configuration variables */
  
  /* The filesystem encoding is chosen by config_init_fs_encoding(),
     see also initfsencoding(). */
  const char *Py_FileSystemDefaultEncoding = NULL;
  int Py_HasFileSystemDefaultEncoding = 0;
  const char *Py_FileSystemDefaultEncodeErrors = NULL;
  static int _Py_HasFileSystemDefaultEncodeErrors = 0;
  
  /* UTF-8 mode (PEP 540): if equals to 1, use the UTF-8 encoding, and change
     stdin and stdout error handler to "surrogateescape". It is equal to
     -1 by default: unknown, will be set by Py_Main() */
  int Py_UTF8Mode = -1;
  int Py_DebugFlag = 0; /* Needed by parser.c */
  int Py_VerboseFlag = 0; /* Needed by import.c */
  int Py_QuietFlag = 0; /* Needed by sysmodule.c */
  int Py_InteractiveFlag = 0; /* Needed by Py_FdIsInteractive() below */
  int Py_InspectFlag = 0; /* Needed to determine whether to exit at SystemExit */
  int Py_OptimizeFlag = 0; /* Needed by compile.c */
  int Py_NoSiteFlag = 0; /* Suppress 'import site' */
  int Py_BytesWarningFlag = 0; /* Warn on str(bytes) and str(buffer) */
  int Py_FrozenFlag = 0; /* Needed by getpath.c */
  int Py_IgnoreEnvironmentFlag = 0; /* e.g. PYTHONPATH, PYTHONHOME */
  int Py_DontWriteBytecodeFlag = 0; /* Suppress writing bytecode files (*.pyc) */
  int Py_NoUserSiteDirectory = 0; /* for -s and site.py */
  int Py_UnbufferedStdioFlag = 0; /* Unbuffered binary std{in,out,err} */
  int Py_HashRandomizationFlag = 0; /* for -R and PYTHONHASHSEED */
  int Py_IsolatedFlag = 0; /* for -I, isolate from user's env */
  #ifdef MS_WINDOWS
  int Py_LegacyWindowsFSEncodingFlag = 0; /* Uses mbcs instead of utf-8 */
  int Py_LegacyWindowsStdioFlag = 0; /* Uses FileIO instead of WindowsConsoleIO */
  #endif
  
  
  void
  _Py_wstrlist_clear(int len, wchar_t **list)
  {
      for (int i=0; i < len; i++) {
          PyMem_RawFree(list[i]);
      }
      PyMem_RawFree(list);
  }
  
  
  wchar_t**
  _Py_wstrlist_copy(int len, wchar_t **list)
  {
      assert((len > 0 && list != NULL) || len == 0);
      size_t size = len * sizeof(list[0]);
      wchar_t **list_copy = PyMem_RawMalloc(size);
      if (list_copy == NULL) {
          return NULL;
      }
      for (int i=0; i < len; i++) {
          wchar_t* arg = _PyMem_RawWcsdup(list[i]);
          if (arg == NULL) {
              _Py_wstrlist_clear(i, list_copy);
              return NULL;
          }
          list_copy[i] = arg;
      }
      return list_copy;
  }
  
  
  void
  _Py_ClearFileSystemEncoding(void)
  {
      if (!Py_HasFileSystemDefaultEncoding && Py_FileSystemDefaultEncoding) {
          PyMem_RawFree((char*)Py_FileSystemDefaultEncoding);
          Py_FileSystemDefaultEncoding = NULL;
      }
      if (!_Py_HasFileSystemDefaultEncodeErrors && Py_FileSystemDefaultEncodeErrors) {
          PyMem_RawFree((char*)Py_FileSystemDefaultEncodeErrors);
          Py_FileSystemDefaultEncodeErrors = NULL;
      }
  }
  
  
  /* Set Py_FileSystemDefaultEncoding and Py_FileSystemDefaultEncodeErrors
     global configuration variables. */
  int
  _Py_SetFileSystemEncoding(const char *encoding, const char *errors)
  {
      char *encoding2 = _PyMem_RawStrdup(encoding);
      if (encoding2 == NULL) {
          return -1;
      }
  
      char *errors2 = _PyMem_RawStrdup(errors);
      if (errors2 == NULL) {
          PyMem_RawFree(encoding2);
          return -1;
      }
  
      _Py_ClearFileSystemEncoding();
  
      Py_FileSystemDefaultEncoding = encoding2;
      Py_HasFileSystemDefaultEncoding = 0;
  
      Py_FileSystemDefaultEncodeErrors = errors2;
      _Py_HasFileSystemDefaultEncodeErrors = 0;
      return 0;
  }
  
  
  /* Helper to allow an embedding application to override the normal
   * mechanism that attempts to figure out an appropriate IO encoding
   */
  
  static char *_Py_StandardStreamEncoding = NULL;
  static char *_Py_StandardStreamErrors = NULL;
  
  int
  Py_SetStandardStreamEncoding(const char *encoding, const char *errors)
  {
      if (Py_IsInitialized()) {
          /* This is too late to have any effect */
          return -1;
      }
  
      int res = 0;
  
      /* Py_SetStandardStreamEncoding() can be called before Py_Initialize(),
         but Py_Initialize() can change the allocator. Use a known allocator
         to be able to release the memory later. */
      PyMemAllocatorEx old_alloc;
      _PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
  
      /* Can't call PyErr_NoMemory() on errors, as Python hasn't been
       * initialised yet.
       *
       * However, the raw memory allocators are initialised appropriately
       * as C static variables, so _PyMem_RawStrdup is OK even though
       * Py_Initialize hasn't been called yet.
       */
      if (encoding) {
          _Py_StandardStreamEncoding = _PyMem_RawStrdup(encoding);
          if (!_Py_StandardStreamEncoding) {
              res = -2;
              goto done;
          }
      }
      if (errors) {
          _Py_StandardStreamErrors = _PyMem_RawStrdup(errors);
          if (!_Py_StandardStreamErrors) {
              if (_Py_StandardStreamEncoding) {
                  PyMem_RawFree(_Py_StandardStreamEncoding);
              }
              res = -3;
              goto done;
          }
      }
  #ifdef MS_WINDOWS
      if (_Py_StandardStreamEncoding) {
          /* Overriding the stream encoding implies legacy streams */
          Py_LegacyWindowsStdioFlag = 1;
      }
  #endif
  
  done:
      PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
  
      return res;
  }
  
  
  void
  _Py_ClearStandardStreamEncoding(void)
  {
      /* Use the same allocator than Py_SetStandardStreamEncoding() */
      PyMemAllocatorEx old_alloc;
      _PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
  
      /* We won't need them anymore. */
      if (_Py_StandardStreamEncoding) {
          PyMem_RawFree(_Py_StandardStreamEncoding);
          _Py_StandardStreamEncoding = NULL;
      }
      if (_Py_StandardStreamErrors) {
          PyMem_RawFree(_Py_StandardStreamErrors);
          _Py_StandardStreamErrors = NULL;
      }
  
      PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
  }
  
  
  /* Free memory allocated in config, but don't clear all attributes */
  void
  _PyCoreConfig_Clear(_PyCoreConfig *config)
  {
  #define CLEAR(ATTR) \
      do { \
          PyMem_RawFree(ATTR); \
          ATTR = NULL; \
      } while (0)
  #define CLEAR_WSTRLIST(LEN, LIST) \
      do { \
          _Py_wstrlist_clear(LEN, LIST); \
          LEN = 0; \
          LIST = NULL; \
      } while (0)
  
      CLEAR(config->pycache_prefix);
      CLEAR(config->module_search_path_env);
      CLEAR(config->home);
      CLEAR(config->program_name);
      CLEAR(config->program);
  
      CLEAR_WSTRLIST(config->argc, config->argv);
      config->argc = -1;
  
      CLEAR_WSTRLIST(config->nwarnoption, config->warnoptions);
      CLEAR_WSTRLIST(config->nxoption, config->xoptions);
      CLEAR_WSTRLIST(config->nmodule_search_path, config->module_search_paths);
      config->nmodule_search_path = -1;
  
      CLEAR(config->executable);
      CLEAR(config->prefix);
      CLEAR(config->base_prefix);
      CLEAR(config->exec_prefix);
  #ifdef MS_WINDOWS
      CLEAR(config->dll_path);
  #endif
      CLEAR(config->base_exec_prefix);
  
      CLEAR(config->filesystem_encoding);
      CLEAR(config->filesystem_errors);
      CLEAR(config->stdio_encoding);
      CLEAR(config->stdio_errors);
  #undef CLEAR
  #undef CLEAR_WSTRLIST
  }
  
  
  int
  _PyCoreConfig_Copy(_PyCoreConfig *config, const _PyCoreConfig *config2)
  {
      _PyCoreConfig_Clear(config);
  
  #define COPY_ATTR(ATTR) config->ATTR = config2->ATTR
  #define COPY_STR_ATTR(ATTR) \
      do { \
          if (config2->ATTR != NULL) { \
              config->ATTR = _PyMem_RawStrdup(config2->ATTR); \
              if (config->ATTR == NULL) { \
                  return -1; \
              } \
          } \
      } while (0)
  #define COPY_WSTR_ATTR(ATTR) \
      do { \
          if (config2->ATTR != NULL) { \
              config->ATTR = _PyMem_RawWcsdup(config2->ATTR); \
              if (config->ATTR == NULL) { \
                  return -1; \
              } \
          } \
      } while (0)
  #define COPY_WSTRLIST(LEN, LIST) \
      do { \
          if (config2->LIST != NULL) { \
              config->LIST = _Py_wstrlist_copy(config2->LEN, config2->LIST); \
              if (config->LIST == NULL) { \
                  return -1; \
              } \
          } \
          config->LEN = config2->LEN; \
      } while (0)
  
      COPY_ATTR(install_signal_handlers);
      COPY_ATTR(use_environment);
      COPY_ATTR(use_hash_seed);
      COPY_ATTR(hash_seed);
      COPY_ATTR(_install_importlib);
      COPY_ATTR(allocator);
      COPY_ATTR(dev_mode);
      COPY_ATTR(faulthandler);
      COPY_ATTR(tracemalloc);
      COPY_ATTR(import_time);
      COPY_ATTR(show_ref_count);
      COPY_ATTR(show_alloc_count);
      COPY_ATTR(dump_refs);
      COPY_ATTR(malloc_stats);
  
      COPY_ATTR(coerce_c_locale);
      COPY_ATTR(coerce_c_locale_warn);
      COPY_ATTR(utf8_mode);
  
      COPY_WSTR_ATTR(pycache_prefix);
      COPY_WSTR_ATTR(module_search_path_env);
      COPY_WSTR_ATTR(home);
      COPY_WSTR_ATTR(program_name);
      COPY_WSTR_ATTR(program);
  
      COPY_WSTRLIST(argc, argv);
      COPY_WSTRLIST(nwarnoption, warnoptions);
      COPY_WSTRLIST(nxoption, xoptions);
      COPY_WSTRLIST(nmodule_search_path, module_search_paths);
  
      COPY_WSTR_ATTR(executable);
      COPY_WSTR_ATTR(prefix);
      COPY_WSTR_ATTR(base_prefix);
      COPY_WSTR_ATTR(exec_prefix);
  #ifdef MS_WINDOWS
      COPY_WSTR_ATTR(dll_path);
  #endif
      COPY_WSTR_ATTR(base_exec_prefix);
  
      COPY_ATTR(isolated);
      COPY_ATTR(site_import);
      COPY_ATTR(bytes_warning);
      COPY_ATTR(inspect);
      COPY_ATTR(interactive);
      COPY_ATTR(optimization_level);
      COPY_ATTR(parser_debug);
      COPY_ATTR(write_bytecode);
      COPY_ATTR(verbose);
      COPY_ATTR(quiet);
      COPY_ATTR(user_site_directory);
      COPY_ATTR(buffered_stdio);
      COPY_STR_ATTR(filesystem_encoding);
      COPY_STR_ATTR(filesystem_errors);
      COPY_STR_ATTR(stdio_encoding);
      COPY_STR_ATTR(stdio_errors);
  #ifdef MS_WINDOWS
      COPY_ATTR(legacy_windows_fs_encoding);
      COPY_ATTR(legacy_windows_stdio);
  #endif
      COPY_ATTR(_check_hash_pycs_mode);
      COPY_ATTR(_frozen);
  
  #undef COPY_ATTR
  #undef COPY_STR_ATTR
  #undef COPY_WSTR_ATTR
  #undef COPY_WSTRLIST
      return 0;
  }
  
  
  const char*
  _PyCoreConfig_GetEnv(const _PyCoreConfig *config, const char *name)
  {
      assert(config->use_environment >= 0);
  
      if (!config->use_environment) {
          return NULL;
      }
  
      const char *var = getenv(name);
      if (var && var[0] != '\0') {
          return var;
      }
      else {
          return NULL;
      }
  }
  
  
  int
  _PyCoreConfig_GetEnvDup(const _PyCoreConfig *config,
                          wchar_t **dest,
                          wchar_t *wname, char *name)
  {
      assert(config->use_environment >= 0);
  
      if (!config->use_environment) {
          *dest = NULL;
          return 0;
      }
  
  #ifdef MS_WINDOWS
      const wchar_t *var = _wgetenv(wname);
      if (!var || var[0] == '\0') {
          *dest = NULL;
          return 0;
      }
  
      wchar_t *copy = _PyMem_RawWcsdup(var);
      if (copy == NULL) {
          return -1;
      }
  
      *dest = copy;
  #else
      const char *var = getenv(name);
      if (!var || var[0] == '\0') {
          *dest = NULL;
          return 0;
      }
  
      size_t len;
      wchar_t *wvar = Py_DecodeLocale(var, &len);
      if (!wvar) {
          if (len == (size_t)-2) {
              return -2;
          }
          else {
              return -1;
          }
      }
      *dest = wvar;
  #endif
      return 0;
  }
  
  
  void
  _PyCoreConfig_GetGlobalConfig(_PyCoreConfig *config)
  {
  #define COPY_FLAG(ATTR, VALUE) \
          if (config->ATTR == -1) { \
              config->ATTR = VALUE; \
          }
  #define COPY_NOT_FLAG(ATTR, VALUE) \
          if (config->ATTR == -1) { \
              config->ATTR = !(VALUE); \
          }
  
      COPY_FLAG(utf8_mode, Py_UTF8Mode);
      COPY_FLAG(isolated, Py_IsolatedFlag);
      COPY_FLAG(bytes_warning, Py_BytesWarningFlag);
      COPY_FLAG(inspect, Py_InspectFlag);
      COPY_FLAG(interactive, Py_InteractiveFlag);
      COPY_FLAG(optimization_level, Py_OptimizeFlag);
      COPY_FLAG(parser_debug, Py_DebugFlag);
      COPY_FLAG(verbose, Py_VerboseFlag);
      COPY_FLAG(quiet, Py_QuietFlag);
  #ifdef MS_WINDOWS
      COPY_FLAG(legacy_windows_fs_encoding, Py_LegacyWindowsFSEncodingFlag);
      COPY_FLAG(legacy_windows_stdio, Py_LegacyWindowsStdioFlag);
  #endif
      COPY_FLAG(_frozen, Py_FrozenFlag);
  
      COPY_NOT_FLAG(use_environment, Py_IgnoreEnvironmentFlag);
      COPY_NOT_FLAG(buffered_stdio, Py_UnbufferedStdioFlag);
      COPY_NOT_FLAG(site_import, Py_NoSiteFlag);
      COPY_NOT_FLAG(write_bytecode, Py_DontWriteBytecodeFlag);
      COPY_NOT_FLAG(user_site_directory, Py_NoUserSiteDirectory);
  
  #undef COPY_FLAG
  #undef COPY_NOT_FLAG
  }
  
  
  /* Set Py_xxx global configuration variables from 'config' configuration. */
  void
  _PyCoreConfig_SetGlobalConfig(const _PyCoreConfig *config)
  {
  #define COPY_FLAG(ATTR, VAR) \
          if (config->ATTR != -1) { \
              VAR = config->ATTR; \
          }
  #define COPY_NOT_FLAG(ATTR, VAR) \
          if (config->ATTR != -1) { \
              VAR = !config->ATTR; \
          }
  
      COPY_FLAG(utf8_mode, Py_UTF8Mode);
      COPY_FLAG(isolated, Py_IsolatedFlag);
      COPY_FLAG(bytes_warning, Py_BytesWarningFlag);
      COPY_FLAG(inspect, Py_InspectFlag);
      COPY_FLAG(interactive, Py_InteractiveFlag);
      COPY_FLAG(optimization_level, Py_OptimizeFlag);
      COPY_FLAG(parser_debug, Py_DebugFlag);
      COPY_FLAG(verbose, Py_VerboseFlag);
      COPY_FLAG(quiet, Py_QuietFlag);
  #ifdef MS_WINDOWS
      COPY_FLAG(legacy_windows_fs_encoding, Py_LegacyWindowsFSEncodingFlag);
      COPY_FLAG(legacy_windows_stdio, Py_LegacyWindowsStdioFlag);
  #endif
  
      COPY_NOT_FLAG(use_environment, Py_IgnoreEnvironmentFlag);
      COPY_NOT_FLAG(buffered_stdio, Py_UnbufferedStdioFlag);
      COPY_NOT_FLAG(site_import, Py_NoSiteFlag);
      COPY_NOT_FLAG(write_bytecode, Py_DontWriteBytecodeFlag);
      COPY_NOT_FLAG(user_site_directory, Py_NoUserSiteDirectory);
  
      /* Random or non-zero hash seed */
      Py_HashRandomizationFlag = (config->use_hash_seed == 0 ||
                                  config->hash_seed != 0);
  
  #undef COPY_FLAG
  #undef COPY_NOT_FLAG
  }
  
  
  /* Get the program name: use PYTHONEXECUTABLE and __PYVENV_LAUNCHER__
     environment variables on macOS if available. */
  static _PyInitError
  config_init_program_name(_PyCoreConfig *config)
  {
      assert(config->program_name == NULL);
  
      /* If Py_SetProgramName() was called, use its value */
      const wchar_t *program_name = _Py_path_config.program_name;
      if (program_name != NULL) {
          config->program_name = _PyMem_RawWcsdup(program_name);
          if (config->program_name == NULL) {
              return _Py_INIT_NO_MEMORY();
          }
          return _Py_INIT_OK();
      }
  
  #ifdef __APPLE__
      /* On MacOS X, when the Python interpreter is embedded in an
         application bundle, it gets executed by a bootstrapping script
         that does os.execve() with an argv[0] that's different from the
         actual Python executable. This is needed to keep the Finder happy,
         or rather, to work around Apple's overly strict requirements of
         the process name. However, we still need a usable sys.executable,
         so the actual executable path is passed in an environment variable.
         See Lib/plat-mac/bundlebuiler.py for details about the bootstrap
         script. */
      const char *p = _PyCoreConfig_GetEnv(config, "PYTHONEXECUTABLE");
      if (p != NULL) {
          size_t len;
          wchar_t* program_name = Py_DecodeLocale(p, &len);
          if (program_name == NULL) {
              return DECODE_LOCALE_ERR("PYTHONEXECUTABLE environment "
                                       "variable", (Py_ssize_t)len);
          }
          config->program_name = program_name;
          return _Py_INIT_OK();
      }
  #ifdef WITH_NEXT_FRAMEWORK
      else {
          const char* pyvenv_launcher = getenv("__PYVENV_LAUNCHER__");
          if (pyvenv_launcher && *pyvenv_launcher) {
              /* Used by Mac/Tools/pythonw.c to forward
               * the argv0 of the stub executable
               */
              size_t len;
              wchar_t* program_name = Py_DecodeLocale(pyvenv_launcher, &len);
              if (program_name == NULL) {
                  return DECODE_LOCALE_ERR("__PYVENV_LAUNCHER__ environment "
                                           "variable", (Py_ssize_t)len);
              }
              config->program_name = program_name;
              return _Py_INIT_OK();
          }
      }
  #endif   /* WITH_NEXT_FRAMEWORK */
  #endif   /* __APPLE__ */
  
      /* Use argv[0] by default, if available */
      if (config->program != NULL) {
          config->program_name = _PyMem_RawWcsdup(config->program);
          if (config->program_name == NULL) {
              return _Py_INIT_NO_MEMORY();
          }
          return _Py_INIT_OK();
      }
  
      /* Last fall back: hardcoded string */
  #ifdef MS_WINDOWS
      const wchar_t *default_program_name = L"python";
  #else
      const wchar_t *default_program_name = L"python3";
  #endif
      config->program_name = _PyMem_RawWcsdup(default_program_name);
      if (config->program_name == NULL) {
          return _Py_INIT_NO_MEMORY();
      }
      return _Py_INIT_OK();
  }
  
  
  static const wchar_t*
  config_get_xoption(const _PyCoreConfig *config, wchar_t *name)
  {
      int nxoption = config->nxoption;
      wchar_t **xoptions = config->xoptions;
      for (int i=0; i < nxoption; i++) {
          wchar_t *option = xoptions[i];
          size_t len;
          wchar_t *sep = wcschr(option, L'=');
          if (sep != NULL) {
              len = (sep - option);
          }
          else {
              len = wcslen(option);
          }
          if (wcsncmp(option, name, len) == 0 && name[len] == L'\0') {
              return option;
          }
      }
      return NULL;
  }
  
  
  static _PyInitError
  config_init_home(_PyCoreConfig *config)
  {
      wchar_t *home;
  
      /* If Py_SetPythonHome() was called, use its value */
      home = _Py_path_config.home;
      if (home) {
          config->home = _PyMem_RawWcsdup(home);
          if (config->home == NULL) {
              return _Py_INIT_NO_MEMORY();
          }
          return _Py_INIT_OK();
      }
  
      int res = _PyCoreConfig_GetEnvDup(config, &home,
                                        L"PYTHONHOME", "PYTHONHOME");
      if (res < 0) {
          return DECODE_LOCALE_ERR("PYTHONHOME", res);
      }
      config->home = home;
      return _Py_INIT_OK();
  }
  
  
  static _PyInitError
  config_init_hash_seed(_PyCoreConfig *config)
  {
      const char *seed_text = _PyCoreConfig_GetEnv(config, "PYTHONHASHSEED");
  
      Py_BUILD_ASSERT(sizeof(_Py_HashSecret_t) == sizeof(_Py_HashSecret.uc));
      /* Convert a text seed to a numeric one */
      if (seed_text && strcmp(seed_text, "random") != 0) {
          const char *endptr = seed_text;
          unsigned long seed;
          errno = 0;
          seed = strtoul(seed_text, (char **)&endptr, 10);
          if (*endptr != '\0'
              || seed > 4294967295UL
              || (errno == ERANGE && seed == ULONG_MAX))
          {
              return _Py_INIT_USER_ERR("PYTHONHASHSEED must be \"random\" "
                                       "or an integer in range [0; 4294967295]");
          }
          /* Use a specific hash */
          config->use_hash_seed = 1;
          config->hash_seed = seed;
      }
      else {
          /* Use a random hash */
          config->use_hash_seed = 0;
          config->hash_seed = 0;
      }
      return _Py_INIT_OK();
  }
  
  
  static _PyInitError
  config_init_utf8_mode(_PyCoreConfig *config)
  {
      const wchar_t *xopt = config_get_xoption(config, L"utf8");
      if (xopt) {
          wchar_t *sep = wcschr(xopt, L'=');
          if (sep) {
              xopt = sep + 1;
              if (wcscmp(xopt, L"1") == 0) {
                  config->utf8_mode = 1;
              }
              else if (wcscmp(xopt, L"0") == 0) {
                  config->utf8_mode = 0;
              }
              else {
                  return _Py_INIT_USER_ERR("invalid -X utf8 option value");
              }
          }
          else {
              config->utf8_mode = 1;
          }
          return _Py_INIT_OK();
      }
  
      const char *opt = _PyCoreConfig_GetEnv(config, "PYTHONUTF8");
      if (opt) {
          if (strcmp(opt, "1") == 0) {
              config->utf8_mode = 1;
          }
          else if (strcmp(opt, "0") == 0) {
              config->utf8_mode = 0;
          }
          else {
              return _Py_INIT_USER_ERR("invalid PYTHONUTF8 environment "
                                       "variable value");
          }
          return _Py_INIT_OK();
      }
  
      return _Py_INIT_OK();
  }
  
  
  static int
  config_str_to_int(const char *str, int *result)
  {
      const char *endptr = str;
      errno = 0;
      long value = strtol(str, (char **)&endptr, 10);
      if (*endptr != '\0' || errno == ERANGE) {
          return -1;
      }
      if (value < INT_MIN || value > INT_MAX) {
          return -1;
      }
  
      *result = (int)value;
      return 0;
  }
  
  
  static int
  config_wstr_to_int(const wchar_t *wstr, int *result)
  {
      const wchar_t *endptr = wstr;
      errno = 0;
      long value = wcstol(wstr, (wchar_t **)&endptr, 10);
      if (*endptr != '\0' || errno == ERANGE) {
          return -1;
      }
      if (value < INT_MIN || value > INT_MAX) {
          return -1;
      }
  
      *result = (int)value;
      return 0;
  }
  
  
  static void
  get_env_flag(_PyCoreConfig *config, int *flag, const char *name)
  {
      const char *var = _PyCoreConfig_GetEnv(config, name);
      if (!var) {
          return;
      }
      int value;
      if (config_str_to_int(var, &value) < 0 || value < 0) {
          /* PYTHONDEBUG=text and PYTHONDEBUG=-2 behave as PYTHONDEBUG=1 */
          value = 1;
      }
      if (*flag < value) {
          *flag = value;
      }
  }
  
  
  static _PyInitError
  config_read_env_vars(_PyCoreConfig *config)
  {
      /* Get environment variables */
      get_env_flag(config, &config->parser_debug, "PYTHONDEBUG");
      get_env_flag(config, &config->verbose, "PYTHONVERBOSE");
      get_env_flag(config, &config->optimization_level, "PYTHONOPTIMIZE");
      get_env_flag(config, &config->inspect, "PYTHONINSPECT");
  
      int dont_write_bytecode = 0;
      get_env_flag(config, &dont_write_bytecode, "PYTHONDONTWRITEBYTECODE");
      if (dont_write_bytecode) {
          config->write_bytecode = 0;
      }
  
      int no_user_site_directory = 0;
      get_env_flag(config, &no_user_site_directory, "PYTHONNOUSERSITE");
      if (no_user_site_directory) {
          config->user_site_directory = 0;
      }
  
      int unbuffered_stdio = 0;
      get_env_flag(config, &unbuffered_stdio, "PYTHONUNBUFFERED");
      if (unbuffered_stdio) {
          config->buffered_stdio = 0;
      }
  
  #ifdef MS_WINDOWS
      get_env_flag(config, &config->legacy_windows_fs_encoding,
                   "PYTHONLEGACYWINDOWSFSENCODING");
      get_env_flag(config, &config->legacy_windows_stdio,
                   "PYTHONLEGACYWINDOWSSTDIO");
  #endif
  
      if (config->allocator == NULL) {
          config->allocator = _PyCoreConfig_GetEnv(config, "PYTHONMALLOC");
      }
  
      if (_PyCoreConfig_GetEnv(config, "PYTHONDUMPREFS")) {
          config->dump_refs = 1;
      }
      if (_PyCoreConfig_GetEnv(config, "PYTHONMALLOCSTATS")) {
          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");
      if (res < 0) {
          return DECODE_LOCALE_ERR("PYTHONPATH", res);
      }
      config->module_search_path_env = path;
  
      if (config->use_hash_seed < 0) {
          _PyInitError err = config_init_hash_seed(config);
          if (_Py_INIT_FAILED(err)) {
              return err;
          }
      }
  
      return _Py_INIT_OK();
  }
  
  
  static _PyInitError
  config_init_tracemalloc(_PyCoreConfig *config)
  {
      int nframe;
      int valid;
  
      const char *env = _PyCoreConfig_GetEnv(config, "PYTHONTRACEMALLOC");
      if (env) {
          if (!config_str_to_int(env, &nframe)) {
              valid = (nframe >= 0);
          }
          else {
              valid = 0;
          }
          if (!valid) {
              return _Py_INIT_USER_ERR("PYTHONTRACEMALLOC: invalid number "
                                       "of frames");
          }
          config->tracemalloc = nframe;
      }
  
      const wchar_t *xoption = config_get_xoption(config, L"tracemalloc");
      if (xoption) {
          const wchar_t *sep = wcschr(xoption, L'=');
          if (sep) {
              if (!config_wstr_to_int(sep + 1, &nframe)) {
                  valid = (nframe >= 0);
              }
              else {
                  valid = 0;
              }
              if (!valid) {
                  return _Py_INIT_USER_ERR("-X tracemalloc=NFRAME: "
                                           "invalid number of frames");
              }
          }
          else {
              /* -X tracemalloc behaves as -X tracemalloc=1 */
              nframe = 1;
          }
          config->tracemalloc = nframe;
      }
      return _Py_INIT_OK();
  }
  
  
  static _PyInitError
  config_init_pycache_prefix(_PyCoreConfig *config)
  {
      assert(config->pycache_prefix == NULL);
  
      const wchar_t *xoption = config_get_xoption(config, L"pycache_prefix");
      if (xoption) {
          const wchar_t *sep = wcschr(xoption, L'=');
          if (sep && wcslen(sep) > 1) {
              config->pycache_prefix = _PyMem_RawWcsdup(sep + 1);
              if (config->pycache_prefix == NULL) {
                  return _Py_INIT_NO_MEMORY();
              }
          }
          else {
              // -X pycache_prefix= can cancel the env var
              config->pycache_prefix = NULL;
          }
      }
      else {
          wchar_t *env;
          int res = _PyCoreConfig_GetEnvDup(config, &env,
                                            L"PYTHONPYCACHEPREFIX",
                                            "PYTHONPYCACHEPREFIX");
          if (res < 0) {
              return DECODE_LOCALE_ERR("PYTHONPYCACHEPREFIX", res);
          }
  
          if (env) {
              config->pycache_prefix = env;
          }
      }
      return _Py_INIT_OK();
  }
  
  
  static _PyInitError
  config_read_complex_options(_PyCoreConfig *config)
  {
      /* More complex options configured by env var and -X option */
      if (config->faulthandler < 0) {
          if (_PyCoreConfig_GetEnv(config, "PYTHONFAULTHANDLER")
             || config_get_xoption(config, L"faulthandler")) {
              config->faulthandler = 1;
          }
      }
      if (_PyCoreConfig_GetEnv(config, "PYTHONPROFILEIMPORTTIME")
         || config_get_xoption(config, L"importtime")) {
          config->import_time = 1;
      }
      if (config_get_xoption(config, L"dev" ) ||
          _PyCoreConfig_GetEnv(config, "PYTHONDEVMODE"))
      {
          config->dev_mode = 1;
      }
  
      _PyInitError err;
      if (config->tracemalloc < 0) {
          err = config_init_tracemalloc(config);
          if (_Py_INIT_FAILED(err)) {
              return err;
          }
      }
  
      if (config->pycache_prefix == NULL) {
          err = config_init_pycache_prefix(config);
          if (_Py_INIT_FAILED(err)) {
              return err;
          }
      }
      return _Py_INIT_OK();
  }
  
  
  static void
  config_init_locale(_PyCoreConfig *config)
  {
      if (config->coerce_c_locale < 0) {
          /* The C locale enables the C locale coercion (PEP 538) */
          if (_Py_LegacyLocaleDetected()) {
              config->coerce_c_locale = 1;
          }
      }
  
  #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
  }
  
  
  static const char *
  get_stdio_errors(const _PyCoreConfig *config)
  {
  #ifndef MS_WINDOWS
      const char *loc = setlocale(LC_CTYPE, NULL);
      if (loc != NULL) {
          /* surrogateescape is the default in the legacy C and POSIX locales */
          if (strcmp(loc, "C") == 0 || strcmp(loc, "POSIX") == 0) {
              return "surrogateescape";
          }
  
  #ifdef PY_COERCE_C_LOCALE
          /* surrogateescape is the default in locale coercion target locales */
          if (_Py_IsLocaleCoercionTarget(loc)) {
              return "surrogateescape";
          }
  #endif
      }
  
      return "strict";
  #else
      /* On Windows, always use surrogateescape by default */
      return "surrogateescape";
  #endif
  }
  
  
  static _PyInitError
  get_locale_encoding(char **locale_encoding)
  {
  #ifdef MS_WINDOWS
      char encoding[20];
      PyOS_snprintf(encoding, sizeof(encoding), "cp%d", GetACP());
  #elif defined(__ANDROID__)
      const char *encoding = "UTF-8";
  #else
      const char *encoding = nl_langinfo(CODESET);
      if (!encoding || encoding[0] == '\0') {
          return _Py_INIT_USER_ERR("failed to get the locale encoding: "
                                   "nl_langinfo(CODESET) failed");
      }
  #endif
      *locale_encoding = _PyMem_RawStrdup(encoding);
      if (*locale_encoding == NULL) {
          return _Py_INIT_NO_MEMORY();
      }
      return _Py_INIT_OK();
  }
  
  
  static _PyInitError
  config_init_stdio_encoding(_PyCoreConfig *config)
  {
      /* If Py_SetStandardStreamEncoding() have been called, use these
          parameters. */
      if (config->stdio_encoding == NULL && _Py_StandardStreamEncoding != NULL) {
          config->stdio_encoding = _PyMem_RawStrdup(_Py_StandardStreamEncoding);
          if (config->stdio_encoding == NULL) {
              return _Py_INIT_NO_MEMORY();
          }
      }
  
      if (config->stdio_errors == NULL && _Py_StandardStreamErrors != NULL) {
          config->stdio_errors = _PyMem_RawStrdup(_Py_StandardStreamErrors);
          if (config->stdio_errors == NULL) {
              return _Py_INIT_NO_MEMORY();
          }
      }
  
      if (config->stdio_encoding != NULL && config->stdio_errors != NULL) {
          return _Py_INIT_OK();
      }
  
      /* PYTHONIOENCODING environment variable */
      const char *opt = _PyCoreConfig_GetEnv(config, "PYTHONIOENCODING");
      if (opt) {
          char *pythonioencoding = _PyMem_RawStrdup(opt);
          if (pythonioencoding == NULL) {
              return _Py_INIT_NO_MEMORY();
          }
  
          char *err = strchr(pythonioencoding, ':');
          if (err) {
              *err = '\0';
              err++;
              if (!err[0]) {
                  err = NULL;
              }
          }
  
          /* Does PYTHONIOENCODING contain an encoding? */
          if (pythonioencoding[0]) {
              if (config->stdio_encoding == NULL) {
                  config->stdio_encoding = _PyMem_RawStrdup(pythonioencoding);
                  if (config->stdio_encoding == NULL) {
                      PyMem_RawFree(pythonioencoding);
                      return _Py_INIT_NO_MEMORY();
                  }
              }
  
              /* If the encoding is set but not the error handler,
                 use "strict" error handler by default.
                 PYTHONIOENCODING=latin1 behaves as
                 PYTHONIOENCODING=latin1:strict. */
              if (!err) {
                  err = "strict";
              }
          }
  
          if (config->stdio_errors == NULL && err != NULL) {
              config->stdio_errors = _PyMem_RawStrdup(err);
              if (config->stdio_errors == NULL) {
                  PyMem_RawFree(pythonioencoding);
                  return _Py_INIT_NO_MEMORY();
              }
          }
  
          PyMem_RawFree(pythonioencoding);
      }
  
      /* UTF-8 Mode uses UTF-8/surrogateescape */
      if (config->utf8_mode) {
          if (config->stdio_encoding == NULL) {
              config->stdio_encoding = _PyMem_RawStrdup("utf-8");
              if (config->stdio_encoding == NULL) {
                  return _Py_INIT_NO_MEMORY();
              }
          }
          if (config->stdio_errors == NULL) {
              config->stdio_errors = _PyMem_RawStrdup("surrogateescape");
              if (config->stdio_errors == NULL) {
                  return _Py_INIT_NO_MEMORY();
              }
          }
      }
  
      /* Choose the default error handler based on the current locale. */
      if (config->stdio_encoding == NULL) {
          _PyInitError err = get_locale_encoding(&config->stdio_encoding);
          if (_Py_INIT_FAILED(err)) {
              return err;
          }
      }
      if (config->stdio_errors == NULL) {
          const char *errors = get_stdio_errors(config);
          config->stdio_errors = _PyMem_RawStrdup(errors);
          if (config->stdio_errors == NULL) {
              return _Py_INIT_NO_MEMORY();
          }
      }
  
      return _Py_INIT_OK();
  }
  
  
  static _PyInitError
  config_init_fs_encoding(_PyCoreConfig *config)
  {
  #ifdef MS_WINDOWS
      if (config->legacy_windows_fs_encoding) {
          /* Legacy Windows filesystem encoding: mbcs/replace */
          if (config->filesystem_encoding == NULL) {
              config->filesystem_encoding = _PyMem_RawStrdup("mbcs");
              if (config->filesystem_encoding == NULL) {
                  return _Py_INIT_NO_MEMORY();
              }
          }
          if (config->filesystem_errors == NULL) {
              config->filesystem_errors = _PyMem_RawStrdup("replace");
              if (config->filesystem_errors == NULL) {
                  return _Py_INIT_NO_MEMORY();
              }
          }
      }
  
      /* Windows defaults to utf-8/surrogatepass (PEP 529).
  
         Note: UTF-8 Mode takes the same code path and the Legacy Windows FS
               encoding has the priortiy over UTF-8 Mode. */
      if (config->filesystem_encoding == NULL) {
          config->filesystem_encoding = _PyMem_RawStrdup("utf-8");
          if (config->filesystem_encoding == NULL) {
              return _Py_INIT_NO_MEMORY();
          }
      }
  
      if (config->filesystem_errors == NULL) {
          config->filesystem_errors = _PyMem_RawStrdup("surrogatepass");
          if (config->filesystem_errors == NULL) {
              return _Py_INIT_NO_MEMORY();
          }
      }
  #else
      if (config->filesystem_encoding == NULL) {
          if (config->utf8_mode) {
              /* UTF-8 Mode use: utf-8/surrogateescape */
              config->filesystem_encoding = _PyMem_RawStrdup("utf-8");
              /* errors defaults to surrogateescape above */
          }
          else if (_Py_GetForceASCII()) {
              config->filesystem_encoding = _PyMem_RawStrdup("ascii");
          }
          else {
              /* macOS and Android use UTF-8,
                 other platforms use the locale encoding. */
  #if defined(__APPLE__) || defined(__ANDROID__)
              config->filesystem_encoding = _PyMem_RawStrdup("utf-8");
  #else
              _PyInitError err = get_locale_encoding(&config->filesystem_encoding);
              if (_Py_INIT_FAILED(err)) {
                  return err;
              }
  #endif
          }
  
          if (config->filesystem_encoding == NULL) {
              return _Py_INIT_NO_MEMORY();
          }
      }
  
      if (config->filesystem_errors == NULL) {
          /* by default, use the "surrogateescape" error handler */
          config->filesystem_errors = _PyMem_RawStrdup("surrogateescape");
          if (config->filesystem_errors == NULL) {
              return _Py_INIT_NO_MEMORY();
          }
      }
  #endif
      return _Py_INIT_OK();
  }
  
  
  /* Read configuration settings from standard locations
   *
   * This function doesn't make any changes to the interpreter state - it
   * merely populates any missing configuration settings. This allows an
   * embedding application to completely override a config option by
   * setting it before calling this function, or else modify the default
   * setting before passing the fully populated config to Py_EndInitialization.
   *
   * More advanced selective initialization tricks are possible by calling
   * this function multiple times with various preconfigured settings.
   */
  
  _PyInitError
  _PyCoreConfig_Read(_PyCoreConfig *config)
  {
      _PyInitError err;
  
      _PyCoreConfig_GetGlobalConfig(config);
      assert(config->use_environment >= 0);
  
      if (config->isolated > 0) {
          config->use_environment = 0;
          config->user_site_directory = 0;
      }
  
  #ifdef MS_WINDOWS
      if (config->legacy_windows_fs_encoding) {
          config->utf8_mode = 0;
      }
  #endif
  
      if (config->use_environment) {
          err = config_read_env_vars(config);
          if (_Py_INIT_FAILED(err)) {
              return err;
          }
      }
  
      /* -X options */
      if (config_get_xoption(config, L"showrefcount")) {
          config->show_ref_count = 1;
      }
      if (config_get_xoption(config, L"showalloccount")) {
          config->show_alloc_count = 1;
      }
  
      err = config_read_complex_options(config);
      if (_Py_INIT_FAILED(err)) {
          return err;
      }
  
      if (config->utf8_mode < 0) {
          err = config_init_utf8_mode(config);
          if (_Py_INIT_FAILED(err)) {
              return err;
          }
      }
  
      if (config->home == NULL) {
          err = config_init_home(config);
          if (_Py_INIT_FAILED(err)) {
              return err;
          }
      }
  
      if (config->program_name == NULL) {
          err = config_init_program_name(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) {
          err = _PyCoreConfig_InitPathConfig(config);
          if (_Py_INIT_FAILED(err)) {
              return err;
          }
      }
  
      /* default values */
      if (config->dev_mode) {
          if (config->faulthandler < 0) {
              config->faulthandler = 1;
          }
          if (config->allocator == NULL) {
              config->allocator = "debug";
          }
      }
      if (config->use_hash_seed < 0) {
          config->use_hash_seed = 0;
          config->hash_seed = 0;
      }
      if (config->faulthandler < 0) {
          config->faulthandler = 0;
      }
      if (config->tracemalloc < 0) {
          config->tracemalloc = 0;
      }
      if (config->coerce_c_locale < 0) {
          config->coerce_c_locale = 0;
      }
      if (config->utf8_mode < 0) {
          config->utf8_mode = 0;
      }
      if (config->argc < 0) {
          config->argc = 0;
      }
  
      if (config->filesystem_encoding == NULL || config->filesystem_errors == NULL) {
          err = config_init_fs_encoding(config);
          if (_Py_INIT_FAILED(err)) {
              return err;
          }
      }
  
      err = config_init_stdio_encoding(config);
      if (_Py_INIT_FAILED(err)) {
          return err;
      }
  
      assert(config->coerce_c_locale >= 0);
      assert(config->use_environment >= 0);
      assert(config->filesystem_encoding != NULL);
      assert(config->filesystem_errors != NULL);
      assert(config->stdio_encoding != NULL);
      assert(config->stdio_errors != NULL);
      assert(config->_check_hash_pycs_mode != NULL);
  
      return _Py_INIT_OK();
  }
  