import com.intellij.util.execution.ParametersListUtil; //导入依赖的package包/类
public CompilerUIConfigurable(@NotNull final Project project) {
  myProject = project;

  myPatternLegendLabel.setText(XmlStringUtil.wrapInHtml(
                                 "Use <b>;</b> to separate patterns and <b>!</b> to negate a pattern. " +
                                 "Accepted wildcards: <b>?</b> &mdash; exactly one symbol; <b>*</b> &mdash; zero or more symbols; " +
                                 "<b>/</b> &mdash; path separator; <b>/**/</b> &mdash; any number of directories; " +
                                 "<i>&lt;dir_name&gt;</i>:<i>&lt;pattern&gt;</i> &mdash; restrict to source roots with the specified name"
  ));
  myPatternLegendLabel.setForeground(new JBColor(Gray._50, Gray._130));
  tweakControls(project);
  myVMOptionsField.getDocument().addDocumentListener(new DocumentAdapter() {
    protected void textChanged(DocumentEvent e) {
      mySharedVMOptionsField.setEnabled(e.getDocument().getLength() == 0);
      myHeapSizeField.setEnabled(ContainerUtil.find(ParametersListUtil.parse(myVMOptionsField.getText()), new Condition<String>() {
        @Override
        public boolean value(String s) {
          return StringUtil.startsWithIgnoreCase(s, "-Xmx");
        }
      }) == null);
    }
  });
}
 

import com.intellij.util.execution.ParametersListUtil; //导入依赖的package包/类
@NotNull
@Override
public List<String> getAdditionalParameters() {
  if (myCommandLineOptions == null) {
    if (myUseCustomProfile && myUserDataDirectoryPath != null) {
      return Collections.singletonList(USER_DATA_DIR_ARG + FileUtilRt.toSystemDependentName(myUserDataDirectoryPath));
    }
    else {
      return Collections.emptyList();
    }
  }

  List<String> cliOptions = ParametersListUtil.parse(myCommandLineOptions);
  if (myUseCustomProfile && myUserDataDirectoryPath != null) {
    cliOptions.add(USER_DATA_DIR_ARG + FileUtilRt.toSystemDependentName(myUserDataDirectoryPath));
  }
  return cliOptions;
}
 

import com.intellij.util.execution.ParametersListUtil; //导入依赖的package包/类
@NotNull
private static Map<String, String> getMavenOptsProperties() {
  Map<String, String> res = ourPropertiesFromMvnOpts;
  if (res == null) {
    String mavenOpts = System.getenv("MAVEN_OPTS");
    if (mavenOpts != null) {
      res = new HashMap<String, String>();
      final String[] split = ParametersListUtil.parseToArray(mavenOpts);
      for (String parameter : split) {
        final Matcher matcher = PROPERTY_PATTERN.matcher(parameter);
        if (matcher.matches()) {
          res.put(matcher.group(1), matcher.group(2));
        }
      }
    }
    else {
      res = Collections.emptyMap();
    }

    ourPropertiesFromMvnOpts = res;
  }

  return res;
}
 

import com.intellij.util.execution.ParametersListUtil; //导入依赖的package包/类
protected void setData(final MavenRunnerParameters data) {
  data.setWorkingDirPath(workingDirComponent.getComponent().getText());
  data.setGoals(ParametersListUtil.parse(goalsComponent.getComponent().getText()));
  data.setResolveToWorkspace(myResolveToWorkspaceCheckBox.isSelected());

  Map<String, Boolean> profilesMap = new LinkedHashMap<String, Boolean>();

  List<String> profiles = ParametersListUtil.parse(profilesComponent.getComponent().getText());

  for (String profile : profiles) {
    Boolean isEnabled = true;
    if (profile.startsWith("-") || profile.startsWith("!")) {
      profile = profile.substring(1);
      if (profile.isEmpty()) continue;

      isEnabled = false;
    }

    profilesMap.put(profile, isEnabled);
  }
  data.setProfilesMap(profilesMap);
}
 

import com.intellij.util.execution.ParametersListUtil; //导入依赖的package包/类
private void createUIComponents() {
  myProtectedBranchesButton = new TextFieldWithBrowseButton.NoPathCompletion(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
      Messages.showTextAreaDialog(myProtectedBranchesButton.getTextField(), "Protected Branches", "Git.Force.Push.Protected.Branches",
                                  ParametersListUtil.COLON_LINE_PARSER, ParametersListUtil.COLON_LINE_JOINER);
    }
  });
  myProtectedBranchesButton.setButtonIcon(AllIcons.Actions.ShowViewer);
  myUpdateMethodComboBox = new ComboBox(new EnumComboBoxModel<UpdateMethod>(UpdateMethod.class));
  myUpdateMethodComboBox.setRenderer(new ListCellRendererWrapper<UpdateMethod>() {
    @Override
    public void customize(JList list, UpdateMethod value, int index, boolean selected, boolean hasFocus) {
      setText(StringUtil.capitalize(StringUtil.toLowerCase(value.name().replace('_', ' '))));
    }
  });
}
 

import com.intellij.util.execution.ParametersListUtil; //导入依赖的package包/类
@NotNull
private static List<String> calculateCommand(@NotNull final String interpreterPath,
                                             @NotNull final TheRRunConfiguration runConfiguration) {
  final List<String> command = new ArrayList<String>();

  command.add(FileUtil.toSystemDependentName(interpreterPath));
  command.addAll(TheRInterpreterConstants.DEFAULT_PARAMETERS);

  final String scriptArgs = runConfiguration.getScriptArgs();

  if (!StringUtil.isEmptyOrSpaces(scriptArgs)) {
    command.add(TheRInterpreterConstants.ARGS_PARAMETER);
    command.addAll(ParametersListUtil.parse(scriptArgs));
  }

  return command;
}
 

import com.intellij.util.execution.ParametersListUtil; //导入依赖的package包/类
@Nonnull
private static Process execute(@Nonnull String exePath, @Nonnull String parametersTemplate, @Nonnull Map<String, String> patterns)
        throws ExecutionException {
  List<String> parameters = ParametersListUtil.parse(parametersTemplate, true);

  List<String> from = new ArrayList<>();
  List<String> to = new ArrayList<>();
  for (Map.Entry<String, String> entry : patterns.entrySet()) {
    from.add(entry.getKey());
    to.add(entry.getValue());
  }

  List<String> args = new ArrayList<>();
  for (String parameter : parameters) {
    String arg = StringUtil.replace(parameter, from, to);
    if (!StringUtil.isEmptyOrSpaces(arg)) args.add(arg);
  }

  GeneralCommandLine commandLine = new GeneralCommandLine();
  commandLine.setExePath(exePath);
  commandLine.addParameters(args);
  return commandLine.createProcess();
}
 

import com.intellij.util.execution.ParametersListUtil; //导入依赖的package包/类
@Nonnull
@Override
public List<String> getAdditionalParameters() {
  if (myCommandLineOptions == null) {
    if (myUseCustomProfile && myUserDataDirectoryPath != null) {
      return Collections.singletonList(USER_DATA_DIR_ARG + FileUtilRt.toSystemDependentName(myUserDataDirectoryPath));
    }
    else {
      return Collections.emptyList();
    }
  }

  List<String> cliOptions = ParametersListUtil.parse(myCommandLineOptions);
  if (myUseCustomProfile && myUserDataDirectoryPath != null) {
    cliOptions.add(USER_DATA_DIR_ARG + FileUtilRt.toSystemDependentName(myUserDataDirectoryPath));
  }
  return cliOptions;
}
 

import com.intellij.util.execution.ParametersListUtil; //导入依赖的package包/类
private static void checkTokenizer(String paramString, String... expected) {
  ParametersList params = new ParametersList();
  params.addParametersString(paramString);
  assertEquals(asList(expected), params.getList());

  List<String> lines = ParametersListUtil.parse(paramString, true);
  assertEquals(paramString, StringUtil.join(lines, " "));
}
 

import com.intellij.util.execution.ParametersListUtil; //导入依赖的package包/类
@NotNull
private static MultiMap<String, String> getBrokenPluginVersions() {
  if (ourBrokenPluginVersions == null) {
    ourBrokenPluginVersions = MultiMap.createSet();

    if (System.getProperty("idea.ignore.disabled.plugins") == null && !isUnitTestMode()) {
      BufferedReader br = new BufferedReader(new InputStreamReader(PluginManagerCore.class.getResourceAsStream("/brokenPlugins.txt")));
      try {
        String s;
        while ((s = br.readLine()) != null) {
          s = s.trim();
          if (s.startsWith("//")) continue;

          List<String> tokens = ParametersListUtil.parse(s);
          if (tokens.isEmpty()) continue;

          if (tokens.size() == 1) {
            throw new RuntimeException("brokenPlugins.txt is broken. The line contains plugin name, but does not contains version: " + s);
          }

          String pluginId = tokens.get(0);
          List<String> versions = tokens.subList(1, tokens.size());

          ourBrokenPluginVersions.putValues(pluginId, versions);
        }
      }
      catch (IOException e) {
        throw new RuntimeException("Failed to read /brokenPlugins.txt", e);
      }
      finally {
        StreamUtil.closeStream(br);
      }
    }
  }
  return ourBrokenPluginVersions;
}
 

import com.intellij.util.execution.ParametersListUtil; //导入依赖的package包/类
/**
 * Load settings into the configuration panel
 *
 * @param settings the settings to load
 */
public void load(@NotNull GitVcsSettings settings, @NotNull GitSharedSettings sharedSettings) {
  myGitField.setText(settings.getAppSettings().getPathToGit());
  mySSHExecutableComboBox.setSelectedItem(settings.isIdeaSsh() ? IDEA_SSH : NATIVE_SSH);
  myAutoUpdateIfPushRejected.setSelected(settings.autoUpdateIfPushRejected());
  mySyncControl.setSelected(settings.getSyncSetting() == DvcsSyncSettings.Value.SYNC);
  myAutoCommitOnCherryPick.setSelected(settings.isAutoCommitOnCherryPick());
  myWarnAboutCrlf.setSelected(settings.warnAboutCrlf());
  myWarnAboutDetachedHead.setSelected(settings.warnAboutDetachedHead());
  myEnableForcePush.setSelected(settings.isForcePushAllowed());
  myUpdateMethodComboBox.setSelectedItem(settings.getUpdateType());
  myProtectedBranchesButton.setText(ParametersListUtil.COLON_LINE_JOINER.fun(sharedSettings.getForcePushProhibitedPatterns()));
}
 

import com.intellij.util.execution.ParametersListUtil; //导入依赖的package包/类
private static List<String> createCommandLine(CompileContext context,
                                              ModuleChunk chunk,
                                              List<File> srcFiles,
                                              String mainOutputDir, @Nullable ProcessorConfigProfile profile, GreclipseSettings settings) {
  final List<String> args = new ArrayList<String>();

  args.add("-cp");
  args.add(getClasspathString(chunk));

  JavaBuilder.addCompilationOptions(args, context, chunk, profile);

  args.add("-d");
  args.add(mainOutputDir);

  //todo AjCompilerSettings exact duplicate, JavaBuilder.loadCommonJavacOptions inexact duplicate 
  List<String> params = ParametersListUtil.parse(settings.cmdLineParams);
  for (Iterator<String> iterator = params.iterator(); iterator.hasNext(); ) {
    String option = iterator.next();
    if ("-target".equals(option)) {
      iterator.next();
      continue;
    }
    else if (option.isEmpty() || "-g".equals(option) || "-verbose".equals(option)) {
      continue;
    }
    args.add(option);
  }

  if (settings.debugInfo) {
    args.add("-g");
  }

  for (File file : srcFiles) {
    args.add(file.getPath());
  }

  return args;
}
 

import com.intellij.util.execution.ParametersListUtil; //导入依赖的package包/类
/** Appends '--script_path' to blaze flags, then runs 'bash -c blaze build ... && run_script' */
private static List<String> getBashCommandsToRunScript(BlazeCommand.Builder blazeCommand) {
  File scriptFile = createTempOutputFile();
  blazeCommand.addBlazeFlags("--script_path=" + scriptFile.getPath());
  String blaze = ParametersListUtil.join(blazeCommand.build().toList());
  return ImmutableList.of("/bin/bash", "-c", blaze + " && " + scriptFile.getPath());
}
 

import com.intellij.util.execution.ParametersListUtil; //导入依赖的package包/类
private static String getScriptParams(BlazeCommandRunConfigurationCommonState state) {
  List<String> params = Lists.newArrayList(state.getExeFlagsState().getExpandedFlags());
  String filterFlag = state.getTestFilterFlag();
  if (filterFlag != null) {
    params.add(filterFlag.substring((BlazeFlags.TEST_FILTER + "=").length()));
  }
  return ParametersListUtil.join(params);
}
 

import com.intellij.util.execution.ParametersListUtil; //导入依赖的package包/类
@NotNull
@Override
public NotNullPairFunction<DotNetConfigurationWithCoverage, GeneralCommandLine, GeneralCommandLine> getModifierForCommandLine()
{
	return new NotNullPairFunction<DotNetConfigurationWithCoverage, GeneralCommandLine, GeneralCommandLine>()
	{
		@NotNull
		@Override
		public GeneralCommandLine fun(DotNetConfigurationWithCoverage t, GeneralCommandLine v)
		{
			CoverageEnabledConfiguration coverageEnabledConfiguration = DotNetCoverageEnabledConfiguration.get(t);

			File openCoverConsoleExecutable = getOpenCoverConsoleExecutable();

			GeneralCommandLine newCommandLine = new GeneralCommandLine();
			newCommandLine.setExePath(openCoverConsoleExecutable.getPath());
			newCommandLine.addParameter("-register:user");
			newCommandLine.addParameter("-target:" + v.getExePath());
			newCommandLine.addParameter("-filter:+[*]*");
			newCommandLine.addParameter("-output:" + coverageEnabledConfiguration.getCoverageFilePath());

			String parametersAsString = ParametersListUtil.join(v.getParametersList().getParameters());
			if(!StringUtil.isEmpty(parametersAsString))
			{
				newCommandLine.addParameter("-targetargs:" + parametersAsString + "");
			}
			return newCommandLine;
		}
	};
}
 

import com.intellij.util.execution.ParametersListUtil; //导入依赖的package包/类
@Override
public boolean executeTask(DataContext dataContext, RunConfiguration runConfiguration, ExecutionEnvironment executionEnvironment, MuleBeforeRunTask muleBeforeRunTask)
{
    final Semaphore targetDone = new Semaphore();
    final List<Boolean> results = new ArrayList<>();

    final Project project = executionEnvironment.getProject();

    MuleConfiguration muleConfiguration = (MuleConfiguration) runConfiguration;

    Module[] modules = muleConfiguration.getModules();

    for (Module nextModule : modules) {
        //final MavenProject mavenProject = getMavenProject(runConfiguration, project);
        final MavenProject mavenProject = getMavenProject(nextModule);
        try {
            ApplicationManager.getApplication().invokeAndWait(new Runnable() {
                public void run() {
                    if (!project.isDisposed() && mavenProject != null) {
                        FileDocumentManager.getInstance().saveAllDocuments();
                        final MavenExplicitProfiles explicitProfiles = MavenProjectsManager.getInstance(project).getExplicitProfiles();
                        final MavenRunner mavenRunner = MavenRunner.getInstance(project);
                        targetDone.down();
                        (new Task.Backgroundable(project, TasksBundle.message("maven.tasks.executing"), true) {
                            public void run(@NotNull ProgressIndicator indicator) {
                                try {
                                    MavenRunnerParameters params =
                                            new MavenRunnerParameters(true, mavenProject.getDirectory(), ParametersListUtil.parse("package"), explicitProfiles.getEnabledProfiles(),
                                                    explicitProfiles.getDisabledProfiles());
                                    boolean result = mavenRunner.runBatch(Collections.singletonList(params), null, null, TasksBundle.message("maven.tasks.executing"), indicator);
                                    results.add(result);
                                } finally {
                                    targetDone.up();
                                }
                            }

                            public boolean shouldStartInBackground() {
                                return MavenRunner.getInstance(project).getSettings().isRunMavenInBackground();
                            }

                            public void processSentToBackground() {
                                MavenRunner.getInstance(project).getSettings().setRunMavenInBackground(true);
                            }
                        }).queue();
                    }
                }
            }, ModalityState.NON_MODAL);
        } catch (Exception exeception) {
            return false;
        }
        targetDone.waitFor();
    }

    boolean endResult = true;

    for (Boolean nextResult : results) {
        endResult = endResult && nextResult;
    }

    return endResult;
}
 

import com.intellij.util.execution.ParametersListUtil; //导入依赖的package包/类
private void createUIComponents() {
  myResourcePatternsField = new RawCommandLineEditor(ParametersListUtil.COLON_LINE_PARSER, ParametersListUtil.COLON_LINE_JOINER);
  myResourcePatternsField.setDialogCaption("Resource patterns");
}
 

import com.intellij.util.execution.ParametersListUtil; //导入依赖的package包/类
public static void showTextAreaDialog(final JTextField textField, final @Nls(capitalization = Nls.Capitalization.Title) String title, @NonNls final String dimensionServiceKey) {
  showTextAreaDialog(textField, title, dimensionServiceKey, ParametersListUtil.DEFAULT_LINE_PARSER, ParametersListUtil.DEFAULT_LINE_JOINER);
}
 

import com.intellij.util.execution.ParametersListUtil; //导入依赖的package包/类
/**
 * @see ParametersListUtil#join(java.util.List)
 */
@NotNull
public static String join(@NotNull final List<String> parameters) {
  return ParametersListUtil.join(parameters);
}
 

import com.intellij.util.execution.ParametersListUtil; //导入依赖的package包/类
/**
 * @see ParametersListUtil#parseToArray(String)
 */
@NotNull
public static String[] parse(@NotNull final String string) {
  return ParametersListUtil.parseToArray(string);
}