static void initializeSysFromGlobals()

in ext/Python/pylifecycle.cpp [278:378]
94 lines of code
9 McCabe index (conditional complexity)

static void initializeSysFromGlobals(Thread* thread) {
  HandleScope scope(thread);
  Runtime* runtime = thread->runtime();
  unique_c_ptr<char> path(OS::executablePath());
  Str executable(&scope, runtime->newStrFromCStr(path.get()));

  Object python_path_obj(&scope, NoneType::object());
  const wchar_t* explicitly_provided_module_search_path =
      Runtime::moduleSearchPath();
  bool has_explicitly_provided_module_search_path =
      explicitly_provided_module_search_path[0] != L'\0';
  if (has_explicitly_provided_module_search_path) {
    // TODO(T88306794): Instead of passing in the python path to initializeSys,
    // we should indicate that binary_location/../lib should not be included in
    // the search path when an explicit module search path is provided.
    Str python_path_str(
        &scope,
        newStrFromWideChar(thread, explicitly_provided_module_search_path));
    Str sep(&scope, SmallStr::fromCStr(":"));
    python_path_obj = strSplit(thread, python_path_str, sep, kMaxWord);
    CHECK(!python_path_obj.isError(),
          "Failed to calculate path provided by `Py_SetPath`.");
  } else {
    const char* python_path_cstr =
        Py_IgnoreEnvironmentFlag ? nullptr : std::getenv("PYTHONPATH");
    if (python_path_cstr != nullptr) {
      Str python_path_str(&scope, runtime->newStrFromCStr(python_path_cstr));
      Str sep(&scope, SmallStr::fromCStr(":"));
      python_path_obj = strSplit(thread, python_path_str, sep, kMaxWord);
      CHECK(!python_path_obj.isError(), "Failed to calculate PYTHONPATH");
    } else {
      python_path_obj = runtime->newList();
    }
  }
  List python_path(&scope, *python_path_obj);
  const char* warnoptions_cstr =
      Py_IgnoreEnvironmentFlag ? nullptr : std::getenv("PYTHONWARNINGS");
  Object warnoptions_obj(&scope, NoneType::object());
  if (warnoptions_cstr != nullptr) {
    Str warnoptions_str(&scope, runtime->newStrFromCStr(warnoptions_cstr));
    Str sep(&scope, SmallStr::fromCStr(","));
    warnoptions_obj = strSplit(thread, warnoptions_str, sep, kMaxWord);
  } else {
    warnoptions_obj = runtime->newList();
  }
  List warnoptions(&scope, *warnoptions_obj);
  Object option(&scope, NoneType::object());
  for (word i = 0, size = warn_options.size(); i < size; i++) {
    option = runtime->newStrFromCStr(warn_options[i]);
    runtime->listAdd(thread, warnoptions, option);
  }
  warn_options.release();

  const char* pycache_prefix_cstr =
      Py_IgnoreEnvironmentFlag ? nullptr : std::getenv("PYTHONPYCACHEPREFIX");
  if (pycache_prefix_cstr != nullptr) {
    Str pycache_prefix_str(&scope,
                           runtime->newStrFromCStr(pycache_prefix_cstr));
    setPycachePrefix(thread, pycache_prefix_str);
  }

  MutableTuple data(
      &scope, runtime->newMutableTuple(static_cast<word>(SysFlag::kNumFlags)));
  data.atPut(static_cast<word>(SysFlag::kDebug),
             SmallInt::fromWord(Py_DebugFlag));
  data.atPut(static_cast<word>(SysFlag::kInspect),
             SmallInt::fromWord(Py_InspectFlag));
  data.atPut(static_cast<word>(SysFlag::kInteractive),
             SmallInt::fromWord(Py_InteractiveFlag));
  data.atPut(static_cast<word>(SysFlag::kOptimize),
             SmallInt::fromWord(Py_OptimizeFlag));
  data.atPut(static_cast<word>(SysFlag::kDontWriteBytecode),
             SmallInt::fromWord(Py_DontWriteBytecodeFlag));
  data.atPut(static_cast<word>(SysFlag::kNoUserSite),
             SmallInt::fromWord(Py_NoUserSiteDirectory));
  data.atPut(static_cast<word>(SysFlag::kNoSite),
             SmallInt::fromWord(Py_NoSiteFlag));
  data.atPut(static_cast<word>(SysFlag::kIgnoreEnvironment),
             SmallInt::fromWord(Py_IgnoreEnvironmentFlag));
  data.atPut(static_cast<word>(SysFlag::kVerbose),
             SmallInt::fromWord(Py_VerboseFlag));
  data.atPut(static_cast<word>(SysFlag::kBytesWarning),
             SmallInt::fromWord(Py_BytesWarningFlag));
  data.atPut(static_cast<word>(SysFlag::kQuiet),
             SmallInt::fromWord(Py_QuietFlag));
  data.atPut(static_cast<word>(SysFlag::kHashRandomization),
             SmallInt::fromWord(Py_HashRandomizationFlag));
  data.atPut(static_cast<word>(SysFlag::kIsolated),
             SmallInt::fromWord(Py_IsolatedFlag));
  data.atPut(static_cast<word>(SysFlag::kDevMode), Bool::falseObj());
  data.atPut(static_cast<word>(SysFlag::kUTF8Mode),
             SmallInt::fromWord(Py_UTF8Mode));
  static_assert(static_cast<word>(SysFlag::kNumFlags) == 15,
                "unexpected flag count");
  Tuple flags_data(&scope, data.becomeImmutable());
  CHECK(initializeSys(thread, executable, python_path, flags_data, warnoptions,
                      /*extend_python_path_with_stdlib=*/
                      !has_explicitly_provided_module_search_path)
            .isNoneType(),
        "initializeSys() failed");
}