| Method from org.apache.tools.ant.types.Commandline Detail: |
|---|
 public void addArguments(String[] line) {
for (int i = 0; i < line.length; i++) {
createArgument().setValue(line[i]);
}
}
Append the arguments to the existing command. |
public void addArgumentsToList(ListIterator list) {
for (int i = 0; i < arguments.size(); i++) {
Argument arg = (Argument) arguments.elementAt(i);
String[] s = arg.getParts();
if (s != null) {
for (int j = 0; j < s.length; j++) {
list.add(s[j]);
}
}
}
} Append all the arguments to the tail of a supplied list. |
public void addCommandToList(ListIterator list) {
if (executable != null) {
list.add(executable);
}
addArgumentsToList(list);
} Add the entire command, including (optional) executable to a list. |
public void clear() {
executable = null;
arguments.removeAllElements();
} Clear out the whole command line. |
public void clearArgs() {
arguments.removeAllElements();
} Clear out the arguments but leave the executable in place for
another operation. |
public Object clone() {
try {
Commandline c = (Commandline) super.clone();
c.arguments = (Vector) arguments.clone();
return c;
} catch (CloneNotSupportedException e) {
throw new BuildException(e);
}
} Generate a deep clone of the contained object. |
public Argument createArgument() {
return this.createArgument(false);
} Create an argument object.
Each commandline object has at most one instance of the
argument class. This method calls
this.createArgument(false). |
public Argument createArgument(boolean insertAtStart) {
Argument argument = new Argument();
if (insertAtStart) {
arguments.insertElementAt(argument, 0);
} else {
arguments.addElement(argument);
}
return argument;
} |
public Marker createMarker() {
return new Marker(arguments.size());
} Return a marker.
This marker can be used to locate a position on the
commandline--to insert something for example--when all
parameters have been set. |
public String describeArguments() {
return describeArguments(this);
} Return a String that describes the arguments suitable for
verbose output before a call to Runtime.exec(String[]). |
public static String describeArguments(Commandline line) {
return describeArguments(line.getArguments());
} Return a String that describes the arguments suitable for
verbose output before a call to Runtime.exec(String[]). |
public static String describeArguments(String[] args) {
return describeArguments(args, 0);
} Return a String that describes the arguments suitable for
verbose output before a call to Runtime.exec(String[]). |
protected static String describeArguments(String[] args,
int offset) {
if (args == null || args.length < = offset) {
return "";
}
StringBuffer buf = new StringBuffer("argument");
if (args.length > offset) {
buf.append("s");
}
buf.append(":").append(StringUtils.LINE_SEP);
for (int i = offset; i < args.length; i++) {
buf.append("\'").append(args[i]).append("\'")
.append(StringUtils.LINE_SEP);
}
buf.append(DISCLAIMER);
return buf.toString();
} Return a String that describes the arguments suitable for
verbose output before a call to Runtime.exec(String[]). |
public String describeCommand() {
return describeCommand(this);
} Return a String that describes the command and arguments suitable for
verbose output before a call to Runtime.exec(String[]). |
public static String describeCommand(Commandline line) {
return describeCommand(line.getCommandline());
} Return a String that describes the command and arguments suitable for
verbose output before a call to Runtime.exec(String[]). |
public static String describeCommand(String[] args) {
if (args == null || args.length == 0) {
return "";
}
StringBuffer buf = new StringBuffer("Executing \'");
buf.append(args[0]);
buf.append("\'");
if (args.length > 1) {
buf.append(" with ");
buf.append(describeArguments(args, 1));
} else {
buf.append(DISCLAIMER);
}
return buf.toString();
} Return a String that describes the command and arguments suitable for
verbose output before a call to Runtime.exec(String[]).
This method assumes that the first entry in the array is the
executable to run. |
public String[] getArguments() {
List result = new ArrayList(arguments.size() * 2);
addArgumentsToList(result.listIterator());
String [] res = new String[result.size()];
return (String[]) result.toArray(res);
} Returns all arguments defined by addLine,
addValue or the argument object. |
public String[] getCommandline() {
List commands = new LinkedList();
ListIterator list = commands.listIterator();
addCommandToList(list);
final String[] result = new String[commands.size()];
return (String[]) commands.toArray(result);
} Return the executable and all defined arguments. |
public String getExecutable() {
return executable;
} |
public Iterator iterator() {
return arguments.iterator();
} Get an iterator to the arguments list. |
public static String quoteArgument(String argument) {
if (argument.indexOf("\"") > -1) {
if (argument.indexOf("\'") > -1) {
throw new BuildException("Can\'t handle single and double"
+ " quotes in same argument");
} else {
return '\'' + argument + '\'';
}
} else if (argument.indexOf("\'") > -1
|| argument.indexOf(" ") > -1
// WIN9x uses a bat file for executing commands
|| (IS_WIN_9X && argument.indexOf(';') != -1)) {
return '\"' + argument + '\"';
} else {
return argument;
}
} Put quotes around the given String if necessary.
If the argument doesn't include spaces or quotes, return it
as is. If it contains double quotes, use single quotes - else
surround the argument by double quotes. |
public void setExecutable(String executable) {
if (executable == null || executable.length() == 0) {
return;
}
this.executable = executable.replace('/', File.separatorChar)
.replace('\\', File.separatorChar);
} Set the executable to run. All file separators in the string
are converted to the platform specific value. |
public int size() {
return getCommandline().length;
} Size operator. This actually creates the command line, so it is not
a zero cost operation. |
public String toString() {
return toString(getCommandline());
} Return the command line as a string. |
public static String toString(String[] line) {
// empty path return empty string
if (line == null || line.length == 0) {
return "";
}
// path containing one or more elements
final StringBuffer result = new StringBuffer();
for (int i = 0; i < line.length; i++) {
if (i > 0) {
result.append(' ');
}
result.append(quoteArgument(line[i]));
}
return result.toString();
} Quote the parts of the given array in way that makes them
usable as command line arguments. |
public static String[] translateCommandline(String toProcess) {
if (toProcess == null || toProcess.length() == 0) {
//no command? no string
return new String[0];
}
// parse with a simple finite state machine
final int normal = 0;
final int inQuote = 1;
final int inDoubleQuote = 2;
int state = normal;
StringTokenizer tok = new StringTokenizer(toProcess, "\"\' ", true);
Vector v = new Vector();
StringBuffer current = new StringBuffer();
boolean lastTokenHasBeenQuoted = false;
while (tok.hasMoreTokens()) {
String nextTok = tok.nextToken();
switch (state) {
case inQuote:
if ("\'".equals(nextTok)) {
lastTokenHasBeenQuoted = true;
state = normal;
} else {
current.append(nextTok);
}
break;
case inDoubleQuote:
if ("\"".equals(nextTok)) {
lastTokenHasBeenQuoted = true;
state = normal;
} else {
current.append(nextTok);
}
break;
default:
if ("\'".equals(nextTok)) {
state = inQuote;
} else if ("\"".equals(nextTok)) {
state = inDoubleQuote;
} else if (" ".equals(nextTok)) {
if (lastTokenHasBeenQuoted || current.length() != 0) {
v.addElement(current.toString());
current = new StringBuffer();
}
} else {
current.append(nextTok);
}
lastTokenHasBeenQuoted = false;
break;
}
}
if (lastTokenHasBeenQuoted || current.length() != 0) {
v.addElement(current.toString());
}
if (state == inQuote || state == inDoubleQuote) {
throw new BuildException("unbalanced quotes in " + toProcess);
}
String[] args = new String[v.size()];
v.copyInto(args);
return args;
} |
org.apache.tools.ant.types.Commandline
Save This Page