blob: 6b602cf9b77543b32b460eb25cf817734a0da755 [file] [log] [blame]
Guido van Rossum667d7041995-08-04 04:20:48 +00001/* Python interpreter main program */
2
3#include "Python.h"
Guido van Rossuma075ce11997-12-05 21:56:45 +00004#include "osdefs.h"
Benjamin Peterson42aa93b2017-12-09 10:26:52 -08005#include "internal/import.h"
Benjamin Petersone425bd72017-12-14 23:48:12 -08006#include "internal/pygetopt.h"
Victor Stinnerf7e5b562017-11-15 15:48:08 -08007#include "internal/pystate.h"
Guido van Rossum667d7041995-08-04 04:20:48 +00008
Antoine Pitrou5651eaa2008-09-06 20:46:58 +00009#include <locale.h>
10
Sjoerd Mullender9cf424b2002-08-09 13:35:18 +000011#if defined(MS_WINDOWS) || defined(__CYGWIN__)
Martin v. Löwis945362c2007-08-30 14:57:25 +000012#include <windows.h>
Steve Dowerbfce0f92016-12-28 15:41:09 -080013#ifdef HAVE_IO_H
14#include <io.h>
15#endif
Thomas Wouters477c8d52006-05-27 19:21:47 +000016#ifdef HAVE_FCNTL_H
Guido van Rossum3e7ae7a1997-01-17 22:05:38 +000017#include <fcntl.h>
18#endif
Thomas Wouters477c8d52006-05-27 19:21:47 +000019#endif
Guido van Rossum3e7ae7a1997-01-17 22:05:38 +000020
Martin v. Löwis945362c2007-08-30 14:57:25 +000021#ifdef _MSC_VER
22#include <crtdbg.h>
23#endif
24
Jesus Ceaab70e2a2012-10-05 01:48:08 +020025#if defined(MS_WINDOWS)
gauravbackback08d2b862017-11-28 20:46:30 +053026#define PYTHONHOMEHELP "<prefix>\\python{major}{minor}"
Guido van Rossuma075ce11997-12-05 21:56:45 +000027#else
gauravbackback08d2b862017-11-28 20:46:30 +053028#define PYTHONHOMEHELP "<prefix>/lib/pythonX.X"
Guido van Rossuma075ce11997-12-05 21:56:45 +000029#endif
30
Guido van Rossuma22865e2000-09-05 04:41:18 +000031#define COPYRIGHT \
Guido van Rossum36002d72001-07-18 16:59:46 +000032 "Type \"help\", \"copyright\", \"credits\" or \"license\" " \
33 "for more information."
Guido van Rossuma22865e2000-09-05 04:41:18 +000034
Thomas Wouters49fd7fa2006-04-21 10:40:58 +000035#ifdef __cplusplus
36extern "C" {
37#endif
38
Victor Stinner46972b72017-11-24 22:55:40 +010039#define DECODE_LOCALE_ERR(NAME, LEN) \
40 (((LEN) == -2) \
Victor Stinner9316ee42017-11-25 03:17:57 +010041 ? _Py_INIT_USER_ERR("cannot decode " #NAME) \
Victor Stinner46972b72017-11-24 22:55:40 +010042 : _Py_INIT_NO_MEMORY())
43
44
Victor Stinner0327bde2017-11-23 17:03:20 +010045#define SET_DECODE_ERROR(NAME, LEN) \
46 do { \
47 if ((LEN) == (size_t)-2) { \
Victor Stinner9316ee42017-11-25 03:17:57 +010048 pymain->err = _Py_INIT_USER_ERR("cannot decode " #NAME); \
Victor Stinner0327bde2017-11-23 17:03:20 +010049 } \
50 else { \
51 pymain->err = _Py_INIT_NO_MEMORY(); \
52 } \
53 } while (0)
54
Guido van Rossumac56b031996-07-21 02:33:38 +000055/* For Py_GetArgcArgv(); set by main() */
Martin v. Löwis790465f2008-04-05 20:41:37 +000056static wchar_t **orig_argv;
Victor Stinnerf7e5b562017-11-15 15:48:08 -080057static int orig_argc;
Guido van Rossum667d7041995-08-04 04:20:48 +000058
Guido van Rossumbceccf52001-04-10 22:07:43 +000059/* command line options */
Christian Heimesad73a9c2013-08-10 16:36:18 +020060#define BASE_OPTS L"bBc:dEhiIJm:OqRsStuvVW:xX:?"
Guido van Rossumbceccf52001-04-10 22:07:43 +000061
Guido van Rossumbceccf52001-04-10 22:07:43 +000062#define PROGRAM_OPTS BASE_OPTS
Guido van Rossum3ed4c152001-03-02 06:18:03 +000063
Benjamin Peterson42aa93b2017-12-09 10:26:52 -080064static const _PyOS_LongOption longoptions[] = {
65 {L"check-hash-based-pycs", 1, 0},
66 {NULL, 0, 0},
67};
68
Guido van Rossum667d7041995-08-04 04:20:48 +000069/* Short usage message (with %s for argv0) */
Serhiy Storchaka2d06e842015-12-25 19:53:18 +020070static const char usage_line[] =
Martin v. Löwis790465f2008-04-05 20:41:37 +000071"usage: %ls [option] ... [-c cmd | -m mod | file | -] [arg] ...\n";
Guido van Rossum667d7041995-08-04 04:20:48 +000072
73/* Long usage message, split into parts < 512 bytes */
Serhiy Storchaka2d06e842015-12-25 19:53:18 +020074static const char usage_1[] = "\
Guido van Rossum667d7041995-08-04 04:20:48 +000075Options and arguments (and corresponding environment variables):\n\
Christian Heimes2ab34442008-09-03 20:31:07 +000076-b : issue warnings about str(bytes_instance), str(bytearray_instance)\n\
77 and comparing bytes/bytearray with str. (-bb: issue errors)\n\
Xiang Zhang0710d752017-03-11 13:02:52 +080078-B : don't write .pyc files on import; also PYTHONDONTWRITEBYTECODE=x\n\
Guido van Rossum393661d2001-08-31 17:40:15 +000079-c cmd : program passed in as string (terminates option list)\n\
Thomas Wouters89f507f2006-12-13 04:49:30 +000080-d : debug output from parser; also PYTHONDEBUG=x\n\
Christian Heimes790c8232008-01-07 21:14:23 +000081-E : ignore PYTHON* environment variables (such as PYTHONPATH)\n\
Thomas Wouters0e3f5912006-08-11 14:57:12 +000082-h : print this help message and exit (also --help)\n\
Guido van Rossum61c345f2001-09-04 03:26:15 +000083";
Serhiy Storchaka2d06e842015-12-25 19:53:18 +020084static const char usage_2[] = "\
Guido van Rossum98297ee2007-11-06 21:34:58 +000085-i : inspect interactively after running script; forces a prompt even\n\
86 if stdin does not appear to be a terminal; also PYTHONINSPECT=x\n\
Christian Heimesad73a9c2013-08-10 16:36:18 +020087-I : isolate Python from the user's environment (implies -E and -s)\n\
Raymond Hettingerdb29e0f2004-10-07 06:46:25 +000088-m mod : run library module as a script (terminates option list)\n\
Thomas Wouters89f507f2006-12-13 04:49:30 +000089-O : optimize generated bytecode slightly; also PYTHONOPTIMIZE=x\n\
Guido van Rossum6b86a421999-01-28 15:07:47 +000090-OO : remove doc-strings in addition to the -O optimizations\n\
Georg Brandl9d871192010-12-04 10:47:18 +000091-q : don't print version and copyright messages on interactive startup\n\
Christian Heimes8dc226f2008-05-06 23:45:46 +000092-s : don't add user site directory to sys.path; also PYTHONNOUSERSITE\n\
Guido van Rossum7922bd71997-08-29 22:34:47 +000093-S : don't imply 'import site' on initialization\n\
Guido van Rossum393661d2001-08-31 17:40:15 +000094";
Serhiy Storchaka2d06e842015-12-25 19:53:18 +020095static const char usage_3[] = "\
Berker Peksag7f580972017-10-13 15:16:31 +030096-u : force the stdout and stderr streams to be unbuffered;\n\
97 this option has no effect on stdin; also PYTHONUNBUFFERED=x\n\
Thomas Wouters89f507f2006-12-13 04:49:30 +000098-v : verbose (trace import statements); also PYTHONVERBOSE=x\n\
99 can be supplied multiple times to increase verbosity\n\
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000100-V : print the Python version number and exit (also --version)\n\
INADA Naoki0e175a62016-11-21 20:57:14 +0900101 when given twice, print more information about the build\n\
Thomas Wouters89f507f2006-12-13 04:49:30 +0000102-W arg : warning control; arg is action:message:category:module:lineno\n\
Philip Jenvey0805ca32010-04-07 04:04:10 +0000103 also PYTHONWARNINGS=arg\n\
Guido van Rossum393661d2001-08-31 17:40:15 +0000104-x : skip first line of source, allowing use of non-Unix forms of #!cmd\n\
Antoine Pitrou9583cac2010-10-21 13:42:28 +0000105-X opt : set implementation-specific option\n\
Benjamin Peterson42aa93b2017-12-09 10:26:52 -0800106--check-hash-based-pycs always|default|never:\n\
107 control how Python invalidates hash-based .pyc files\n\
Guido van Rossum7922bd71997-08-29 22:34:47 +0000108";
Serhiy Storchaka2d06e842015-12-25 19:53:18 +0200109static const char usage_4[] = "\
Guido van Rossum98297ee2007-11-06 21:34:58 +0000110file : program read from script file\n\
111- : program read from stdin (default; interactive mode if a tty)\n\
Thomas Wouters89f507f2006-12-13 04:49:30 +0000112arg ...: arguments passed to program in sys.argv[1:]\n\n\
Guido van Rossum667d7041995-08-04 04:20:48 +0000113Other environment variables:\n\
114PYTHONSTARTUP: file executed on interactive startup (no default)\n\
Serhiy Storchaka1ba01612015-12-30 09:28:19 +0200115PYTHONPATH : '%lc'-separated list of directories prefixed to the\n\
Guido van Rossum667d7041995-08-04 04:20:48 +0000116 default module search path. The result is sys.path.\n\
Christian Heimes790c8232008-01-07 21:14:23 +0000117";
Serhiy Storchaka2d06e842015-12-25 19:53:18 +0200118static const char usage_5[] =
Serhiy Storchaka1ba01612015-12-30 09:28:19 +0200119"PYTHONHOME : alternate <prefix> directory (or <prefix>%lc<exec_prefix>).\n"
Victor Stinner9802b392010-08-19 11:36:43 +0000120" The default module search path uses %s.\n"
121"PYTHONCASEOK : ignore case in 'import' statements (Windows).\n"
122"PYTHONIOENCODING: Encoding[:errors] used for stdin/stdout/stderr.\n"
Victor Stinner34be807c2016-03-14 12:04:26 +0100123"PYTHONFAULTHANDLER: dump the Python traceback on fatal errors.\n";
124static const char usage_6[] =
125"PYTHONHASHSEED: if this variable is set to 'random', a random value is used\n"
126" to seed the hashes of str, bytes and datetime objects. It can also be\n"
127" set to an integer in the range [0,4294967295] to get hash values with a\n"
128" predictable seed.\n"
129"PYTHONMALLOC: set the Python memory allocators and/or install debug hooks\n"
130" on Python memory allocators. Use PYTHONMALLOC=debug to install debug\n"
Nick Coghlaneb817952017-06-18 12:29:42 +1000131" hooks.\n"
Stéphane Wirtel7d1017d2017-06-12 13:30:33 +0200132"PYTHONCOERCECLOCALE: if this variable is set to 0, it disables the locale\n"
Nick Coghlaneb817952017-06-18 12:29:42 +1000133" coercion behavior. Use PYTHONCOERCECLOCALE=warn to request display of\n"
Victor Stinner5e3806f2017-11-30 11:40:24 +0100134" locale coercion and locale compatibility warnings on stderr.\n"
135"PYTHONDEVMODE: enable the development mode.\n";
Guido van Rossum667d7041995-08-04 04:20:48 +0000136
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800137static void
Victor Stinnera7368ac2017-11-15 18:11:45 -0800138pymain_usage(int error, const wchar_t* program)
Barry Warsaw3b2aedb2000-09-15 18:40:42 +0000139{
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800140 FILE *f = error ? stderr : stdout;
Guido van Rossum393661d2001-08-31 17:40:15 +0000141
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000142 fprintf(f, usage_line, program);
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800143 if (error)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000144 fprintf(f, "Try `python -h' for more information.\n");
145 else {
146 fputs(usage_1, f);
147 fputs(usage_2, f);
148 fputs(usage_3, f);
Serhiy Storchaka1ba01612015-12-30 09:28:19 +0200149 fprintf(f, usage_4, (wint_t)DELIM);
150 fprintf(f, usage_5, (wint_t)DELIM, PYTHONHOMEHELP);
Georg Brandl2daf6ae2012-02-20 19:54:16 +0100151 fputs(usage_6, f);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000152 }
Barry Warsaw3b2aedb2000-09-15 18:40:42 +0000153}
154
Victor Stinnera7368ac2017-11-15 18:11:45 -0800155
Serhiy Storchaka4ae06c52017-12-12 13:55:04 +0200156static const char*
Victor Stinnera7368ac2017-11-15 18:11:45 -0800157pymain_get_env_var(const char *name)
158{
Serhiy Storchaka4ae06c52017-12-12 13:55:04 +0200159 const char *var = Py_GETENV(name);
Victor Stinnera7368ac2017-11-15 18:11:45 -0800160 if (var && var[0] != '\0') {
161 return var;
162 }
163 else {
164 return NULL;
165 }
166}
167
168
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800169static void
Victor Stinner33c377e2017-12-05 15:12:41 +0100170pymain_run_startup(PyCompilerFlags *cf)
Martin v. Löwis6caea372003-11-18 19:46:25 +0000171{
Serhiy Storchaka4ae06c52017-12-12 13:55:04 +0200172 const char *startup = pymain_get_env_var("PYTHONSTARTUP");
Victor Stinner6bf992a2017-12-06 17:26:10 +0100173 if (startup == NULL) {
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800174 return;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000175 }
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800176
177 FILE *fp = _Py_fopen(startup, "r");
178 if (fp == NULL) {
179 int save_errno = errno;
180 PySys_WriteStderr("Could not open PYTHONSTARTUP\n");
181 errno = save_errno;
182
183 PyErr_SetFromErrnoWithFilename(PyExc_OSError,
184 startup);
185 PyErr_Print();
186 PyErr_Clear();
187 return;
188 }
189
190 (void) PyRun_SimpleFileExFlags(fp, startup, 0, cf);
191 PyErr_Clear();
192 fclose(fp);
Martin v. Löwis6caea372003-11-18 19:46:25 +0000193}
194
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800195static void
196pymain_run_interactive_hook(void)
Antoine Pitrou1a6cb302013-05-04 20:08:35 +0200197{
198 PyObject *sys, *hook, *result;
199 sys = PyImport_ImportModule("sys");
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800200 if (sys == NULL) {
Antoine Pitrou1a6cb302013-05-04 20:08:35 +0200201 goto error;
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800202 }
203
Antoine Pitrou1a6cb302013-05-04 20:08:35 +0200204 hook = PyObject_GetAttrString(sys, "__interactivehook__");
205 Py_DECREF(sys);
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800206 if (hook == NULL) {
Antoine Pitrou1a6cb302013-05-04 20:08:35 +0200207 PyErr_Clear();
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800208 return;
Antoine Pitrou1a6cb302013-05-04 20:08:35 +0200209 }
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800210
211 result = _PyObject_CallNoArg(hook);
212 Py_DECREF(hook);
213 if (result == NULL) {
214 goto error;
215 }
216 Py_DECREF(result);
217
Antoine Pitrou1a6cb302013-05-04 20:08:35 +0200218 return;
219
220error:
221 PySys_WriteStderr("Failed calling sys.__interactivehook__\n");
222 PyErr_Print();
223 PyErr_Clear();
224}
225
Thomas Woutersa9773292006-04-21 09:43:23 +0000226
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800227static int
228pymain_run_module(wchar_t *modname, int set_argv0)
Raymond Hettingerdb29e0f2004-10-07 06:46:25 +0000229{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000230 PyObject *module, *runpy, *runmodule, *runargs, *result;
231 runpy = PyImport_ImportModule("runpy");
232 if (runpy == NULL) {
233 fprintf(stderr, "Could not import runpy module\n");
Victor Stinner7d36e4f2013-04-10 00:27:23 +0200234 PyErr_Print();
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000235 return -1;
236 }
237 runmodule = PyObject_GetAttrString(runpy, "_run_module_as_main");
238 if (runmodule == NULL) {
239 fprintf(stderr, "Could not access runpy._run_module_as_main\n");
Victor Stinner7d36e4f2013-04-10 00:27:23 +0200240 PyErr_Print();
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000241 Py_DECREF(runpy);
242 return -1;
243 }
244 module = PyUnicode_FromWideChar(modname, wcslen(modname));
245 if (module == NULL) {
246 fprintf(stderr, "Could not convert module name to unicode\n");
Victor Stinner7d36e4f2013-04-10 00:27:23 +0200247 PyErr_Print();
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000248 Py_DECREF(runpy);
249 Py_DECREF(runmodule);
250 return -1;
251 }
252 runargs = Py_BuildValue("(Oi)", module, set_argv0);
253 if (runargs == NULL) {
254 fprintf(stderr,
255 "Could not create arguments for runpy._run_module_as_main\n");
Victor Stinner7d36e4f2013-04-10 00:27:23 +0200256 PyErr_Print();
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000257 Py_DECREF(runpy);
258 Py_DECREF(runmodule);
259 Py_DECREF(module);
260 return -1;
261 }
262 result = PyObject_Call(runmodule, runargs, NULL);
263 if (result == NULL) {
264 PyErr_Print();
265 }
266 Py_DECREF(runpy);
267 Py_DECREF(runmodule);
268 Py_DECREF(module);
269 Py_DECREF(runargs);
270 if (result == NULL) {
271 return -1;
272 }
273 Py_DECREF(result);
274 return 0;
Raymond Hettingerdb29e0f2004-10-07 06:46:25 +0000275}
Barry Warsaw3b2aedb2000-09-15 18:40:42 +0000276
Nick Coghland2977a32017-03-12 20:38:32 +1000277static PyObject *
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800278pymain_get_importer(wchar_t *filename)
Christian Heimes9cd17752007-11-18 19:35:23 +0000279{
Nick Coghland2977a32017-03-12 20:38:32 +1000280 PyObject *sys_path0 = NULL, *importer;
Christian Heimes9cd17752007-11-18 19:35:23 +0000281
Nick Coghland2977a32017-03-12 20:38:32 +1000282 sys_path0 = PyUnicode_FromWideChar(filename, wcslen(filename));
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800283 if (sys_path0 == NULL) {
Victor Stinner4726e402010-10-06 23:24:57 +0000284 goto error;
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800285 }
Victor Stinner4726e402010-10-06 23:24:57 +0000286
Nick Coghland2977a32017-03-12 20:38:32 +1000287 importer = PyImport_GetImporter(sys_path0);
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800288 if (importer == NULL) {
Victor Stinner4726e402010-10-06 23:24:57 +0000289 goto error;
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800290 }
Victor Stinner4726e402010-10-06 23:24:57 +0000291
Brett Cannonaa936422012-04-27 15:30:58 -0400292 if (importer == Py_None) {
Nick Coghland2977a32017-03-12 20:38:32 +1000293 Py_DECREF(sys_path0);
Victor Stinner4726e402010-10-06 23:24:57 +0000294 Py_DECREF(importer);
Nick Coghland2977a32017-03-12 20:38:32 +1000295 return NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000296 }
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800297
Victor Stinner4726e402010-10-06 23:24:57 +0000298 Py_DECREF(importer);
Nick Coghland2977a32017-03-12 20:38:32 +1000299 return sys_path0;
Victor Stinner4726e402010-10-06 23:24:57 +0000300
Nick Coghland2977a32017-03-12 20:38:32 +1000301error:
302 Py_XDECREF(sys_path0);
303 PySys_WriteStderr("Failed checking if argv[0] is an import path entry\n");
304 PyErr_Print();
305 PyErr_Clear();
306 return NULL;
307}
308
309
310static int
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800311pymain_run_command(wchar_t *command, PyCompilerFlags *cf)
Victor Stinnera62207c2010-08-07 10:57:17 +0000312{
313 PyObject *unicode, *bytes;
314 int ret;
315
316 unicode = PyUnicode_FromWideChar(command, -1);
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800317 if (unicode == NULL) {
Victor Stinnera62207c2010-08-07 10:57:17 +0000318 goto error;
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800319 }
320
Victor Stinnera62207c2010-08-07 10:57:17 +0000321 bytes = PyUnicode_AsUTF8String(unicode);
322 Py_DECREF(unicode);
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800323 if (bytes == NULL) {
Victor Stinnera62207c2010-08-07 10:57:17 +0000324 goto error;
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800325 }
326
Victor Stinnera62207c2010-08-07 10:57:17 +0000327 ret = PyRun_SimpleStringFlags(PyBytes_AsString(bytes), cf);
328 Py_DECREF(bytes);
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800329 return (ret != 0);
Victor Stinnera62207c2010-08-07 10:57:17 +0000330
331error:
Victor Stinner398356b2010-08-18 22:23:22 +0000332 PySys_WriteStderr("Unable to decode the command from the command line:\n");
Victor Stinnera62207c2010-08-07 10:57:17 +0000333 PyErr_Print();
334 return 1;
335}
336
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800337
Victor Stinner0a3ddad2010-08-07 16:34:25 +0000338static int
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800339pymain_run_file(FILE *fp, const wchar_t *filename, PyCompilerFlags *p_cf)
Victor Stinner0a3ddad2010-08-07 16:34:25 +0000340{
341 PyObject *unicode, *bytes = NULL;
Serhiy Storchakae2f92de2017-11-11 13:06:26 +0200342 const char *filename_str;
Victor Stinner0a3ddad2010-08-07 16:34:25 +0000343 int run;
344
345 /* call pending calls like signal handlers (SIGINT) */
346 if (Py_MakePendingCalls() == -1) {
347 PyErr_Print();
348 return 1;
349 }
350
351 if (filename) {
352 unicode = PyUnicode_FromWideChar(filename, wcslen(filename));
353 if (unicode != NULL) {
Victor Stinnere0f32682010-10-17 19:34:51 +0000354 bytes = PyUnicode_EncodeFSDefault(unicode);
Victor Stinner0a3ddad2010-08-07 16:34:25 +0000355 Py_DECREF(unicode);
356 }
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800357 if (bytes != NULL) {
Victor Stinner0a3ddad2010-08-07 16:34:25 +0000358 filename_str = PyBytes_AsString(bytes);
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800359 }
Victor Stinner0a3ddad2010-08-07 16:34:25 +0000360 else {
361 PyErr_Clear();
Victor Stinnere0f32682010-10-17 19:34:51 +0000362 filename_str = "<encoding error>";
Victor Stinner0a3ddad2010-08-07 16:34:25 +0000363 }
364 }
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800365 else {
Victor Stinner0a3ddad2010-08-07 16:34:25 +0000366 filename_str = "<stdin>";
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800367 }
Victor Stinner0a3ddad2010-08-07 16:34:25 +0000368
369 run = PyRun_AnyFileExFlags(fp, filename_str, filename != NULL, p_cf);
370 Py_XDECREF(bytes);
371 return run != 0;
372}
373
Christian Heimes9cd17752007-11-18 19:35:23 +0000374
Guido van Rossum667d7041995-08-04 04:20:48 +0000375/* Main program */
376
Eric Snow6b4be192017-05-22 21:36:03 -0700377typedef struct {
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800378 size_t len;
379 wchar_t **options;
380} _Py_OptList;
381
382typedef struct {
Eric Snow6b4be192017-05-22 21:36:03 -0700383 wchar_t *filename; /* Trailing arg without -c or -m */
384 wchar_t *command; /* -c argument */
385 wchar_t *module; /* -m argument */
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800386 _Py_OptList warning_options; /* -W options */
Eric Snow6b4be192017-05-22 21:36:03 -0700387 int print_help; /* -h, -? options */
388 int print_version; /* -V option */
Victor Stinner6bf992a2017-12-06 17:26:10 +0100389 int bytes_warning; /* Py_BytesWarningFlag, -b */
390 int debug; /* Py_DebugFlag, -b, PYTHONDEBUG */
391 int inspect; /* Py_InspectFlag, -i, PYTHONINSPECT */
392 int interactive; /* Py_InteractiveFlag, -i */
393 int isolated; /* Py_IsolatedFlag, -I */
394 int optimization_level; /* Py_OptimizeFlag, -O, PYTHONOPTIMIZE */
395 int dont_write_bytecode; /* Py_DontWriteBytecodeFlag, -B, PYTHONDONTWRITEBYTECODE */
396 int no_user_site_directory; /* Py_NoUserSiteDirectory, -I, -s, PYTHONNOUSERSITE */
397 int no_site_import; /* Py_NoSiteFlag, -S */
398 int use_unbuffered_io; /* Py_UnbufferedStdioFlag, -u, PYTHONUNBUFFERED */
399 int verbosity; /* Py_VerboseFlag, -v, PYTHONVERBOSE */
400 int quiet_flag; /* Py_QuietFlag, -q */
Eric Snow6b4be192017-05-22 21:36:03 -0700401 int skip_first_line; /* -x option */
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800402 _Py_OptList xoptions; /* -X options */
Benjamin Peterson42aa93b2017-12-09 10:26:52 -0800403 const char *check_hash_pycs_mode; /* --check-hash-based-pycs */
Victor Stinner6bf992a2017-12-06 17:26:10 +0100404#ifdef MS_WINDOWS
405 int legacy_windows_fs_encoding; /* Py_LegacyWindowsFSEncodingFlag,
406 PYTHONLEGACYWINDOWSFSENCODING */
407 int legacy_windows_stdio; /* Py_LegacyWindowsStdioFlag,
408 PYTHONLEGACYWINDOWSSTDIO */
409#endif
Eric Snow6b4be192017-05-22 21:36:03 -0700410} _Py_CommandLineDetails;
411
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800412/* Structure used by Py_Main() to pass data to subfunctions */
413typedef struct {
414 /* Exit status ("exit code") */
415 int status;
416 PyCompilerFlags cf;
417 /* non-zero is stdin is a TTY or if -i option is used */
418 int stdin_is_interactive;
419 _PyCoreConfig core_config;
Victor Stinnere32e79f2017-11-23 01:49:45 +0100420 _PyMainInterpreterConfig config;
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800421 _Py_CommandLineDetails cmdline;
422 PyObject *main_importer_path;
423 /* non-zero if filename, command (-c) or module (-m) is set
424 on the command line */
425 int run_code;
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800426 /* Error message if a function failed */
427 _PyInitError err;
428 /* PYTHONWARNINGS env var */
429 _Py_OptList env_warning_options;
430 int argc;
431 wchar_t **argv;
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +0100432
433 int sys_argc;
434 wchar_t **sys_argv;
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800435} _PyMain;
436
437/* .cmdline is initialized to zeros */
438#define _PyMain_INIT \
Victor Stinnerd5dda982017-12-13 17:31:16 +0100439 {.core_config = _PyCoreConfig_INIT, \
Victor Stinnere32e79f2017-11-23 01:49:45 +0100440 .config = _PyMainInterpreterConfig_INIT, \
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800441 .run_code = -1, \
Victor Stinnerd5dda982017-12-13 17:31:16 +0100442 .err = _Py_INIT_OK()}
443/* Note: _PyMain_INIT sets other fields to 0/NULL */
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800444
445
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800446static void
447pymain_optlist_clear(_Py_OptList *list)
448{
449 for (size_t i=0; i < list->len; i++) {
450 PyMem_RawFree(list->options[i]);
451 }
452 PyMem_RawFree(list->options);
453 list->len = 0;
454 list->options = NULL;
455}
456
Victor Stinner92a3c6f2017-12-06 18:12:59 +0100457
458/* Free global variables which cannot be freed in Py_Finalize():
459 configuration options set before Py_Initialize() which should
460 remain valid after Py_Finalize(), since Py_Initialize()/Py_Finalize() can
461 be called multiple times.
462
463 Called with the current memory allocators. */
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800464static void
Victor Stinner92a3c6f2017-12-06 18:12:59 +0100465pymain_free_globals(_PyMain *pymain)
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800466{
Victor Stinner92a3c6f2017-12-06 18:12:59 +0100467 _PyPathConfig_Clear(&_Py_path_config);
468 _PyImport_Fini2();
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +0100469 _PyCoreConfig_Clear(&pymain->core_config);
Victor Stinnerd4341102017-11-23 00:12:09 +0100470
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800471#ifdef __INSURE__
472 /* Insure++ is a memory analysis tool that aids in discovering
473 * memory leaks and other memory problems. On Python exit, the
474 * interned string dictionaries are flagged as being in use at exit
475 * (which it is). Under normal circumstances, this is fine because
476 * the memory will be automatically reclaimed by the system. Under
477 * memory debugging, it's a huge source of useless noise, so we
478 * trade off slower shutdown for less distraction in the memory
479 * reports. -baw
480 */
481 _Py_ReleaseInternedUnicodeStrings();
482#endif /* __INSURE__ */
483}
484
Victor Stinner92a3c6f2017-12-06 18:12:59 +0100485
486static void
487pymain_free_pymain(_PyMain *pymain)
488{
489 _Py_CommandLineDetails *cmdline = &pymain->cmdline;
490 pymain_optlist_clear(&cmdline->warning_options);
491 pymain_optlist_clear(&cmdline->xoptions);
492 PyMem_RawFree(cmdline->command);
493
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +0100494 PyMem_RawFree(pymain->sys_argv);
Victor Stinner92a3c6f2017-12-06 18:12:59 +0100495 pymain_optlist_clear(&pymain->env_warning_options);
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +0100496}
497
498
499/* Clear Python ojects */
500static void
501pymain_free_python(_PyMain *pymain)
502{
Victor Stinner92a3c6f2017-12-06 18:12:59 +0100503 Py_CLEAR(pymain->main_importer_path);
504
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +0100505 _PyMainInterpreterConfig_Clear(&pymain->config);
Victor Stinner92a3c6f2017-12-06 18:12:59 +0100506}
507
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +0100508
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800509static void
510pymain_free(_PyMain *pymain)
511{
Victor Stinner5d39e042017-11-29 17:20:38 +0100512 /* Force the allocator used by pymain_parse_cmdline_envvars() */
513 PyMemAllocatorEx old_alloc;
514 _PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800515
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +0100516 pymain_free_python(pymain);
Victor Stinner92a3c6f2017-12-06 18:12:59 +0100517 pymain_free_pymain(pymain);
518 pymain_free_globals(pymain);
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800519
520 PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
521}
522
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +0100523
Eric Snow6b4be192017-05-22 21:36:03 -0700524static int
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800525pymain_run_main_from_importer(_PyMain *pymain)
Guido van Rossum667d7041995-08-04 04:20:48 +0000526{
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800527 /* Assume sys_path0 has already been checked by pymain_get_importer(),
528 * so put it in sys.path[0] and import __main__ */
Victor Stinner11a247d2017-12-13 21:05:57 +0100529 PyObject *sys_path = PySys_GetObject("path");
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800530 if (sys_path == NULL) {
531 PyErr_SetString(PyExc_RuntimeError, "unable to get sys.path");
532 goto error;
533 }
534
Victor Stinner11a247d2017-12-13 21:05:57 +0100535 if (PyList_Insert(sys_path, 0, pymain->main_importer_path)) {
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800536 goto error;
537 }
538
Victor Stinner11a247d2017-12-13 21:05:57 +0100539 int sts = pymain_run_module(L"__main__", 0);
540 return (sts != 0);
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800541
542error:
543 Py_CLEAR(pymain->main_importer_path);
544 PyErr_Print();
545 return 1;
546}
547
548
549static wchar_t*
Serhiy Storchaka4ae06c52017-12-12 13:55:04 +0200550pymain_wstrdup(_PyMain *pymain, const wchar_t *str)
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800551{
Victor Stinner46972b72017-11-24 22:55:40 +0100552 wchar_t *str2 = _PyMem_RawWcsdup(str);
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800553 if (str2 == NULL) {
Victor Stinner0327bde2017-11-23 17:03:20 +0100554 pymain->err = _Py_INIT_NO_MEMORY();
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800555 return NULL;
556 }
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800557 return str2;
558}
559
560
561static int
Serhiy Storchaka4ae06c52017-12-12 13:55:04 +0200562pymain_optlist_append(_PyMain *pymain, _Py_OptList *list, const wchar_t *str)
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800563{
Victor Stinnerd4341102017-11-23 00:12:09 +0100564 wchar_t *str2 = pymain_wstrdup(pymain, str);
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800565 if (str2 == NULL) {
566 return -1;
567 }
568
569 size_t size = (list->len + 1) * sizeof(list[0]);
570 wchar_t **options2 = (wchar_t **)PyMem_RawRealloc(list->options, size);
571 if (options2 == NULL) {
572 PyMem_RawFree(str2);
Victor Stinner0327bde2017-11-23 17:03:20 +0100573 pymain->err = _Py_INIT_NO_MEMORY();
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800574 return -1;
575 }
576 options2[list->len] = str2;
577 list->options = options2;
578 list->len++;
579 return 0;
580}
581
582
583/* Parse the command line arguments
584 Return 0 on success.
585 Return 1 if parsing failed.
586 Set pymain->err and return -1 on other errors. */
587static int
Victor Stinnera7368ac2017-11-15 18:11:45 -0800588pymain_parse_cmdline_impl(_PyMain *pymain)
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800589{
590 _Py_CommandLineDetails *cmdline = &pymain->cmdline;
Eric Snow6b4be192017-05-22 21:36:03 -0700591
Antoine Pitrou86838b02012-02-21 19:03:47 +0100592 _PyOS_ResetGetOpt();
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800593 do {
Benjamin Peterson42aa93b2017-12-09 10:26:52 -0800594 int longindex = -1;
595 int c = _PyOS_GetOpt(pymain->argc, pymain->argv, PROGRAM_OPTS,
596 longoptions, &longindex);
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800597 if (c == EOF) {
598 break;
599 }
Guido van Rossum47f5fdc2000-12-15 22:00:54 +0000600
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000601 if (c == 'c') {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000602 /* -c is the last option; following arguments
603 that look like options are left for the
604 command to interpret. */
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800605 size_t len = wcslen(_PyOS_optarg) + 1 + 1;
606 wchar_t *command = PyMem_RawMalloc(sizeof(wchar_t) * len);
607 if (command == NULL) {
Victor Stinner0327bde2017-11-23 17:03:20 +0100608 pymain->err = _Py_INIT_NO_MEMORY();
Victor Stinnera7368ac2017-11-15 18:11:45 -0800609 return -1;
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800610 }
611 memcpy(command, _PyOS_optarg, len * sizeof(wchar_t));
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000612 command[len - 2] = '\n';
613 command[len - 1] = 0;
Eric Snow6b4be192017-05-22 21:36:03 -0700614 cmdline->command = command;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000615 break;
616 }
Guido van Rossum393661d2001-08-31 17:40:15 +0000617
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000618 if (c == 'm') {
619 /* -m is the last option; following arguments
620 that look like options are left for the
621 module to interpret. */
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800622 cmdline->module = _PyOS_optarg;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000623 break;
624 }
Raymond Hettingerdb29e0f2004-10-07 06:46:25 +0000625
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000626 switch (c) {
Benjamin Peterson42aa93b2017-12-09 10:26:52 -0800627 case 0:
628 // Handle long option.
629 assert(longindex == 0); // Only one long option now.
630 if (!wcscmp(_PyOS_optarg, L"always")) {
631 cmdline->check_hash_pycs_mode = "always";
632 } else if (!wcscmp(_PyOS_optarg, L"never")) {
633 cmdline->check_hash_pycs_mode = "never";
634 } else if (!wcscmp(_PyOS_optarg, L"default")) {
635 cmdline->check_hash_pycs_mode = "default";
636 } else {
637 fprintf(stderr, "--check-hash-based-pycs must be one of "
638 "'default', 'always', or 'never'\n");
639 return 1;
640 }
641 break;
642
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000643 case 'b':
Eric Snow6b4be192017-05-22 21:36:03 -0700644 cmdline->bytes_warning++;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000645 break;
Guido van Rossum667d7041995-08-04 04:20:48 +0000646
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000647 case 'd':
Eric Snow6b4be192017-05-22 21:36:03 -0700648 cmdline->debug++;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000649 break;
Guido van Rossum667d7041995-08-04 04:20:48 +0000650
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000651 case 'i':
Eric Snow6b4be192017-05-22 21:36:03 -0700652 cmdline->inspect++;
653 cmdline->interactive++;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000654 break;
Guido van Rossum667d7041995-08-04 04:20:48 +0000655
Christian Heimesad73a9c2013-08-10 16:36:18 +0200656 case 'I':
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800657 pymain->core_config.ignore_environment++;
Eric Snow6b4be192017-05-22 21:36:03 -0700658 cmdline->isolated++;
659 cmdline->no_user_site_directory++;
Christian Heimesad73a9c2013-08-10 16:36:18 +0200660 break;
661
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000662 /* case 'J': reserved for Jython */
Christian Heimes33fe8092008-04-13 13:53:33 +0000663
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000664 case 'O':
Eric Snow6b4be192017-05-22 21:36:03 -0700665 cmdline->optimization_level++;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000666 break;
Guido van Rossum7614da61997-03-03 19:14:45 +0000667
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000668 case 'B':
Eric Snow6b4be192017-05-22 21:36:03 -0700669 cmdline->dont_write_bytecode++;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000670 break;
Christian Heimes790c8232008-01-07 21:14:23 +0000671
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000672 case 's':
Eric Snow6b4be192017-05-22 21:36:03 -0700673 cmdline->no_user_site_directory++;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000674 break;
Christian Heimes8dc226f2008-05-06 23:45:46 +0000675
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000676 case 'S':
Eric Snow6b4be192017-05-22 21:36:03 -0700677 cmdline->no_site_import++;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000678 break;
Guido van Rossum7922bd71997-08-29 22:34:47 +0000679
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000680 case 'E':
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800681 pymain->core_config.ignore_environment++;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000682 break;
Neil Schemenauer7d4bb9f2001-07-23 16:30:27 +0000683
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000684 case 't':
685 /* ignored for backwards compatibility */
686 break;
Guido van Rossumbba92ca1998-04-10 19:39:15 +0000687
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000688 case 'u':
Eric Snow6b4be192017-05-22 21:36:03 -0700689 cmdline->use_unbuffered_io = 1;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000690 break;
Guido van Rossum667d7041995-08-04 04:20:48 +0000691
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000692 case 'v':
Eric Snow6b4be192017-05-22 21:36:03 -0700693 cmdline->verbosity++;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000694 break;
Guido van Rossum667d7041995-08-04 04:20:48 +0000695
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000696 case 'x':
Eric Snow6b4be192017-05-22 21:36:03 -0700697 cmdline->skip_first_line = 1;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000698 break;
Guido van Rossuma075ce11997-12-05 21:56:45 +0000699
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000700 case 'h':
701 case '?':
Eric Snow6b4be192017-05-22 21:36:03 -0700702 cmdline->print_help++;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000703 break;
Guido van Rossum45aecf42006-03-15 04:58:47 +0000704
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000705 case 'V':
Eric Snow6b4be192017-05-22 21:36:03 -0700706 cmdline->print_version++;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000707 break;
Guido van Rossumc15a9a12000-05-01 17:54:33 +0000708
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000709 case 'W':
Victor Stinnera7368ac2017-11-15 18:11:45 -0800710 if (pymain_optlist_append(pymain, &cmdline->warning_options,
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800711 _PyOS_optarg) < 0) {
Victor Stinnera7368ac2017-11-15 18:11:45 -0800712 return -1;
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800713 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000714 break;
Guido van Rossum47f5fdc2000-12-15 22:00:54 +0000715
Antoine Pitrou9583cac2010-10-21 13:42:28 +0000716 case 'X':
Victor Stinnera7368ac2017-11-15 18:11:45 -0800717 if (pymain_optlist_append(pymain, &cmdline->xoptions,
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800718 _PyOS_optarg) < 0) {
Victor Stinnera7368ac2017-11-15 18:11:45 -0800719 return -1;
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800720 }
Antoine Pitrou9583cac2010-10-21 13:42:28 +0000721 break;
722
Georg Brandl9d871192010-12-04 10:47:18 +0000723 case 'q':
Eric Snow6b4be192017-05-22 21:36:03 -0700724 cmdline->quiet_flag++;
Georg Brandl9d871192010-12-04 10:47:18 +0000725 break;
726
Georg Brandl2daf6ae2012-02-20 19:54:16 +0100727 case 'R':
Victor Stinner358e5e12017-12-15 00:51:22 +0100728 pymain->core_config.use_hash_seed = 0;
Georg Brandl2daf6ae2012-02-20 19:54:16 +0100729 break;
730
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000731 /* This space reserved for other options */
Guido van Rossum667d7041995-08-04 04:20:48 +0000732
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000733 default:
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800734 /* unknown argument: parsing failed */
735 return 1;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000736 }
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800737 } while (1);
738
739 if (cmdline->command == NULL && cmdline->module == NULL
740 && _PyOS_optind < pymain->argc
741 && wcscmp(pymain->argv[_PyOS_optind], L"-") != 0)
742 {
743 cmdline->filename = pymain->argv[_PyOS_optind];
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000744 }
Guido van Rossum667d7041995-08-04 04:20:48 +0000745
Victor Stinnerd5dda982017-12-13 17:31:16 +0100746 /* -c and -m options are exclusive */
747 assert(!(cmdline->command != NULL && cmdline->module != NULL));
748
Eric Snow6b4be192017-05-22 21:36:03 -0700749 return 0;
750}
Barry Warsaw3b2aedb2000-09-15 18:40:42 +0000751
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800752
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800753static int
Victor Stinner374c6e12017-12-14 12:05:26 +0100754pymain_add_xoption(PyObject *opts, const wchar_t *s)
755{
756 PyObject *name, *value;
757
758 const wchar_t *name_end = wcschr(s, L'=');
759 if (!name_end) {
760 name = PyUnicode_FromWideChar(s, -1);
761 value = Py_True;
762 Py_INCREF(value);
763 }
764 else {
765 name = PyUnicode_FromWideChar(s, name_end - s);
766 value = PyUnicode_FromWideChar(name_end + 1, -1);
767 }
768 if (name == NULL || value == NULL) {
769 goto error;
770 }
771 if (PyDict_SetItem(opts, name, value) < 0) {
772 goto error;
773 }
774 Py_DECREF(name);
775 Py_DECREF(value);
776 return 0;
777
778error:
779 Py_XDECREF(name);
780 Py_XDECREF(value);
781 return -1;
782}
783
784static int
785pymain_init_xoptions_dict(_PyMain *pymain)
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800786{
787 _Py_OptList *options = &pymain->cmdline.xoptions;
Victor Stinner374c6e12017-12-14 12:05:26 +0100788 PyObject *dict = PyDict_New();
789 if (dict == NULL) {
790 return -1;
791 }
792
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800793 for (size_t i=0; i < options->len; i++) {
794 wchar_t *option = options->options[i];
Victor Stinner374c6e12017-12-14 12:05:26 +0100795 if (pymain_add_xoption(dict, option) < 0) {
796 Py_DECREF(dict);
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800797 return -1;
798 }
799 }
Victor Stinner374c6e12017-12-14 12:05:26 +0100800
801 pymain->config.xoptions = dict;
Eric Snow6b4be192017-05-22 21:36:03 -0700802 return 0;
803}
804
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800805
806static int
Victor Stinner374c6e12017-12-14 12:05:26 +0100807pymain_add_warnings_optlist(PyObject *warnoptions, _Py_OptList *warnings)
Eric Snow6b4be192017-05-22 21:36:03 -0700808{
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800809 for (size_t i = 0; i < warnings->len; i++) {
810 PyObject *option = PyUnicode_FromWideChar(warnings->options[i], -1);
811 if (option == NULL) {
812 return -1;
Eric Snow6b4be192017-05-22 21:36:03 -0700813 }
Victor Stinner374c6e12017-12-14 12:05:26 +0100814 if (PyList_Append(warnoptions, option)) {
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800815 Py_DECREF(option);
816 return -1;
Eric Snow6b4be192017-05-22 21:36:03 -0700817 }
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800818 Py_DECREF(option);
Eric Snow6b4be192017-05-22 21:36:03 -0700819 }
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800820 return 0;
821}
Eric Snow6b4be192017-05-22 21:36:03 -0700822
Victor Stinner747f48e2017-12-12 22:59:48 +0100823
824static int
Victor Stinner374c6e12017-12-14 12:05:26 +0100825pymain_add_warning_dev_mode(PyObject *warnoptions, _PyCoreConfig *core_config)
Victor Stinner747f48e2017-12-12 22:59:48 +0100826{
827 if (core_config->dev_mode) {
828 PyObject *option = PyUnicode_FromString("default");
829 if (option == NULL) {
830 return -1;
831 }
Victor Stinner374c6e12017-12-14 12:05:26 +0100832 if (PyList_Append(warnoptions, option)) {
Victor Stinner747f48e2017-12-12 22:59:48 +0100833 Py_DECREF(option);
834 return -1;
835 }
836 Py_DECREF(option);
837 }
838 return 0;
839}
840
841
842static int
Victor Stinner374c6e12017-12-14 12:05:26 +0100843pymain_add_warning_bytes_flag(PyObject *warnoptions, int bytes_warning_flag)
Victor Stinner747f48e2017-12-12 22:59:48 +0100844{
845 /* If the bytes_warning_flag isn't set, bytesobject.c and bytearrayobject.c
846 * don't even try to emit a warning, so we skip setting the filter in that
847 * case.
848 */
Victor Stinner374c6e12017-12-14 12:05:26 +0100849 if (!bytes_warning_flag) {
850 return 0;
Victor Stinner747f48e2017-12-12 22:59:48 +0100851 }
Victor Stinner374c6e12017-12-14 12:05:26 +0100852
853 const char *filter = (bytes_warning_flag > 1) ? "error::BytesWarning":
854 "default::BytesWarning";
855 PyObject *option = PyUnicode_FromString(filter);
856 if (option == NULL) {
857 return -1;
858 }
859 if (PyList_Append(warnoptions, option)) {
860 Py_DECREF(option);
861 return -1;
862 }
863 Py_DECREF(option);
Victor Stinner747f48e2017-12-12 22:59:48 +0100864 return 0;
865}
866
867
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800868static int
Victor Stinner374c6e12017-12-14 12:05:26 +0100869pymain_init_warnoptions(_PyMain *pymain)
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800870{
Victor Stinner374c6e12017-12-14 12:05:26 +0100871 PyObject *warnoptions = PyList_New(0);
872 if (warnoptions == NULL) {
873 return -1;
874 }
Eric Snow1abcf672017-05-23 21:46:51 -0700875
Victor Stinner747f48e2017-12-12 22:59:48 +0100876 /* The priority order for warnings configuration is (highest precedence
877 * first):
878 *
879 * - the BytesWarning filter, if needed ('-b', '-bb')
880 * - any '-W' command line options; then
881 * - the 'PYTHONWARNINGS' environment variable; then
882 * - the dev mode filter ('-X dev', 'PYTHONDEVMODE'); then
883 * - any implicit filters added by _warnings.c/warnings.py
884 *
885 * All settings except the last are passed to the warnings module via
886 * the `sys.warnoptions` list. Since the warnings module works on the basis
887 * of "the most recently added filter will be checked first", we add
888 * the lowest precedence entries first so that later entries override them.
889 */
890
Victor Stinner374c6e12017-12-14 12:05:26 +0100891 if (pymain_add_warning_dev_mode(warnoptions, &pymain->core_config) < 0) {
892 goto error;
Victor Stinner747f48e2017-12-12 22:59:48 +0100893 }
Victor Stinner374c6e12017-12-14 12:05:26 +0100894 if (pymain_add_warnings_optlist(warnoptions, &pymain->env_warning_options) < 0) {
895 goto error;
Eric Snow6b4be192017-05-22 21:36:03 -0700896 }
Victor Stinner374c6e12017-12-14 12:05:26 +0100897 if (pymain_add_warnings_optlist(warnoptions, &pymain->cmdline.warning_options) < 0) {
898 goto error;
Eric Snow6b4be192017-05-22 21:36:03 -0700899 }
Victor Stinner374c6e12017-12-14 12:05:26 +0100900 if (pymain_add_warning_bytes_flag(warnoptions, pymain->cmdline.bytes_warning) < 0) {
901 goto error;
Victor Stinner747f48e2017-12-12 22:59:48 +0100902 }
Victor Stinner374c6e12017-12-14 12:05:26 +0100903
904 pymain->config.warnoptions = warnoptions;
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800905 return 0;
Victor Stinner374c6e12017-12-14 12:05:26 +0100906
907error:
908 Py_DECREF(warnoptions);
909 return -1;
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800910}
Eric Snow6b4be192017-05-22 21:36:03 -0700911
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800912
913/* Get warning options from PYTHONWARNINGS environment variable.
914 Return 0 on success.
915 Set pymain->err and return -1 on error. */
916static int
917pymain_warnings_envvar(_PyMain *pymain)
918{
919 if (Py_IgnoreEnvironmentFlag) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000920 return 0;
921 }
Barry Warsaw3b2aedb2000-09-15 18:40:42 +0000922
Philip Jenveye53de3d2010-04-14 03:01:39 +0000923#ifdef MS_WINDOWS
Serhiy Storchaka4ae06c52017-12-12 13:55:04 +0200924 const wchar_t *wp;
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800925
926 if ((wp = _wgetenv(L"PYTHONWARNINGS")) && *wp != L'\0') {
Victor Stinnerd4341102017-11-23 00:12:09 +0100927 wchar_t *warning, *context = NULL;
Philip Jenvey0805ca32010-04-07 04:04:10 +0000928
Victor Stinnerd4341102017-11-23 00:12:09 +0100929 wchar_t *buf = pymain_wstrdup(pymain, wp);
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800930 if (buf == NULL) {
Victor Stinnera7368ac2017-11-15 18:11:45 -0800931 return -1;
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800932 }
Steve Dowerf63dab52015-02-25 20:48:01 -0800933 for (warning = wcstok_s(buf, L",", &context);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000934 warning != NULL;
Steve Dowerf63dab52015-02-25 20:48:01 -0800935 warning = wcstok_s(NULL, L",", &context)) {
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800936
Victor Stinnera7368ac2017-11-15 18:11:45 -0800937 if (pymain_optlist_append(pymain, &pymain->env_warning_options,
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800938 warning) < 0) {
939 PyMem_RawFree(buf);
Victor Stinnera7368ac2017-11-15 18:11:45 -0800940 return -1;
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800941 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000942 }
Victor Stinner1a7425f2013-07-07 16:25:15 +0200943 PyMem_RawFree(buf);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000944 }
Philip Jenveye53de3d2010-04-14 03:01:39 +0000945#else
Serhiy Storchaka4ae06c52017-12-12 13:55:04 +0200946 const char *p = pymain_get_env_var("PYTHONWARNINGS");
Victor Stinner6bf992a2017-12-06 17:26:10 +0100947 if (p != NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000948 char *buf, *oldloc;
Philip Jenveye53de3d2010-04-14 03:01:39 +0000949
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000950 /* settle for strtok here as there's no one standard
951 C89 wcstok */
Victor Stinner1a7425f2013-07-07 16:25:15 +0200952 buf = (char *)PyMem_RawMalloc(strlen(p) + 1);
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800953 if (buf == NULL) {
Victor Stinner0327bde2017-11-23 17:03:20 +0100954 pymain->err = _Py_INIT_NO_MEMORY();
Victor Stinnera7368ac2017-11-15 18:11:45 -0800955 return -1;
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800956 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000957 strcpy(buf, p);
Victor Stinner49fc8ec2013-07-07 23:30:24 +0200958 oldloc = _PyMem_RawStrdup(setlocale(LC_ALL, NULL));
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000959 setlocale(LC_ALL, "");
960 for (p = strtok(buf, ","); p != NULL; p = strtok(NULL, ",")) {
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800961 size_t len;
962 wchar_t *warning = Py_DecodeLocale(p, &len);
963 if (warning == NULL) {
Victor Stinner0327bde2017-11-23 17:03:20 +0100964 SET_DECODE_ERROR("PYTHONWARNINGS environment variable", len);
Victor Stinnerd4341102017-11-23 00:12:09 +0100965 return -1;
Victor Stinneraf02e1c2011-12-16 23:56:01 +0100966 }
Victor Stinnera7368ac2017-11-15 18:11:45 -0800967 if (pymain_optlist_append(pymain, &pymain->env_warning_options,
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800968 warning) < 0) {
969 PyMem_RawFree(warning);
Victor Stinnera7368ac2017-11-15 18:11:45 -0800970 return -1;
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800971 }
972 PyMem_RawFree(warning);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000973 }
974 setlocale(LC_ALL, oldloc);
Victor Stinner49fc8ec2013-07-07 23:30:24 +0200975 PyMem_RawFree(oldloc);
Victor Stinner1a7425f2013-07-07 16:25:15 +0200976 PyMem_RawFree(buf);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000977 }
Philip Jenveye53de3d2010-04-14 03:01:39 +0000978#endif
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800979 return 0;
Victor Stinnerf7e5b562017-11-15 15:48:08 -0800980}
981
982
983static void
984pymain_init_stdio(_PyMain *pymain)
985{
986 pymain->stdin_is_interactive = (isatty(fileno(stdin))
987 || Py_InteractiveFlag);
Guido van Rossum775af911997-02-14 19:50:32 +0000988
Sjoerd Mullender9cf424b2002-08-09 13:35:18 +0000989#if defined(MS_WINDOWS) || defined(__CYGWIN__)
Victor Stinner89e34362011-01-07 18:47:22 +0000990 /* don't translate newlines (\r\n <=> \n) */
991 _setmode(fileno(stdin), O_BINARY);
992 _setmode(fileno(stdout), O_BINARY);
993 _setmode(fileno(stderr), O_BINARY);
Guido van Rossumf22d7e21997-01-11 19:28:55 +0000994#endif
Victor Stinner89e34362011-01-07 18:47:22 +0000995
996 if (Py_UnbufferedStdioFlag) {
Guido van Rossum22ffac11998-03-06 15:30:39 +0000997#ifdef HAVE_SETVBUF
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000998 setvbuf(stdin, (char *)NULL, _IONBF, BUFSIZ);
999 setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ);
1000 setvbuf(stderr, (char *)NULL, _IONBF, BUFSIZ);
Guido van Rossum22ffac11998-03-06 15:30:39 +00001001#else /* !HAVE_SETVBUF */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001002 setbuf(stdin, (char *)NULL);
1003 setbuf(stdout, (char *)NULL);
1004 setbuf(stderr, (char *)NULL);
Guido van Rossum22ffac11998-03-06 15:30:39 +00001005#endif /* !HAVE_SETVBUF */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001006 }
1007 else if (Py_InteractiveFlag) {
Guido van Rossumb31c7dc1997-04-11 22:19:12 +00001008#ifdef MS_WINDOWS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001009 /* Doesn't have to have line-buffered -- use unbuffered */
1010 /* Any set[v]buf(stdin, ...) screws up Tkinter :-( */
1011 setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ);
Guido van Rossum22ffac11998-03-06 15:30:39 +00001012#else /* !MS_WINDOWS */
1013#ifdef HAVE_SETVBUF
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001014 setvbuf(stdin, (char *)NULL, _IOLBF, BUFSIZ);
1015 setvbuf(stdout, (char *)NULL, _IOLBF, BUFSIZ);
Guido van Rossum22ffac11998-03-06 15:30:39 +00001016#endif /* HAVE_SETVBUF */
1017#endif /* !MS_WINDOWS */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001018 /* Leave stderr alone - it should be unbuffered anyway. */
1019 }
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001020}
Guido van Rossum667d7041995-08-04 04:20:48 +00001021
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001022
1023/* Get the program name: use PYTHONEXECUTABLE and __PYVENV_LAUNCHER__
Victor Stinner31a83932017-12-04 13:39:15 +01001024 environment variables on macOS if available. */
1025static _PyInitError
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001026config_get_program_name(_PyCoreConfig *config)
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001027{
Victor Stinner31a83932017-12-04 13:39:15 +01001028 assert(config->program_name == NULL);
1029
1030 /* If Py_SetProgramName() was called, use its value */
Serhiy Storchaka4ae06c52017-12-12 13:55:04 +02001031 const wchar_t *program_name = _Py_path_config.program_name;
Victor Stinner31a83932017-12-04 13:39:15 +01001032 if (program_name != NULL) {
1033 config->program_name = _PyMem_RawWcsdup(program_name);
1034 if (config->program_name == NULL) {
1035 return _Py_INIT_NO_MEMORY();
1036 }
1037 }
1038
Just van Rossum2ac79ef2003-03-05 15:46:54 +00001039#ifdef __APPLE__
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001040 /* On MacOS X, when the Python interpreter is embedded in an
1041 application bundle, it gets executed by a bootstrapping script
1042 that does os.execve() with an argv[0] that's different from the
1043 actual Python executable. This is needed to keep the Finder happy,
1044 or rather, to work around Apple's overly strict requirements of
1045 the process name. However, we still need a usable sys.executable,
1046 so the actual executable path is passed in an environment variable.
1047 See Lib/plat-mac/bundlebuiler.py for details about the bootstrap
1048 script. */
Serhiy Storchaka4ae06c52017-12-12 13:55:04 +02001049 const char *p = pymain_get_env_var("PYTHONEXECUTABLE");
Victor Stinner6bf992a2017-12-06 17:26:10 +01001050 if (p != NULL) {
Victor Stinner31a83932017-12-04 13:39:15 +01001051 size_t len;
1052 wchar_t* program_name = Py_DecodeLocale(p, &len);
1053 if (program_name == NULL) {
1054 return DECODE_LOCALE_ERR("PYTHONEXECUTABLE environment "
1055 "variable", (Py_ssize_t)len);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001056 }
Victor Stinner31a83932017-12-04 13:39:15 +01001057 config->program_name = program_name;
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001058 }
Vinay Sajip90db6612012-07-17 17:33:46 +01001059#ifdef WITH_NEXT_FRAMEWORK
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001060 else {
Serhiy Storchaka4ae06c52017-12-12 13:55:04 +02001061 const char* pyvenv_launcher = getenv("__PYVENV_LAUNCHER__");
Vinay Sajip90db6612012-07-17 17:33:46 +01001062 if (pyvenv_launcher && *pyvenv_launcher) {
1063 /* Used by Mac/Tools/pythonw.c to forward
1064 * the argv0 of the stub executable
1065 */
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001066 size_t len;
Victor Stinner31a83932017-12-04 13:39:15 +01001067 wchar_t* program_name = Py_DecodeLocale(pyvenv_launcher, &len);
1068 if (program_name == NULL) {
1069 return DECODE_LOCALE_ERR("__PYVENV_LAUNCHER__ environment "
1070 "variable", (Py_ssize_t)len);
Vinay Sajip90db6612012-07-17 17:33:46 +01001071 }
Victor Stinner31a83932017-12-04 13:39:15 +01001072 config->program_name = program_name;
Vinay Sajip90db6612012-07-17 17:33:46 +01001073 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001074 }
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001075#endif /* WITH_NEXT_FRAMEWORK */
1076#endif /* __APPLE__ */
Victor Stinneraf5a8952017-12-02 10:11:32 +01001077
Victor Stinner31a83932017-12-04 13:39:15 +01001078 return _Py_INIT_OK();
1079}
1080
1081
1082/* If config_get_program_name() found no program name: use argv[0] by default.
1083 Return 0 on success. Set pymain->err and return -1 on error. */
1084static int
1085pymain_get_program_name(_PyMain *pymain)
1086{
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001087 if (pymain->core_config.program_name == NULL) {
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001088 /* Use argv[0] by default */
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001089 pymain->core_config.program_name = pymain_wstrdup(pymain, pymain->argv[0]);
1090 if (pymain->core_config.program_name == NULL) {
Victor Stinnera7368ac2017-11-15 18:11:45 -08001091 return -1;
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001092 }
1093 }
1094 return 0;
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001095}
1096
1097
1098/* Initialize the main interpreter.
1099 *
1100 * Replaces previous call to Py_Initialize()
1101 *
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001102 * Return 0 on success.
1103 * Set pymain->err and return -1 on error.
1104 */
1105static int
1106pymain_init_main_interpreter(_PyMain *pymain)
1107{
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001108 _PyInitError err;
1109
Victor Stinnere32e79f2017-11-23 01:49:45 +01001110 err = _Py_InitializeMainInterpreter(&pymain->config);
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001111 if (_Py_INIT_FAILED(err)) {
1112 pymain->err = err;
1113 return -1;
1114 }
1115 return 0;
1116}
1117
1118
1119static void
1120pymain_header(_PyMain *pymain)
1121{
Eric Snow1abcf672017-05-23 21:46:51 -07001122 /* TODO: Move this to _PyRun_PrepareMain */
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001123 if (Py_QuietFlag) {
1124 return;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001125 }
Guido van Rossum393661d2001-08-31 17:40:15 +00001126
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001127 if (!Py_VerboseFlag && (pymain->run_code || !pymain->stdin_is_interactive)) {
1128 return;
1129 }
1130
1131 fprintf(stderr, "Python %s on %s\n", Py_GetVersion(), Py_GetPlatform());
1132 if (!Py_NoSiteFlag) {
1133 fprintf(stderr, "%s\n", COPYRIGHT);
1134 }
1135}
1136
1137
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001138static int
Victor Stinner374c6e12017-12-14 12:05:26 +01001139pymain_init_argv(_PyMain *pymain)
Victor Stinner11a247d2017-12-13 21:05:57 +01001140{
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001141 int argc = pymain->sys_argc;
1142 wchar_t** argv = pymain->sys_argv;
1143
1144 if (argc <= 0 || pymain->sys_argv == NULL) {
Victor Stinner11a247d2017-12-13 21:05:57 +01001145 /* Ensure at least one (empty) argument is seen */
1146 static wchar_t *empty_argv[1] = {L""};
1147 argv = empty_argv;
1148 argc = 1;
1149 }
1150
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001151 PyObject *list = PyList_New(argc);
1152 if (list == NULL) {
1153 return -1;
Victor Stinner11a247d2017-12-13 21:05:57 +01001154 }
1155
1156 for (int i = 0; i < argc; i++) {
1157 PyObject *v = PyUnicode_FromWideChar(argv[i], -1);
1158 if (v == NULL) {
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001159 Py_DECREF(list);
1160 return -1;
Victor Stinner11a247d2017-12-13 21:05:57 +01001161 }
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001162 PyList_SET_ITEM(list, i, v);
Victor Stinner11a247d2017-12-13 21:05:57 +01001163 }
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001164
1165 pymain->config.argv = list;
1166 return 0;
Victor Stinner11a247d2017-12-13 21:05:57 +01001167}
1168
1169
Victor Stinnerd5dda982017-12-13 17:31:16 +01001170static int
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001171pymain_init_sys_argv(_PyMain *pymain)
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001172{
1173 _Py_CommandLineDetails *cmdline = &pymain->cmdline;
1174
Victor Stinnerd5dda982017-12-13 17:31:16 +01001175 if (cmdline->command != NULL || cmdline->module != NULL) {
1176 /* Backup _PyOS_optind */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001177 _PyOS_optind--;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001178 }
Guido van Rossum667d7041995-08-04 04:20:48 +00001179
Victor Stinnerd5dda982017-12-13 17:31:16 +01001180 /* Copy argv to be able to modify it (to force -c/-m) */
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001181 pymain->sys_argc = pymain->argc - _PyOS_optind;
1182 size_t size = pymain->sys_argc * sizeof(pymain->argv[0]);
1183 pymain->sys_argv = PyMem_RawMalloc(size);
1184 if (pymain->sys_argv == NULL) {
Victor Stinnerd5dda982017-12-13 17:31:16 +01001185 pymain->err = _Py_INIT_NO_MEMORY();
1186 return -1;
1187 }
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001188 memcpy(pymain->sys_argv, &pymain->argv[_PyOS_optind], size);
Victor Stinnerd5dda982017-12-13 17:31:16 +01001189
Victor Stinnerd5dda982017-12-13 17:31:16 +01001190 if (cmdline->command != NULL) {
1191 /* Force sys.argv[0] = '-c' */
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001192 pymain->sys_argv[0] = L"-c";
Victor Stinnerd5dda982017-12-13 17:31:16 +01001193 }
1194 else if (cmdline->module != NULL) {
1195 /* Force sys.argv[0] = '-m'*/
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001196 pymain->sys_argv[0] = L"-m";
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001197 }
Victor Stinner11a247d2017-12-13 21:05:57 +01001198 return 0;
Victor Stinner11a247d2017-12-13 21:05:57 +01001199}
1200
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001201
Victor Stinner11a247d2017-12-13 21:05:57 +01001202static int
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001203pymain_update_sys_path(_PyMain *pymain)
Victor Stinner11a247d2017-12-13 21:05:57 +01001204{
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001205 if (pymain->main_importer_path != NULL) {
1206 /* Let pymain_run_main_from_importer() adjust sys.path[0] later */
1207 return 0;
1208 }
1209
1210 if (Py_IsolatedFlag) {
1211 return 0;
1212 }
1213
1214 /* Prepend argv[0] to sys.path.
1215 If argv[0] is a symlink, use the real path. */
1216 PyObject *sys_path = PySys_GetObject("path");
1217 if (sys_path == NULL) {
1218 pymain->err = _Py_INIT_ERR("can't get sys.path");
Victor Stinnerd5dda982017-12-13 17:31:16 +01001219 return -1;
1220 }
1221
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001222 PyObject *path0 = _PyPathConfig_ComputeArgv0(pymain->sys_argc, pymain->sys_argv);
1223 if (path0 == NULL) {
1224 pymain->err = _Py_INIT_NO_MEMORY();
1225 return -1;
Victor Stinner11a247d2017-12-13 21:05:57 +01001226 }
1227
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001228 /* Prepend path0 to sys.path */
1229 if (PyList_Insert(sys_path, 0, path0) < 0) {
1230 Py_DECREF(path0);
1231 pymain->err = _Py_INIT_ERR("sys.path.insert(0, path0) failed");
1232 return -1;
1233 }
1234 Py_DECREF(path0);
1235
Victor Stinnerd5dda982017-12-13 17:31:16 +01001236 return 0;
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001237}
1238
1239
Victor Stinner6bf992a2017-12-06 17:26:10 +01001240/* Get Py_xxx global configuration variables */
1241static void
1242pymain_get_global_config(_PyMain *pymain)
1243{
1244 _Py_CommandLineDetails *cmdline = &pymain->cmdline;
Victor Stinner6bf992a2017-12-06 17:26:10 +01001245
Victor Stinner91106cd2017-12-13 12:29:09 +01001246 cmdline->bytes_warning = Py_BytesWarningFlag;
1247 cmdline->debug = Py_DebugFlag;
1248 cmdline->inspect = Py_InspectFlag;
1249 cmdline->interactive = Py_InteractiveFlag;
1250 cmdline->isolated = Py_IsolatedFlag;
1251 cmdline->optimization_level = Py_OptimizeFlag;
1252 cmdline->dont_write_bytecode = Py_DontWriteBytecodeFlag;
1253 cmdline->no_user_site_directory = Py_NoUserSiteDirectory;
1254 cmdline->no_site_import = Py_NoSiteFlag;
1255 cmdline->use_unbuffered_io = Py_UnbufferedStdioFlag;
1256 cmdline->verbosity = Py_VerboseFlag;
1257 cmdline->quiet_flag = Py_QuietFlag;
1258#ifdef MS_WINDOWS
1259 cmdline->legacy_windows_fs_encoding = Py_LegacyWindowsFSEncodingFlag;
1260 cmdline->legacy_windows_stdio = Py_LegacyWindowsStdioFlag;
1261#endif
1262 cmdline->check_hash_pycs_mode = _Py_CheckHashBasedPycsMode ;
1263
1264 pymain->core_config.ignore_environment = Py_IgnoreEnvironmentFlag;
1265 pymain->core_config.utf8_mode = Py_UTF8Mode;
Victor Stinner6bf992a2017-12-06 17:26:10 +01001266}
1267
1268
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001269/* Set Py_XXX global configuration variables */
1270static void
1271pymain_set_global_config(_PyMain *pymain)
1272{
1273 _Py_CommandLineDetails *cmdline = &pymain->cmdline;
Victor Stinner91106cd2017-12-13 12:29:09 +01001274
1275 Py_BytesWarningFlag = cmdline->bytes_warning;
1276 Py_DebugFlag = cmdline->debug;
1277 Py_InspectFlag = cmdline->inspect;
1278 Py_InteractiveFlag = cmdline->interactive;
1279 Py_IsolatedFlag = cmdline->isolated;
1280 Py_OptimizeFlag = cmdline->optimization_level;
1281 Py_DontWriteBytecodeFlag = cmdline->dont_write_bytecode;
1282 Py_NoUserSiteDirectory = cmdline->no_user_site_directory;
1283 Py_NoSiteFlag = cmdline->no_site_import;
1284 Py_UnbufferedStdioFlag = cmdline->use_unbuffered_io;
1285 Py_VerboseFlag = cmdline->verbosity;
1286 Py_QuietFlag = cmdline->quiet_flag;
1287 _Py_CheckHashBasedPycsMode = cmdline->check_hash_pycs_mode;
Victor Stinner6bf992a2017-12-06 17:26:10 +01001288#ifdef MS_WINDOWS
Victor Stinner91106cd2017-12-13 12:29:09 +01001289 Py_LegacyWindowsFSEncodingFlag = cmdline->legacy_windows_fs_encoding;
1290 Py_LegacyWindowsStdioFlag = cmdline->legacy_windows_stdio;
Victor Stinner6bf992a2017-12-06 17:26:10 +01001291#endif
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001292
Victor Stinner91106cd2017-12-13 12:29:09 +01001293 Py_IgnoreEnvironmentFlag = pymain->core_config.ignore_environment;
1294 Py_UTF8Mode = pymain->core_config.utf8_mode;
Victor Stinner358e5e12017-12-15 00:51:22 +01001295
1296 /* Random or non-zero hash seed */
1297 Py_HashRandomizationFlag = (pymain->core_config.use_hash_seed == 0 ||
1298 pymain->core_config.hash_seed != 0);
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001299}
1300
1301
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001302static void
1303pymain_import_readline(_PyMain *pymain)
1304{
1305 if (Py_IsolatedFlag) {
1306 return;
1307 }
1308 if (!Py_InspectFlag && pymain->run_code) {
1309 return;
1310 }
1311 if (!isatty(fileno(stdin))) {
1312 return;
Nick Coghland2977a32017-03-12 20:38:32 +10001313 }
Guido van Rossum667d7041995-08-04 04:20:48 +00001314
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001315 PyObject *mod = PyImport_ImportModule("readline");
1316 if (mod == NULL) {
1317 PyErr_Clear();
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001318 }
1319 else {
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001320 Py_DECREF(mod);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001321 }
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001322}
1323
1324
1325static FILE*
1326pymain_open_filename(_PyMain *pymain)
1327{
1328 _Py_CommandLineDetails *cmdline = &pymain->cmdline;
1329 FILE* fp;
1330
1331 fp = _Py_wfopen(cmdline->filename, L"r");
1332 if (fp == NULL) {
1333 char *cfilename_buffer;
1334 const char *cfilename;
1335 int err = errno;
1336 cfilename_buffer = Py_EncodeLocale(cmdline->filename, NULL);
1337 if (cfilename_buffer != NULL)
1338 cfilename = cfilename_buffer;
1339 else
1340 cfilename = "<unprintable file name>";
1341 fprintf(stderr, "%ls: can't open file '%s': [Errno %d] %s\n",
1342 pymain->argv[0], cfilename, err, strerror(err));
1343 PyMem_Free(cfilename_buffer);
1344 pymain->status = 2;
1345 return NULL;
1346 }
1347
1348 if (cmdline->skip_first_line) {
1349 int ch;
1350 /* Push back first newline so line numbers
1351 remain the same */
1352 while ((ch = getc(fp)) != EOF) {
1353 if (ch == '\n') {
1354 (void)ungetc(ch, fp);
1355 break;
1356 }
1357 }
1358 }
1359
1360 struct _Py_stat_struct sb;
1361 if (_Py_fstat_noraise(fileno(fp), &sb) == 0 &&
1362 S_ISDIR(sb.st_mode)) {
1363 fprintf(stderr,
1364 "%ls: '%ls' is a directory, cannot continue\n",
1365 pymain->argv[0], cmdline->filename);
1366 fclose(fp);
1367 pymain->status = 1;
1368 return NULL;
1369 }
1370
1371 return fp;
1372}
1373
1374
1375static void
Victor Stinnera7368ac2017-11-15 18:11:45 -08001376pymain_run_filename(_PyMain *pymain)
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001377{
1378 _Py_CommandLineDetails *cmdline = &pymain->cmdline;
1379
1380 if (cmdline->filename == NULL && pymain->stdin_is_interactive) {
1381 Py_InspectFlag = 0; /* do exit on SystemExit */
Victor Stinner33c377e2017-12-05 15:12:41 +01001382 pymain_run_startup(&pymain->cf);
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001383 pymain_run_interactive_hook();
1384 }
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001385
1386 if (pymain->main_importer_path != NULL) {
1387 pymain->status = pymain_run_main_from_importer(pymain);
1388 return;
1389 }
1390
1391 FILE *fp;
1392 if (cmdline->filename != NULL) {
1393 fp = pymain_open_filename(pymain);
1394 if (fp == NULL) {
1395 return;
1396 }
1397 }
1398 else {
1399 fp = stdin;
1400 }
1401
1402 pymain->status = pymain_run_file(fp, cmdline->filename, &pymain->cf);
1403}
1404
1405
1406static void
1407pymain_repl(_PyMain *pymain)
1408{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001409 /* Check this environment variable at the end, to give programs the
Victor Stinnera7368ac2017-11-15 18:11:45 -08001410 opportunity to set it from Python. */
1411 if (!Py_InspectFlag && pymain_get_env_var("PYTHONINSPECT")) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001412 Py_InspectFlag = 1;
1413 }
Guido van Rossum667d7041995-08-04 04:20:48 +00001414
Victor Stinnera7368ac2017-11-15 18:11:45 -08001415 if (!(Py_InspectFlag && pymain->stdin_is_interactive
1416 && pymain->run_code)) {
1417 return;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001418 }
Victor Stinnera7368ac2017-11-15 18:11:45 -08001419
1420 Py_InspectFlag = 0;
1421 pymain_run_interactive_hook();
Victor Stinner33c377e2017-12-05 15:12:41 +01001422
Victor Stinnera7368ac2017-11-15 18:11:45 -08001423 int res = PyRun_AnyFileFlags(stdin, "<stdin>", &pymain->cf);
1424 pymain->status = (res != 0);
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001425}
1426
1427
1428/* Parse the command line.
1429 Handle --version and --help options directly.
1430
1431 Return 1 if Python must exit.
1432 Return 0 on success.
1433 Set pymain->err and return -1 on failure. */
1434static int
Victor Stinnera7368ac2017-11-15 18:11:45 -08001435pymain_parse_cmdline(_PyMain *pymain)
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001436{
1437 _Py_CommandLineDetails *cmdline = &pymain->cmdline;
1438
Victor Stinnera7368ac2017-11-15 18:11:45 -08001439 int res = pymain_parse_cmdline_impl(pymain);
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001440 if (res < 0) {
1441 return -1;
1442 }
1443 if (res) {
Victor Stinnera7368ac2017-11-15 18:11:45 -08001444 pymain_usage(1, pymain->argv[0]);
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001445 pymain->status = 2;
1446 return 1;
1447 }
1448
1449 if (cmdline->print_help) {
Victor Stinnera7368ac2017-11-15 18:11:45 -08001450 pymain_usage(0, pymain->argv[0]);
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001451 pymain->status = 0;
1452 return 1;
1453 }
1454
1455 if (cmdline->print_version) {
1456 printf("Python %s\n",
1457 (cmdline->print_version >= 2) ? Py_GetVersion() : PY_VERSION);
1458 return 1;
1459 }
1460
1461 pymain->run_code = (cmdline->command != NULL || cmdline->filename != NULL
1462 || cmdline->module != NULL);
1463
1464 return 0;
1465}
1466
1467
Serhiy Storchaka4ae06c52017-12-12 13:55:04 +02001468static const wchar_t*
Victor Stinnera7368ac2017-11-15 18:11:45 -08001469pymain_get_xoption(_PyMain *pymain, wchar_t *name)
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001470{
Victor Stinnera7368ac2017-11-15 18:11:45 -08001471 _Py_OptList *list = &pymain->cmdline.xoptions;
1472 for (size_t i=0; i < list->len; i++) {
1473 wchar_t *option = list->options[i];
1474 size_t len;
1475 wchar_t *sep = wcschr(option, L'=');
1476 if (sep != NULL) {
1477 len = (sep - option);
1478 }
1479 else {
1480 len = wcslen(option);
1481 }
1482 if (wcsncmp(option, name, len) == 0 && name[len] == L'\0') {
1483 return option;
1484 }
1485 }
1486 return NULL;
1487}
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001488
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001489
Victor Stinnera7368ac2017-11-15 18:11:45 -08001490static int
Serhiy Storchaka4ae06c52017-12-12 13:55:04 +02001491pymain_str_to_int(const char *str, int *result)
Victor Stinnera7368ac2017-11-15 18:11:45 -08001492{
1493 errno = 0;
Serhiy Storchaka4ae06c52017-12-12 13:55:04 +02001494 const char *endptr = str;
1495 long value = strtol(str, (char **)&endptr, 10);
Victor Stinnera7368ac2017-11-15 18:11:45 -08001496 if (*endptr != '\0' || errno == ERANGE) {
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001497 return -1;
1498 }
Victor Stinnera7368ac2017-11-15 18:11:45 -08001499 if (value < INT_MIN || value > INT_MAX) {
1500 return -1;
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001501 }
1502
Victor Stinnera7368ac2017-11-15 18:11:45 -08001503 *result = (int)value;
1504 return 0;
1505}
1506
1507
1508static int
Serhiy Storchaka4ae06c52017-12-12 13:55:04 +02001509pymain_wstr_to_int(const wchar_t *wstr, int *result)
Victor Stinnera7368ac2017-11-15 18:11:45 -08001510{
1511 errno = 0;
Serhiy Storchaka4ae06c52017-12-12 13:55:04 +02001512 const wchar_t *endptr = wstr;
1513 long value = wcstol(wstr, (wchar_t **)&endptr, 10);
Victor Stinnera7368ac2017-11-15 18:11:45 -08001514 if (*endptr != '\0' || errno == ERANGE) {
1515 return -1;
1516 }
1517 if (value < INT_MIN || value > INT_MAX) {
1518 return -1;
1519 }
1520
1521 *result = (int)value;
1522 return 0;
1523}
1524
1525
1526static int
1527pymain_init_tracemalloc(_PyMain *pymain)
1528{
1529 int nframe;
1530 int valid;
1531
Serhiy Storchaka4ae06c52017-12-12 13:55:04 +02001532 const char *env = pymain_get_env_var("PYTHONTRACEMALLOC");
Victor Stinnera7368ac2017-11-15 18:11:45 -08001533 if (env) {
1534 if (!pymain_str_to_int(env, &nframe)) {
1535 valid = (nframe >= 1);
1536 }
1537 else {
1538 valid = 0;
1539 }
1540 if (!valid) {
1541 pymain->err = _Py_INIT_USER_ERR("PYTHONTRACEMALLOC: invalid "
1542 "number of frames");
1543 return -1;
1544 }
1545 pymain->core_config.tracemalloc = nframe;
1546 }
1547
Serhiy Storchaka4ae06c52017-12-12 13:55:04 +02001548 const wchar_t *xoption = pymain_get_xoption(pymain, L"tracemalloc");
Victor Stinnera7368ac2017-11-15 18:11:45 -08001549 if (xoption) {
Serhiy Storchaka4ae06c52017-12-12 13:55:04 +02001550 const wchar_t *sep = wcschr(xoption, L'=');
Victor Stinnera7368ac2017-11-15 18:11:45 -08001551 if (sep) {
1552 if (!pymain_wstr_to_int(sep + 1, &nframe)) {
1553 valid = (nframe >= 1);
1554 }
1555 else {
1556 valid = 0;
1557 }
1558 if (!valid) {
1559 pymain->err = _Py_INIT_USER_ERR("-X tracemalloc=NFRAME: "
1560 "invalid number of frames");
1561 return -1;
1562 }
1563 }
1564 else {
1565 /* -X tracemalloc behaves as -X tracemalloc=1 */
1566 nframe = 1;
1567 }
1568 pymain->core_config.tracemalloc = nframe;
1569 }
1570 return 0;
1571}
1572
1573
1574static void
1575pymain_set_flag_from_env(int *flag, const char *name)
1576{
Serhiy Storchaka4ae06c52017-12-12 13:55:04 +02001577 const char *var = pymain_get_env_var(name);
Victor Stinnera7368ac2017-11-15 18:11:45 -08001578 if (!var) {
1579 return;
1580 }
1581 int value;
1582 if (pymain_str_to_int(var, &value) < 0 || value < 0) {
1583 /* PYTHONDEBUG=text and PYTHONDEBUG=-2 behave as PYTHONDEBUG=1 */
1584 value = 1;
1585 }
1586 if (*flag < value) {
1587 *flag = value;
1588 }
1589}
1590
1591
1592static void
1593pymain_set_flags_from_env(_PyMain *pymain)
1594{
Victor Stinner6bf992a2017-12-06 17:26:10 +01001595 _Py_CommandLineDetails *cmdline = &pymain->cmdline;
1596 pymain_set_flag_from_env(&cmdline->debug,
Victor Stinnera7368ac2017-11-15 18:11:45 -08001597 "PYTHONDEBUG");
Victor Stinner6bf992a2017-12-06 17:26:10 +01001598 pymain_set_flag_from_env(&cmdline->verbosity,
Victor Stinnera7368ac2017-11-15 18:11:45 -08001599 "PYTHONVERBOSE");
Victor Stinner6bf992a2017-12-06 17:26:10 +01001600 pymain_set_flag_from_env(&cmdline->optimization_level,
Victor Stinnera7368ac2017-11-15 18:11:45 -08001601 "PYTHONOPTIMIZE");
Victor Stinner6bf992a2017-12-06 17:26:10 +01001602 pymain_set_flag_from_env(&cmdline->inspect,
Victor Stinnera7368ac2017-11-15 18:11:45 -08001603 "PYTHONINSPECT");
Victor Stinner6bf992a2017-12-06 17:26:10 +01001604 pymain_set_flag_from_env(&cmdline->dont_write_bytecode,
Victor Stinnera7368ac2017-11-15 18:11:45 -08001605 "PYTHONDONTWRITEBYTECODE");
Victor Stinner6bf992a2017-12-06 17:26:10 +01001606 pymain_set_flag_from_env(&cmdline->no_user_site_directory,
Victor Stinnera7368ac2017-11-15 18:11:45 -08001607 "PYTHONNOUSERSITE");
Victor Stinner6bf992a2017-12-06 17:26:10 +01001608 pymain_set_flag_from_env(&cmdline->use_unbuffered_io,
Victor Stinnera7368ac2017-11-15 18:11:45 -08001609 "PYTHONUNBUFFERED");
1610#ifdef MS_WINDOWS
Victor Stinner6bf992a2017-12-06 17:26:10 +01001611 pymain_set_flag_from_env(&cmdline->legacy_windows_fs_encoding,
Victor Stinnera7368ac2017-11-15 18:11:45 -08001612 "PYTHONLEGACYWINDOWSFSENCODING");
Victor Stinner6bf992a2017-12-06 17:26:10 +01001613 pymain_set_flag_from_env(&cmdline->legacy_windows_stdio,
Victor Stinnera7368ac2017-11-15 18:11:45 -08001614 "PYTHONLEGACYWINDOWSSTDIO");
1615#endif
1616}
1617
1618
1619static int
Victor Stinner46972b72017-11-24 22:55:40 +01001620config_get_env_var_dup(wchar_t **dest, wchar_t *wname, char *name)
Victor Stinnerd4341102017-11-23 00:12:09 +01001621{
1622 if (Py_IgnoreEnvironmentFlag) {
Victor Stinner1f151112017-11-23 10:43:14 +01001623 *dest = NULL;
Victor Stinnerd4341102017-11-23 00:12:09 +01001624 return 0;
1625 }
1626
1627#ifdef MS_WINDOWS
Serhiy Storchaka4ae06c52017-12-12 13:55:04 +02001628 const wchar_t *var = _wgetenv(wname);
Victor Stinner1f151112017-11-23 10:43:14 +01001629 if (!var || var[0] == '\0') {
1630 *dest = NULL;
Victor Stinnerd4341102017-11-23 00:12:09 +01001631 return 0;
1632 }
1633
Victor Stinner46972b72017-11-24 22:55:40 +01001634 wchar_t *copy = _PyMem_RawWcsdup(var);
Victor Stinner1f151112017-11-23 10:43:14 +01001635 if (copy == NULL) {
Victor Stinnerd4341102017-11-23 00:12:09 +01001636 return -1;
1637 }
1638
Victor Stinner1f151112017-11-23 10:43:14 +01001639 *dest = copy;
Victor Stinnerd4341102017-11-23 00:12:09 +01001640#else
Serhiy Storchaka4ae06c52017-12-12 13:55:04 +02001641 const char *var = getenv(name);
Victor Stinner1f151112017-11-23 10:43:14 +01001642 if (!var || var[0] == '\0') {
1643 *dest = NULL;
Victor Stinnerd4341102017-11-23 00:12:09 +01001644 return 0;
1645 }
1646
1647 size_t len;
Victor Stinner1f151112017-11-23 10:43:14 +01001648 wchar_t *wvar = Py_DecodeLocale(var, &len);
1649 if (!wvar) {
Victor Stinnerd4341102017-11-23 00:12:09 +01001650 if (len == (size_t)-2) {
Victor Stinner1f151112017-11-23 10:43:14 +01001651 return -2;
Victor Stinnerd4341102017-11-23 00:12:09 +01001652 }
1653 else {
Victor Stinner1f151112017-11-23 10:43:14 +01001654 return -1;
1655 }
1656 }
1657 *dest = wvar;
1658#endif
1659 return 0;
1660}
1661
1662
Victor Stinner46972b72017-11-24 22:55:40 +01001663static _PyInitError
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001664config_init_pythonpath(_PyCoreConfig *config)
Victor Stinner1f151112017-11-23 10:43:14 +01001665{
1666 wchar_t *path;
Victor Stinner46972b72017-11-24 22:55:40 +01001667 int res = config_get_env_var_dup(&path, L"PYTHONPATH", "PYTHONPATH");
Victor Stinner1f151112017-11-23 10:43:14 +01001668 if (res < 0) {
Victor Stinner46972b72017-11-24 22:55:40 +01001669 return DECODE_LOCALE_ERR("PYTHONHOME", res);
Victor Stinnerd4341102017-11-23 00:12:09 +01001670 }
Victor Stinner46972b72017-11-24 22:55:40 +01001671 config->module_search_path_env = path;
1672 return _Py_INIT_OK();
Victor Stinner1f151112017-11-23 10:43:14 +01001673}
1674
1675
Victor Stinner46972b72017-11-24 22:55:40 +01001676static _PyInitError
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001677config_init_home(_PyCoreConfig *config)
Victor Stinner1f151112017-11-23 10:43:14 +01001678{
1679 wchar_t *home;
1680
Victor Stinner31a83932017-12-04 13:39:15 +01001681 /* If Py_SetPythonHome() was called, use its value */
1682 home = _Py_path_config.home;
Victor Stinner1f151112017-11-23 10:43:14 +01001683 if (home) {
Victor Stinner46972b72017-11-24 22:55:40 +01001684 config->home = _PyMem_RawWcsdup(home);
1685 if (config->home == NULL) {
1686 return _Py_INIT_NO_MEMORY();
Victor Stinner1f151112017-11-23 10:43:14 +01001687 }
Victor Stinner46972b72017-11-24 22:55:40 +01001688 return _Py_INIT_OK();
Victor Stinner1f151112017-11-23 10:43:14 +01001689 }
1690
Victor Stinner46972b72017-11-24 22:55:40 +01001691 int res = config_get_env_var_dup(&home, L"PYTHONHOME", "PYTHONHOME");
Victor Stinner1f151112017-11-23 10:43:14 +01001692 if (res < 0) {
Victor Stinner46972b72017-11-24 22:55:40 +01001693 return DECODE_LOCALE_ERR("PYTHONHOME", res);
Victor Stinner1f151112017-11-23 10:43:14 +01001694 }
Victor Stinner46972b72017-11-24 22:55:40 +01001695 config->home = home;
1696 return _Py_INIT_OK();
Victor Stinnerd4341102017-11-23 00:12:09 +01001697}
1698
1699
Victor Stinner358e5e12017-12-15 00:51:22 +01001700static _PyInitError
1701config_init_hash_seed(_PyCoreConfig *config)
1702{
1703 if (config->use_hash_seed < 0) {
1704 const char *seed_text = pymain_get_env_var("PYTHONHASHSEED");
1705 int use_hash_seed;
1706 unsigned long hash_seed;
1707 if (_Py_ReadHashSeed(seed_text, &use_hash_seed, &hash_seed) < 0) {
1708 return _Py_INIT_USER_ERR("PYTHONHASHSEED must be \"random\" "
1709 "or an integer in range [0; 4294967295]");
1710 }
1711 config->use_hash_seed = use_hash_seed;
1712 config->hash_seed = hash_seed;
1713 }
1714 return _Py_INIT_OK();
1715}
1716
1717
Victor Stinner46972b72017-11-24 22:55:40 +01001718_PyInitError
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001719_PyCoreConfig_ReadEnv(_PyCoreConfig *config)
Victor Stinner46972b72017-11-24 22:55:40 +01001720{
Victor Stinner31a83932017-12-04 13:39:15 +01001721 _PyInitError err = config_init_home(config);
Victor Stinner46972b72017-11-24 22:55:40 +01001722 if (_Py_INIT_FAILED(err)) {
1723 return err;
1724 }
1725
1726 err = config_init_pythonpath(config);
1727 if (_Py_INIT_FAILED(err)) {
1728 return err;
1729 }
1730
Victor Stinner31a83932017-12-04 13:39:15 +01001731 err = config_get_program_name(config);
1732 if (_Py_INIT_FAILED(err)) {
1733 return err;
Victor Stinnerf04ebe22017-11-25 00:01:23 +01001734 }
1735
Victor Stinner358e5e12017-12-15 00:51:22 +01001736 err = config_init_hash_seed(config);
1737 if (_Py_INIT_FAILED(err)) {
1738 return err;
1739 }
1740
Victor Stinner46972b72017-11-24 22:55:40 +01001741 return _Py_INIT_OK();
1742}
1743
1744
Victor Stinner91106cd2017-12-13 12:29:09 +01001745static int
1746pymain_init_utf8_mode(_PyMain *pymain)
1747{
1748 _PyCoreConfig *core_config = &pymain->core_config;
1749
1750#ifdef MS_WINDOWS
1751 if (pymain->cmdline.legacy_windows_fs_encoding) {
1752 core_config->utf8_mode = 0;
1753 return 0;
1754 }
1755#endif
1756
Victor Stinnerd5dda982017-12-13 17:31:16 +01001757 const wchar_t *xopt = pymain_get_xoption(pymain, L"utf8");
Victor Stinner91106cd2017-12-13 12:29:09 +01001758 if (xopt) {
1759 wchar_t *sep = wcschr(xopt, L'=');
1760 if (sep) {
1761 xopt = sep + 1;
1762 if (wcscmp(xopt, L"1") == 0) {
1763 core_config->utf8_mode = 1;
1764 }
1765 else if (wcscmp(xopt, L"0") == 0) {
1766 core_config->utf8_mode = 0;
1767 }
1768 else {
1769 pymain->err = _Py_INIT_USER_ERR("invalid -X utf8 option value");
1770 return -1;
1771 }
1772 }
1773 else {
1774 core_config->utf8_mode = 1;
1775 }
1776 return 0;
1777 }
1778
Victor Stinnerd5dda982017-12-13 17:31:16 +01001779 const char *opt = pymain_get_env_var("PYTHONUTF8");
Victor Stinner91106cd2017-12-13 12:29:09 +01001780 if (opt) {
1781 if (strcmp(opt, "1") == 0) {
1782 core_config->utf8_mode = 1;
1783 }
1784 else if (strcmp(opt, "0") == 0) {
1785 core_config->utf8_mode = 0;
1786 }
1787 else {
1788 pymain->err = _Py_INIT_USER_ERR("invalid PYTHONUTF8 environment "
1789 "variable value");
1790 return -1;
1791 }
1792 return 0;
1793 }
1794 return 0;
1795}
Victor Stinner46972b72017-11-24 22:55:40 +01001796
1797
Victor Stinnerd4341102017-11-23 00:12:09 +01001798static int
Victor Stinnera7368ac2017-11-15 18:11:45 -08001799pymain_parse_envvars(_PyMain *pymain)
1800{
1801 _PyCoreConfig *core_config = &pymain->core_config;
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001802
1803 /* Get environment variables */
Victor Stinnera7368ac2017-11-15 18:11:45 -08001804 pymain_set_flags_from_env(pymain);
1805
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001806 if (pymain_warnings_envvar(pymain) < 0) {
1807 return -1;
1808 }
Victor Stinnerf04ebe22017-11-25 00:01:23 +01001809
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001810 _PyInitError err = _PyCoreConfig_ReadEnv(&pymain->core_config);
Victor Stinner46972b72017-11-24 22:55:40 +01001811 if (_Py_INIT_FAILED(pymain->err)) {
1812 pymain->err = err;
Victor Stinner1f151112017-11-23 10:43:14 +01001813 return -1;
1814 }
Victor Stinner31a83932017-12-04 13:39:15 +01001815 if (pymain_get_program_name(pymain) < 0) {
1816 return -1;
1817 }
1818
Victor Stinner6bf992a2017-12-06 17:26:10 +01001819 core_config->allocator = pymain_get_env_var("PYTHONMALLOC");
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001820
Victor Stinner25420fe2017-11-20 18:12:22 -08001821 /* -X options */
1822 if (pymain_get_xoption(pymain, L"showrefcount")) {
1823 core_config->show_ref_count = 1;
1824 }
1825 if (pymain_get_xoption(pymain, L"showalloccount")) {
1826 core_config->show_alloc_count = 1;
1827 }
1828
Victor Stinnera7368ac2017-11-15 18:11:45 -08001829 /* More complex options: env var and/or -X option */
1830 if (pymain_get_env_var("PYTHONFAULTHANDLER")
1831 || pymain_get_xoption(pymain, L"faulthandler")) {
1832 core_config->faulthandler = 1;
1833 }
1834 if (pymain_get_env_var("PYTHONPROFILEIMPORTTIME")
1835 || pymain_get_xoption(pymain, L"importtime")) {
Victor Stinner25420fe2017-11-20 18:12:22 -08001836 core_config->import_time = 1;
Victor Stinnera7368ac2017-11-15 18:11:45 -08001837 }
1838 if (pymain_init_tracemalloc(pymain) < 0) {
1839 return -1;
1840 }
Victor Stinner5e3806f2017-11-30 11:40:24 +01001841 if (pymain_get_xoption(pymain, L"dev" ) ||
1842 pymain_get_env_var("PYTHONDEVMODE"))
1843 {
Victor Stinner09f3a8a2017-11-20 17:32:40 -08001844 core_config->dev_mode = 1;
Victor Stinnerccb04422017-11-16 03:20:31 -08001845 core_config->faulthandler = 1;
Victor Stinner09f3a8a2017-11-20 17:32:40 -08001846 core_config->allocator = "debug";
Victor Stinnerccb04422017-11-16 03:20:31 -08001847 }
Victor Stinner6bf992a2017-12-06 17:26:10 +01001848 if (pymain_get_env_var("PYTHONDUMPREFS")) {
1849 pymain->core_config.dump_refs = 1;
1850 }
1851 if (pymain_get_env_var("PYTHONMALLOCSTATS")) {
1852 pymain->core_config.malloc_stats = 1;
1853 }
1854
Victor Stinner91106cd2017-12-13 12:29:09 +01001855 if (pymain_init_utf8_mode(pymain) < 0) {
1856 return -1;
1857 }
Victor Stinner6bf992a2017-12-06 17:26:10 +01001858
Victor Stinnerf7e5b562017-11-15 15:48:08 -08001859 return 0;
1860}
1861
1862
Victor Stinnera7368ac2017-11-15 18:11:45 -08001863/* Parse command line options and environment variables.
1864 This code must not use Python runtime apart PyMem_Raw memory allocator.
1865
1866 Return 0 on success.
1867 Return 1 if Python is done and must exit.
1868 Set pymain->err and return -1 on error. */
1869static int
1870pymain_parse_cmdline_envvars_impl(_PyMain *pymain)
1871{
1872 int res = pymain_parse_cmdline(pymain);
1873 if (res < 0) {
1874 return -1;
1875 }
1876 if (res > 0) {
1877 return 1;
1878 }
1879
Victor Stinner6bf992a2017-12-06 17:26:10 +01001880 /* Set Py_IgnoreEnvironmentFlag needed by Py_GETENV() */
Victor Stinnera7368ac2017-11-15 18:11:45 -08001881 pymain_set_global_config(pymain);
1882
1883 if (pymain_parse_envvars(pymain) < 0) {
1884 return -1;
1885 }
Victor Stinner91106cd2017-12-13 12:29:09 +01001886 /* FIXME: if utf8_mode value changed, parse again cmdline */
Victor Stinnera7368ac2017-11-15 18:11:45 -08001887
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01001888 if (pymain_init_sys_argv(pymain) < 0) {
1889 return -1;
1890 }
1891
1892 _PyInitError err = _PyCoreConfig_Read(&pymain->core_config);
Victor Stinner31a83932017-12-04 13:39:15 +01001893 if (_Py_INIT_FAILED(err)) {
1894 pymain->err = err;
1895 return -1;
1896 }
Victor Stinnera7368ac2017-11-15 18:11:45 -08001897 return 0;
1898}
1899
1900
1901static int
1902pymain_parse_cmdline_envvars(_PyMain *pymain)
1903{
Victor Stinner5d39e042017-11-29 17:20:38 +01001904 /* Force default allocator, since pymain_free() must use the same allocator
1905 than this function. */
1906 PyMemAllocatorEx old_alloc;
1907 _PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
Victor Stinnera7368ac2017-11-15 18:11:45 -08001908
1909 int res = pymain_parse_cmdline_envvars_impl(pymain);
1910
Victor Stinnera7368ac2017-11-15 18:11:45 -08001911 PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
Victor Stinnera7368ac2017-11-15 18:11:45 -08001912 return res;
1913}
1914
Victor Stinner91106cd2017-12-13 12:29:09 +01001915
Victor Stinnerda273412017-12-15 01:46:02 +01001916/* Read configuration settings from standard locations
1917 *
1918 * This function doesn't make any changes to the interpreter state - it
1919 * merely populates any missing configuration settings. This allows an
1920 * embedding application to completely override a config option by
1921 * setting it before calling this function, or else modify the default
1922 * setting before passing the fully populated config to Py_EndInitialization.
1923 *
1924 * More advanced selective initialization tricks are possible by calling
1925 * this function multiple times with various preconfigured settings.
1926 */
1927
1928_PyInitError
1929_PyCoreConfig_Read(_PyCoreConfig *config)
1930{
1931 if (config->program_name == NULL) {
1932#ifdef MS_WINDOWS
1933 const wchar_t *program_name = L"python";
1934#else
1935 const wchar_t *program_name = L"python3";
1936#endif
1937 config->program_name = _PyMem_RawWcsdup(program_name);
1938 if (config->program_name == NULL) {
1939 return _Py_INIT_NO_MEMORY();
1940 }
1941 }
1942
1943 return _Py_INIT_OK();
1944}
1945
1946
1947void
1948_PyCoreConfig_Clear(_PyCoreConfig *config)
1949{
1950#define CLEAR(ATTR) \
1951 do { \
1952 PyMem_RawFree(ATTR); \
1953 ATTR = NULL; \
1954 } while (0)
1955
1956 CLEAR(config->module_search_path_env);
1957 CLEAR(config->home);
1958 CLEAR(config->program_name);
1959#undef CLEAR
1960}
1961
1962
1963int
1964_PyCoreConfig_Copy(_PyCoreConfig *config, const _PyCoreConfig *config2)
1965{
1966 _PyCoreConfig_Clear(config);
1967
1968#define COPY_ATTR(ATTR) config->ATTR = config2->ATTR
1969 COPY_ATTR(ignore_environment);
1970 COPY_ATTR(use_hash_seed);
1971 COPY_ATTR(hash_seed);
1972 COPY_ATTR(_disable_importlib);
1973 COPY_ATTR(allocator);
1974 COPY_ATTR(dev_mode);
1975 COPY_ATTR(faulthandler);
1976 COPY_ATTR(tracemalloc);
1977 COPY_ATTR(import_time);
1978 COPY_ATTR(show_ref_count);
1979 COPY_ATTR(show_alloc_count);
1980 COPY_ATTR(dump_refs);
1981 COPY_ATTR(malloc_stats);
1982 COPY_ATTR(utf8_mode);
1983#undef COPY_ATTR
1984
1985#define COPY_STR_ATTR(ATTR) \
1986 do { \
1987 if (config2->ATTR != NULL) { \
1988 config->ATTR = _PyMem_RawWcsdup(config2->ATTR); \
1989 if (config->ATTR == NULL) { \
1990 return -1; \
1991 } \
1992 } \
1993 } while (0)
1994
1995 COPY_STR_ATTR(module_search_path_env);
1996 COPY_STR_ATTR(home);
1997 COPY_STR_ATTR(program_name);
1998#undef COPY_STR_ATTR
1999 return 0;
2000}
2001
2002
2003void
2004_PyMainInterpreterConfig_Clear(_PyMainInterpreterConfig *config)
2005{
2006 Py_CLEAR(config->argv);
Victor Stinner41264f12017-12-15 02:05:29 +01002007 Py_CLEAR(config->executable);
2008 Py_CLEAR(config->prefix);
2009 Py_CLEAR(config->base_prefix);
2010 Py_CLEAR(config->exec_prefix);
2011 Py_CLEAR(config->base_exec_prefix);
Victor Stinnerda273412017-12-15 01:46:02 +01002012 Py_CLEAR(config->warnoptions);
2013 Py_CLEAR(config->xoptions);
Victor Stinner41264f12017-12-15 02:05:29 +01002014 Py_CLEAR(config->module_search_path);
Victor Stinnerda273412017-12-15 01:46:02 +01002015}
2016
2017
2018static PyObject*
2019config_copy_attr(PyObject *obj)
2020{
2021 if (PyUnicode_Check(obj)) {
2022 Py_INCREF(obj);
2023 return obj;
2024 }
2025 else if (PyList_Check(obj)) {
2026 return PyList_GetSlice(obj, 0, Py_SIZE(obj));
2027 }
2028 else if (PyDict_Check(obj)) {
2029 /* The dict type is used for xoptions. Make the assumption that keys
2030 and values are immutables */
2031 return PyDict_Copy(obj);
2032 }
2033 else {
2034 PyErr_Format(PyExc_TypeError,
2035 "cannot copy config attribute of type %.200s",
2036 Py_TYPE(obj)->tp_name);
2037 return NULL;
2038 }
2039}
2040
2041
2042int
2043_PyMainInterpreterConfig_Copy(_PyMainInterpreterConfig *config,
2044 const _PyMainInterpreterConfig *config2)
2045{
2046 _PyMainInterpreterConfig_Clear(config);
2047
2048#define COPY_ATTR(ATTR) \
2049 do { \
2050 if (config2->ATTR != NULL) { \
2051 config->ATTR = config_copy_attr(config2->ATTR); \
2052 if (config->ATTR == NULL) { \
2053 return -1; \
2054 } \
2055 } \
2056 } while (0)
2057
2058 COPY_ATTR(argv);
Victor Stinner41264f12017-12-15 02:05:29 +01002059 COPY_ATTR(executable);
2060 COPY_ATTR(prefix);
2061 COPY_ATTR(base_prefix);
2062 COPY_ATTR(exec_prefix);
2063 COPY_ATTR(base_exec_prefix);
Victor Stinnerda273412017-12-15 01:46:02 +01002064 COPY_ATTR(warnoptions);
2065 COPY_ATTR(xoptions);
Victor Stinner41264f12017-12-15 02:05:29 +01002066 COPY_ATTR(module_search_path);
Victor Stinnerda273412017-12-15 01:46:02 +01002067#undef COPY_ATTR
2068 return 0;
2069}
2070
2071
2072
2073
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01002074static PyObject *
2075config_create_path_list(const wchar_t *path, wchar_t delim)
2076{
2077 int i, n;
2078 const wchar_t *p;
2079 PyObject *v;
2080
2081 n = 1;
2082 p = path;
2083 while ((p = wcschr(p, delim)) != NULL) {
2084 n++;
2085 p++;
2086 }
2087 v = PyList_New(n);
2088 if (v == NULL) {
2089 return NULL;
2090 }
2091 for (i = 0; ; i++) {
2092 p = wcschr(path, delim);
2093 if (p == NULL) {
2094 p = path + wcslen(path); /* End of string */
2095 }
2096 PyObject *w = PyUnicode_FromWideChar(path, (Py_ssize_t)(p - path));
2097 if (w == NULL) {
2098 Py_DECREF(v);
2099 return NULL;
2100 }
2101 PyList_SET_ITEM(v, i, w);
2102 if (*p == '\0') {
2103 break;
2104 }
2105 path = p+1;
2106 }
2107 return v;
2108}
2109
2110
Victor Stinner41264f12017-12-15 02:05:29 +01002111_PyInitError
2112_PyMainInterpreterConfig_Read(_PyMainInterpreterConfig *config, _PyCoreConfig *core_config)
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01002113{
2114 _PyInitError err = _PyPathConfig_Init(core_config);
2115 if (_Py_INIT_FAILED(err)) {
2116 return err;
2117 }
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01002118
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01002119 /* Signal handlers are installed by default */
2120 if (config->install_signal_handlers < 0) {
2121 config->install_signal_handlers = 1;
2122 }
2123
2124 if (config->module_search_path == NULL &&
2125 !core_config->_disable_importlib)
Victor Stinner41264f12017-12-15 02:05:29 +01002126
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01002127 {
Victor Stinner41264f12017-12-15 02:05:29 +01002128 wchar_t *sys_path = Py_GetPath();
2129 config->module_search_path = config_create_path_list(sys_path, DELIM);
2130 if (config->module_search_path == NULL) {
2131 return _Py_INIT_NO_MEMORY();
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01002132 }
2133 }
Victor Stinner41264f12017-12-15 02:05:29 +01002134
2135 if (config->executable == NULL) {
2136 config->executable = PyUnicode_FromWideChar(Py_GetProgramFullPath(), -1);
2137 if (config->executable == NULL) {
2138 return _Py_INIT_NO_MEMORY();
2139 }
2140 }
2141
2142 if (config->prefix == NULL) {
2143 config->prefix = PyUnicode_FromWideChar(Py_GetPrefix(), -1);
2144 if (config->prefix == NULL) {
2145 return _Py_INIT_NO_MEMORY();
2146 }
2147 }
2148
2149 if (config->exec_prefix == NULL) {
2150 config->exec_prefix = PyUnicode_FromWideChar(Py_GetExecPrefix(), -1);
2151 if (config->exec_prefix == NULL) {
2152 return _Py_INIT_NO_MEMORY();
2153 }
2154 }
2155
2156 if (config->base_prefix == NULL) {
2157 Py_INCREF(config->prefix);
2158 config->base_prefix = config->prefix;
2159 }
2160
2161 if (config->base_exec_prefix == NULL) {
2162 Py_INCREF(config->exec_prefix);
2163 config->base_exec_prefix = config->exec_prefix;
2164 }
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01002165 return _Py_INIT_OK();
2166}
2167
2168
2169static int
2170pymain_init_python_core(_PyMain *pymain)
2171{
Victor Stinner6bf992a2017-12-06 17:26:10 +01002172 pymain_set_global_config(pymain);
2173
Victor Stinnera7368ac2017-11-15 18:11:45 -08002174 pymain_init_stdio(pymain);
2175
2176 pymain->err = _Py_InitializeCore(&pymain->core_config);
2177 if (_Py_INIT_FAILED(pymain->err)) {
2178 return -1;
2179 }
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01002180 return 0;
2181}
Victor Stinnera7368ac2017-11-15 18:11:45 -08002182
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01002183
2184static int
2185pymain_init_python_main(_PyMain *pymain)
2186{
Victor Stinner374c6e12017-12-14 12:05:26 +01002187 if (pymain_init_xoptions_dict(pymain)) {
2188 pymain->err = _Py_INIT_NO_MEMORY();
Victor Stinnera7368ac2017-11-15 18:11:45 -08002189 return -1;
2190 }
Victor Stinner374c6e12017-12-14 12:05:26 +01002191 if (pymain_init_warnoptions(pymain)) {
2192 pymain->err = _Py_INIT_NO_MEMORY();
Victor Stinnera7368ac2017-11-15 18:11:45 -08002193 return -1;
2194 }
Victor Stinner374c6e12017-12-14 12:05:26 +01002195 if (pymain_init_argv(pymain) < 0) {
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01002196 pymain->err = _Py_INIT_ERR("failed to create sys.argv");
2197 return -1;
2198 }
2199
2200 _PyInitError err = _PyMainInterpreterConfig_Read(&pymain->config,
2201 &pymain->core_config);
2202 if (_Py_INIT_FAILED(err)) {
2203 pymain->err = err;
2204 return -1;
2205 }
2206
Victor Stinnera7368ac2017-11-15 18:11:45 -08002207 if (pymain_init_main_interpreter(pymain)) {
2208 return -1;
2209 }
Victor Stinnerd5dda982017-12-13 17:31:16 +01002210
2211 if (pymain->cmdline.filename != NULL) {
2212 /* If filename is a package (ex: directory or ZIP file) which contains
2213 __main__.py, main_importer_path is set to filename and will be
2214 prepended to sys.path by pymain_run_main_from_importer(). Otherwise,
2215 main_importer_path is set to NULL. */
2216 pymain->main_importer_path = pymain_get_importer(pymain->cmdline.filename);
2217 }
2218
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01002219 if (pymain_update_sys_path(pymain) < 0) {
Victor Stinnerd5dda982017-12-13 17:31:16 +01002220 return -1;
2221 }
Victor Stinnera7368ac2017-11-15 18:11:45 -08002222 return 0;
2223}
2224
2225
2226static void
2227pymain_run_python(_PyMain *pymain)
2228{
2229 _Py_CommandLineDetails *cmdline = &pymain->cmdline;
2230
2231 pymain_header(pymain);
2232 pymain_import_readline(pymain);
2233
Victor Stinnera7368ac2017-11-15 18:11:45 -08002234 if (cmdline->command) {
2235 pymain->status = pymain_run_command(cmdline->command, &pymain->cf);
2236 }
2237 else if (cmdline->module) {
2238 pymain->status = (pymain_run_module(cmdline->module, 1) != 0);
2239 }
2240 else {
2241 pymain_run_filename(pymain);
2242 }
2243 pymain_repl(pymain);
2244}
2245
2246
Victor Stinnerf7e5b562017-11-15 15:48:08 -08002247static int
2248pymain_init(_PyMain *pymain)
2249{
2250 pymain->err = _PyRuntime_Initialize();
2251 if (_Py_INIT_FAILED(pymain->err)) {
2252 return -1;
2253 }
2254
Victor Stinner91106cd2017-12-13 12:29:09 +01002255 pymain->core_config.utf8_mode = Py_UTF8Mode;
Victor Stinnera7368ac2017-11-15 18:11:45 -08002256 pymain->core_config._disable_importlib = 0;
Victor Stinnere32e79f2017-11-23 01:49:45 +01002257 pymain->config.install_signal_handlers = 1;
Victor Stinnerf7e5b562017-11-15 15:48:08 -08002258
Victor Stinnera7368ac2017-11-15 18:11:45 -08002259 orig_argc = pymain->argc; /* For Py_GetArgcArgv() */
2260 orig_argv = pymain->argv;
2261 return 0;
Victor Stinnerf7e5b562017-11-15 15:48:08 -08002262}
2263
Victor Stinnera7368ac2017-11-15 18:11:45 -08002264
Victor Stinnerf7e5b562017-11-15 15:48:08 -08002265static int
Victor Stinnera7368ac2017-11-15 18:11:45 -08002266pymain_impl(_PyMain *pymain)
Victor Stinnerf7e5b562017-11-15 15:48:08 -08002267{
Victor Stinnera7368ac2017-11-15 18:11:45 -08002268 int res = pymain_init(pymain);
2269 if (res < 0) {
Victor Stinnerf7e5b562017-11-15 15:48:08 -08002270 return -1;
2271 }
2272
Victor Stinner6bf992a2017-12-06 17:26:10 +01002273 pymain_get_global_config(pymain);
2274
Victor Stinnera7368ac2017-11-15 18:11:45 -08002275 res = pymain_parse_cmdline_envvars(pymain);
2276 if (res < 0) {
2277 return -1;
2278 }
2279 if (res > 0) {
2280 /* --help or --version command: we are done */
2281 return 0;
2282 }
2283
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01002284 res = pymain_init_python_core(pymain);
2285 if (res < 0) {
2286 return -1;
2287 }
2288
2289 res = pymain_init_python_main(pymain);
Victor Stinnera7368ac2017-11-15 18:11:45 -08002290 if (res < 0) {
Victor Stinnerf7e5b562017-11-15 15:48:08 -08002291 return -1;
2292 }
2293
Victor Stinnera7368ac2017-11-15 18:11:45 -08002294 pymain_run_python(pymain);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002295
Victor Stinnerb5fd9ad2017-12-14 02:20:52 +01002296 pymain_free_python(pymain);
2297
Martin Panterb4ce1fc2015-11-30 03:18:29 +00002298 if (Py_FinalizeEx() < 0) {
2299 /* Value unlikely to be confused with a non-error exit status or
Victor Stinnera7368ac2017-11-15 18:11:45 -08002300 other special meaning */
Victor Stinnerf7e5b562017-11-15 15:48:08 -08002301 pymain->status = 120;
Martin Panterb4ce1fc2015-11-30 03:18:29 +00002302 }
Victor Stinnerf7e5b562017-11-15 15:48:08 -08002303 return 0;
2304}
Barry Warsaw3e13b1e2001-02-23 16:46:39 +00002305
Victor Stinnerf7e5b562017-11-15 15:48:08 -08002306
2307int
2308Py_Main(int argc, wchar_t **argv)
2309{
2310 _PyMain pymain = _PyMain_INIT;
2311 memset(&pymain.cmdline, 0, sizeof(pymain.cmdline));
2312 pymain.argc = argc;
2313 pymain.argv = argv;
2314
Victor Stinnera7368ac2017-11-15 18:11:45 -08002315 if (pymain_impl(&pymain) < 0) {
Victor Stinnerf7e5b562017-11-15 15:48:08 -08002316 _Py_FatalInitError(pymain.err);
2317 }
Victor Stinnerf7e5b562017-11-15 15:48:08 -08002318 pymain_free(&pymain);
2319
2320 return pymain.status;
Guido van Rossum667d7041995-08-04 04:20:48 +00002321}
2322
Skip Montanaro786ea6b2004-03-01 15:44:05 +00002323/* this is gonna seem *real weird*, but if you put some other code between
2324 Py_Main() and Py_GetArgcArgv() you will need to adjust the test in the
2325 while statement in Misc/gdbinit:ppystack */
Guido van Rossum667d7041995-08-04 04:20:48 +00002326
Guido van Rossum667d7041995-08-04 04:20:48 +00002327/* Make the *original* argc/argv available to other modules.
2328 This is rare, but it is needed by the secureware extension. */
2329
2330void
Martin v. Löwis790465f2008-04-05 20:41:37 +00002331Py_GetArgcArgv(int *argc, wchar_t ***argv)
Guido van Rossum667d7041995-08-04 04:20:48 +00002332{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002333 *argc = orig_argc;
2334 *argv = orig_argv;
Guido van Rossum667d7041995-08-04 04:20:48 +00002335}
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002336
2337#ifdef __cplusplus
2338}
2339#endif