typedef struct {
wchar_t *path_env; /* PATH environment variable */
- wchar_t *home; /* PYTHONHOME environment variable */
- wchar_t *module_search_path_env; /* PYTHONPATH environment variable */
- wchar_t *program_name; /* Program name */
wchar_t *pythonpath; /* PYTHONPATH define */
wchar_t *prefix; /* PREFIX define */
wchar_t *exec_prefix; /* EXEC_PREFIX define */
bytes long.
*/
static int
-search_for_prefix(PyCalculatePath *calculate, wchar_t *prefix)
+search_for_prefix(const _PyMainInterpreterConfig *main_config,
+ PyCalculatePath *calculate, wchar_t *prefix)
{
size_t n;
wchar_t *vpath;
/* If PYTHONHOME is set, we believe it unconditionally */
- if (calculate->home) {
- wcsncpy(prefix, calculate->home, MAXPATHLEN);
+ if (main_config->home) {
+ wcsncpy(prefix, main_config->home, MAXPATHLEN);
prefix[MAXPATHLEN] = L'\0';
wchar_t *delim = wcschr(prefix, DELIM);
if (delim) {
static void
-calculate_prefix(PyCalculatePath *calculate, wchar_t *prefix)
+calculate_prefix(const _PyMainInterpreterConfig *main_config,
+ PyCalculatePath *calculate, wchar_t *prefix)
{
- calculate->prefix_found = search_for_prefix(calculate, prefix);
+ calculate->prefix_found = search_for_prefix(main_config, calculate, prefix);
if (!calculate->prefix_found) {
if (!Py_FrozenFlag) {
fprintf(stderr,
MAXPATHLEN bytes long.
*/
static int
-search_for_exec_prefix(PyCalculatePath *calculate, wchar_t *exec_prefix)
+search_for_exec_prefix(const _PyMainInterpreterConfig *main_config,
+ PyCalculatePath *calculate, wchar_t *exec_prefix)
{
size_t n;
/* If PYTHONHOME is set, we believe it unconditionally */
- if (calculate->home) {
- wchar_t *delim = wcschr(calculate->home, DELIM);
+ if (main_config->home) {
+ wchar_t *delim = wcschr(main_config->home, DELIM);
if (delim) {
wcsncpy(exec_prefix, delim+1, MAXPATHLEN);
}
else {
- wcsncpy(exec_prefix, calculate->home, MAXPATHLEN);
+ wcsncpy(exec_prefix, main_config->home, MAXPATHLEN);
}
exec_prefix[MAXPATHLEN] = L'\0';
joinpath(exec_prefix, calculate->lib_python);
static void
-calculate_exec_prefix(PyCalculatePath *calculate, wchar_t *exec_prefix)
+calculate_exec_prefix(const _PyMainInterpreterConfig *main_config,
+ PyCalculatePath *calculate, wchar_t *exec_prefix)
{
- calculate->exec_prefix_found = search_for_exec_prefix(calculate, exec_prefix);
+ calculate->exec_prefix_found = search_for_exec_prefix(main_config,
+ calculate,
+ exec_prefix);
if (!calculate->exec_prefix_found) {
if (!Py_FrozenFlag) {
fprintf(stderr,
static _PyInitError
-calculate_program_full_path(PyCalculatePath *calculate, _PyPathConfig *config)
+calculate_program_full_path(const _PyMainInterpreterConfig *main_config,
+ PyCalculatePath *calculate, _PyPathConfig *config)
{
wchar_t program_full_path[MAXPATHLEN+1];
memset(program_full_path, 0, sizeof(program_full_path));
* other way to find a directory to start the search from. If
* $PATH isn't exported, you lose.
*/
- if (wcschr(calculate->program_name, SEP)) {
- wcsncpy(program_full_path, calculate->program_name, MAXPATHLEN);
+ if (wcschr(main_config->program_name, SEP)) {
+ wcsncpy(program_full_path, main_config->program_name, MAXPATHLEN);
}
#ifdef __APPLE__
/* On Mac OS X, if a script uses an interpreter of the form
wcsncpy(program_full_path, path, MAXPATHLEN);
}
- joinpath(program_full_path, calculate->program_name);
+ joinpath(program_full_path, main_config->program_name);
if (isxfile(program_full_path)) {
break;
}
static _PyInitError
-calculate_module_search_path(PyCalculatePath *calculate,
+calculate_module_search_path(const _PyMainInterpreterConfig *main_config,
+ PyCalculatePath *calculate,
const wchar_t *prefix, const wchar_t *exec_prefix,
_PyPathConfig *config)
{
/* Calculate size of return buffer */
size_t bufsz = 0;
- if (calculate->module_search_path_env != NULL) {
- bufsz += wcslen(calculate->module_search_path_env) + 1;
+ if (main_config->module_search_path_env != NULL) {
+ bufsz += wcslen(main_config->module_search_path_env) + 1;
}
wchar_t *defpath = calculate->pythonpath;
buf[0] = '\0';
/* Run-time value of $PYTHONPATH goes first */
- if (calculate->module_search_path_env) {
- wcscpy(buf, calculate->module_search_path_env);
+ if (main_config->module_search_path_env) {
+ wcscpy(buf, main_config->module_search_path_env);
wcscat(buf, delimiter);
}
calculate_init(PyCalculatePath *calculate,
const _PyMainInterpreterConfig *main_config)
{
- calculate->home = main_config->home;
- calculate->module_search_path_env = main_config->module_search_path_env;
- calculate->program_name = main_config->program_name;
-
size_t len;
char *path = getenv("PATH");
if (path) {
static _PyInitError
-calculate_path_impl(PyCalculatePath *calculate, _PyPathConfig *config)
+calculate_path_impl(const _PyMainInterpreterConfig *main_config,
+ PyCalculatePath *calculate, _PyPathConfig *config)
{
- _PyInitError err = calculate_program_full_path(calculate, config);
+ _PyInitError err;
+
+ err = calculate_program_full_path(main_config, calculate, config);
if (_Py_INIT_FAILED(err)) {
return err;
}
wchar_t prefix[MAXPATHLEN+1];
memset(prefix, 0, sizeof(prefix));
- calculate_prefix(calculate, prefix);
+ calculate_prefix(main_config, calculate, prefix);
calculate_zip_path(calculate, prefix);
wchar_t exec_prefix[MAXPATHLEN+1];
memset(exec_prefix, 0, sizeof(exec_prefix));
- calculate_exec_prefix(calculate, exec_prefix);
+ calculate_exec_prefix(main_config, calculate, exec_prefix);
if ((!calculate->prefix_found || !calculate->exec_prefix_found) &&
!Py_FrozenFlag)
"Consider setting $PYTHONHOME to <prefix>[:<exec_prefix>]\n");
}
- err = calculate_module_search_path(calculate, prefix, exec_prefix,
- config);
+ err = calculate_module_search_path(main_config, calculate,
+ prefix, exec_prefix, config);
if (_Py_INIT_FAILED(err)) {
return err;
}
_PyPathConfig new_path_config;
memset(&new_path_config, 0, sizeof(new_path_config));
- err = calculate_path_impl(&calculate, &new_path_config);
+ err = calculate_path_impl(main_config, &calculate, &new_path_config);
if (_Py_INIT_FAILED(err)) {
pathconfig_clear(&new_path_config);
goto done;
_PyMainInterpreterConfig config = _PyMainInterpreterConfig_INIT;
err = _PyMainInterpreterConfig_ReadEnv(&config);
- if (!_Py_INIT_FAILED(err)) {
- err = _PyPathConfig_Init(&config);
+ if (_Py_INIT_FAILED(err)) {
+ goto error;
+ }
+
+ err = _PyMainInterpreterConfig_Read(&config);
+ if (_Py_INIT_FAILED(err)) {
+ goto error;
}
- _PyMainInterpreterConfig_Clear(&config);
+ err = _PyPathConfig_Init(&config);
if (_Py_INIT_FAILED(err)) {
- _Py_FatalInitError(err);
+ goto error;
}
+
+ _PyMainInterpreterConfig_Clear(&config);
+ return;
+
+error:
+ _PyMainInterpreterConfig_Clear(&config);
+ _Py_FatalInitError(err);
}
/* non-zero if filename, command (-c) or module (-m) is set
on the command line */
int run_code;
- wchar_t *program_name;
/* Error message if a function failed */
_PyInitError err;
/* PYTHONWARNINGS env var */
.config = _PyMainInterpreterConfig_INIT, \
.main_importer_path = NULL, \
.run_code = -1, \
- .program_name = NULL, \
.err = _Py_INIT_OK(), \
.env_warning_options = {0, NULL}}
pymain_optlist_clear(&pymain->env_warning_options);
Py_CLEAR(pymain->main_importer_path);
- PyMem_RawFree(pymain->program_name);
_PyMainInterpreterConfig_Clear(&pymain->config);
/* Get the program name: use PYTHONEXECUTABLE and __PYVENV_LAUNCHER__
- environment variables on macOS if available, use argv[0] by default.
-
- Return 0 on success.
- Set pymain->err and return -1 on error. */
-static int
-pymain_get_program_name(_PyMain *pymain)
+ environment variables on macOS if available. */
+static _PyInitError
+config_get_program_name(_PyMainInterpreterConfig *config)
{
- assert(pymain->program_name == NULL);
+ assert(config->program_name == NULL);
#ifdef __APPLE__
char *p;
/* On MacOS X, when the Python interpreter is embedded in an
buffer = PyMem_RawMalloc(len * sizeof(wchar_t));
if (buffer == NULL) {
- pymain->err = _Py_INIT_NO_MEMORY();
- return -1;
+ return _Py_INIT_NO_MEMORY();
}
mbstowcs(buffer, p, len);
- pymain->program_name = buffer;
+ pymain->config.program_name = buffer;
}
#ifdef WITH_NEXT_FRAMEWORK
else {
size_t len;
wchar_t* wbuf = Py_DecodeLocale(pyvenv_launcher, &len);
if (wbuf == NULL) {
- SET_DECODE_ERROR("__PYVENV_LAUNCHER__", len);
- return -1;
+ return SET_DECODE_ERROR("__PYVENV_LAUNCHER__", len);
}
- pymain->program_name = wbuf;
+ pymain->config.program_name = wbuf;
}
}
#endif /* WITH_NEXT_FRAMEWORK */
#endif /* __APPLE__ */
+ return _Py_INIT_OK();
+}
- if (pymain->program_name == NULL) {
+
+/* If config_get_program_name() found no program name: use argv[0] by default.
+ Return 0 on success. Set pymain->err and return -1 on error. */
+static int
+pymain_get_program_name(_PyMain *pymain)
+{
+ if (pymain->config.program_name == NULL) {
/* Use argv[0] by default */
- pymain->program_name = pymain_wstrdup(pymain, pymain->argv[0]);
- if (pymain->program_name == NULL) {
+ pymain->config.program_name = pymain_wstrdup(pymain, pymain->argv[0]);
+ if (pymain->config.program_name == NULL) {
return -1;
}
}
return err;
}
- /* FIXME: _PyMainInterpreterConfig_Read() has the same code. Remove it
- here? See also pymain_get_program_name() and pymain_parse_envvars(). */
- config->program_name = _PyMem_RawWcsdup(Py_GetProgramName());
- if (config->program_name == NULL) {
- return _Py_INIT_NO_MEMORY();
+ err = config_get_program_name(config);
+ if (_Py_INIT_FAILED(err)) {
+ return err;
}
return _Py_INIT_OK();
if (pymain_warnings_envvar(pymain) < 0) {
return -1;
}
- if (pymain_get_program_name(pymain) < 0) {
- return -1;
- }
- core_config->allocator = Py_GETENV("PYTHONMALLOC");
-
- /* FIXME: move pymain_get_program_name() code into
- _PyMainInterpreterConfig_ReadEnv().
- Problem: _PyMainInterpreterConfig_ReadEnv() doesn't have access
- to argv[0]. */
- Py_SetProgramName(pymain->program_name);
- /* Don't free program_name here: the argument to Py_SetProgramName
- must remain valid until Py_FinalizeEx is called. The string is freed
- by pymain_free(). */
_PyInitError err = _PyMainInterpreterConfig_ReadEnv(&pymain->config);
if (_Py_INIT_FAILED(pymain->err)) {
pymain->err = err;
return -1;
}
+ if (pymain_get_program_name(pymain) < 0) {
+ return -1;
+ }
+
+ core_config->allocator = Py_GETENV("PYTHONMALLOC");
/* -X options */
if (pymain_get_xoption(pymain, L"showrefcount")) {
{
pymain_init_stdio(pymain);
+ Py_SetProgramName(pymain->config.program_name);
+ /* Don't free program_name here: the argument to Py_SetProgramName
+ must remain valid until Py_FinalizeEx is called. The string is freed
+ by pymain_free(). */
+
pymain->err = _Py_InitializeCore(&pymain->core_config);
if (_Py_INIT_FAILED(pymain->err)) {
return -1;
#endif
typedef struct {
- wchar_t *module_search_path_env; /* PYTHONPATH environment variable */
wchar_t *path_env; /* PATH environment variable */
wchar_t *home; /* PYTHONHOME environment variable */
wchar_t *machine_path; /* from HKEY_LOCAL_MACHINE */
wchar_t *user_path; /* from HKEY_CURRENT_USER */
- wchar_t *program_name; /* Program name */
wchar_t argv0_path[MAXPATHLEN+1];
wchar_t zip_path[MAXPATHLEN+1];
} PyCalculatePath;
static _PyInitError
-get_program_full_path(PyCalculatePath *calculate, _PyPathConfig *config)
+get_program_full_path(const _PyMainInterpreterConfig *main_config,
+ PyCalculatePath *calculate, _PyPathConfig *config)
{
wchar_t program_full_path[MAXPATHLEN+1];
memset(program_full_path, 0, sizeof(program_full_path));
* $PATH isn't exported, you lose.
*/
#ifdef ALTSEP
- if (wcschr(calculate->program_name, SEP) || wcschr(calculate->program_name, ALTSEP))
+ if (wcschr(main_config->program_name, SEP) ||
+ wcschr(main_config->program_name, ALTSEP))
#else
- if (wcschr(calculate->program_name, SEP))
+ if (wcschr(main_config->program_name, SEP))
#endif
{
- wcsncpy(program_full_path, calculate->program_name, MAXPATHLEN);
+ wcsncpy(program_full_path, main_config->program_name, MAXPATHLEN);
}
else if (calculate->path_env) {
wchar_t *path = calculate->path_env;
}
/* join() is safe for MAXPATHLEN+1 size buffer */
- join(program_full_path, calculate->program_name);
+ join(program_full_path, main_config->program_name);
if (exists(program_full_path)) {
break;
}
const _PyMainInterpreterConfig *main_config)
{
calculate->home = main_config->home;
- calculate->module_search_path_env = main_config->module_search_path_env;
- calculate->program_name = main_config->program_name;
-
calculate->path_env = _wgetenv(L"PATH");
}
static _PyInitError
-calculate_module_search_path(PyCalculatePath *calculate, _PyPathConfig *config, wchar_t *prefix)
+calculate_module_search_path(const _PyMainInterpreterConfig *main_config,
+ PyCalculatePath *calculate, _PyPathConfig *config,
+ wchar_t *prefix)
{
int skiphome = calculate->home==NULL ? 0 : 1;
#ifdef Py_ENABLE_SHARED
#endif
/* We only use the default relative PYTHONPATH if we haven't
anything better to use! */
- int skipdefault = (calculate->module_search_path_env!=NULL || calculate->home!=NULL || \
+ int skipdefault = (main_config->module_search_path_env!=NULL || calculate->home!=NULL || \
calculate->machine_path!=NULL || calculate->user_path!=NULL);
/* We need to construct a path from the following parts.
bufsz += wcslen(calculate->machine_path) + 1;
}
bufsz += wcslen(calculate->zip_path) + 1;
- if (calculate->module_search_path_env != NULL) {
- bufsz += wcslen(calculate->module_search_path_env) + 1;
+ if (main_config->module_search_path_env != NULL) {
+ bufsz += wcslen(main_config->module_search_path_env) + 1;
}
wchar_t *buf, *start_buf;
if (buf == NULL) {
/* We can't exit, so print a warning and limp along */
fprintf(stderr, "Can't malloc dynamic PYTHONPATH.\n");
- if (calculate->module_search_path_env) {
+ if (main_config->module_search_path_env) {
fprintf(stderr, "Using environment $PYTHONPATH.\n");
- config->module_search_path = calculate->module_search_path_env;
+ config->module_search_path = main_config->module_search_path_env;
}
else {
fprintf(stderr, "Using default static path.\n");
}
start_buf = buf;
- if (calculate->module_search_path_env) {
- if (wcscpy_s(buf, bufsz - (buf - start_buf), calculate->module_search_path_env)) {
+ if (main_config->module_search_path_env) {
+ if (wcscpy_s(buf, bufsz - (buf - start_buf), main_config->module_search_path_env)) {
return INIT_ERR_BUFFER_OVERFLOW();
}
buf = wcschr(buf, L'\0');
static _PyInitError
-calculate_path_impl(PyCalculatePath *calculate, _PyPathConfig *config,
- const _PyMainInterpreterConfig *main_config)
+calculate_path_impl(const _PyMainInterpreterConfig *main_config,
+ PyCalculatePath *calculate, _PyPathConfig *config)
{
_PyInitError err;
return err;
}
- err = get_program_full_path(calculate, config);
+ err = get_program_full_path(main_config, calculate, config);
if (_Py_INIT_FAILED(err)) {
return err;
}
calculate_home_prefix(calculate, prefix);
- err = calculate_module_search_path(calculate, config, prefix);
+ err = calculate_module_search_path(main_config, calculate, config, prefix);
if (_Py_INIT_FAILED(err)) {
return err;
}
_PyPathConfig new_path_config;
memset(&new_path_config, 0, sizeof(new_path_config));
- err = calculate_path_impl(&calculate, &new_path_config, main_config);
+ err = calculate_path_impl(main_config, &calculate, &new_path_config);
if (_Py_INIT_FAILED(err)) {
goto done;
}
_PyMainInterpreterConfig config = _PyMainInterpreterConfig_INIT;
err = _PyMainInterpreterConfig_ReadEnv(&config);
- if (!_Py_INIT_FAILED(err)) {
- err = _PyPathConfig_Init(&config);
+ if (_Py_INIT_FAILED(err)) {
+ goto error;
+ }
+
+ err = _PyMainInterpreterConfig_Read(&config);
+ if (_Py_INIT_FAILED(err)) {
+ goto error;
}
- _PyMainInterpreterConfig_Clear(&config);
+ err = _PyPathConfig_Init(&config);
if (_Py_INIT_FAILED(err)) {
- _Py_FatalInitError(err);
+ goto error;
}
+
+ _PyMainInterpreterConfig_Clear(&config);
+ return;
+
+error:
+ _PyMainInterpreterConfig_Clear(&config);
+ _Py_FatalInitError(err);
}
projects / python / commitdiff