import com.intellij.util.EnvironmentUtil; //导入依赖的package包/类
/**
 * Creates process builder and setups it's commandLine, working directory, environment variables
 *
 * @param workingDir         Process working dir
 * @param executablePath     Path to executable file
 * @param arguments          Process commandLine  @return process builder
 */
public static GeneralCommandLine createAndSetupCmdLine(@Nullable final String workingDir,
                                                       @Nullable final Map<String, String> userDefinedEnv,
                                                       final boolean passParentEnv,
                                                       @NotNull final String executablePath,
                                                       @NotNull final String... arguments) {
  GeneralCommandLine cmdLine = new GeneralCommandLine();

  cmdLine.setExePath(toSystemDependentName(executablePath));

  if (workingDir != null) {
    cmdLine.setWorkDirectory(toSystemDependentName(workingDir));
  }

  cmdLine.addParameters(arguments);

  cmdLine.withParentEnvironmentType(passParentEnv ? ParentEnvironmentType.CONSOLE : ParentEnvironmentType.NONE);
  cmdLine.withEnvironment(userDefinedEnv);
  //Inline parent env variables occurrences
  EnvironmentUtil.inlineParentOccurrences(cmdLine.getEnvironment());

  return cmdLine;
}
 

import com.intellij.util.EnvironmentUtil; //导入依赖的package包/类
/**
 * A constructor
 *
 * @param project   a project
 * @param directory a process directory
 * @param command   a command to execute (if empty string, the parameter is ignored)
 */
protected GitHandler(@NotNull Project project, @NotNull File directory, @NotNull GitCommand command) {
  myProject = project;
  myCommand = command;
  myAppSettings = GitVcsApplicationSettings.getInstance();
  myProjectSettings = GitVcsSettings.getInstance(myProject);
  myEnv = new HashMap<String, String>(EnvironmentUtil.getEnvironmentMap());
  myVcs = ObjectUtils.assertNotNull(GitVcs.getInstance(project));
  myWorkingDirectory = directory;
  myCommandLine = new GeneralCommandLine();
  if (myAppSettings != null) {
    myCommandLine.setExePath(myAppSettings.getPathToGit());
  }
  myCommandLine.setWorkDirectory(myWorkingDirectory);
  if (GitVersionSpecialty.CAN_OVERRIDE_GIT_CONFIG_FOR_COMMAND.existsIn(myVcs.getVersion())) {
    myCommandLine.addParameters("-c", "core.quotepath=false");
  }
  myCommandLine.addParameter(command.name());
  myStdoutSuppressed = true;
  mySilent = myCommand.lockingPolicy() == GitCommand.LockingPolicy.READ;
}
 

import com.intellij.util.EnvironmentUtil; //导入依赖的package包/类
@NotNull
@Override
protected Map<String, String> compute() {
  Map<String, String> cvsEnv = new HashMap<String, String>();

  Map<String, String> knownToCvs = EnvironmentUtil.getEnvironmentMap();
  @SuppressWarnings("SpellCheckingInspection") String[] toCvs = {
    "CVSIGNORE", "CVSWRAPPERS", "CVSREAD", "CVSREADONLYFS", "CVSUMASK",
    "CVSROOT", "CVSEDITOR", "EDITOR", "VISUAL", "PATH", "HOME", "HOMEPATH", "HOMEDRIVE", "CVS_RSH", "CVS_SERVER",
    "CVS_PASSFILE", "CVS_CLIENT_PORT", "CVS_PROXY_PORT", "CVS_RCMD_PORT", "CVS_CLIENT_LOG",
    "CVS_SERVER_SLEEP", "CVS_IGNORE_REMOTE_ROOT", "CVS_LOCAL_BRANCH_NUM", "COMSPEC", "TMPDIR",
    "CVS_PID", "COMSPEC", "CVS_VERIFY_TEMPLATE", "CVS_NOBASES", "CVS_SIGN_COMMITS", "CVS_VERIFY_CHECKOUTS"
  };
  for (String name : toCvs) {
    String value = knownToCvs.get(name);
    if (value != null) {
      cvsEnv.put(name, value);
    }
  }

  return cvsEnv;
}
 

import com.intellij.util.EnvironmentUtil; //导入依赖的package包/类
private void updateSshTunnelDependentValues(@Nullable String tunnelSetting) {
  String svnSshVariableName = SshTunnelRuntimeModule.getSvnSshVariableName(
    !StringUtil.isEmpty(tunnelSetting) ? tunnelSetting : SshTunnelRuntimeModule.DEFAULT_SSH_TUNNEL_VALUE);
  String svnSshVariableValue = StringUtil.notNullize(EnvironmentUtil.getValue(svnSshVariableName));

  mySvnSshVariableLabel.setText(svnSshVariableName + ":");
  mySvnSshVariableField.setText(svnSshVariableValue);

  boolean isSvnSshVariableNameInTunnel = !StringUtil.isEmpty(svnSshVariableName);
  mySvnSshVariableLabel.setVisible(isSvnSshVariableNameInTunnel);
  mySvnSshVariableField.setVisible(isSvnSshVariableNameInTunnel);

  myExecutablePathTextField.getEmptyText().setText(SshTunnelRuntimeModule.getExecutablePath(tunnelSetting));

  setUpdateTunnelButtonEnabled(tunnelSetting);
}
 

import com.intellij.util.EnvironmentUtil; //导入依赖的package包/类
private static GaugeSettingsModel getSettingsFromPATH(GaugeSettingsModel model) throws GaugeNotFoundException {
    String path = EnvironmentUtil.getValue("PATH");
    LOG.info("PATH => " + path);
    if (!StringUtils.isEmpty(path)) {
        for (String entry : path.split(File.pathSeparator)) {
            File file = new File(entry, gaugeExecutable());
            if (isValidGaugeExec(file)) {
                LOG.info("executable path from `PATH`: " + file.getAbsolutePath());
                return new GaugeSettingsModel(file.getAbsolutePath(), model.getHomePath(), model.useIntelliJTestRunner());
            }
        }
    }
    String msg = "Could not find executable in `PATH`. Please make sure Gauge is installed." +
            "\nIf Gauge is installed then set the Gauge executable path in settings -> tools -> gauge.";
    throw new GaugeNotFoundException(msg);
}
 

import com.intellij.util.EnvironmentUtil; //导入依赖的package包/类
@NotNull
public Process launchProcess(@NotNull final ModuleChunk chunk, @NotNull final String outputDir, @NotNull final CompileContext compileContext) throws IOException {
  final String[] commands = createStartupCommand(chunk, compileContext, outputDir);

  if (LOG.isDebugEnabled()) {
    @NonNls final StringBuilder buf = StringBuilderSpinAllocator.alloc();
    try {
      buf.append("\n===================================Environment:===========================\n");
      for (String pair : EnvironmentUtil.getEnvironment()) {
        buf.append("\t").append(pair).append("\n");
      }
      buf.append("=============================================================================\n");
      buf.append("Running compiler: ");
      for (final String command : commands) {
        buf.append(" ").append(command);
      }

      LOG.debug(buf.toString());
    }
    finally {
      StringBuilderSpinAllocator.dispose(buf);
    }
  }

  return Runtime.getRuntime().exec(commands);
}
 

import com.intellij.util.EnvironmentUtil; //导入依赖的package包/类
void setupEnvironment(final Map<String, String> environment) {
  environment.clear();

  if (myPassParentEnvironment) {
    environment.putAll(EnvironmentUtil.getEnvironmentMap());
  }

  if (!myEnvParams.isEmpty()) {
    if (SystemInfo.isWindows) {
      THashMap<String, String> envVars = new THashMap<String, String>(CaseInsensitiveStringHashingStrategy.INSTANCE);
      envVars.putAll(environment);
      envVars.putAll(myEnvParams);
      environment.clear();
      environment.putAll(envVars);
    }
    else {
      environment.putAll(myEnvParams);
    }
  }
}
 

import com.intellij.util.EnvironmentUtil; //导入依赖的package包/类
private static void setupJavaPath(List<EnvironmentVariable> vars, String varName, String jrePath)
{
	if(jrePath != null)
	{
		vars.add(new EnvironmentVariable(varName, jrePath, true));
	}
	else
	{
		String envValue = EnvironmentUtil.getValue(varName);

		if(envValue != null)
		{
			vars.add(new EnvironmentVariable(varName, envValue, true));
		}
	}
}
 

import com.intellij.util.EnvironmentUtil; //导入依赖的package包/类
public void configureConfiguration(SimpleProgramParameters parameters, CommonProgramRunConfigurationParameters configuration) {
  Project project = configuration.getProject();
  Module module = getModule(configuration);

  parameters.getProgramParametersList().addParametersString(expandPath(configuration.getProgramParameters(), module, project));

  parameters.setWorkingDirectory(getWorkingDir(configuration, project, module));

  Map<String, String> envs = new HashMap<>(configuration.getEnvs());
  EnvironmentUtil.inlineParentOccurrences(envs);
  for (Map.Entry<String, String> each : envs.entrySet()) {
    each.setValue(expandPath(each.getValue(), module, project));
  }

  parameters.setEnv(envs);
  parameters.setPassParentEnvs(configuration.isPassParentEnvs());
}
 

import com.intellij.util.EnvironmentUtil; //导入依赖的package包/类
@Override
@NotNull
public Process launchProcess(@NotNull final ModuleChunk chunk, @NotNull final String outputDir, @NotNull final CompileContext compileContext) throws IOException
{
	final GeneralCommandLine commandLine = createStartupCommand(chunk, compileContext, outputDir);

	StringBuilder buf = new StringBuilder();
	buf.append("\n===================================Environment:===========================\n");
	for(String pair : EnvironmentUtil.getEnvironment())
	{
		buf.append("\t").append(pair).append("\n");
	}
	buf.append("=============================================================================\n");
	buf.append("Running compiler: ").append(commandLine);

	LOG.info(buf.toString());

	try
	{
		return commandLine.createProcess();
	}
	catch(ExecutionException e)
	{
		throw new IOException(e);
	}
}
 

import com.intellij.util.EnvironmentUtil; //导入依赖的package包/类
@Test
public void testLinuxPathEnv() {
    System.out.println("System PATH env:" + System.getenv("PATH"));
    System.out.println("System PATH env by IDEA:" + EnvironmentUtil.getValue("PATH"));
    System.out.println("JAVA_HOME:" + System.getenv("JAVA_HOME"));
    System.out.println("adb:" + RNPathUtil.getExecuteFullPathSingle("adb"));
}
 

import com.intellij.util.EnvironmentUtil; //导入依赖的package包/类
/**
 * Calculate git's path.
 *
 * @return path of the git executable, including the executable name.
 */
@Nullable
private String findGitExePath() {

    if (StringUtil.isNotEmpty(gitPathCache)) {
        return gitPathCache;
    }

    String path = EnvironmentUtil.getValue("PATH");
    if (StringUtil.isEmpty(path)) {
        return null;
    }

    String[] dirs;
    if (SystemInfo.isWindows) {
        dirs = path.split(";");
    } else {
        dirs = path.split(":");
    }

    for (String dir : dirs) {
        String filename;
        if (SystemInfo.isWindows) {
            filename = dir + "/git.exe";
        } else {
            filename = dir + "/git";
        }
        File file = new File(filename);
        if (file.exists() && file.isFile()) {
            gitPathCache = filename;
            return gitPathCache;
        }
    }

    return null;
}
 

import com.intellij.util.EnvironmentUtil; //导入依赖的package包/类
@NotNull
private static List<File> listNodeInterpretersFromNvm(String exeFileName) {
    String nvmDirPath = EnvironmentUtil.getValue("NVM_DIR");
    if (StringUtil.isEmpty(nvmDirPath)) {
        return Collections.emptyList();
    }
    File nvmDir = new File(nvmDirPath);
    if (nvmDir.isDirectory() && nvmDir.isAbsolute()) {
        return listNodeInterpretersFromVersionDir(nvmDir, exeFileName);
    }
    return Collections.emptyList();
}
 

import com.intellij.util.EnvironmentUtil; //导入依赖的package包/类
@NotNull
private static List<File> findExeFilesInPath(@NotNull String fileBaseName,
                                             boolean stopAfterFirstMatch,
                                             boolean logDetails,
                                             @Nullable FileFilter filter) {
  String systemPath = EnvironmentUtil.getValue(PATH_ENV_VAR_NAME);
  return doFindExeFilesInPath(systemPath, fileBaseName, stopAfterFirstMatch, logDetails, filter);
}
 

import com.intellij.util.EnvironmentUtil; //导入依赖的package包/类
/**
 * Returns an environment that will be passed to a child process.
 */
@NotNull
public Map<String, String> getParentEnvironment() {
  switch (myParentEnvironmentType) {
    case SYSTEM:
      return System.getenv();
    case CONSOLE:
      return EnvironmentUtil.getEnvironmentMap();
    default:
      return Collections.emptyMap();
  }
}
 

import com.intellij.util.EnvironmentUtil; //导入依赖的package包/类
private static void fixProcessEnvironment(Logger log) {
  if (!Main.isCommandLine()) {
    System.setProperty("__idea.mac.env.lock", "unlocked");
  }
  boolean envReady = EnvironmentUtil.isEnvironmentReady();  // trigger environment loading
  if (!envReady) {
    log.info("initializing environment");
  }
}
 

import com.intellij.util.EnvironmentUtil; //导入依赖的package包/类
public void setupEnvs(Map<String, String> envs, boolean passDefault) {
  if (!envs.isEmpty()) {
    final HashMap<String, String> map = new HashMap<String, String>(envs);
    EnvironmentUtil.inlineParentOccurrences(map);
    setEnv(map);
    setPassParentEnvs(passDefault);
  }
}
 

import com.intellij.util.EnvironmentUtil; //导入依赖的package包/类
@NotNull
public static String getSshTunnelValue(@Nullable String tunnelSetting) {
  tunnelSetting = !StringUtil.isEmpty(tunnelSetting) ? tunnelSetting : DEFAULT_SSH_TUNNEL_VALUE;
  String svnSshVariableName = getSvnSshVariableName(tunnelSetting);
  String svnSshVariableValue = EnvironmentUtil.getValue(svnSshVariableName);

  return !StringUtil.isEmpty(svnSshVariableValue)
         ? svnSshVariableValue
         : !StringUtil.isEmpty(svnSshVariableName) ? tunnelSetting.substring(1 + svnSshVariableName.length()) : tunnelSetting;
}
 

import com.intellij.util.EnvironmentUtil; //导入依赖的package包/类
@NotNull
public static List<File> listNodeInterpretersFromNvm(String exeFileName) {
    String nvmDirPath = EnvironmentUtil.getValue(NVM_DIR);
    if (StringUtil.isEmpty(nvmDirPath)) {
        return Collections.emptyList();
    }
    File nvmDir = new File(nvmDirPath);
    if (nvmDir.isDirectory() && nvmDir.isAbsolute()) {
        return listNodeInterpretersFromVersionDir(nvmDir, exeFileName);
    }
    return Collections.emptyList();
}
 

import com.intellij.util.EnvironmentUtil; //导入依赖的package包/类
@Override
protected List<EnvironmentVariable> getEnvironmentVariables(TomcatLocalModel tomcatModel)
{
	try
	{
		ArrayList<EnvironmentVariable> vars = new ArrayList<>();
		vars.add(new EnvironmentVariable("CATALINA_HOME", tomcatModel.getHomeDirectory(), true));
		vars.add(new EnvironmentVariable("CATALINA_BASE", tomcatModel.getBaseDirectoryPath(), true));
		String tmpDir = EnvironmentUtil.getValue(CATALINA_TMPDIR_ENV_PROPERTY);
		if(tmpDir == null)
		{
			vars.add(new EnvironmentVariable(CATALINA_TMPDIR_ENV_PROPERTY, getCatalinaTempDirectory(tomcatModel), true));
		}
		String[] javaEnvVars = {
				JAVA_HOME_ENV_PROPERTY,
				JRE_HOME_ENV_PROPERTY
		};
		String jrePath = tomcatModel.getJrePath();
		for(String varName : javaEnvVars)
		{
			setupJavaPath(vars, varName, jrePath);
		}

		return vars;
	}
	catch(RuntimeConfigurationException e)
	{
		LOG.error(e);
		return null;
	}
}