Java GeneralCommandLine.withParentEnvironmentType方法代码示例

import com.intellij.execution.configurations.GeneralCommandLine; //导入方法依赖的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.execution.configurations.GeneralCommandLine; //导入方法依赖的package包/类
protected synchronized void execute(GeneralCommandLine commandLine) throws AuthenticationException {
  try {
    commandLine.withParentEnvironmentType(ParentEnvironmentType.CONSOLE);
    myProcess = commandLine.createProcess();

    myErrThread = new ReadProcessThread(
      new BufferedReader(new InputStreamReader(myProcess.getErrorStream(), EncodingManager.getInstance().getDefaultCharset()))) {
      protected void textAvailable(String s) {
        myErrorText.append(s);
        myErrorRegistry.registerError(s);
        myContainsError = true;
      }
    };
    final Application application = ApplicationManager.getApplication();
    myStdErrFuture = application.executeOnPooledThread(myErrThread);

    myInputStream = myProcess.getInputStream();
    myOutputStream = myProcess.getOutputStream();

    waitForProcess(application);
  }
  catch (Exception e) {
    closeInternal();
    throw new AuthenticationException(e.getLocalizedMessage(), e);
  }
}
 

import com.intellij.execution.configurations.GeneralCommandLine; //导入方法依赖的package包/类
public void configureCommandLine(@NotNull GeneralCommandLine commandLine, boolean consoleParentEnvs) {
  if (myPassParentEnvs) {
    commandLine.withParentEnvironmentType(consoleParentEnvs ? GeneralCommandLine.ParentEnvironmentType.CONSOLE
                                                            : GeneralCommandLine.ParentEnvironmentType.SYSTEM);
  }
  else {
    commandLine.withParentEnvironmentType(GeneralCommandLine.ParentEnvironmentType.NONE);
  }
  commandLine.withEnvironment(myEnvs);
}
 

import com.intellij.execution.configurations.GeneralCommandLine; //导入方法依赖的package包/类
public static GeneralCommandLine setupJVMCommandLine(final String exePath,
                                                     final SimpleJavaParameters javaParameters,
                                                     final boolean forceDynamicClasspath) {
  final GeneralCommandLine commandLine = new GeneralCommandLine(exePath);

  final ParametersList vmParametersList = javaParameters.getVMParametersList();
  commandLine.withEnvironment(javaParameters.getEnv());
  commandLine.withParentEnvironmentType(javaParameters.isPassParentEnvs() ? ParentEnvironmentType.CONSOLE : ParentEnvironmentType.NONE);

  final Class commandLineWrapper;
  if ((commandLineWrapper = getCommandLineWrapperClass()) != null) {
    if (forceDynamicClasspath && !vmParametersList.hasParameter("-classpath") && !vmParametersList.hasParameter("-cp")) {
      if (isClassPathJarEnabled(javaParameters, PathUtil.getJarPathForClass(ClassPath.class))) {
        appendJarClasspathParams(javaParameters, commandLine, vmParametersList, commandLineWrapper);
      }
      else {
        appendOldCommandLineWrapper(javaParameters, commandLine, vmParametersList, commandLineWrapper);
      }
    }
    else {
      appendParamsEncodingClasspath(javaParameters, commandLine, vmParametersList);
    }
  }
  else {
    appendParamsEncodingClasspath(javaParameters, commandLine, vmParametersList);
  }

  final String mainClass = javaParameters.getMainClass();
  final String jarPath = javaParameters.getJarPath();
  if (mainClass != null) {
    commandLine.addParameter(mainClass);
  }
  else if (jarPath != null) {
    commandLine.addParameter("-jar");
    commandLine.addParameter(jarPath);
  }

  commandLine.addParameters(javaParameters.getProgramParametersList().getList());

  commandLine.withWorkDirectory(javaParameters.getWorkingDirectory());

  return commandLine;
}
 

import com.intellij.execution.configurations.GeneralCommandLine; //导入方法依赖的package包/类
@Override
public CidrDebugProcess createDebugProcess(CommandLineState state, XDebugSession session)
    throws ExecutionException {
  TargetExpression target = configuration.getTarget();
  if (target == null) {
    throw new ExecutionException("Cannot parse run configuration target.");
  }
  if (runner.executableToDebug == null) {
    throw new ExecutionException("No debug binary found.");
  }
  WorkspaceRoot workspaceRoot = WorkspaceRoot.fromProject(project);

  GeneralCommandLine commandLine = new GeneralCommandLine(runner.executableToDebug.getPath());
  File workingDir = workspaceRoot.directory();
  commandLine.setWorkDirectory(workingDir);
  commandLine.addParameters(handlerState.getExeFlagsState().getExpandedFlags());

  EnvironmentVariablesData envState = handlerState.getEnvVarsState().getData();
  commandLine.withParentEnvironmentType(
      envState.isPassParentEnvs() ? ParentEnvironmentType.SYSTEM : ParentEnvironmentType.NONE);
  commandLine.getEnvironment().putAll(envState.getEnvs());

  String testPrefix = "--gtest";
  if (Blaze.getBuildSystem(project).equals(BuildSystem.Blaze)) {
    testPrefix = "--gunit";
  }
  // Disable colored output, to workaround parsing bug (CPP-10054)
  // Note: cc_test runner currently only supports GUnit tests.
  if (Kind.CC_TEST.equals(configuration.getTargetKind())) {
    commandLine.addParameter(testPrefix + "_color=no");
  }

  String testFilter = convertToGUnitTestFilter(handlerState.getTestFilterFlag(), testPrefix);
  if (testFilter != null) {
    commandLine.addParameter(testFilter);
  }

  TrivialInstaller installer = new TrivialInstaller(commandLine);
  ImmutableList<String> startupCommands = getGdbStartupCommands(workingDir);
  CLionRunParameters parameters =
      new CLionRunParameters(
          new BlazeGDBDriverConfiguration(project, startupCommands, workspaceRoot), installer);

  state.setConsoleBuilder(createConsoleBuilder(null));
  state.addConsoleFilters(getConsoleFilters().toArray(new Filter[0]));
  return new CidrLocalDebugProcess(parameters, session, state.getConsoleBuilder());
}