jdk-sandbox: comparison jdk/src/share/bin/java.c

equal deleted inserted replaced

-:710d839c5cfa
+:78536cac0841
 /*
 * Prototypes for functions internal to launcher.
 */
 static void SetClassPath(const char *s);
-static void SetModulesBootClassPath(const char *s);
 static void SelectVersion(int argc, char **argv, char **main_class);
-static jboolean ParseArguments(int *pargc, char ***pargv, char **pjarfile,
+static jboolean ParseArguments(int *pargc, char ***pargv,
-char **pclassname, int *pret, const char *jvmpath);
+int *pmode, char **pwhat,
+int *pret, const char *jrepath);
 static jboolean InitializeJVM(JavaVM **pvm, JNIEnv **penv,
 InvocationFunctions *ifn);
 static jstring NewPlatformString(JNIEnv *env, char *s);
 static jobjectArray NewPlatformStringArray(JNIEnv *env, char **strv, int strc);
-static jclass LoadMainClass(JNIEnv *env, jboolean isJar, char *name);
+static jclass LoadMainClass(JNIEnv *env, int mode, char *name);
 static void TranslateApplicationArgs(int jargc, const char **jargv, int *pargc, char ***pargv);
 static jboolean AddApplicationOptions(int cpathc, const char **cpathv);
 static void SetApplicationClassPath(const char**);
 /*
 * Running Java code in primordial thread caused many problems. We will
 * create a new thread to invoke JVM. See 6316197 for more information.
 */
-static jlong threadStackSize    = 0;  /* stack size of the new thread */
+static jlong threadStackSize = 0;  /* stack size of the new thread */
 static jlong maxHeapSize        = 0;  /* max heap size */
 static jlong initialHeapSize    = 0;  /* inital heap size */
 int JNICALL JavaMain(void * args); /* entry point                  */
+enum LaunchMode {               // cf. sun.launcher.LauncherHelper
+LM_UNKNOWN = 0,
+LM_CLASS,
+LM_JAR
+};
+static const char *launchModeNames[]
+= { "Unknown", "Main class", "JAR file" };
 typedef struct {
-int     argc;
+int    argc;
-char ** argv;
+char **argv;
-char *  jarfile;
+int    mode;
-char *  classname;
+char  *what;
 InvocationFunctions ifn;
 } JavaMainArgs;
 /*
 * Entry point.
 */
 jboolean cpwildcard,                    /* classpath wildcard*/
 jboolean javaw,                         /* windows-only javaw */
 jint ergo                               /* ergonomics class policy */
 )
 {
-char *jarfile = 0;
+int mode = LM_UNKNOWN;
-char *classname = 0;
+char *what = NULL;
 char *cpath = 0;
 char *main_class = NULL;
 int ret;
 InvocationFunctions ifn;
 jlong start, end;
 cpath = ".";
 }
 SetClassPath(cpath);
 }
-/*
+/* Parse command line options; if the return value of
-*  Parse command line options; if the return value of
+* ParseArguments is false, the program should exit.
-*  ParseArguments is false, the program should exit.
 */
-if (!ParseArguments(&argc, &argv, &jarfile, &classname, &ret, jvmpath)) {
+if (!ParseArguments(&argc, &argv, &mode, &what, &ret, jrepath))
+{
 return(ret);
 }
-/* Set bootclasspath for modules */
-SetModulesBootClassPath(jrepath);
 /* Override class path if -jar flag was specified */
-if (jarfile != 0) {
+if (mode == LM_JAR) {
-SetClassPath(jarfile);
+SetClassPath(what);     /* Override class path */
 }
 /* set the -Dsun.java.command pseudo property */
-SetJavaCommandLineProp(classname, jarfile, argc, argv);
+SetJavaCommandLineProp(what, argc, argv);
 /* Set the -Dsun.java.launcher pseudo property */
 SetJavaLauncherProp();
 /* set the -Dsun.java.launcher.* platform properties */
 SetJavaLauncherPlatformProps();
 /* Show the splash screen if needed */
 ShowSplashScreen();
-return ContinueInNewThread(&ifn, argc, argv, jarfile, classname, ret);
+return ContinueInNewThread(&ifn, argc, argv, mode, what, ret);
 }
 /*
 * Always detach the main thread so that it appears to have ended when
 * the application's main method exits.  This will invoke the
 JavaMain(void * _args)
 {
 JavaMainArgs *args = (JavaMainArgs *)_args;
 int argc = args->argc;
 char **argv = args->argv;
-char *jarfile = args->jarfile;
+int mode = args->mode;
-char *classname = args->classname;
+char *what = args->what;
 InvocationFunctions ifn = args->ifn;
 JavaVM *vm = 0;
 JNIEnv *env = 0;
-jclass mainClass;
+jclass mainClass = NULL;
 jmethodID mainID;
 jobjectArray mainArgs;
 int ret = 0;
 jlong start, end;
 if (showSettings != NULL) {
 ShowSettings(env, showSettings);
 CHECK_EXCEPTION_LEAVE(1);
 }
 /* If the user specified neither a class name nor a JAR file */
-if (printXUsage || printUsage || (jarfile == 0 && classname == 0)) {
+if (printXUsage || printUsage || what == 0 || mode == LM_UNKNOWN) {
 PrintUsage(env, printXUsage);
 CHECK_EXCEPTION_LEAVE(1);
 LEAVE();
 }
 end = CounterGet();
 JLI_TraceLauncher("%ld micro seconds to InitializeJVM\n",
 (long)(jint)Counter2Micros(end-start));
 }
-/* At this stage, argc/argv have the applications' arguments */
+/* At this stage, argc/argv have the application's arguments */
 if (JLI_IsTraceLauncher()){
 int i;
-printf("Main-Class is '%s'\n", classname ? classname : "");
+printf("%s is '%s'\n", launchModeNames[mode], what);
-printf("Apps' argc is %d\n", argc);
+printf("App's argc is %d\n", argc);
 for (i=0; i < argc; i++) {
 printf("    argv[%2d] = '%s'\n", i, argv[i]);
 }
 }
 *          Main-Class attribute gets properly passed through
 *          all environments,
 *     2)   Remove the vestages of maintaining main_class through
 *          the environment (and remove these comments).
 */
-if (jarfile != 0) {
+mainClass = LoadMainClass(env, mode, what);
-mainClass = LoadMainClass(env, JNI_TRUE, jarfile);
-} else {
-mainClass = LoadMainClass(env, JNI_FALSE, classname);
-}
 CHECK_EXCEPTION_NULL_LEAVE(mainClass);
 /*
 * The LoadMainClass not only loads the main class, it will also ensure
 * that the main method's signature is correct, therefore further checking
 }
 if (JLI_StrCCmp(str, "-Xms") == 0) {
 jlong tmp;
 if (parse_size(str + 4, &tmp)) {
 initialHeapSize = tmp;
 }
 }
 }
 static void
 {
 char *def;
 const char *orig = s;
 static const char format[] = "-Djava.class.path=%s";
 s = JLI_WildcardExpandClasspath(s);
-def = JLI_MemAlloc(sizeof(format)
-- 2 /* strlen("%s") */
-+ JLI_StrLen(s));
-sprintf(def, format, s);
-AddOption(def, NULL);
-if (s != orig)
-JLI_MemFree((char *) s);
-}
-/*
-* Set the bootclasspath for modules.
-* A temporary workaround until jigsaw is integrated into JDK 7.
-*/
-static void
-SetModulesBootClassPath(const char *jrepath)
-{
-char *def, *s;
-char pathname[MAXPATHLEN];
-const char separator[] = { FILE_SEPARATOR, '\0' };
-const char *orig = jrepath;
-static const char format[] = "-Xbootclasspath/p:%s";
-struct stat statbuf;
-/* return if jre/lib/rt.jar exists */
-JLI_Snprintf(pathname, sizeof(pathname), "%s%slib%srt.jar", jrepath, separator, separator);
-if (stat(pathname, &statbuf) == 0) {
-return;
-}
-/* return if jre/classes exists */
-JLI_Snprintf(pathname, sizeof(pathname), "%s%sclasses", jrepath, separator);
-if (stat(pathname, &statbuf) == 0) {
-return;
-}
-/* modularized jre */
-JLI_Snprintf(pathname, sizeof(pathname), "%s%slib%s*", jrepath, separator, separator);
-s = (char *) JLI_WildcardExpandClasspath(pathname);
 def = JLI_MemAlloc(sizeof(format)
 - 2 /* strlen("%s") */
 + JLI_StrLen(s));
 sprintf(def, format, s);
 AddOption(def, NULL);
 }
 /*
 * Parses command line arguments.  Returns JNI_FALSE if launcher
 * should exit without starting vm, returns JNI_TRUE if vm needs
-* to be started to process  given options. *pret (the launcher
+* to be started to process given options.  *pret (the launcher
 * process return value) is set to 0 for a normal exit.
 */
 static jboolean
-ParseArguments(int *pargc, char ***pargv, char **pjarfile,
+ParseArguments(int *pargc, char ***pargv,
-char **pclassname, int *pret, const char *jvmpath)
+int *pmode, char **pwhat,
+int *pret, const char *jrepath)
 {
 int argc = *pargc;
 char **argv = *pargv;
-jboolean jarflag = JNI_FALSE;
+int mode = LM_UNKNOWN;
 char *arg;
 *pret = 0;
 while ((arg = *argv) != 0 && *arg == '-') {
 argv++; --argc;
 if (JLI_StrCmp(arg, "-classpath") == 0 || JLI_StrCmp(arg, "-cp") == 0) {
 ARG_CHECK (argc, ARG_ERROR1, arg);
 SetClassPath(*argv);
+mode = LM_CLASS;
 argv++; --argc;
 } else if (JLI_StrCmp(arg, "-jar") == 0) {
 ARG_CHECK (argc, ARG_ERROR2, arg);
-jarflag = JNI_TRUE;
+mode = LM_JAR;
 } else if (JLI_StrCmp(arg, "-help") == 0 ||
 JLI_StrCmp(arg, "-h") == 0 ||
 JLI_StrCmp(arg, "-?") == 0) {
 printUsage = JNI_TRUE;
 return JNI_TRUE;
 AddOption(arg, NULL);
 }
 }
 if (--argc >= 0) {
-if (jarflag) {
+*pwhat = *argv++;
-*pjarfile = *argv++;
+}
-*pclassname = NULL;
-} else {
+if (*pwhat == NULL) {
-*pjarfile = NULL;
+*pret = 1;
-*pclassname = *argv++;
+} else if (mode == LM_UNKNOWN) {
-}
+/* default to LM_CLASS if -jar and -cp option are
+* not specified */
+mode = LM_CLASS;
+}
+if (argc >= 0) {
 *pargc = argc;
 *pargv = argv;
 }
-if (*pjarfile == NULL && *pclassname == NULL) {
-*pret = 1;
+*pmode = mode;
-}
 return JNI_TRUE;
 }
 /*
 * Initializes the Java Virtual Machine. Also frees options array when
 /*
 * Loads a class and verifies that the main class is present and it is ok to
 * call it for more details refer to the java implementation.
 */
 static jclass
-LoadMainClass(JNIEnv *env, jboolean isJar, char *name)
+LoadMainClass(JNIEnv *env, int mode, char *name)
 {
 jclass cls;
 jmethodID mid;
 jstring str;
 jobject result;
 if (JLI_IsTraceLauncher()) {
 start = CounterGet();
 }
 NULL_CHECK0(cls = FindBootStrapClass(env, "sun/launcher/LauncherHelper"));
 NULL_CHECK0(mid = (*env)->GetStaticMethodID(env, cls, "checkAndLoadMain",
-"(ZZLjava/lang/String;)Ljava/lang/Object;"));
+"(ZILjava/lang/String;)Ljava/lang/Class;"));
 str = (*env)->NewStringUTF(env, name);
-result = (*env)->CallStaticObjectMethod(env, cls, mid, JNI_TRUE, isJar, str);
+result = (*env)->CallStaticObjectMethod(env, cls, mid, JNI_TRUE, mode, str);
 if (JLI_IsTraceLauncher()) {
 end   = CounterGet();
 printf("%ld micro seconds to load main class\n",
 (long)(jint)Counter2Micros(end-start));
 * (or jar file name) and the arguments to the class's main method
 * to the instrumentation memory region. The sun.java.command pseudo
 * property is not exported by HotSpot to the Java layer.
 */
 void
-SetJavaCommandLineProp(char *classname, char *jarfile,
+SetJavaCommandLineProp(char *what, int argc, char **argv)
-int argc, char **argv)
 {
 int i = 0;
 size_t len = 0;
 char* javaCommand = NULL;
 char* dashDstr = "-Dsun.java.command=";
-if (classname == NULL && jarfile == NULL) {
+if (what == NULL) {
 /* unexpected, one of these should be set. just return without
 * setting the property
 */
 return;
 }
-/* if the class name is not set, then use the jarfile name */
-if (classname == NULL) {
-classname = jarfile;
-}
 /* determine the amount of memory to allocate assuming
 * the individual components will be space separated
 */
-len = JLI_StrLen(classname);
+len = JLI_StrLen(what);
 for (i = 0; i < argc; i++) {
 len += JLI_StrLen(argv[i]) + 1;
 }
 /* allocate the memory */
 javaCommand = (char*) JLI_MemAlloc(len + JLI_StrLen(dashDstr) + 1);
 /* build the -D string */
 *javaCommand = '\0';
 JLI_StrCat(javaCommand, dashDstr);
-JLI_StrCat(javaCommand, classname);
+JLI_StrCat(javaCommand, what);
 for (i = 0; i < argc; i++) {
 /* the components of the string are space separated. In
 * the case of embedded white space, the relationship of
 * the white space separated components to their true
 /*
 * JVM would like to know if it's created by a standard Sun launcher, or by
 * user native application, the following property indicates the former.
 */
-void SetJavaLauncherProp() {
+void
+SetJavaLauncherProp() {
 AddOption("-Dsun.java.launcher=SUN_STANDARD", NULL);
 }
 /*
 * Prints the version information from the java.version and other properties.
 {
 return _wc_enabled;
 }
 static int
-ContinueInNewThread(InvocationFunctions* ifn, int argc,
+ContinueInNewThread(InvocationFunctions* ifn, int argc, char **argv,
-char **argv, char *jarfile, char *classname, int ret)
+int mode, char *what, int ret)
 {
 /*
 * If user doesn't specify stack size, check if VM has a preference.
 * Note that HotSpot no longer supports JNI_VERSION_1_1 but it will
 JavaMainArgs args;
 int rslt;
 args.argc = argc;
 args.argv = argv;
-args.jarfile = jarfile;
+args.mode = mode;
-args.classname = classname;
+args.what = what;
 args.ifn = *ifn;
 rslt = ContinueInNewThread0(JavaMain, threadStackSize, (void*)&args);
 /* If the caller has deemed there is an error we
 * simply return that, otherwise we return the value of

changeset 7997	78536cac0841
parent 7810	d4730191e53c
child 8174	89e3a22d4cd7