/*
* The Apache Software License, Version 1.1
*
* Copyright (c) 2000-2002 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution, if
* any, must include the following acknowlegement:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowlegement may appear in the software itself,
* if and wherever such third-party acknowlegements normally appear.
*
* 4. The names "The Jakarta Project", "Ant", and "Apache Software
* Foundation" must not be used to endorse or promote products derived
* from this software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache"
* nor may "Apache" appear in their names without prior written
* permission of the Apache Group.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
package org.apache.tools.ant;
import org.apache.tools.ant.input.DefaultInputHandler;
import org.apache.tools.ant.input.InputHandler;
import org.apache.tools.ant.util.JavaEnvUtils;
import java.io.File;
import java.io.FileInputStream;
import java.io.PrintStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Vector;
import java.util.Properties;
import java.util.Enumeration;
/**
* Command line entry point into Ant. This class is entered via the
* cannonical `public static void main` entry point and reads the
* command line arguments. It then assembles and executes an Ant
* project.
* <p>
* If you integrating Ant into some other tool, this is not the class
* to use as an entry point. Please see the source code of this
* class to see how it manipulates the Ant project classes.
*
* @author duncan@x180.com
*/
public class Main {
/** The default build file name. */
public static final String DEFAULT_BUILD_FILENAME = "build.xml";
/** Our current message output status. Follows Project.MSG_XXX. */
private int msgOutputLevel = Project.MSG_INFO;
/** File that we are using for configuration. */
private File buildFile; /* null */
/** Stream to use for logging. */
private static PrintStream out = System.out;
/** Stream that we are using for logging error messages. */
private static PrintStream err = System.err;
/** The build targets. */
private Vector targets = new Vector(5);
/** Set of properties that can be used by tasks. */
private Properties definedProps = new Properties();
/** Names of classes to add as listeners to project. */
private Vector listeners = new Vector(5);
/** File names of property files to load on startup. */
private Vector propertyFiles = new Vector(5);
/**
* The Ant logger class. There may be only one logger. It will have
* the right to use the 'out' PrintStream. The class must implements the
* BuildLogger interface.
*/
private String loggerClassname = null;
/**
* The Ant InputHandler class. There may be only one input
* handler.
*/
private String inputHandlerClassname = null;
/**
* Whether or not output to the log is to be unadorned.
*/
private boolean emacsMode = false;
/**
* Whether or not this instance has successfully been
* constructed and is ready to run.
*/
private boolean readyToRun = false;
/**
* Whether or not we should only parse and display the project help
* information.
*/
private boolean projectHelp = false;
/**
* Is a logfile being used? This is used to
* check if the output streams must be closed.
*/
private static boolean isLogFileUsed = false;
/**
* Prints the message of the Throwable if it (the message) is not
* <code>null</code>.
*
* @param t Throwable to print the message of.
* Must not be <code>null</code>.
*/
private static void printMessage(Throwable t) {
String message = t.getMessage();
if (message != null) {
System.err.println(message);
}
}
/**
* Creates a new instance of this class using the
* arguments specified, gives it any extra user properties which have been
* specified, and then runs the build using the classloader provided.
*
* @param args Command line arguments. Must not be <code>null</code>.
* @param additionalUserProperties Any extra properties to use in this
* build. May be <code>null</code>, which is the equivalent to
* passing in an empty set of properties.
* @param coreLoader Classloader used for core classes. May be
* <code>null</code> in which case the system classloader is used.
*/
public static void start(String[] args, Properties additionalUserProperties,
ClassLoader coreLoader) {
Main m = null;
try {
Diagnostics.validateVersion();
m = new Main(args);
} catch (Throwable exc) {
printMessage(exc);
System.exit(1);
}
if (additionalUserProperties != null) {
for (Enumeration e = additionalUserProperties.keys();
e.hasMoreElements();) {
String key = (String) e.nextElement();
String property = additionalUserProperties.getProperty(key);
m.definedProps.put(key, property);
}
}
try {
m.runBuild(coreLoader);
System.exit(0);
} catch (BuildException be) {
if (m.err != System.err) {
printMessage(be);
}
System.exit(1);
} catch (Throwable exc) {
exc.printStackTrace();
printMessage(exc);
System.exit(1);
} finally {
if (isLogFileUsed) {
if (out != null) {
try {
out.close();
} catch (final Exception e) {
//ignore
}
}
if (err != null) {
try {
err.close();
} catch (final Exception e) {
//ignore
}
}
}
}
}
/**
* Command line entry point. This method kicks off the building
* of a project object and executes a build using either a given
* target or the default target.
*
* @param args Command line arguments. Must not be <code>null</code>.
*/
public static void main(String[] args) {
start(args, null, null);
}
// XXX: (Jon Skeet) Error handling appears to be inconsistent here.
// Sometimes there's just a return statement, and sometimes a
// BuildException is thrown. What's the rationale for when to do
// what?
/**
* Sole constructor, which parses and deals with command line
* arguments.
*
* @param args Command line arguments. Must not be <code>null</code>.
*
* @exception BuildException if the specified build file doesn't exist
* or is a directory.
*/
protected Main(String[] args) throws BuildException {
String searchForThis = null;
PrintStream logTo = null;
// cycle through given args
for (int i = 0; i < args.length; i++) {
String arg = args[i];
if (arg.equals("-help")) {
printUsage();
return;
} else if (arg.equals("-version")) {
printVersion();
return;
} else if (arg.equals("-diagnostics")){
Diagnostics.doReport(System.out);
return;
} else if (arg.equals("-quiet") || arg.equals("-q")) {
msgOutputLevel = Project.MSG_WARN;
} else if (arg.equals("-verbose") || arg.equals("-v")) {
printVersion();
msgOutputLevel = Project.MSG_VERBOSE;
} else if (arg.equals("-debug")) {
printVersion();
msgOutputLevel = Project.MSG_DEBUG;
} else if (arg.equals("-logfile") || arg.equals("-l")) {
try {
File logFile = new File(args[i + 1]);
i++;
logTo = new PrintStream(new FileOutputStream(logFile));
isLogFileUsed = true;
} catch (IOException ioe) {
String msg = "Cannot write on the specified log file. "
+ "Make sure the path exists and you have write "
+ "permissions.";
System.out.println(msg);
return;
} catch (ArrayIndexOutOfBoundsException aioobe) {
String msg = "You must specify a log file when " +
"using the -log argument";
System.out.println(msg);
return;
}
} else if (arg.equals("-buildfile") || arg.equals("-file")
|| arg.equals("-f")) {
try {
buildFile = new File(args[i + 1]);
i++;
} catch (ArrayIndexOutOfBoundsException aioobe) {
String msg = "You must specify a buildfile when " +
"using the -buildfile argument";
System.out.println(msg);
return;
}
} else if (arg.equals("-listener")) {
try {
listeners.addElement(args[i + 1]);
i++;
} catch (ArrayIndexOutOfBoundsException aioobe) {
String msg = "You must specify a classname when " +
"using the -listener argument";
System.out.println(msg);
return;
}
} else if (arg.startsWith("-D")) {
/* Interestingly enough, we get to here when a user
* uses -Dname=value. However, in some cases, the JDK
* goes ahead and parses this out to args
* {"-Dname", "value"}
* so instead of parsing on "=", we just make the "-D"
* characters go away and skip one argument forward.
*
* I don't know how to predict when the JDK is going
* to help or not, so we simply look for the equals sign.
*/
String name = arg.substring(2, arg.length());
String value = null;
int posEq = name.indexOf("=");
if (posEq > 0) {
value = name.substring(posEq + 1);
name = name.substring(0, posEq);
} else if (i < args.length - 1) {
value = args[++i];
}
definedProps.put(name, value);
} else if (arg.equals("-logger")) {
if (loggerClassname != null) {
System.out.println("Only one logger class may "
+ " be specified.");
return;
}
try {
loggerClassname = args[++i];
} catch (ArrayIndexOutOfBoundsException aioobe) {
System.out.println("You must specify a classname when " +
"using the -logger argument");
return;
}
} else if (arg.equals("-inputhandler")) {
if (inputHandlerClassname != null) {
System.out.println("Only one input handler class may " +
"be specified.");
return;
}
try {
inputHandlerClassname = args[++i];
} catch (ArrayIndexOutOfBoundsException aioobe) {
System.out.println("You must specify a classname when " +
"using the -inputhandler argument");
return;
}
} else if (arg.equals("-emacs")) {
emacsMode = true;
} else if (arg.equals("-projecthelp")) {
// set the flag to display the targets and quit
projectHelp = true;
} else if (arg.equals("-find")) {
// eat up next arg if present, default to build.xml
if (i < args.length - 1) {
searchForThis = args[++i];
} else {
searchForThis = DEFAULT_BUILD_FILENAME;
}
} else if (arg.startsWith("-propertyfile")) {
try {
propertyFiles.addElement(args[i + 1]);
i++;
} catch (ArrayIndexOutOfBoundsException aioobe) {
String msg = "You must specify a property filename when " +
"using the -propertyfile argument";
System.out.println(msg);
return;
}
} else if (arg.startsWith("-")) {
// we don't have any more args to recognize!
String msg = "Unknown argument: " + arg;
System.out.println(msg);
printUsage();
return;
} else {
// if it's no other arg, it may be the target
targets.addElement(arg);
}
}
// if buildFile was not specified on the command line,
if (buildFile == null) {
// but -find then search for it
if (searchForThis != null) {
buildFile = findBuildFile(System.getProperty("user.dir"),
searchForThis);
} else {
buildFile = new File(DEFAULT_BUILD_FILENAME);
}
}
// make sure buildfile exists
if (!buildFile.exists()) {
System.out.println("Buildfile: " + buildFile + " does not exist!");
throw new BuildException("Build failed");
}
// make sure it's not a directory (this falls into the ultra
// paranoid lets check everything catagory
if (buildFile.isDirectory()) {
System.out.println("What? Buildfile: " + buildFile + " is a dir!");
throw new BuildException("Build failed");
}
// Load the property files specified by -propertyfile
for (int propertyFileIndex = 0;
propertyFileIndex < propertyFiles.size();
propertyFileIndex++) {
String filename
= (String) propertyFiles.elementAt(propertyFileIndex);
Properties props = new Properties();
FileInputStream fis = null;
try {
fis = new FileInputStream(filename);
props.load(fis);
} catch (IOException e) {
System.out.println("Could not load property file "
+ filename + ": " + e.getMessage());
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e){
}
}
}
// ensure that -D properties take precedence
Enumeration propertyNames = props.propertyNames();
while (propertyNames.hasMoreElements()) {
String name = (String) propertyNames.nextElement();
if (definedProps.getProperty(name) == null) {
definedProps.put(name, props.getProperty(name));
}
}
}
if (msgOutputLevel >= Project.MSG_INFO) {
System.out.println("Buildfile: " + buildFile);
}
if (logTo != null) {
out = err = logTo;
System.setOut(out);
System.setErr(out);
}
readyToRun = true;
}
/**
* Helper to get the parent file for a given file.
* <p>
* Added to simulate File.getParentFile() from JDK 1.2.
*
* @param file File to find parent of. Must not be <code>null</code>.
* @return Parent file or null if none
*/
private File getParentFile(File file) {
String filename = file.getAbsolutePath();
file = new File(filename);
filename = file.getParent();
if (filename != null && msgOutputLevel >= Project.MSG_VERBOSE) {
System.out.println("Searching in " + filename);
}
return (filename == null) ? null : new File(filename);
}
/**
* Search parent directories for the build file.
* <p>
* Takes the given target as a suffix to append to each
* parent directory in seach of a build file. Once the
* root of the file-system has been reached an exception
* is thrown.
*
* @param start Leaf directory of search.
* Must not be <code>null</code>.
* @param suffix Suffix filename to look for in parents.
* Must not be <code>null</code>.
*
* @return A handle to the build file if one is found
*
* @exception BuildException if no build file is found
*/
private File findBuildFile(String start, String suffix)
throws BuildException {
if (msgOutputLevel >= Project.MSG_INFO) {
System.out.println("Searching for " + suffix + " ...");
}
File parent = new File(new File(start).getAbsolutePath());
File file = new File(parent, suffix);
// check if the target file exists in the current directory
while (!file.exists()) {
// change to parent directory
parent = getParentFile(parent);
// if parent is null, then we are at the root of the fs,
// complain that we can't find the build file.
if (parent == null) {
throw new BuildException("Could not locate a build file!");
}
// refresh our file handle
file = new File(parent, suffix);
}
return file;
}
/**
* Executes the build. If the constructor for this instance failed
* (e.g. returned after issuing a warning), this method returns
* immediately.
*
* @param coreLoader The classloader to use to find core classes.
* May be <code>null</code>, in which case the
* system classloader is used.
*
* @exception BuildException if the build fails
*/
private void runBuild(ClassLoader coreLoader) throws BuildException {
if (!readyToRun) {
return;
}
final Project project = new Project();
project.setCoreLoader(coreLoader);
Throwable error = null;
try {
addBuildListeners(project);
addInputHandler(project);
PrintStream err = System.err;
PrintStream out = System.out;
// use a system manager that prevents from System.exit()
// only in JDK > 1.1
SecurityManager oldsm = null;
if (!JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_0) &&
!JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_1)){
oldsm = System.getSecurityManager();
//SecurityManager can not be installed here for backwards
//compatability reasons (PD). Needs to be loaded prior to
//ant class if we are going to implement it.
//System.setSecurityManager(new NoExitSecurityManager());
}
try {
System.setOut(new PrintStream(new DemuxOutputStream(project, false)));
System.setErr(new PrintStream(new DemuxOutputStream(project, true)));
if (!projectHelp) {
project.fireBuildStarted();
}
project.init();
project.setUserProperty("ant.version", getAntVersion());
// set user-define properties
Enumeration e = definedProps.keys();
while (e.hasMoreElements()) {
String arg = (String) e.nextElement();
String value = (String) definedProps.get(arg);
project.setUserProperty(arg, value);
}
project.setUserProperty("ant.file",
buildFile.getAbsolutePath());
ProjectHelper.configureProject(project, buildFile);
if (projectHelp) {
printDescription(project);
printTargets(project, msgOutputLevel > Project.MSG_INFO);
return;
}
// make sure that we have a target to execute
if (targets.size() == 0) {
targets.addElement(project.getDefaultTarget());
}
project.executeTargets(targets);
} finally {
// put back the original security manager
//The following will never eval to true. (PD)
if (oldsm != null){
System.setSecurityManager(oldsm);
}
System.setOut(out);
System.setErr(err);
}
} catch (RuntimeException exc) {
error = exc;
throw exc;
} catch (Error err) {
error = err;
throw err;
} finally {
if (!projectHelp) {
project.fireBuildFinished(error);
}
}
}
/**
* Adds the listeners specified in the command line arguments,
* along with the default listener, to the specified project.
*
* @param project The project to add listeners to.
* Must not be <code>null</code>.
*/
protected void addBuildListeners(Project project) {
// Add the default listener
project.addBuildListener(createLogger());
for (int i = 0; i < listeners.size(); i++) {
String className = (String) listeners.elementAt(i);
try {
BuildListener listener =
(BuildListener) Class.forName(className).newInstance();
project.addBuildListener(listener);
} catch (Throwable exc) {
throw new BuildException("Unable to instantiate listener "
+ className, exc);
}
}
}
/**
* Creates the InputHandler and adds it to the project.
*
* @exception BuildException if a specified InputHandler
* implementation could not be loaded.
*/
private void addInputHandler(Project project) {
InputHandler handler = null;
if (inputHandlerClassname == null) {
handler = new DefaultInputHandler();
} else {
try {
handler = (InputHandler)
(Class.forName(inputHandlerClassname).newInstance());
} catch (ClassCastException e) {
String msg = "The specified input handler class "
+ inputHandlerClassname
+ " does not implement the InputHandler interface";
throw new BuildException(msg);
}
catch (Exception e) {
String msg = "Unable to instantiate specified input handler "
+ "class " + inputHandlerClassname + " : "
+ e.getClass().getName();
throw new BuildException(msg);
}
}
project.setInputHandler(handler);
}
// XXX: (Jon Skeet) Any reason for writing a message and then using a bare
// RuntimeException rather than just using a BuildException here? Is it
// in case the message could end up being written to no loggers (as the
// loggers could have failed to be created due to this failure)?
/**
* Creates the default build logger for sending build events to the ant
* log.
*
* @return the logger instance for this build.
*/
private BuildLogger createLogger() {
BuildLogger logger = null;
if (loggerClassname != null) {
try {
logger = (BuildLogger) (Class.forName(loggerClassname).newInstance());
} catch (ClassCastException e) {
System.err.println("The specified logger class "
+ loggerClassname
+ " does not implement the BuildLogger interface");
throw new RuntimeException();
} catch (Exception e) {
System.err.println("Unable to instantiate specified logger "
+ "class " + loggerClassname + " : "
+ e.getClass().getName());
throw new RuntimeException();
}
} else {
logger = new DefaultLogger();
}
logger.setMessageOutputLevel(msgOutputLevel);
logger.setOutputPrintStream(out);
logger.setErrorPrintStream(err);
logger.setEmacsMode(emacsMode);
return logger;
}
/**
* Prints the usage information for this class to <code>System.out</code>.
*/
private static void printUsage() {
String lSep = System.getProperty("line.separator");
StringBuffer msg = new StringBuffer();
msg.append("ant [options] [target [target2 [target3] ...]]" + lSep);
msg.append("Options: " + lSep);
msg.append(" -help print this message" + lSep);
msg.append(" -projecthelp print project help information" + lSep);
msg.append(" -version print the version information and exit" + lSep);
msg.append(" -diagnostics print information that might be helpful to" + lSep);
msg.append(" diagnose or report problems." + lSep);
msg.append(" -quiet, -q be extra quiet" + lSep);
msg.append(" -verbose, -v be extra verbose" + lSep);
msg.append(" -debug print debugging information" + lSep);
msg.append(" -emacs produce logging information without adornments" + lSep);
msg.append(" -logfile <file> use given file for log" + lSep);
msg.append(" -l <file> ''" + lSep);
msg.append(" -logger <classname> the class which is to perform logging" + lSep);
msg.append(" -listener <classname> add an instance of class as a project listener" + lSep);
msg.append(" -buildfile <file> use given buildfile" + lSep);
msg.append(" -file <file> ''" + lSep);
msg.append(" -f <file> ''" + lSep);
msg.append(" -D<property>=<value> use value for given property" + lSep);
msg.append(" -propertyfile <name> load all properties from file with -D" + lSep);
msg.append(" properties taking precedence" + lSep);
msg.append(" -inputhandler <class> the class which will handle input requests" + lSep);
msg.append(" -find <file> search for buildfile towards the root of the" + lSep);
msg.append(" filesystem and use it" + lSep);
System.out.println(msg.toString());
}
/**
* Prints the Ant version information to <code>System.out</code>.
*
* @exception BuildException if the version information is unavailable
*/
private static void printVersion() throws BuildException {
System.out.println(getAntVersion());
}
/**
* Cache of the Ant version information when it has been loaded.
*/
private static String antVersion = null;
/**
* Returns the Ant version information, if available. Once the information
* has been loaded once, it's cached and returned from the cache on future
* calls.
*
* @return the Ant version information as a String
* (always non-<code>null</code>)
*
* @exception BuildException if the version information is unavailable
*/
public static synchronized String getAntVersion() throws BuildException {
if (antVersion == null) {
try {
Properties props = new Properties();
InputStream in =
Main.class.getResourceAsStream("/org/apache/tools/ant/version.txt");
props.load(in);
in.close();
StringBuffer msg = new StringBuffer();
msg.append("Apache Ant version ");
msg.append(props.getProperty("VERSION"));
msg.append(" compiled on ");
msg.append(props.getProperty("DATE"));
antVersion = msg.toString();
} catch (IOException ioe) {
throw new BuildException("Could not load the version information:"
+ ioe.getMessage());
} catch (NullPointerException npe) {
throw new BuildException("Could not load the version information.");
}
}
return antVersion;
}
/**
* Prints the description of a project (if there is one) to
* <code>System.out</code>.
*
* @param project The project to display a description of.
* Must not be <code>null</code>.
*/
private static void printDescription(Project project) {
if (project.getDescription() != null) {
project.log(project.getDescription());
}
}
/**
* Prints a list of all targets in the specified project to
* <code>System.out</code>, optionally including subtargets.
*
* @param project The project to display a description of.
* Must not be <code>null</code>.
* @param printSubTargets Whether or not subtarget names should also be
* printed.
*/
private static void printTargets(Project project, boolean printSubTargets) {
// find the target with the longest name
int maxLength = 0;
Enumeration ptargets = project.getTargets().elements();
String targetName;
String targetDescription;
Target currentTarget;
// split the targets in top-level and sub-targets depending
// on the presence of a description
Vector topNames = new Vector();
Vector topDescriptions = new Vector();
Vector subNames = new Vector();
while (ptargets.hasMoreElements()) {
currentTarget = (Target) ptargets.nextElement();
targetName = currentTarget.getName();
targetDescription = currentTarget.getDescription();
// maintain a sorted list of targets
if (targetDescription == null) {
int pos = findTargetPosition(subNames, targetName);
subNames.insertElementAt(targetName, pos);
} else {
int pos = findTargetPosition(topNames, targetName);
topNames.insertElementAt(targetName, pos);
topDescriptions.insertElementAt(targetDescription, pos);
if (targetName.length() > maxLength) {
maxLength = targetName.length();
}
}
}
printTargets(project, topNames, topDescriptions, "Main targets:",
maxLength);
//if there were no main targets, we list all subtargets
//as it means nothing has a description
if(topNames.size()==0) {
printSubTargets=true;
}
if (printSubTargets) {
printTargets(project, subNames, null, "Subtargets:", 0);
}
String defaultTarget = project.getDefaultTarget();
if (defaultTarget != null && !"".equals(defaultTarget)) {
// shouldn't need to check but...
project.log("Default target: " + defaultTarget);
}
}
/**
* Searches for the correct place to insert a name into a list so as
* to keep the list sorted alphabetically.
*
* @param names The current list of names. Must not be <code>null</code>.
* @param name The name to find a place for.
* Must not be <code>null</code>.
*
* @return the correct place in the list for the given name
*/
private static int findTargetPosition(Vector names, String name) {
int res = names.size();
for (int i = 0; i < names.size() && res == names.size(); i++) {
if (name.compareTo((String) names.elementAt(i)) < 0) {
res = i;
}
}
return res;
}
/**
* Writes a formatted list of target names to <code>System.out</code>
* with an optional description.
*
* @param names The names to be printed.
* Must not be <code>null</code>.
* @param descriptions The associated target descriptions.
* May be <code>null</code>, in which case
* no descriptions are displayed.
* If non-<code>null</code>, this should have
* as many elements as <code>names</code>.
* @param heading The heading to display.
* Should not be <code>null</code>.
* @param maxlen The maximum length of the names of the targets.
* If descriptions are given, they are padded to this
* position so they line up (so long as the names really
* <i>are</i> shorter than this).
*/
private static void printTargets(Project project,Vector names,
Vector descriptions,String heading,
int maxlen) {
// now, start printing the targets and their descriptions
String lSep = System.getProperty("line.separator");
// got a bit annoyed that I couldn't find a pad function
String spaces = " ";
while (spaces.length() < maxlen) {
spaces += spaces;
}
StringBuffer msg = new StringBuffer();
msg.append(heading + lSep + lSep);
for (int i = 0; i < names.size(); i++) {
msg.append(" ");
msg.append(names.elementAt(i));
if (descriptions != null) {
msg.append(spaces.substring(0, maxlen - ((String) names.elementAt(i)).length() + 2));
msg.append(descriptions.elementAt(i));
}
msg.append(lSep);
}
project.log(msg.toString());
}
}