private void configureConfiguration(SimpleJavaParameters parameters, XQueryRunConfiguration configuration) {
    ProgramParametersUtil.configureConfiguration(parameters, configuration);

    Project project = configuration.getProject();
    Module module = getModule(configuration);
    ;

    String alternativeJrePath = configuration.getAlternativeJrePath();
    if (alternativeJrePath != null) {
        configuration.setAlternativeJrePath(expandPath(alternativeJrePath, null, project));
    }

    String vmParameters = configuration.getVMParameters();
    if (vmParameters != null) {
        vmParameters = expandPath(vmParameters, module, project);

        for (Map.Entry<String, String> each : parameters.getEnv().entrySet()) {
            vmParameters = StringUtil.replace(vmParameters, "$" + each.getKey() + "$", each.getValue(), false);
        }
    }

    parameters.getVMParametersList().addParametersString(vmParameters);
}
 

private void configureModule(final RunConfigurationModule runConfigurationModule,
                             final SimpleJavaParameters parameters,
                             @Nullable String jreHome) throws CantRunException {
    Module module = runConfigurationModule.getModule();
    if (module == null) {
        throw CantRunException.noModuleConfigured(runConfigurationModule.getModuleName());
    }
    configureByModule(parameters, module, createModuleJdk(module, jreHome));
}
 

private void configureByModule(SimpleJavaParameters parameters, final Module module, final Sdk jdk) throws CantRunException {
    if (jdk == null) {
        throw CantRunException.noJdkConfigured();
    }
    parameters.setJdk(jdk);
    setDefaultCharset(parameters, module.getProject());
    configureEnumerator(OrderEnumerator.orderEntries(module).runtimeOnly().recursively(), jdk).collectPaths(parameters.getClassPath());
}
 

private SimpleJavaParameters prepareRunnerParameters() throws CantRunException {
    final SimpleJavaParameters parameters = new SimpleJavaParameters();
    parameters.setMainClass(configuration.getRunClass());
    boolean isDebugging = getEnvironment().getExecutor().getId().equals(DefaultDebugExecutor.EXECUTOR_ID);
    parameters.getProgramParametersList().prepend(getSerializedConfig(configuration, isDebugging, port).getAbsolutePath());
    parameters.getClassPath().addFirst(new XQueryRunnerClasspathEntryGenerator().generateRunnerClasspathEntries(configuration));
    return parameters;
}
 

private static void appendParamsEncodingClasspath(SimpleJavaParameters javaParameters,
                                                  GeneralCommandLine commandLine,
                                                  ParametersList parametersList) {
  commandLine.addParameters(parametersList.getList());
  appendEncoding(javaParameters, commandLine, parametersList);
  if (!parametersList.hasParameter("-classpath") && !parametersList.hasParameter("-cp")){
    commandLine.addParameter("-classpath");
    commandLine.addParameter(javaParameters.getClassPath().getPathsString());
  }
}
 

public static GeneralCommandLine createFromJavaParameters(final SimpleJavaParameters javaParameters,
                                                          final Project project,
                                                          final boolean dynamicClasspath) throws CantRunException {
    return createFromJavaParameters(javaParameters, dynamicClasspath && JdkUtil.useDynamicClasspath(project));
}
 

@Override
public void enhanceRemoteProcessing(@NotNull SimpleJavaParameters parameters) {
  parameters.getVMParametersList().addProperty(
    ExternalSystemConstants.EXTERNAL_SYSTEM_ID_KEY, PantsConstants.SYSTEM_ID.getId()
  );
}
 

private SimpleJavaParameters getJavaParameters() throws ExecutionException {
    if (myParams == null) {
        myParams = createJavaParameters();
    }
    return myParams;
}
 

private SimpleJavaParameters createJavaParameters() throws ExecutionException {
    final SimpleJavaParameters parameters = prepareRunnerParameters();
    configureJreRelatedParameters(parameters);
    return parameters;
}
 

private void configureJreRelatedParameters(SimpleJavaParameters parameters) throws CantRunException {
    final RunConfigurationModule module = configuration.getConfigurationModule();
    final String jreHome = configuration.isAlternativeJrePathEnabled() ? configuration.getAlternativeJrePath() : null;
    configureModule(module, parameters, jreHome);
    configureConfiguration(parameters, configuration);
}
 

private void setDefaultCharset(SimpleJavaParameters parameters, final Project project) {
    Charset encoding = EncodingProjectManager.getInstance(project).getDefaultCharset();
    parameters.setCharset(encoding);
}
 

private GeneralCommandLine createFromJavaParameters(final SimpleJavaParameters javaParameters,
                                                    final Project project) throws CantRunException {
    return createFromJavaParameters(javaParameters, JdkUtil.useDynamicClasspath(project));
}
 

/**
 * Our recommended practice is to work with third-party api from external process in order to avoid potential problems with
 * the whole ide process. For example, the api might contain a memory leak which crashed the whole process etc.
 * <p/>
 * This method is a callback which allows particular external system integration to adjust that external process
 * settings. Most of the time that means classpath adjusting.
 *
 * @param parameters  parameters to be applied to the slave process which will be used for external system communication
 */
void enhanceRemoteProcessing(@Nonnull SimpleJavaParameters parameters) throws ExecutionException;