Java Commandline类代码示例

import org.apache.tools.ant.types.Commandline; //导入依赖的package包/类
/**
 * Add the file names to the Commandline. Log them in verbose mode.
 * @param cmd the Commandline to be executed
 */
private void logAndAddFilesToCompile(Commandline cmd) {
  log("Compilation " + cmd.describeArguments(),
      Project.MSG_VERBOSE);

  StringBuffer niceSourceList = new StringBuffer("File");
  if (compileList.length != 1) {
    niceSourceList.append("s");
  }
  niceSourceList.append(" to be compiled:");
  niceSourceList.append(StringUtils.LINE_SEP);

  for (int i = 0; i < compileList.length; i++) {
    String arg = compileList[i].getAbsolutePath();
    cmd.createArgument().setValue(arg);
    niceSourceList.append("    ");
    niceSourceList.append(arg);
    niceSourceList.append(StringUtils.LINE_SEP);
  }
  log(niceSourceList.toString(), Project.MSG_VERBOSE);
}
 

import org.apache.tools.ant.types.Commandline; //导入依赖的package包/类
public static Map<String, String> parseBuildArgs(String commandLine) {
    // this also accounts for quote, escapes, ...
    Commandline parsed = new Commandline(commandLine);
    Map<String, String> result = new HashMap<>();

    String[] arguments = parsed.getArguments();
    for (int i = 0; i < arguments.length; i++) {
        String arg = arguments[i];
        if (arg.equals("--build-arg")) {
            if (arguments.length < i + 1) {
                throw new IllegalArgumentException("Missing parameter for --build-arg: " + commandLine);
            }
            String keyVal = arguments[i+1];

            String parts[] = keyVal.split("=", 2);
            if (parts.length != 2) {
                throw new IllegalArgumentException("Illegal syntax for --build-arg " + keyVal + ", need KEY=VALUE");
            }
            String key = parts[0];
            String value = parts[1];

            result.put(key, value);
        }
    }
    return result;
}
 

import org.apache.tools.ant.types.Commandline; //导入依赖的package包/类
protected boolean executeCmd (Commandline cmd)
{
	try
	{
		System.out.println (cmd.toString ());
		Execute exe = new Execute ();
		exe.setCommandline (cmd.getCommandline ());
		exe.execute ();
		if (exe.getExitValue () == 0)
			return false;
	}
	catch (Exception ex)
	{
	}
	return true;
}
 

import org.apache.tools.ant.types.Commandline; //导入依赖的package包/类
public void addToCommandline(Commandline cmdl)
{
    if (hasSelectors() || hasPatterns())
    {
        DirectoryScanner scanner = getDirectoryScanner(getProject());

        if (includeDirs)
        {
            addFiles(scanner.getBasedir(), scanner.getIncludedDirectories(), cmdl);
        }

        addFiles(scanner.getBasedir(), scanner.getIncludedFiles(), cmdl);
    }
    else if (spec != null)
    {
        cmdl.createArgument().setValue("-" + spec.getFullName() + "=");
    }
}
 

import org.apache.tools.ant.types.Commandline; //导入依赖的package包/类
protected void addFiles(File base, String[] files, Commandline cmdl)
{
    FileUtils utils = FileUtils.getFileUtils();

    if (spec == null)
    {
        for (int i = 0; i < files.length; i++)
        {
            cmdl.createArgument().setValue(utils.resolveFile(base, files[i]).getAbsolutePath());
        }
    }
    else
    {
        for (int i = 0; i < files.length; i++)
        {
            cmdl.createArgument().setValue("-" + spec.getFullName() + equalString() +
                                           utils.resolveFile(base, files[i]).getAbsolutePath());
        }
    }
}
 

import org.apache.tools.ant.types.Commandline; //导入依赖的package包/类
protected void addFiles(File base, String[] files, Commandline cmdl)
{
    FileUtils utils = FileUtils.getFileUtils();
 
    for (int i = 0; i < files.length; ++i)
    {
        File f = utils.resolveFile(base, files[i]);
        String absolutePath = f.getAbsolutePath();

        if( f.isFile() && !absolutePath.endsWith(".swc") && !absolutePath.endsWith(".ane") )
        	continue;

        if (spec != null)
        {
            cmdl.createArgument().setValue("-" + spec.getFullName() + equalString() + absolutePath);
        }
        else
        {
            cmdl.createArgument().setValue(absolutePath);
        }
    }    
}
 

import org.apache.tools.ant.types.Commandline; //导入依赖的package包/类
/**
 * Execute the created command line.
 *
 * @param  cmd            The command line to run.
 * @return                int the exit code.
 * @throws BuildException if something goes wrong
 */
protected int run(Commandline cmd) {
    try {
        Execute exe = new Execute(new LogStreamHandler(this,
                Project.MSG_INFO,
                Project.MSG_WARN));

        exe.setAntRun(getProject());
        exe.setWorkingDirectory(getProject().getBaseDir());
        exe.setCommandline(cmd.getCommandline());
        exe.setVMLauncher(false);  // Use the OS VM launcher so we get environment variables
        return exe.execute();
    } catch (java.io.IOException e) {
        throw new BuildException(e, getLocation());
    }
}
 

import org.apache.tools.ant.types.Commandline; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
protected boolean run(Commandline cmd, ProjectComponent log)
    throws BuildException {
    ExecuteJava ej = new ExecuteJava();
    Class<?> c = getN2aClass();
    if (c == null) {
        throw new BuildException(
            "Couldn't load Kaffe's Native2Ascii class");
    }

    cmd.setExecutable(c.getName());
    ej.setJavaCommand(cmd);
    ej.execute(log.getProject());
    // otherwise ExecuteJava has thrown an exception
    return true;
}
 

import org.apache.tools.ant.types.Commandline; //导入依赖的package包/类
/**
 * Check the command line options.
 */
private void checkOptions(Commandline cmd) {
    if (getComment() != null) {
        cmd.createArgument().setValue(FLAG_COMMENT);
        cmd.createArgument().setValue(getComment());
    }

    if (getTask() != null) {
        cmd.createArgument().setValue(FLAG_TASK);
        cmd.createArgument().setValue(getTask());
    }

    if (getFile() != null) {
        cmd.createArgument().setValue(file.getAbsolutePath());
    }
}
 

import org.apache.tools.ant.types.Commandline; //导入依赖的package包/类
/**
 * Run the compilation.
 * @return true if the compiler ran with a zero exit result (ok)
 * @exception BuildException if the compilation has problems.
 */
@Override
public boolean execute() throws BuildException {
    attributes.log("Using modern compiler", Project.MSG_VERBOSE);
    Commandline cmd = setupModernJavacCommand();

    // Use reflection to be able to build on all JDKs >= 1.1:
    try {
        Class<?> c = Class.forName("com.sun.tools.javac.Main");
        Object compiler = c.newInstance();
        Method compile = c.getMethod("compile", String[].class);
        int result = ((Integer) compile.invoke(compiler,
            (Object) cmd.getArguments())).intValue();
        return result == MODERN_COMPILER_SUCCESS;
    } catch (Exception ex) {
        if (ex instanceof BuildException) {
            throw (BuildException) ex;
        }
        throw new BuildException("Error starting modern compiler",
                                 ex, location);
    }
}
 

import org.apache.tools.ant.types.Commandline; //导入依赖的package包/类
/**
 * Executes the task.
 * <p>
 * Builds a command line to execute ccm and then calls Exec's run method
 * to execute the command line.
 * </p>
 * @throws BuildException on error
 */
@Override
public void execute() throws BuildException {
    Commandline commandLine = new Commandline();

    // build the command line from what we got the format
    // as specified in the CCM.EXE help
    commandLine.setExecutable(getCcmCommand());
    commandLine.createArgument().setValue(getCcmAction());

    checkOptions(commandLine);

    int result = run(commandLine);
    if (Execute.isFailure(result)) {
        throw new BuildException("Failed executing: " + commandLine,
            getLocation());
    }
}
 

import org.apache.tools.ant.types.Commandline; //导入依赖的package包/类
/**
 * helper method to execute our command on VMS.
 * @param cmd Commandline
 * @param firstFileName int
 * @return boolean
 */
private boolean execOnVMS(Commandline cmd, int firstFileName) {
    File vmsFile = null;
    try {
        vmsFile = JavaEnvUtils.createVmsJavaOptionFile(cmd.getArguments());
        String[] commandLine = {cmd.getExecutable(),
                                "-V",
                                vmsFile.getPath()};
        return 0 == executeExternalCompile(commandLine,
                        firstFileName,
                        true);

    } catch (IOException e) {
        throw new BuildException(
            "Failed to create a temporary file for \"-V\" switch");
    } finally {
        FileUtils.delete(vmsFile);
    }
}
 

import org.apache.tools.ant.types.Commandline; //导入依赖的package包/类
@Test
public void releaseIsUsedForJava9() {
    LogCapturingJavac javac = new LogCapturingJavac();
    Project p = new Project();
    javac.setProject(p);
    javac.setCompiler("javac9");
    javac.setSource("6");
    javac.setTarget("6");
    javac.setRelease("6");
    javac.setSourcepath(new Path(p));
    SourceTargetHelperNoOverride sth = new SourceTargetHelperNoOverride();
    sth.setJavac(javac);
    Commandline cmd = new Commandline();
    sth.setupModernJavacCommandlineSwitches(cmd);
    assertContains("Ignoring source, target and bootclasspath as "
                   + "release has been set", javac.getLog());
    String[] args = cmd.getCommandline();
    assertEquals(5, args.length);
    assertEquals("-classpath", args[0]);
    assertEquals("-g:none", args[2]);
    assertEquals("--release", args[3]);
    assertEquals("6", args[4]);
}
 

import org.apache.tools.ant.types.Commandline; //导入依赖的package包/类
/**
 * Launches the given command in a new process, in the given
 * working directory.
 *
 * @param project
 *        the Ant project.
 * @param cmd
 *        the command line to execute as an array of strings.
 * @param env
 *        the environment to set as an array of strings.
 * @param workingDir
 *        the working directory where the command should run.
 * @return the created Process.
 * @throws IOException
 *         probably forwarded from Runtime#exec.
 */
@Override
public Process exec(Project project, String[] cmd, String[] env,
                    File workingDir) throws IOException {
    try {
        if (project != null) {
            project.log("Execute:Java13CommandLauncher: "
                        + Commandline.describeCommand(cmd),
                        Project.MSG_DEBUG);
        }
        return Runtime.getRuntime().exec(cmd, env, workingDir);
    } catch (IOException ioex) {
        throw ioex;
    } catch (Exception exc) {
        // IllegalAccess, IllegalArgument, ClassCast
        throw new BuildException("Unable to execute command", exc);
    }
}
 

import org.apache.tools.ant.types.Commandline; //导入依赖的package包/类
/**
 * Build the command line
 * <p>
 * CheckOutFile required parameters: -server -name -password -database -project -file<br>
 * CheckOutFile optional parameters: -workdir -verbose -nocache -nocompression -soshome<br>
 *
 * CheckOutProject required parameters: -server -name -password -database -project<br>
 * CheckOutProject optional parameters:-workdir -recursive -verbose -nocache
 * -nocompression -soshome
 * </p>
 *
 * @return    Commandline the generated command to be executed
 */
@Override
protected Commandline buildCmdLine() {
    commandLine = new Commandline();

    // If we find a "file" attribute then act on a file otherwise act on a project
    if (getFilename() != null) {
        // add -command CheckOutFile to the commandline
        commandLine.createArgument().setValue(SOSCmd.FLAG_COMMAND);
        commandLine.createArgument().setValue(SOSCmd.COMMAND_CHECKOUT_FILE);
        // add -file xxxxx to the commandline
        commandLine.createArgument().setValue(SOSCmd.FLAG_FILE);
        commandLine.createArgument().setValue(getFilename());
    } else {
        // add -command CheckOutProject to the commandline
        commandLine.createArgument().setValue(SOSCmd.FLAG_COMMAND);
        commandLine.createArgument().setValue(SOSCmd.COMMAND_CHECKOUT_PROJECT);
        // look for a recursive option
        commandLine.createArgument().setValue(getRecursive());
    }

    getRequiredAttributes();
    getOptionalAttributes();

    return commandLine;
}