FileDocCategorySizeDatePackage
Launcher.javaAPI DocApache Ant 1.7012212Wed Dec 13 06:16:22 GMT 2006org.apache.tools.ant.launch

Launcher

public class Launcher extends Object
This is a launcher for Ant.
since
Ant 1.6

Fields Summary
public static final String
ANTHOME_PROPERTY
The Ant Home (installation) Directory property. {@value}
public static final String
ANTLIBDIR_PROPERTY
The Ant Library Directory property. {@value}
public static final String
ANT_PRIVATEDIR
The directory name of the per-user ant directory. {@value}
public static final String
ANT_PRIVATELIB
The name of a per-user library directory. {@value}
public static final String
USER_LIBDIR
The location of a per-user library directory.

It's value is the concatenation of {@link #ANT_PRIVATEDIR} with {@link #ANT_PRIVATELIB}, with an appropriate file separator in between. For example, on Unix, it's .ant/lib.

public static final String
MAIN_CLASS
The startup class that is to be run. {@value}
public static final String
USER_HOMEDIR
System property with user home directory. {@value}
private static final String
JAVA_CLASS_PATH
System property with application classpath. {@value}
protected static final int
EXIT_CODE_ERROR
Exit code on trouble
Constructors Summary
Methods Summary
private voidaddPath(java.lang.String path, boolean getJars, java.util.List libPathURLs)
Add a CLASSPATH or -lib to lib path urls.

param
path the classpath or lib path to add to the libPathULRLs
param
getJars if true and a path is a directory, add the jars in the directory to the path urls
param
libPathURLs the list of paths to add to

        StringTokenizer tokenizer = new StringTokenizer(path, File.pathSeparator);
        while (tokenizer.hasMoreElements()) {
            String elementName = tokenizer.nextToken();
            File element = new File(elementName);
            if (elementName.indexOf("%") != -1 && !element.exists()) {
                continue;
            }
            if (getJars && element.isDirectory()) {
                // add any jars in the directory
                URL[] dirURLs = Locator.getLocationURLs(element);
                for (int j = 0; j < dirURLs.length; ++j) {
                    libPathURLs.add(dirURLs[j]);
                }
            }

            libPathURLs.add(Locator.fileToURL(element));
        }
private java.net.URL[]getJarArray(java.net.URL[] libJars, java.net.URL[] userJars, java.net.URL[] systemJars, java.io.File toolsJar)
Combine the various jar sources into a single array of jars.

param
libJars the jars specified in -lib command line options
param
userJars the jars in ~/.ant/lib
param
systemJars the jars in $ANT_HOME/lib
param
toolsJar the tools.jar file
return
a combined array
throws
MalformedURLException if there is a problem.

        int numJars = libJars.length + userJars.length + systemJars.length;
        if (toolsJar != null) {
            numJars++;
        }
        URL[] jars = new URL[numJars];
        System.arraycopy(libJars, 0, jars, 0, libJars.length);
        System.arraycopy(userJars, 0, jars, libJars.length, userJars.length);
        System.arraycopy(systemJars, 0, jars, userJars.length + libJars.length,
            systemJars.length);

        if (toolsJar != null) {
            jars[jars.length - 1] = Locator.fileToURL(toolsJar);
        }
        return jars;
private java.net.URL[]getLibPathURLs(java.lang.String cpString, java.util.List libPaths)
Get the list of -lib enties and -cp entry into a URL array.

param
cpString the classpath string
param
libPaths the list of -lib entries.
return
an array of URLs.

        List libPathURLs = new ArrayList();

        if (cpString != null) {
            addPath(cpString, false, libPathURLs);
        }

        for (Iterator i = libPaths.iterator(); i.hasNext();) {
            String libPath = (String) i.next();
            addPath(libPath, true, libPathURLs);
        }

        return  (URL[]) libPathURLs.toArray(new URL[libPathURLs.size()]);
private java.net.URL[]getSystemURLs(java.io.File antLauncherDir)
Get the jar files in ANT_HOME/lib. determine ant library directory for system jars: use property or default using location of ant-launcher.jar

        File antLibDir = null;
        String antLibDirProperty = System.getProperty(ANTLIBDIR_PROPERTY);
        if (antLibDirProperty != null) {
            antLibDir = new File(antLibDirProperty);
        }
        if ((antLibDir == null) || !antLibDir.exists()) {
            antLibDir = antLauncherDir;
            System.setProperty(ANTLIBDIR_PROPERTY, antLibDir.getAbsolutePath());
        }
        return Locator.getLocationURLs(antLibDir);
private java.net.URL[]getUserURLs()
Get the jar files in user.home/.ant/lib

        File userLibDir
            = new File(System.getProperty(USER_HOMEDIR), USER_LIBDIR);

        return Locator.getLocationURLs(userLibDir);
public static voidmain(java.lang.String[] args)
Entry point for starting command line Ant.

param
args commandline arguments


                     
         
        int exitCode;
        try {
            Launcher launcher = new Launcher();
            exitCode = launcher.run(args);
        } catch (LaunchException e) {
            exitCode = EXIT_CODE_ERROR;
            System.err.println(e.getMessage());
        } catch (Throwable t) {
            exitCode = EXIT_CODE_ERROR;
            t.printStackTrace(System.err);
        }
        if (exitCode != 0) {
            System.exit(exitCode);
        }
private intrun(java.lang.String[] args)
Run the launcher to launch Ant.

param
args the command line arguments
return
an exit code. As the normal ant main calls exit when it ends, this is for handling failures at bind-time
exception
MalformedURLException if the URLs required for the classloader cannot be created.

        String antHomeProperty = System.getProperty(ANTHOME_PROPERTY);
        File antHome = null;

        File sourceJar = Locator.getClassSource(getClass());
        File jarDir = sourceJar.getParentFile();
        String mainClassname = MAIN_CLASS;

        if (antHomeProperty != null) {
            antHome = new File(antHomeProperty);
        }

        if (antHome == null || !antHome.exists()) {
            antHome = jarDir.getParentFile();
            System.setProperty(ANTHOME_PROPERTY, antHome.getAbsolutePath());
        }

        if (!antHome.exists()) {
            throw new LaunchException("Ant home is set incorrectly or "
                + "ant could not be located");
        }

        List libPaths = new ArrayList();
        String cpString = null;
        List argList = new ArrayList();
        String[] newArgs;
        boolean  noUserLib = false;
        boolean  noClassPath = false;

        for (int i = 0; i < args.length; ++i) {
            if (args[i].equals("-lib")) {
                if (i == args.length - 1) {
                    throw new LaunchException("The -lib argument must "
                        + "be followed by a library location");
                }
                libPaths.add(args[++i]);
            } else if (args[i].equals("-cp")) {
                if (i == args.length - 1) {
                    throw new LaunchException("The -cp argument must "
                        + "be followed by a classpath expression");
                }
                if (cpString != null) {
                    throw new LaunchException("The -cp argument must "
                        + "not be repeated");
                }
                cpString = args[++i];
            } else if (args[i].equals("--nouserlib") || args[i].equals("-nouserlib")) {
                noUserLib = true;
            } else if (args[i].equals("--noclasspath") || args[i].equals("-noclasspath")) {
                noClassPath = true;
            } else if (args[i].equals("-main")) {
                if (i == args.length - 1) {
                    throw new LaunchException("The -main argument must "
                            + "be followed by a library location");
                }
                mainClassname = args[++i];
            } else {
                argList.add(args[i]);
            }
        }

        //decide whether to copy the existing arg set, or
        //build a new one from the list of all args excluding the special
        //operations that only we handle
        if (argList.size() == args.length) {
            newArgs = args;
        } else {
            newArgs = (String[]) argList.toArray(new String[argList.size()]);
        }

        URL[] libURLs    = getLibPathURLs(
            noClassPath ? null : cpString, libPaths);
        URL[] systemURLs = getSystemURLs(jarDir);
        URL[] userURLs   = noUserLib ? new URL[0] : getUserURLs();

        URL[] jars = getJarArray(
            libURLs, userURLs, systemURLs, Locator.getToolsJar());

        // now update the class.path property
        StringBuffer baseClassPath
            = new StringBuffer(System.getProperty(JAVA_CLASS_PATH));
        if (baseClassPath.charAt(baseClassPath.length() - 1)
                == File.pathSeparatorChar) {
            baseClassPath.setLength(baseClassPath.length() - 1);
        }

        for (int i = 0; i < jars.length; ++i) {
            baseClassPath.append(File.pathSeparatorChar);
            baseClassPath.append(Locator.fromURI(jars[i].toString()));
        }

        System.setProperty(JAVA_CLASS_PATH, baseClassPath.toString());

        URLClassLoader loader = new URLClassLoader(jars);
        Thread.currentThread().setContextClassLoader(loader);
        Class mainClass = null;
        int exitCode = 0;
        try {
            mainClass = loader.loadClass(mainClassname);
            AntMain main = (AntMain) mainClass.newInstance();
            main.startAnt(newArgs, null, null);
        } catch (InstantiationException ex) {
            System.err.println(
                "Incompatible version of " + mainClassname + " detected");
            File mainJar = Locator.getClassSource(mainClass);
            System.err.println(
                "Location of this class " + mainJar);
            exitCode = EXIT_CODE_ERROR;
        } catch (Throwable t) {
            t.printStackTrace(System.err);
            exitCode = EXIT_CODE_ERROR;
        }
        return exitCode;