Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

bpo-34170: Add _PyCoreConfig.bytes_warning (GH-8447) 

Add more fields to _PyCoreConfig:

* _check_hash_pycs_mode
* bytes_warning
* debug
* inspect
* interactive
* legacy_windows_fs_encoding
* legacy_windows_stdio
* optimization_level
* quiet
* unbuffered_stdio
* user_site_directory
* verbose
* write_bytecode

Changes:

* Remove pymain_get_global_config() and pymain_set_global_config()
  which became useless. These functions have been replaced by
  _PyCoreConfig_GetGlobalConfig() and
  _PyCoreConfig_SetGlobalConfig().
* sys.flags.dont_write_bytecode value is now restricted to 1 even if
  -B option is specified multiple times on the command line.
* PyThreadState_Clear() now uses the config from the current
  interpreter rather than using global Py_VerboseFlag
This commit is contained in:
Victor Stinner 2018-07-25 01:37:05 +02:00 committed by GitHub
parent 95d34c2a37
commit 53b7d4e402
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 294 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

144
Include/pystate.h
View File

@ -87,18 +87,147 @@ typedef struct {
these manipulations if site is explicitly imported later (call these manipulations if site is explicitly imported later (call
site.main() if you want them to be triggered). site.main() if you want them to be triggered).
Set to 0 by the -S command line option. If set to -1 (default), set to Set to 0 by the -S command line option. If set to -1 (default), it is
the negative value of Py_NoSiteFlag. */ set to !Py_NoSiteFlag. */
int site_import; int site_import;
/* Bytes warnings:
* If equal to 1, issue a warning when comparing bytes or bytearray with
str or bytes with int.
* If equal or greater to 2, issue an error.
Incremented by the -b command line option. If set to -1 (default), inherit
Py_BytesWarningFlag value. */
int bytes_warning;
/* If greater than 0, enable inspect: when a script is passed as first
argument or the -c option is used, enter interactive mode after
executing the script or the command, even when sys.stdin does not appear
to be a terminal.
Incremented by the -i command line option. Set to 1 if the PYTHONINSPECT
environment variable is non-empty. If set to -1 (default), inherit
Py_InspectFlag value. */
int inspect;
/* If greater than 0: enable the interactive mode (REPL).
Incremented by the -i command line option. If set to -1 (default),
inherit Py_InteractiveFlag value. */
int interactive;
/* Optimization level.
Incremented by the -O command line option. Set by the PYTHONOPTIMIZE
environment variable. If set to -1 (default), inherit Py_OptimizeFlag
value. */
int optimization_level;
/* If greater than 0, enable the debug mode: turn on parser debugging
output (for expert only, depending on compilation options).
Incremented by the -d command line option. Set by the PYTHONDEBUG
environment variable. If set to -1 (default), inherit Py_DebugFlag
value. */
int debug;
/* If equal to 0, Python won't try to write ``.pyc`` files on the
import of source modules.
Set to 0 by the -B command line option and the PYTHONDONTWRITEBYTECODE
environment variable. If set to -1 (default), it is set to
!Py_DontWriteBytecodeFlag. */
int write_bytecode;
/* If greater than 0, enable the verbose mode: print a message each time a
module is initialized, showing the place (filename or built-in module)
from which it is loaded.
If greater or equal to 2, print a message for each file that is checked
for when searching for a module. Also provides information on module
cleanup at exit.
Incremented by the -v option. Set by the PYTHONVERBOSE environment
variable. If set to -1 (default), inherit Py_VerboseFlag value. */
int verbose;
/* If greater than 0, enable the quiet mode: Don't display the copyright
and version messages even in interactive mode.
Incremented by the -q option. If set to -1 (default), inherit
Py_QuietFlag value. */
int quiet;
/* If greater than 0, don't add the user site-packages directory to
sys.path.
Set to 0 by the -s and -I command line options , and the PYTHONNOUSERSITE
environment variable. If set to -1 (default), it is set to
!Py_NoUserSiteDirectory. */
int user_site_directory;
/* If greater than 0, enable unbuffered mode: force the stdout and stderr
streams to be unbuffered.
Set to 1 by the -u option. Set by the PYTHONUNBUFFERED environment
variable. If set to -1 (default), inherit Py_UnbufferedStdioFlag
value. */
int unbuffered_stdio;
#ifdef MS_WINDOWS
/* If greater than 1, use the "mbcs" encoding instead of the UTF-8
encoding for the filesystem encoding.
Set to 1 if the PYTHONLEGACYWINDOWSFSENCODING environment variable is
set to a non-empty string. If set to -1 (default), inherit
Py_LegacyWindowsFSEncodingFlag value.
See PEP 529 for more details. */
int legacy_windows_fs_encoding;
/* If greater than zero, use io.FileIO instead of WindowsConsoleIO for sys
standard streams.
Set to 1 if the PYTHONLEGACYWINDOWSSTDIO environment variable is set to
a non-empty string. If set to -1 (default), inherit
Py_LegacyWindowsStdioFlag value.
See PEP 528 for more details. */
int legacy_windows_stdio;
#endif
/* --- Private fields -------- */ /* --- Private fields -------- */
/* Install importlib? If set to 0, importlib is not initialized at all. /* Install importlib? If set to 0, importlib is not initialized at all.
Needed by freeze_importlib: see install_importlib argument of Needed by freeze_importlib: see install_importlib argument of
_Py_InitializeEx_Private(). */ _Py_InitializeEx_Private(). */
int _install_importlib; int _install_importlib;
/* Value of the --check-hash-based-pycs configure option. Valid values:
- "default" means the 'check_source' flag in hash-based pycs
determines invalidation
- "always" causes the interpreter to hash the source file for
invalidation regardless of value of 'check_source' bit
- "never" causes the interpreter to always assume hash-based pycs are
valid
Set by the --check-hash-based-pycs command line option.
If set to NULL (default), inherit _Py_CheckHashBasedPycsMode value.
See PEP 552 "Deterministic pycs" for more details. */
const char *_check_hash_pycs_mode;
} _PyCoreConfig; } _PyCoreConfig;
#ifdef MS_WINDOWS
# define _PyCoreConfig_WINDOWS_INIT \
.legacy_windows_fs_encoding = -1, \
.legacy_windows_stdio = -1,
#else
# define _PyCoreConfig_WINDOWS_INIT
#endif
#define _PyCoreConfig_INIT \ #define _PyCoreConfig_INIT \
(_PyCoreConfig){ \ (_PyCoreConfig){ \
.install_signal_handlers = -1, \ .install_signal_handlers = -1, \
@ -110,6 +239,17 @@ typedef struct {
.nmodule_search_path = -1, \ .nmodule_search_path = -1, \
.isolated = -1, \ .isolated = -1, \
.site_import = -1, \ .site_import = -1, \
.bytes_warning = -1, \
.inspect = -1, \
.interactive = -1, \
.optimization_level = -1, \
.debug= -1, \
.write_bytecode = -1, \
.verbose = -1, \
.quiet = -1, \
.user_site_directory = -1, \
.unbuffered_stdio = -1, \
_PyCoreConfig_WINDOWS_INIT \
._install_importlib = 1} ._install_importlib = 1}
/* Note: _PyCoreConfig_INIT sets other fields to 0/NULL */ /* Note: _PyCoreConfig_INIT sets other fields to 0/NULL */

4
Lib/test/test_cmd_line.py
View File

@ -507,13 +507,15 @@ class CmdLineTest(unittest.TestCase):
PYTHONDONTWRITEBYTECODE=value, PYTHONDONTWRITEBYTECODE=value,
PYTHONVERBOSE=value, PYTHONVERBOSE=value,
) )
dont_write_bytecode = int(bool(value))
code = ( code = (
"import sys; " "import sys; "
"sys.stderr.write(str(sys.flags)); " "sys.stderr.write(str(sys.flags)); "
f"""sys.exit(not ( f"""sys.exit(not (
sys.flags.debug == sys.flags.optimize == sys.flags.debug == sys.flags.optimize ==
sys.flags.dont_write_bytecode == sys.flags.verbose == sys.flags.verbose ==
{expected} {expected}
and sys.flags.dont_write_bytecode == {dont_write_bytecode}
))""" ))"""
) )
with self.subTest(envar_value=value): with self.subTest(envar_value=value):

258
Modules/main.c
View File

@ -415,29 +415,12 @@ pymain_run_file(FILE *fp, const wchar_t *filename, PyCompilerFlags *p_cf)
typedef struct { typedef struct {
wchar_t **argv; wchar_t **argv;
int nwarnoption; /* Number of -W options */ int nwarnoption; /* Number of -W command line options */
wchar_t **warnoptions; /* -W options */ wchar_t **warnoptions; /* Command line -W options */
int nenv_warnoption; /* Number of PYTHONWARNINGS options */ int nenv_warnoption; /* Number of PYTHONWARNINGS environment variables */
wchar_t **env_warnoptions; /* PYTHONWARNINGS options */ wchar_t **env_warnoptions; /* PYTHONWARNINGS environment variables */
int print_help; /* -h, -? options */ int print_help; /* -h, -? options */
int print_version; /* -V option */ int print_version; /* -V option */
int bytes_warning; /* Py_BytesWarningFlag, -b */
int debug; /* Py_DebugFlag, -b, PYTHONDEBUG */
int inspect; /* Py_InspectFlag, -i, PYTHONINSPECT */
int interactive; /* Py_InteractiveFlag, -i */
int optimization_level; /* Py_OptimizeFlag, -O, PYTHONOPTIMIZE */
int dont_write_bytecode; /* Py_DontWriteBytecodeFlag, -B, PYTHONDONTWRITEBYTECODE */
int no_user_site_directory; /* Py_NoUserSiteDirectory, -I, -s, PYTHONNOUSERSITE */
int use_unbuffered_io; /* Py_UnbufferedStdioFlag, -u, PYTHONUNBUFFERED */
int verbosity; /* Py_VerboseFlag, -v, PYTHONVERBOSE */
int quiet_flag; /* Py_QuietFlag, -q */
const char *check_hash_pycs_mode; /* --check-hash-based-pycs */
#ifdef MS_WINDOWS
int legacy_windows_fs_encoding; /* Py_LegacyWindowsFSEncodingFlag,
PYTHONLEGACYWINDOWSFSENCODING */
int legacy_windows_stdio; /* Py_LegacyWindowsStdioFlag,
PYTHONLEGACYWINDOWSSTDIO */
#endif
} _Py_CommandLineDetails; } _Py_CommandLineDetails;
/* Structure used by Py_Main() to pass data to subfunctions */ /* Structure used by Py_Main() to pass data to subfunctions */
@ -570,42 +553,41 @@ pymain_init_cmdline_argv(_PyMain *pymain, _Py_CommandLineDetails *cmdline)
static void static void
_PyCoreConfig_GetGlobalConfig(_PyCoreConfig *config) _PyCoreConfig_GetGlobalConfig(_PyCoreConfig *config)
{ {
if (config->ignore_environment == -1) { #define COPY_FLAG(ATTR, VALUE) \
config->ignore_environment = Py_IgnoreEnvironmentFlag; if (config->ATTR == -1) { \
} config->ATTR = VALUE; \
if (config->utf8_mode == -1) { }
config->utf8_mode = Py_UTF8Mode; #define COPY_NOT_FLAG(ATTR, VALUE) \
} if (config->ATTR == -1) { \
if (config->isolated == -1) { config->ATTR = !(VALUE); \
config->isolated = Py_IsolatedFlag; }
}
if (config->site_import == -1) {
config->site_import = !Py_NoSiteFlag;
}
}
COPY_FLAG(ignore_environment, Py_IgnoreEnvironmentFlag);
/* Get Py_xxx global configuration variables */ COPY_FLAG(utf8_mode, Py_UTF8Mode);
static void COPY_FLAG(isolated, Py_IsolatedFlag);
pymain_get_global_config(_PyMain *pymain, _Py_CommandLineDetails *cmdline) COPY_FLAG(bytes_warning, Py_BytesWarningFlag);
{ COPY_FLAG(inspect, Py_InspectFlag);
_PyCoreConfig_GetGlobalConfig(&pymain->config); COPY_FLAG(interactive, Py_InteractiveFlag);
COPY_FLAG(optimization_level, Py_OptimizeFlag);
cmdline->bytes_warning = Py_BytesWarningFlag; COPY_FLAG(debug, Py_DebugFlag);
cmdline->debug = Py_DebugFlag; COPY_FLAG(verbose, Py_VerboseFlag);
cmdline->inspect = Py_InspectFlag; COPY_FLAG(quiet, Py_QuietFlag);
cmdline->interactive = Py_InteractiveFlag; COPY_FLAG(unbuffered_stdio, Py_UnbufferedStdioFlag);
cmdline->optimization_level = Py_OptimizeFlag;
cmdline->dont_write_bytecode = Py_DontWriteBytecodeFlag;
cmdline->no_user_site_directory = Py_NoUserSiteDirectory;
cmdline->use_unbuffered_io = Py_UnbufferedStdioFlag;
cmdline->verbosity = Py_VerboseFlag;
cmdline->quiet_flag = Py_QuietFlag;
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
cmdline->legacy_windows_fs_encoding = Py_LegacyWindowsFSEncodingFlag; COPY_FLAG(legacy_windows_fs_encoding, Py_LegacyWindowsFSEncodingFlag);
cmdline->legacy_windows_stdio = Py_LegacyWindowsStdioFlag; COPY_FLAG(legacy_windows_stdio, Py_LegacyWindowsStdioFlag);
#endif #endif
cmdline->check_hash_pycs_mode = _Py_CheckHashBasedPycsMode ;
COPY_NOT_FLAG(site_import, Py_NoSiteFlag);
COPY_NOT_FLAG(write_bytecode, Py_DontWriteBytecodeFlag);
COPY_NOT_FLAG(user_site_directory, Py_NoUserSiteDirectory);
if (config->_check_hash_pycs_mode == NULL) {
config->_check_hash_pycs_mode = _Py_CheckHashBasedPycsMode;
}
#undef COPY_FLAG
#undef COPY_NOT_FLAG
} }
@ -613,46 +595,45 @@ pymain_get_global_config(_PyMain *pymain, _Py_CommandLineDetails *cmdline)
void void
_PyCoreConfig_SetGlobalConfig(const _PyCoreConfig *config) _PyCoreConfig_SetGlobalConfig(const _PyCoreConfig *config)
{ {
if (config->ignore_environment != -1) { #define COPY_FLAG(ATTR, VAR) \
Py_IgnoreEnvironmentFlag = config->ignore_environment; if (config->ATTR != -1) { \
} VAR = config->ATTR; \
if (config->utf8_mode != -1) { }
Py_UTF8Mode = config->utf8_mode; #define COPY_NOT_FLAG(ATTR, VAR) \
} if (config->ATTR != -1) { \
if (config->isolated != -1) { VAR = !config->ATTR; \
Py_IsolatedFlag = config->isolated; }
}
if (config->site_import != -1) { COPY_FLAG(ignore_environment, Py_IgnoreEnvironmentFlag);
Py_NoSiteFlag = !config->site_import; 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(debug, Py_DebugFlag);
COPY_FLAG(verbose, Py_VerboseFlag);
COPY_FLAG(quiet, Py_QuietFlag);
COPY_FLAG(unbuffered_stdio, Py_UnbufferedStdioFlag);
#ifdef MS_WINDOWS
COPY_FLAG(legacy_windows_fs_encoding, Py_LegacyWindowsFSEncodingFlag);
COPY_FLAG(legacy_windows_stdio, Py_LegacyWindowsStdioFlag);
#endif
COPY_NOT_FLAG(site_import, Py_NoSiteFlag);
COPY_NOT_FLAG(write_bytecode, Py_DontWriteBytecodeFlag);
COPY_NOT_FLAG(user_site_directory, Py_NoUserSiteDirectory);
if (config->_check_hash_pycs_mode != NULL) {
_Py_CheckHashBasedPycsMode = config->_check_hash_pycs_mode;
} }
/* Random or non-zero hash seed */ /* Random or non-zero hash seed */
Py_HashRandomizationFlag = (config->use_hash_seed == 0 || Py_HashRandomizationFlag = (config->use_hash_seed == 0 ||
config->hash_seed != 0); config->hash_seed != 0);
}
#undef COPY_FLAG
/* Set Py_xxx global configuration variables */ #undef COPY_NOT_FLAG
static void
pymain_set_global_config(_PyMain *pymain, _Py_CommandLineDetails *cmdline)
{
_PyCoreConfig_SetGlobalConfig(&pymain->config);
Py_BytesWarningFlag = cmdline->bytes_warning;
Py_DebugFlag = cmdline->debug;
Py_InspectFlag = cmdline->inspect;
Py_InteractiveFlag = cmdline->interactive;
Py_OptimizeFlag = cmdline->optimization_level;
Py_DontWriteBytecodeFlag = cmdline->dont_write_bytecode;
Py_NoUserSiteDirectory = cmdline->no_user_site_directory;
Py_UnbufferedStdioFlag = cmdline->use_unbuffered_io;
Py_VerboseFlag = cmdline->verbosity;
Py_QuietFlag = cmdline->quiet_flag;
_Py_CheckHashBasedPycsMode = cmdline->check_hash_pycs_mode;
#ifdef MS_WINDOWS
Py_LegacyWindowsFSEncodingFlag = cmdline->legacy_windows_fs_encoding;
Py_LegacyWindowsStdioFlag = cmdline->legacy_windows_stdio;
#endif
} }
@ -762,6 +743,21 @@ _PyCoreConfig_Copy(_PyCoreConfig *config, const _PyCoreConfig *config2)
COPY_ATTR(isolated); COPY_ATTR(isolated);
COPY_ATTR(site_import); COPY_ATTR(site_import);
COPY_ATTR(bytes_warning);
COPY_ATTR(inspect);
COPY_ATTR(interactive);
COPY_ATTR(optimization_level);
COPY_ATTR(debug);
COPY_ATTR(write_bytecode);
COPY_ATTR(verbose);
COPY_ATTR(quiet);
COPY_ATTR(user_site_directory);
COPY_ATTR(unbuffered_stdio);
#ifdef MS_WINDOWS
COPY_ATTR(legacy_windows_fs_encoding);
COPY_ATTR(legacy_windows_stdio);
#endif
COPY_ATTR(_check_hash_pycs_mode);
#undef COPY_ATTR #undef COPY_ATTR
#undef COPY_STR_ATTR #undef COPY_STR_ATTR
@ -990,11 +986,11 @@ pymain_parse_cmdline_impl(_PyMain *pymain, _Py_CommandLineDetails *cmdline)
// Handle long option. // Handle long option.
assert(longindex == 0); // Only one long option now. assert(longindex == 0); // Only one long option now.
if (!wcscmp(_PyOS_optarg, L"always")) { if (!wcscmp(_PyOS_optarg, L"always")) {
cmdline->check_hash_pycs_mode = "always"; config->_check_hash_pycs_mode = "always";
} else if (!wcscmp(_PyOS_optarg, L"never")) { } else if (!wcscmp(_PyOS_optarg, L"never")) {
cmdline->check_hash_pycs_mode = "never"; config->_check_hash_pycs_mode = "never";
} else if (!wcscmp(_PyOS_optarg, L"default")) { } else if (!wcscmp(_PyOS_optarg, L"default")) {
cmdline->check_hash_pycs_mode = "default"; config->_check_hash_pycs_mode = "default";
} else { } else {
fprintf(stderr, "--check-hash-based-pycs must be one of " fprintf(stderr, "--check-hash-based-pycs must be one of "
"'default', 'always', or 'never'\n"); "'default', 'always', or 'never'\n");
@ -1003,36 +999,36 @@ pymain_parse_cmdline_impl(_PyMain *pymain, _Py_CommandLineDetails *cmdline)
break; break;
case 'b': case 'b':
cmdline->bytes_warning++; config->bytes_warning++;
break; break;
case 'd': case 'd':
cmdline->debug++; config->debug++;
break; break;
case 'i': case 'i':
cmdline->inspect++; config->inspect++;
cmdline->interactive++; config->interactive++;
break; break;
case 'I': case 'I':
config->ignore_environment++; config->ignore_environment++;
config->isolated++; config->isolated++;
cmdline->no_user_site_directory++; config->user_site_directory = 0;
break; break;
/* case 'J': reserved for Jython */ /* case 'J': reserved for Jython */
case 'O': case 'O':
cmdline->optimization_level++; config->optimization_level++;
break; break;
case 'B': case 'B':
cmdline->dont_write_bytecode++; config->write_bytecode = 0;
break; break;
case 's': case 's':
cmdline->no_user_site_directory++; config->user_site_directory = 0;
break; break;
case 'S': case 'S':
@ -1048,11 +1044,11 @@ pymain_parse_cmdline_impl(_PyMain *pymain, _Py_CommandLineDetails *cmdline)
break; break;
case 'u': case 'u':
cmdline->use_unbuffered_io = 1; config->unbuffered_stdio = 1;
break; break;
case 'v': case 'v':
cmdline->verbosity++; config->verbose++;
break; break;
case 'x': case 'x':
@ -1087,7 +1083,7 @@ pymain_parse_cmdline_impl(_PyMain *pymain, _Py_CommandLineDetails *cmdline)
break; break;
case 'q': case 'q':
cmdline->quiet_flag++; config->quiet++;
break; break;
case 'R': case 'R':
@ -1237,9 +1233,9 @@ config_init_warnoptions(_PyCoreConfig *config, _Py_CommandLineDetails *cmdline)
* don't even try to emit a warning, so we skip setting the filter in that * don't even try to emit a warning, so we skip setting the filter in that
* case. * case.
*/ */
if (cmdline->bytes_warning) { if (config->bytes_warning) {
wchar_t *filter; wchar_t *filter;
if (cmdline->bytes_warning> 1) { if (config->bytes_warning> 1) {
filter = L"error::BytesWarning"; filter = L"error::BytesWarning";
} }
else { else {
@ -1299,8 +1295,10 @@ cmdline_init_env_warnoptions(_PyMain *pymain, _Py_CommandLineDetails *cmdline)
static void static void
pymain_init_stdio(_PyMain *pymain) pymain_init_stdio(_PyMain *pymain)
{ {
_PyCoreConfig *config = &pymain->config;
pymain->stdin_is_interactive = (isatty(fileno(stdin)) pymain->stdin_is_interactive = (isatty(fileno(stdin))
|| Py_InteractiveFlag); || config->interactive);
#if defined(MS_WINDOWS) || defined(__CYGWIN__) #if defined(MS_WINDOWS) || defined(__CYGWIN__)
/* don't translate newlines (\r\n <=> \n) */ /* don't translate newlines (\r\n <=> \n) */
@ -1309,7 +1307,7 @@ pymain_init_stdio(_PyMain *pymain)
_setmode(fileno(stderr), O_BINARY); _setmode(fileno(stderr), O_BINARY);
#endif #endif
if (Py_UnbufferedStdioFlag) { if (config->unbuffered_stdio) {
#ifdef HAVE_SETVBUF #ifdef HAVE_SETVBUF
setvbuf(stdin, (char *)NULL, _IONBF, BUFSIZ); setvbuf(stdin, (char *)NULL, _IONBF, BUFSIZ);
setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ); setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ);
@ -1320,7 +1318,7 @@ pymain_init_stdio(_PyMain *pymain)
setbuf(stderr, (char *)NULL); setbuf(stderr, (char *)NULL);
#endif /* !HAVE_SETVBUF */ #endif /* !HAVE_SETVBUF */
} }
else if (Py_InteractiveFlag) { else if (config->interactive) {
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
/* Doesn't have to have line-buffered -- use unbuffered */ /* Doesn't have to have line-buffered -- use unbuffered */
/* Any set[v]buf(stdin, ...) screws up Tkinter :-( */ /* Any set[v]buf(stdin, ...) screws up Tkinter :-( */
@ -1886,17 +1884,29 @@ static void
cmdline_get_env_flags(_PyMain *pymain, _Py_CommandLineDetails *cmdline) cmdline_get_env_flags(_PyMain *pymain, _Py_CommandLineDetails *cmdline)
{ {
_PyCoreConfig *config = &pymain->config; _PyCoreConfig *config = &pymain->config;
get_env_flag(config, &cmdline->debug, "PYTHONDEBUG");
get_env_flag(config, &cmdline->verbosity, "PYTHONVERBOSE"); get_env_flag(config, &config->debug, "PYTHONDEBUG");
get_env_flag(config, &cmdline->optimization_level, "PYTHONOPTIMIZE"); get_env_flag(config, &config->verbose, "PYTHONVERBOSE");
get_env_flag(config, &cmdline->inspect, "PYTHONINSPECT"); get_env_flag(config, &config->optimization_level, "PYTHONOPTIMIZE");
get_env_flag(config, &cmdline->dont_write_bytecode, "PYTHONDONTWRITEBYTECODE"); get_env_flag(config, &config->inspect, "PYTHONINSPECT");
get_env_flag(config, &cmdline->no_user_site_directory, "PYTHONNOUSERSITE");
get_env_flag(config, &cmdline->use_unbuffered_io, "PYTHONUNBUFFERED"); 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;
}
get_env_flag(config, &config->unbuffered_stdio, "PYTHONUNBUFFERED");
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
get_env_flag(config, &cmdline->legacy_windows_fs_encoding, get_env_flag(config, &config->legacy_windows_fs_encoding,
"PYTHONLEGACYWINDOWSFSENCODING"); "PYTHONLEGACYWINDOWSFSENCODING");
get_env_flag(config, &cmdline->legacy_windows_stdio, get_env_flag(config, &config->legacy_windows_stdio,
"PYTHONLEGACYWINDOWSSTDIO"); "PYTHONLEGACYWINDOWSSTDIO");
#endif #endif
} }
@ -2077,6 +2087,7 @@ config_read_complex_options(_PyCoreConfig *config)
static int static int
pymain_read_conf_impl(_PyMain *pymain, _Py_CommandLineDetails *cmdline) pymain_read_conf_impl(_PyMain *pymain, _Py_CommandLineDetails *cmdline)
{ {
_PyCoreConfig *config = &pymain->config;
_PyInitError err; _PyInitError err;
int res = pymain_parse_cmdline(pymain, cmdline); int res = pymain_parse_cmdline(pymain, cmdline);
@ -2094,8 +2105,8 @@ pymain_read_conf_impl(_PyMain *pymain, _Py_CommandLineDetails *cmdline)
} }
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
if (cmdline->legacy_windows_fs_encoding) { if (config->legacy_windows_fs_encoding) {
pymain->config.utf8_mode = 0; config->utf8_mode = 0;
} }
#endif #endif
@ -2103,7 +2114,7 @@ pymain_read_conf_impl(_PyMain *pymain, _Py_CommandLineDetails *cmdline)
return -1; return -1;
} }
err = _PyCoreConfig_Read(&pymain->config); err = _PyCoreConfig_Read(config);
if (_Py_INIT_FAILED(err)) { if (_Py_INIT_FAILED(err)) {
pymain->err = err; pymain->err = err;
@ -2203,7 +2214,6 @@ pymain_read_conf(_PyMain *pymain, _Py_CommandLineDetails *cmdline)
} }
pymain_clear_cmdline(pymain, cmdline); pymain_clear_cmdline(pymain, cmdline);
memset(cmdline, 0, sizeof(*cmdline)); memset(cmdline, 0, sizeof(*cmdline));
pymain_get_global_config(pymain, cmdline);
pymain->config.utf8_mode = new_utf8_mode; pymain->config.utf8_mode = new_utf8_mode;
/* The encoding changed: read again the configuration /* The encoding changed: read again the configuration
@ -2615,12 +2625,8 @@ pymain_cmdline(_PyMain *pymain)
_Py_CommandLineDetails cmdline; _Py_CommandLineDetails cmdline;
memset(&cmdline, 0, sizeof(cmdline)); memset(&cmdline, 0, sizeof(cmdline));
pymain_get_global_config(pymain, &cmdline);
int res = pymain_cmdline_impl(pymain, &cmdline); int res = pymain_cmdline_impl(pymain, &cmdline);
pymain_set_global_config(pymain, &cmdline);
pymain_clear_cmdline(pymain, &cmdline); pymain_clear_cmdline(pymain, &cmdline);
#ifdef Py_DEBUG #ifdef Py_DEBUG
@ -2639,6 +2645,8 @@ pymain_main(_PyMain *pymain)
{ {
pymain_init(pymain); pymain_init(pymain);
_PyCoreConfig_GetGlobalConfig(&pymain->config);
int res = pymain_cmdline(pymain); int res = pymain_cmdline(pymain);
if (res < 0) { if (res < 0) {
_Py_FatalInitError(pymain->err); _Py_FatalInitError(pymain->err);
@ -2647,6 +2655,8 @@ pymain_main(_PyMain *pymain)
goto done; goto done;
} }
_PyCoreConfig_SetGlobalConfig(&pymain->config);
pymain_init_stdio(pymain); pymain_init_stdio(pymain);
/* bpo-34008: For backward compatibility reasons, calling Py_Main() after /* bpo-34008: For backward compatibility reasons, calling Py_Main() after

11
Objects/bytearrayobject.c
View File

@ -999,12 +999,13 @@ bytearray_repr(PyByteArrayObject *self)
static PyObject * static PyObject *
bytearray_str(PyObject *op) bytearray_str(PyObject *op)
{ {
if (Py_BytesWarningFlag) { if (Py_BytesWarningFlag) {
if (PyErr_WarnEx(PyExc_BytesWarning, if (PyErr_WarnEx(PyExc_BytesWarning,
"str() on a bytearray instance", 1)) "str() on a bytearray instance", 1)) {
return NULL; return NULL;
} }
return bytearray_repr((PyByteArrayObject*)op); }
return bytearray_repr((PyByteArrayObject*)op);
} }
static PyObject * static PyObject *

3
Objects/bytesobject.c
View File

@ -1416,8 +1416,9 @@ bytes_str(PyObject *op)
{ {
if (Py_BytesWarningFlag) { if (Py_BytesWarningFlag) {
if (PyErr_WarnEx(PyExc_BytesWarning, if (PyErr_WarnEx(PyExc_BytesWarning,
"str() on a bytes instance", 1)) "str() on a bytes instance", 1)) {
return NULL; return NULL;
}
} }
return bytes_repr(op); return bytes_repr(op);
} }

6
Parser/pgenmain.c
View File

@ -24,9 +24,9 @@
#include "parsetok.h" #include "parsetok.h"
#include "pgen.h" #include "pgen.h"
int Py_DebugFlag; int Py_DebugFlag = 0;
int Py_VerboseFlag; int Py_VerboseFlag = 0;
int Py_IgnoreEnvironmentFlag; int Py_IgnoreEnvironmentFlag = 0;
_PyRuntimeState _PyRuntime = _PyRuntimeState_INIT; _PyRuntimeState _PyRuntime = _PyRuntimeState_INIT;
/* Forward */ /* Forward */

6
Python/pystate.c
View File

@ -568,7 +568,9 @@ _PyState_ClearModules(void)
void void
PyThreadState_Clear(PyThreadState *tstate) PyThreadState_Clear(PyThreadState *tstate)
{ {
if (Py_VerboseFlag && tstate->frame != NULL) int verbose = tstate->interp->core_config.verbose;
if (verbose && tstate->frame != NULL)
fprintf(stderr, fprintf(stderr,
"PyThreadState_Clear: warning: thread still has a frame\n"); "PyThreadState_Clear: warning: thread still has a frame\n");
@ -586,7 +588,7 @@ PyThreadState_Clear(PyThreadState *tstate)
Py_CLEAR(tstate->exc_state.exc_traceback); Py_CLEAR(tstate->exc_state.exc_traceback);
/* The stack of exception states should contain just this thread. */ /* The stack of exception states should contain just this thread. */
if (Py_VerboseFlag && tstate->exc_info != &tstate->exc_state) { if (verbose && tstate->exc_info != &tstate->exc_state) {
fprintf(stderr, fprintf(stderr,
"PyThreadState_Clear: warning: thread still has a generator\n"); "PyThreadState_Clear: warning: thread still has a generator\n");
} }