import com.intellij.execution.process.BaseOSProcessHandler; //导入依赖的package包/类
@Override
public void attach(@NotNull ProcessHandler processHandler)
{
	processHandler.putUserData(KEY, this);
	execute(() ->
	{
		int pid = -1;
		if(SystemInfo.isUnix && processHandler instanceof BaseOSProcessHandler)
		{
			pid = OSProcessUtil.getProcessID(((BaseOSProcessHandler) processHandler).getProcess());
		}
		synchronized(myLock)
		{
			myPid = pid;
		}
	});
}
 

import com.intellij.execution.process.BaseOSProcessHandler; //导入依赖的package包/类
protected static Future<?> executeOnPooledThread(Runnable task)
{
	final Application application = ApplicationManager.getApplication();

	if(application != null)
	{
		return application.executeOnPooledThread(task);
	}

	return BaseOSProcessHandler.ExecutorServiceHolder.submit(task);
}
 

import com.intellij.execution.process.BaseOSProcessHandler; //导入依赖的package包/类
private void compileFile(final CompileContext context, ModuleBuildTarget target, List<String> line, File source, File dir)
  throws StopBuildException {
  final JpsModule module = target.getModule();
  List<String> cmdLine = new ArrayList<String>(line);
  cmdLine.add(source.getAbsolutePath());

  StringBuilder cmdMessage = new StringBuilder();
  for (String cmdPart : cmdLine) {
    cmdMessage.append(cmdPart).append(' ');
  }

  context.processMessage(
    new CompilerMessage(getPresentableName(), BuildMessage.Kind.INFO, cmdMessage.toString())
  );

  try {
    Process process = new ProcessBuilder()
      .command(cmdLine)
      .start();


    BaseOSProcessHandler handler = new BaseOSProcessHandler(process, StringUtil.join(cmdLine, " "), CharsetToolkit.UTF8_CHARSET);

    final AtomicBoolean hasErrors = new AtomicBoolean();
    handler.addProcessListener(new ThriftOutputConsumer(source.getAbsolutePath(), context, hasErrors, module, dir));
    handler.startNotify();
    handler.waitFor();
    if (hasErrors.get()) {
      throw new StopBuildException();
    }
  }
  catch (IOException e) {
    context.processMessage(
      new CompilerMessage(getPresentableName(), BuildMessage.Kind.ERROR, "Failed to translate files . Error: " + e.getMessage())
    );
  }
}
 

import com.intellij.execution.process.BaseOSProcessHandler; //导入依赖的package包/类
public static void handleDexCompilationResult(@NotNull Process process,
                                              @NotNull String outputFilePath,
                                              @NotNull final Map<AndroidCompilerMessageKind, List<String>> messages, boolean multiDex) {
  final BaseOSProcessHandler handler = new BaseOSProcessHandler(process, null, null);
  handler.addProcessListener(new ProcessAdapter() {
    private AndroidCompilerMessageKind myCategory = null;

    @Override
    public void onTextAvailable(ProcessEvent event, Key outputType) {
      String[] msgs = event.getText().split("\\n");
      for (String msg : msgs) {
        msg = msg.trim();
        String msglc = msg.toLowerCase();
        if (outputType == ProcessOutputTypes.STDERR) {
          if (WARNING_PATTERN.matcher(msglc).matches()) {
            myCategory = AndroidCompilerMessageKind.WARNING;
          }
          if (ERROR_PATTERN.matcher(msglc).matches() || EXCEPTION_PATTERN.matcher(msglc).matches() || myCategory == null) {
            myCategory = AndroidCompilerMessageKind.ERROR;
          }
          messages.get(myCategory).add(msg);
        }
        else if (outputType == ProcessOutputTypes.STDOUT) {
          if (!msglc.startsWith("processing")) {
            messages.get(AndroidCompilerMessageKind.INFORMATION).add(msg);
          }
        }

        LOG.debug(msg);
      }
    }
  });

  handler.startNotify();
  handler.waitFor();

  final List<String> errors = messages.get(AndroidCompilerMessageKind.ERROR);

  if (new File(outputFilePath).isFile()) {
    // if compilation finished correctly, show all errors as warnings
    messages.get(AndroidCompilerMessageKind.WARNING).addAll(errors);
    errors.clear();
  }
  else if (errors.size() == 0 && !multiDex) {
    errors.add("Cannot create classes.dex file");
  }
}
 

import com.intellij.execution.process.BaseOSProcessHandler; //导入依赖的package包/类
@Override
public GroovycContinuation runGroovyc(Collection<String> compilationClassPath,
                                      boolean forStubs,
                                      JpsGroovySettings settings,
                                      File tempFile,
                                      final GroovycOutputParser parser)
  throws Exception {
  List<String> classpath = new ArrayList<String>();
  if (myOptimizeClassLoading) {
    classpath.addAll(GroovyBuilder.getGroovyRtRoots());
    classpath.add(ClasspathBootstrap.getResourcePath(Function.class));
    classpath.add(ClasspathBootstrap.getResourcePath(UrlClassLoader.class));
    classpath.add(ClasspathBootstrap.getResourceFile(THashMap.class).getPath());
  } else {
    classpath.addAll(compilationClassPath);
  }

  List<String> vmParams = ContainerUtilRt.newArrayList();
  vmParams.add("-Xmx" + System.getProperty("groovyc.heap.size", settings.heapSize) + "m");
  vmParams.add("-Dfile.encoding=" + System.getProperty("file.encoding"));
  //vmParams.add("-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5239");
  
  if ("false".equals(System.getProperty(GroovyRtConstants.GROOVYC_ASM_RESOLVING_ONLY))) {
    vmParams.add("-D" + GroovyRtConstants.GROOVYC_ASM_RESOLVING_ONLY + "=false");
  }
  String configScript = settings.configScript;
  if (StringUtil.isNotEmpty(configScript)) {
    vmParams.add("-D" + GroovyRtConstants.GROOVYC_CONFIG_SCRIPT + "=" + configScript);
  }

  String grapeRoot = System.getProperty(GroovycOutputParser.GRAPE_ROOT);
  if (grapeRoot != null) {
    vmParams.add("-D" + GroovycOutputParser.GRAPE_ROOT + "=" + grapeRoot);
  }

  final List<String> cmd = ExternalProcessUtil.buildJavaCommandLine(
    getJavaExecutable(myChunk),
    "org.jetbrains.groovy.compiler.rt.GroovycRunner",
    Collections.<String>emptyList(), classpath,
    vmParams,
    getProgramParams(tempFile, settings, forStubs)
  );
  final Process process = Runtime.getRuntime().exec(ArrayUtil.toStringArray(cmd));
  ProcessHandler handler = new BaseOSProcessHandler(process, null, null) {
    @Override
    protected Future<?> executeOnPooledThread(Runnable task) {
      return SharedThreadPool.getInstance().executeOnPooledThread(task);
    }

    @Override
    public void notifyTextAvailable(String text, Key outputType) {
      parser.notifyTextAvailable(text, outputType);
    }
  };

  handler.startNotify();
  handler.waitFor();
  parser.notifyFinished(process.exitValue());
  return null;
}
 

import com.intellij.execution.process.BaseOSProcessHandler; //导入依赖的package包/类
public ExternalJavacDescriptor(BaseOSProcessHandler process, JavacServerClient client) {
  this.process = process;
  this.client = client;
}
 

import com.intellij.execution.process.BaseOSProcessHandler; //导入依赖的package包/类
/**
 * Runs {@link IgnoreLanguage} executable with the given command and current working directory.
 *
 * @param language  current language
 * @param command   to call
 * @param directory current working directory
 * @param parser    {@link ExecutionOutputParser} implementation
 * @param <T>       return type
 * @return result of the call
 */
@Nullable
private static <T> ArrayList<T> run(@NotNull IgnoreLanguage language,
                                    @NotNull String command,
                                    @Nullable VirtualFile directory,
                                    @Nullable final ExecutionOutputParser<T> parser) {
    final String bin = bin(language);
    if (bin == null) {
        return null;
    }

    try {
        final String cmd = bin + " " + command;
        final File workingDirectory = directory != null ? new File(directory.getPath()) : null;
        final Process process = Runtime.getRuntime().exec(cmd, null, workingDirectory);

        ProcessHandler handler = new BaseOSProcessHandler(process, StringUtil.join(cmd, " "), null) {
            @NotNull
            @Override
            protected Future<?> executeOnPooledThread(@NotNull Runnable task) {
                return SharedThreadPool.getInstance().executeOnPooledThread(task);
            }

            @Override
            public void notifyTextAvailable(String text, Key outputType) {
                if (parser != null) {
                    parser.onTextAvailable(text, outputType);
                }
            }
        };

        handler.startNotify();
        if (!handler.waitFor(DEFAULT_TIMEOUT)) {
            return null;
        }
        if (parser != null) {
            parser.notifyFinished(process.exitValue());
            if (parser.isErrorsReported()) {
                return null;
            }
            return parser.getOutput();
        }
    } catch (IOException ignored) {
    }

    return null;
}