update/org.eclipse.update/src/org/eclipse/update/internal/ui/Main.java

package org.eclipse.update.internal.ui;
/*
 * (c) Copyright IBM Corp. 2000, 2001.
 * All Rights Reserved.
 */

import java.net.*;
import java.lang.reflect.*;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.util.Vector;
/**
 * Startup class for Eclipse. Creates a class loader using
 * supplied URL of platform installation, loads and calls
 * the Eclipse Boot Loader
 */
public class Main {
	protected boolean debug = false;
	protected boolean usage = false;
	protected String bootLocation = null;
	protected String application;
	protected URL pluginPathLocation;
	protected String location;

	// constants
	private static final String APPLICATION = "-application";
	private static final String BOOT = "-boot";
	private static final String DEBUG = "-debug";
	private static final String USAGE = "-?";
	private static final String BOOTLOADER = "org.eclipse.core.boot.BootLoader";

	// The project containing the boot loader code.  This is used to construct
	// the correct class path for running in VAJ and VAME.
	private static final String PROJECT_NAME = "Eclipse Core Boot";

	private static boolean inVAJ;
	static {
		try {
			Class.forName("com.ibm.uvm.lang.ProjectClassLoader");
			inVAJ = true;
		} catch (Exception e) {
			inVAJ = false;
		}
	}
	private static boolean inVAME;
	static {
		try {
			Class.forName("com.ibm.eclipse.VAME");
			inVAME = true;
		} catch (Exception e) {
			inVAME = false;
		}
	}

protected void basicRun(String[] args) throws Exception {
	Class clazz = getBootLoader(bootLocation);
	Method method = clazz.getDeclaredMethod("run", new Class[] { String.class, URL.class, String.class, String[].class });
	try {
		method.invoke(clazz, new Object[] { application, pluginPathLocation, location, args });
	} catch (InvocationTargetException e) {
		if (e.getTargetException() instanceof Error)
			throw (Error) e.getTargetException();
		else
			throw e;
	}
}
public Class getBootLoader(String base) throws Exception {
	URLClassLoader loader = new URLClassLoader(new URL[] { getBootURL(base)}, null);
	return loader.loadClass(BOOTLOADER);
}
/**
 * Returns the <code>URL</code> where the boot classes are located.
 */
protected URL getBootURL(String base) throws MalformedURLException {
	URL url = null;
	if (base != null) 
		return new URL(base);
	// Create a URL based on the location of this class' code.
	// strip off jar file and/or last directory to get 
	// to the directory containing projects.
	url = getClass().getProtectionDomain().getCodeSource().getLocation();
	String path = url.getFile();
	if (path.endsWith(".jar"))
		path = path.substring(0, path.lastIndexOf("/"));
	if (path.endsWith("/"))
		path = path.substring(0, path.length() - 1);
	if (inVAJ || inVAME) {
		int ix = path.lastIndexOf("/");
		path = path.substring(0, ix + 1);
		path = path + PROJECT_NAME + "/";
	} else
		path = path + "/plugins/org.eclipse.core.boot/boot.jar";
	return new URL(url.getProtocol(), url.getHost(), url.getPort(), path);
}
/**
 * Print the usage of this launcher on the system console
 */
protected void printUsage(PrintWriter out) {
	out.println("The general form of using the Platform bootstrap main is:");
	out.println("      java <main class> -application <name> [option list]");
	out.println("where the required arguments are:");
	out.println("      -application <name> : the application to run ");
	out.println("and where the option list can be any number of the following:");
	out.println("      -platform <location> : run in the given location");
	out.println("      -debug [debug options file] : turn on debug mode.  Read debug options from ");
	out.println("          the specified file or from ./.options if not specified.");
	out.println("      -? : print this message");
	out.flush();
}
protected String[] processCommandLine(String[] args) throws Exception {
	int[] configArgs = new int[100];
	configArgs[0] = -1; // need to initialize the first element to something that could not be an index.
	int configArgIndex = 0;
	for (int i = 0; i < args.length; i++) {
		boolean found = false;
		// check for args without parameters (i.e., a flag arg)
		// check if debug should be enabled for the entire platform
		if (args[i].equalsIgnoreCase(DEBUG)) {
			debug = true;
			// passed thru this arg (i.e., do not set found = true
		}

		// look for the usage flag
		if (args[i].equalsIgnoreCase(USAGE)) {
			usage = true;
			// passed thru this arg (i.e., do not set found = true
		}

		if (found) {
			configArgs[configArgIndex++] = i;
			continue;
		}
		// check for args with parameters. If we are at the last argument or if the next one
		// has a '-' as the first character, then we can't have an arg with a parm so continue.
		if (i == args.length - 1 || args[i + 1].startsWith("-")) {
			continue;
		}
		String arg = args[++i];

		// look for the laucher to run
		if (args[i - 1].equalsIgnoreCase(BOOT)) {
			found = true;
			bootLocation = arg;
		}

		// look for the application to run
		if (args[i - 1].equalsIgnoreCase(APPLICATION)) {
			found = true;
			application = arg;
		}

		// done checking for args.  Remember where an arg was found 
		if (found) {
			configArgs[configArgIndex++] = i - 1;
			configArgs[configArgIndex++] = i;
		}
	}

	// remove all the arguments consumed by this argument parsing
	if (configArgIndex == 0)
		return args;
	String[] passThruArgs = new String[args.length - configArgIndex];
	configArgIndex = 0;
	int j = 0;
	for (int i = 0; i < args.length; i++) {
		if (i == configArgs[configArgIndex])
			configArgIndex++;
		else
			passThruArgs[j++] = args[i];
	}
	return passThruArgs;
}
public void run(String[] args) throws Exception {
	String[] passThruArgs = processCommandLine(args);
	if (usage) {
		printUsage(new PrintWriter(System.out));
		return;
	}
	basicRun(passThruArgs);
}
}