int main(int argc, char ** argv)
{
    char *jarfile = 0;
    char *classname = 0;
    char *s = 0;
    char *main_class = NULL;
    int ret;
    InvocationFunctions ifn;
    jlong start, end;
    char jrepath[MAXPATHLEN], jvmpath[MAXPATHLEN];
    char ** original_argv = argv;

    if (getenv("_JAVA_LAUNCHER_DEBUG") != 0) {
        _launcher_debug = JNI_TRUE;
        printf("----_JAVA_LAUNCHER_DEBUG----\n");
    }
    ...
    ...
}

CreateExecutionEnvironment(&argc, &argv,
                           jrepath, sizeof(jrepath),
                           jvmpath, sizeof(jvmpath),
                           original_argv);

/*
 *  Parse command line options; if the return value of
 *  ParseArguments is false, the program should exit.
 */
if (!ParseArguments(&argc, &argv, &jarfile, &classname, &ret, jvmpath)) {
  exit(ret);
}

/* Override class path if -jar flag was specified */
if (jarfile != 0) {
    SetClassPath(jarfile);
}

/* set the -Dsun.java.command pseudo property */
SetJavaCommandLineProp(classname, jarfile, argc, argv);

/* Set the -Dsun.java.launcher pseudo property */
SetJavaLauncherProp();

/* set the -Dsun.java.launcher.* platform properties */
SetJavaLauncherPlatformProps();

// -Xmn for compatibility with other JVM vendors
   } else if (match_option(option, "-Xmn", &tail)) {
     julong long_initial_eden_size = 0;
     ArgsRange errcode = parse_memory_size(tail, &long_initial_eden_size, 1);
     if (errcode != arg_in_range) {
       jio_fprintf(defaultStream::error_stream(),
                   "Invalid initial eden size: %s\n", option->optionString);
       describe_range_error(errcode);
       return JNI_EINVAL;
     }
     FLAG_SET_CMDLINE(uintx, MaxNewSize, (uintx)long_initial_eden_size);
     FLAG_SET_CMDLINE(uintx, NewSize, (uintx)long_initial_eden_size);
   // -Xms
   } else if (match_option(option, "-Xms", &tail)) {
     julong long_initial_heap_size = 0;
     ArgsRange errcode = parse_memory_size(tail, &long_initial_heap_size, 1);
     if (errcode != arg_in_range) {
       jio_fprintf(defaultStream::error_stream(),
                   "Invalid initial heap size: %s\n", option->optionString);
       describe_range_error(errcode);
       return JNI_EINVAL;
     }
     FLAG_SET_CMDLINE(uintx, InitialHeapSize, (uintx)long_initial_heap_size);
     // Currently the minimum size and the initial heap sizes are the same.
     set_min_heap_size(InitialHeapSize);
   // -Xmx
   } else if (match_option(option, "-Xmx", &tail)) {
     julong long_max_heap_size = 0;
     ArgsRange errcode = parse_memory_size(tail, &long_max_heap_size, 1);
     if (errcode != arg_in_range) {
       jio_fprintf(defaultStream::error_stream(),
                   "Invalid maximum heap size: %s\n", option->optionString);
       describe_range_error(errcode);
       return JNI_EINVAL;
     }
     FLAG_SET_CMDLINE(uintx, MaxHeapSize, (uintx)long_max_heap_size);
   // Xmaxf
   } else if (match_option(option, "-Xmaxf", &tail)) {
     int maxf = (int)(atof(tail) * 100);
     if (maxf < 0 || maxf > 100) {
       jio_fprintf(defaultStream::error_stream(),
                   "Bad max heap free percentage size: %s\n",
                   option->optionString);
       return JNI_EINVAL;
     } else {
       FLAG_SET_CMDLINE(uintx, MaxHeapFreeRatio, maxf);
     }
   // Xminf
   } else if (match_option(option, "-Xminf", &tail)) {
     int minf = (int)(atof(tail) * 100);
     if (minf < 0 || minf > 100) {
       jio_fprintf(defaultStream::error_stream(),
                   "Bad min heap free percentage size: %s\n",
                   option->optionString);
       return JNI_EINVAL;
     } else {
       FLAG_SET_CMDLINE(uintx, MinHeapFreeRatio, minf);
     }

bool Arguments::check_gc_consistency() {
  bool status = true;
  // Ensure that the user has not selected conflicting sets
  // of collectors. [Note: this check is merely a user convenience;
  // collectors over-ride each other so that only a non-conflicting
  // set is selected; however what the user gets is not what they
  // may have expected from the combination they asked for. It's
  // better to reduce user confusion by not allowing them to
  // select conflicting combinations.
  uint i = 0;
  if (UseSerialGC)                       i++;
  if (UseConcMarkSweepGC || UseParNewGC) i++;
  if (UseParallelGC || UseParallelOldGC) i++;
  if (UseG1GC)                           i++;
  if (i > 1) {
    jio_fprintf(defaultStream::error_stream(),
                "Conflicting collector combinations in option list; "
                "please refer to the release notes for the combinations "
                "allowed\n");
    status = false;
  }

  return status;
}

if (threadStackSize == 0) {
    struct JDK1_1InitArgs args1_1;
    memset((void*)&args1_1, 0, sizeof(args1_1));
    args1_1.version = JNI_VERSION_1_1;
    ifn.GetDefaultJavaVMInitArgs(&args1_1);  /* ignore return value */
    if (args1_1.javaStackSize > 0) {
       threadStackSize = args1_1.javaStackSize;
    }
  }

{ /* Create a new thread to create JVM and invoke main method */
      struct JavaMainArgs args;

      args.argc = argc;
      args.argv = argv;
      args.jarfile = jarfile;
      args.classname = classname;
      args.ifn = ifn;

      return ContinueInNewThread(JavaMain, threadStackSize, (void*)&args);
    }

if (jarfile != 0) {
    mainClassName = GetMainClassName(env, jarfile);
    if ((*env)->ExceptionOccurred(env)) {
        ReportExceptionDescription(env);
        goto leave;
    }
    if (mainClassName == NULL) {
      const char * format = "Failed to load Main-Class manifest "
                            "attribute from\n%s";
      message = (char*)JLI_MemAlloc((strlen(format) + strlen(jarfile)) *
                                sizeof(char));
      sprintf(message, format, jarfile);
      messageDest = JNI_TRUE;
      goto leave;
    }
    classname = (char *)(*env)->GetStringUTFChars(env, mainClassName, 0);
    if (classname == NULL) {
        ReportExceptionDescription(env);
        goto leave;
    }
    mainClass = LoadClass(env, classname);
    if(mainClass == NULL) { /* exception occured */
        const char * format = "Could not find the main class: %s. Program will exit.";
        ReportExceptionDescription(env);
        message = (char *)JLI_MemAlloc((strlen(format) +
                                        strlen(classname)) * sizeof(char) );
        messageDest = JNI_TRUE;
        sprintf(message, format, classname);
        goto leave;
    }
    (*env)->ReleaseStringUTFChars(env, mainClassName, classname);
} else {
  mainClassName = NewPlatformString(env, classname);
  if (mainClassName == NULL) {
    const char * format = "Failed to load Main Class: %s";
    message = (char *)JLI_MemAlloc((strlen(format) + strlen(classname)) *
                               sizeof(char) );
    sprintf(message, format, classname);
    messageDest = JNI_TRUE;
    goto leave;
  }
  classname = (char *)(*env)->GetStringUTFChars(env, mainClassName, 0);
  if (classname == NULL) {
    ReportExceptionDescription(env);
    goto leave;
  }
  mainClass = LoadClass(env, classname);
  if(mainClass == NULL) { /* exception occured */
    const char * format = "Could not find the main class: %s.  Program will exit.";
    ReportExceptionDescription(env);
    message = (char *)JLI_MemAlloc((strlen(format) +
                                    strlen(classname)) * sizeof(char) );
    messageDest = JNI_TRUE;
    sprintf(message, format, classname);
    goto leave;
  }
  (*env)->ReleaseStringUTFChars(env, mainClassName, classname);
}

/* Get the application's main method */
   mainID = (*env)->GetStaticMethodID(env, mainClass, "main",
                                      "([Ljava/lang/String;)V");
   if (mainID == NULL) {
       if ((*env)->ExceptionOccurred(env)) {
           ReportExceptionDescription(env);
       } else {
         message = "No main method found in specified class.";
         messageDest = JNI_TRUE;
       }
       goto leave;
   }

   {    /* Make sure the main method is public */
       jint mods;
       jmethodID mid;
       jobject obj = (*env)->ToReflectedMethod(env, mainClass,
                                               mainID, JNI_TRUE);

       if( obj == NULL) { /* exception occurred */
           ReportExceptionDescription(env);
           goto leave;
       }

       mid =
         (*env)->GetMethodID(env,
                             (*env)->GetObjectClass(env, obj),
                             "getModifiers", "()I");
       if ((*env)->ExceptionOccurred(env)) {
           ReportExceptionDescription(env);
           goto leave;
       }

       mods = (*env)->CallIntMethod(env, obj, mid);
       if ((mods & 1) == 0) { /* if (!Modifier.isPublic(mods)) ... */
           message = "Main method not public.";
           messageDest = JNI_TRUE;
           goto leave;
       }
   }

/* Invoke main method. */
(*env)->CallStaticVoidMethod(env, mainClass, mainID, mainArgs);