cvm.java

This is a resource based on j2me embedded,if you dont understand,you can connection with me .

/*
 * @(#)CVM.java	1.116 06/11/07
 *
 * Copyright  1990-2008 Sun Microsystems, Inc. All Rights Reserved.  
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER  
 *   
 * This program is free software; you can redistribute it and/or  
 * modify it under the terms of the GNU General Public License version  
 * 2 only, as published by the Free Software Foundation.   
 *   
 * This program is distributed in the hope that it will be useful, but  
 * WITHOUT ANY WARRANTY; without even the implied warranty of  
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU  
 * General Public License version 2 for more details (a copy is  
 * included at /legal/license.txt).   
 *   
 * You should have received a copy of the GNU General Public License  
 * version 2 along with this work; if not, write to the Free Software  
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  
 * 02110-1301 USA   
 *   
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa  
 * Clara, CA 95054 or visit www.sun.com if you need additional  
 * information or have any questions. 
 *
 */

package sun.misc;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;
import sun.misc.Version;
import java.io.FileInputStream;
import java.util.jar.JarFile;
import java.util.jar.Manifest;
import java.util.jar.Attributes;
import java.io.IOException;
import java.util.ArrayList;
import java.io.File;
import java.util.StringTokenizer;

public final class CVM {
    /** WARNING! NO STATIC INITIALIZER IS ALLOWED IN THIS CLASS!

	More precisely, no initial assignment is allowed to either of
	these two variables. */
    private static String mainClassName;
    private static String[] mainArgs;

    private static String savedNativeOptions;

    // The status of command-line argument parsing
    public static final int ARG_PARSE_UNINIT = 0;
    public static final int ARG_PARSE_OK     = 1;
    public static final int ARG_PARSE_ERR    = 2;
    public static final int ARG_PARSE_EXITVM = 3;
    public static final int ARG_PARSE_USAGE  = 4;

    private static int parseStatus; 

    private static void usage(String nativeOptions) {
	// Print usage statement
	System.err.println(
	    "usage: cvm [-fullversion] [-showversion] [-version] [-help] " + 
	    "[-D<property>=<value>] [-XbuildOptions] [-XshowBuildOptions] " +
	    "[-XappName=<value>] " + "[-cp <classpath> | -classpath <classpath>] " + 
	    nativeOptions +
	    "{<main class name> | -jar <jarfile> | -appletviewer <URL>} " + 
            "[<arguments>...]"
	);
    }

    /** Parse command line options handed up from ansiJavaMain through
	JNI_CreateJavaVM. This parses command line options like -D to
	define user-specified properties; it must be called after
	System.initializeSystemClass(). In its current usage it
	receives argv[1..(argc - 1)] in String form from the C
	initialization code, with "-Xcvm" prepended onto the main
	class and its arguments. This allows the building of the
	String array which will later be passed to main() to be done
	in Java. Note that it is not necessary to use this
	functionality. */
    public static int parseCommandLineOptions(String[] args,
						  String nativeOptions,
						  boolean ignoreUnrecognized)
    {
	parseStatus = ARG_PARSE_UNINIT;

	String pathSeparator = System.getProperty("path.separator", ":");
	ArrayList xrunArgs = new ArrayList();
	ArrayList agentlibArgs = new ArrayList();

	for (int i = 0; i < args.length; i++) {

	    /* %comment: rt039 */

            /* NOTE: It would be best to move the support for
               -XappName into the PP layer */
	    if (args[i].startsWith("-D") || args[i].startsWith("-XappName")) {
		if (!addUserProperty(args[i].substring(2))) {
		    System.err.println("Error parsing property " + args[i]);
		    usage(nativeOptions);
		    parseStatus = ARG_PARSE_ERR;
		    return parseStatus;
		}
	    } else if (args[i].startsWith("-version")) {
		Version.print(true); // Long version
		parseStatus = ARG_PARSE_EXITVM; // Don't parse any more
		return parseStatus;
	    } else if (args[i].startsWith("-showversion")) {
		Version.print(true); // Long version
		// continue with VM execution
            } else if (args[i].startsWith("-Xnoagent")) {
		// eat this old jdb launching option
                // continue with VM execution
	    } else if (args[i].startsWith("-Xtrace:")) {
		String traceArg = args[i].substring(8);
		int debugFlags = Integer.decode(traceArg).intValue();
		CVM.setDebugFlags(debugFlags);
		// continue with VM execution
	    } else if (args[i].startsWith("-agentlib") ||
		       args[i].startsWith("-agentpath")) {
		if (!agentlibSupported()) {
		    System.err.println("-agentlib, -agentpath not supported");
		    usage(nativeOptions);
		    parseStatus = ARG_PARSE_ERR;
		    return parseStatus;
		}
		agentlibArgs.add(args[i]);
		// continue with VM execution
	    } else if (args[i].startsWith("-Xrun")) {
		if (!xrunSupported()) {
		    System.err.println("-Xrun not supported");
		    usage(nativeOptions);
		    parseStatus = ARG_PARSE_ERR;
		    return parseStatus;
		}
		xrunArgs.add(args[i]);
		// continue with VM execution
	    } else if (args[i].startsWith("-Xdebug")) {
		if (!xdebugSet()) {
		    System.err.println("-Xdebug not supported, debugging not enabled");
		    usage(nativeOptions);
		    parseStatus = ARG_PARSE_ERR;
		    return parseStatus;
		}
		// continue with VM execution
	    } else if (args[i].startsWith("-XtimeStamping")) {
		TimeStamps.enable();
	    } else if (args[i].startsWith("-Xjit:")) {
		String jitArg = args[i].substring(6);
		if (!JIT.reparseJitOptions(jitArg)) {
		    System.err.println("Error parsing JIT args " + args[i]);
		    usage(nativeOptions);
		    parseStatus = ARG_PARSE_ERR;
		    return parseStatus;
		}
		// continue with VM execution
	    } else if (args[i].startsWith("-Xverify:")) {
		String verifyArg = args[i].substring(9);
		if (!CVM.parseVerifyOptions(verifyArg)) {
		    System.err.println("Error parsing verify args " + args[i]);
		    usage(nativeOptions);
		    parseStatus = ARG_PARSE_ERR;
		    return parseStatus;
		}
		// continue with VM execution
	    } else if (args[i].startsWith("-Xopt:")) {
		String xoptArg = args[i].substring(6);
		if (!CVM.parseXoptOptions(xoptArg)) {
		    System.err.println("Error parsing -Xopt args " + args[i]);
		    usage(nativeOptions);
		    parseStatus = ARG_PARSE_ERR;
		    return parseStatus;
		}
		// continue with VM execution
	    } else if (args[i].startsWith("-Xss")) {
		String xssArg = args[i].substring(4);
		if (!CVM.parseXssOption(xssArg)) {
		    System.err.println("Error parsing -Xss args " + args[i]);
		    usage(nativeOptions);
		    parseStatus = ARG_PARSE_ERR;
		    return parseStatus;
		}
		// continue with VM execution
	    } else if (args[i].startsWith("-Xgc:")) {
		String xgcArg = args[i].substring(5);
		if (!CVM.parseXgcOptions(xgcArg)) {
		    System.err.println("Error parsing -Xgc args " + args[i]);
		    usage(nativeOptions);
		    parseStatus = ARG_PARSE_ERR;
		    return parseStatus;
		}
		// continue with VM execution
	    } else if (args[i].startsWith("-fullversion")) {
		Version.print(false); // Short version
		parseStatus = ARG_PARSE_EXITVM; // Don't parse any more
		return parseStatus;
	    } else if (args[i].startsWith("-ea") ||
		       args[i].startsWith("-enableassertions") ||
		       args[i].startsWith("-da") ||
		       args[i].startsWith("-disableassertions") ||
	               args[i].startsWith("-esa") ||
		       args[i].startsWith("-enablesystemassertions") ||
		       args[i].startsWith("-dsa") ||
		       args[i].startsWith("-disablesystemassertions")) {
		if (!CVM.parseAssertionOptions(args[i])) {
		    System.err.println("Error parsing assertion args " + args[i]);
		    usage(nativeOptions);
		    parseStatus = ARG_PARSE_ERR;
		    return parseStatus;
		}
		// continue with VM execution
	    } else if (args[i].startsWith("-XbuildOptions")) {
		printBuildOptions();
		parseStatus = ARG_PARSE_EXITVM; // Don't parse any more
		return parseStatus;
	    } else if (args[i].startsWith("-XshowBuildOptions")) {
		printBuildOptions();
		// continue with VM execution
	    } else if (args[i].startsWith("-Xcvm") 
                       || args[i].startsWith("-Xjar")
                       || args[i].startsWith("-appletviewer")) {

		/* TODO: It would be best to move "-appletviewer" to
                   the PP layer */

                if (args[i].startsWith("-Xjar")) {
                  try {
                    // get main class name from manifest
                    JarFile jarFile = new JarFile(args[i].substring(6));
                    Manifest man = jarFile.getManifest();
                    Attributes attr;
		    mainClassName = null;
		    if (man != null){
			attr = man.getMainAttributes();
			mainClassName = attr.getValue("Main-Class");
		    }
                    if (mainClassName == null) {
                      System.err.println("-jar: Could not find Main-Class manifest attribute");
		      usage(nativeOptions);
		      parseStatus = ARG_PARSE_ERR;
		      return parseStatus;
                    }
                  } catch (IOException e) {
	              e.printStackTrace();
                      parseStatus = ARG_PARSE_ERR;
		      return parseStatus;
	          }             

                } else if (args[i].startsWith("-appletviewer")){
                  mainClassName = ("sun.applet.AppletViewer");
                } else {
		// We have to assume that everything else in the
		// command line options is the main class plus its
		// arguments.
                  mainClassName = args[i].substring(5);
                }


		if (mainClassName.startsWith("-") ||
		    mainClassName.length() == 0) 
		{
		    System.err.println("Main class name \"" +
				       mainClassName + "\" is not valid");
		    usage(nativeOptions);
		    parseStatus = ARG_PARSE_ERR;
		    return parseStatus;
		}
		mainClassName = mainClassName.replace('/', '.');
		
		int numMainArgs = args.length - i - 1;
		mainArgs = new String[numMainArgs];
		for (int j = 0; j < numMainArgs; j++) {
		    String arg = args[i + j + 1];
		    if (!arg.startsWith("-Xcvm")) {
			throw new InternalError(
		            "Illegal use of -Xcvm internal " +
			    "command line options"
			);
		    }
		    mainArgs[j] = arg.substring(5);
		}
		break;
// NOTE: do we really want to check all possible options here, or
// should the caller have filtered out the options that it understood?
	    } else {
		if (args[i].startsWith("-")) {
		    if (args[i].equals("-help")) {
			usage(nativeOptions);
			parseStatus = ARG_PARSE_USAGE; 
			return parseStatus;
		    }
		    if (!ignoreUnrecognized && 
                        !args[i].equals("-jar") &&
                        !args[i].equals("-cp") && 
                        !args[i].equals("-classpath") && 
                        !args[i].startsWith("-Xcp") &&
                        !args[i].startsWith("-Xms") &&
                        !args[i].startsWith("-Xmx") &&
                        !args[i].startsWith("-Xserver") &&
			!args[i].startsWith("-Xbootclasspath=") &&
			!args[i].startsWith("-Xbootclasspath:") &&
			!args[i].startsWith("-Xbootclasspath/a=") &&
			!args[i].startsWith("-Xbootclasspath/a:")) {
			System.err.println("Unrecognized option " + args[i]);
			usage(nativeOptions);
			parseStatus = ARG_PARSE_ERR;
			return parseStatus;