359 do { \
360 if ((*env)->ExceptionOccurred(env)) { \
361 JLI_ReportExceptionDescription(env); \
362 LEAVE(); \
363 } \
364 if ((CENL_exception) == NULL) { \
365 JLI_ReportErrorMessage(JNI_ERROR); \
366 LEAVE(); \
367 } \
368 } while (JNI_FALSE)
369
370 #define CHECK_EXCEPTION_LEAVE(CEL_return_value) \
371 do { \
372 if ((*env)->ExceptionOccurred(env)) { \
373 JLI_ReportExceptionDescription(env); \
374 ret = (CEL_return_value); \
375 LEAVE(); \
376 } \
377 } while (JNI_FALSE)
378
379
380 int JNICALL
381 JavaMain(void * _args)
382 {
383 JavaMainArgs *args = (JavaMainArgs *)_args;
384 int argc = args->argc;
385 char **argv = args->argv;
386 int mode = args->mode;
387 char *what = args->what;
388 InvocationFunctions ifn = args->ifn;
389
390 JavaVM *vm = 0;
391 JNIEnv *env = 0;
392 jclass mainClass = NULL;
393 jclass appClass = NULL; // actual application class being launched
394 jmethodID mainID;
395 jobjectArray mainArgs;
396 int ret = 0;
397 jlong start, end;
398
1512 {
1513 int len = (int)JLI_StrLen(s);
1514 jbyteArray ary;
1515 jclass cls = GetLauncherHelperClass(env);
1516 NULL_CHECK0(cls);
1517 if (s == NULL)
1518 return 0;
1519
1520 ary = (*env)->NewByteArray(env, len);
1521 if (ary != 0) {
1522 jstring str = 0;
1523 (*env)->SetByteArrayRegion(env, ary, 0, len, (jbyte *)s);
1524 if (!(*env)->ExceptionOccurred(env)) {
1525 if (makePlatformStringMID == NULL) {
1526 NULL_CHECK0(makePlatformStringMID = (*env)->GetStaticMethodID(env,
1527 cls, "makePlatformString", "(Z[B)Ljava/lang/String;"));
1528 }
1529 str = (*env)->CallStaticObjectMethod(env, cls,
1530 makePlatformStringMID, USE_STDERR, ary);
1531 (*env)->DeleteLocalRef(env, ary);
1532 return str;
1533 }
1534 }
1535 return 0;
1536 }
1537
1538 /*
1539 * Returns a new array of Java string objects for the specified
1540 * array of platform strings.
1541 */
1542 jobjectArray
1543 NewPlatformStringArray(JNIEnv *env, char **strv, int strc)
1544 {
1545 jarray cls;
1546 jarray ary;
1547 int i;
1548
1549 NULL_CHECK0(cls = FindBootStrapClass(env, "java/lang/String"));
1550 NULL_CHECK0(ary = (*env)->NewObjectArray(env, strc, cls, 0));
1551 for (i = 0; i < strc; i++) {
1563 */
1564 static jclass
1565 LoadMainClass(JNIEnv *env, int mode, char *name)
1566 {
1567 jmethodID mid;
1568 jstring str;
1569 jobject result;
1570 jlong start, end;
1571 jclass cls = GetLauncherHelperClass(env);
1572 NULL_CHECK0(cls);
1573 if (JLI_IsTraceLauncher()) {
1574 start = CounterGet();
1575 }
1576 NULL_CHECK0(mid = (*env)->GetStaticMethodID(env, cls,
1577 "checkAndLoadMain",
1578 "(ZILjava/lang/String;)Ljava/lang/Class;"));
1579
1580 NULL_CHECK0(str = NewPlatformString(env, name));
1581 NULL_CHECK0(result = (*env)->CallStaticObjectMethod(env, cls, mid,
1582 USE_STDERR, mode, str));
1583
1584 if (JLI_IsTraceLauncher()) {
1585 end = CounterGet();
1586 printf("%ld micro seconds to load main class\n",
1587 (long)(jint)Counter2Micros(end-start));
1588 printf("----%s----\n", JLDEBUG_ENV_ENTRY);
1589 }
1590
1591 return (jclass)result;
1592 }
1593
1594 static jclass
1595 GetApplicationClass(JNIEnv *env)
1596 {
1597 jmethodID mid;
1598 jclass cls = GetLauncherHelperClass(env);
1599 NULL_CHECK0(cls);
1600 NULL_CHECK0(mid = (*env)->GetStaticMethodID(env, cls,
1601 "getApplicationClass",
1602 "()Ljava/lang/Class;"));
1603
1604 return (*env)->CallStaticObjectMethod(env, cls, mid);
1605 }
1606
1607 /*
1608 * For tools, convert command line args thus:
1609 * javac -cp foo:foo/"*" -J-ms32m ...
1610 * java -ms32m -cp JLI_WildcardExpandClasspath(foo:foo/"*") ...
1611 *
1612 * Takes 4 parameters, and returns the populated arguments
1613 */
1614 static void
1615 TranslateApplicationArgs(int jargc, const char **jargv, int *pargc, char ***pargv)
1616 {
1617 int argc = *pargc;
1618 char **argv = *pargv;
1619 int nargc = argc + jargc;
1620 char **nargv = JLI_MemAlloc((nargc + 1) * sizeof(char *));
1621 int i;
1622
1623 *pargc = nargc;
1624 *pargv = nargv;
1795 }
1796
1797 /*
1798 * Prints the version information from the java.version and other properties.
1799 */
1800 static void
1801 PrintJavaVersion(JNIEnv *env, jboolean extraLF)
1802 {
1803 jclass ver;
1804 jmethodID print;
1805
1806 NULL_CHECK(ver = FindBootStrapClass(env, "java/lang/VersionProps"));
1807 NULL_CHECK(print = (*env)->GetStaticMethodID(env,
1808 ver,
1809 (extraLF == JNI_TRUE) ? "println" : "print",
1810 "()V"
1811 )
1812 );
1813
1814 (*env)->CallStaticVoidMethod(env, ver, print);
1815 }
1816
1817 /*
1818 * Prints all the Java settings, see the java implementation for more details.
1819 */
1820 static void
1821 ShowSettings(JNIEnv *env, char *optString)
1822 {
1823 jmethodID showSettingsID;
1824 jstring joptString;
1825 jclass cls = GetLauncherHelperClass(env);
1826 NULL_CHECK(cls);
1827 NULL_CHECK(showSettingsID = (*env)->GetStaticMethodID(env, cls,
1828 "showSettings", "(ZLjava/lang/String;JJJZ)V"));
1829 NULL_CHECK(joptString = (*env)->NewStringUTF(env, optString));
1830 (*env)->CallStaticVoidMethod(env, cls, showSettingsID,
1831 USE_STDERR,
1832 joptString,
1833 (jlong)initialHeapSize,
1834 (jlong)maxHeapSize,
1835 (jlong)threadStackSize,
1836 ServerClassMachine());
1837 }
1838
1839 /**
1840 * List modules supported by the runtime
1841 */
1842 static void
1843 ListModules(JNIEnv *env, char *optString)
1844 {
1845 jmethodID listModulesID;
1846 jstring joptString = NULL;
1847 jclass cls = GetLauncherHelperClass(env);
1848 NULL_CHECK(cls);
1849 NULL_CHECK(listModulesID = (*env)->GetStaticMethodID(env, cls,
1850 "listModules", "(ZLjava/lang/String;)V"));
1851 NULL_CHECK(joptString = (*env)->NewStringUTF(env, optString));
1852 (*env)->CallStaticVoidMethod(env, cls, listModulesID,
1853 USE_STDERR,
1854 joptString);
1855 }
1856
1857 /*
1858 * Prints default usage or the Xusage message, see sun.launcher.LauncherHelper.java
1859 */
1860 static void
1861 PrintUsage(JNIEnv* env, jboolean doXUsage)
1862 {
1863 jmethodID initHelp, vmSelect, vmSynonym, vmErgo, printHelp, printXUsageMessage;
1864 jstring jprogname, vm1, vm2;
1865 int i;
1866 jclass cls = GetLauncherHelperClass(env);
1867 NULL_CHECK(cls);
1868 if (doXUsage) {
1869 NULL_CHECK(printXUsageMessage = (*env)->GetStaticMethodID(env, cls,
1870 "printXUsageMessage", "(Z)V"));
1871 (*env)->CallStaticVoidMethod(env, cls, printXUsageMessage, USE_STDERR);
1872 } else {
1873 NULL_CHECK(initHelp = (*env)->GetStaticMethodID(env, cls,
1874 "initHelpMessage", "(Ljava/lang/String;)V"));
1875
1876 NULL_CHECK(vmSelect = (*env)->GetStaticMethodID(env, cls, "appendVmSelectMessage",
1877 "(Ljava/lang/String;Ljava/lang/String;)V"));
1878
1879 NULL_CHECK(vmSynonym = (*env)->GetStaticMethodID(env, cls,
1880 "appendVmSynonymMessage",
1881 "(Ljava/lang/String;Ljava/lang/String;)V"));
1882 NULL_CHECK(vmErgo = (*env)->GetStaticMethodID(env, cls,
1883 "appendVmErgoMessage", "(ZLjava/lang/String;)V"));
1884
1885 NULL_CHECK(printHelp = (*env)->GetStaticMethodID(env, cls,
1886 "printHelpMessage", "(Z)V"));
1887
1888 NULL_CHECK(jprogname = (*env)->NewStringUTF(env, _program_name));
1889
1890 /* Initialize the usage message with the usual preamble */
1891 (*env)->CallStaticVoidMethod(env, cls, initHelp, jprogname);
1916 CHECK_EXCEPTION_RETURN();
1917 }
1918 }
1919
1920 /* The first known VM is the default */
1921 {
1922 jboolean isServerClassMachine = ServerClassMachine();
1923
1924 const char* defaultVM = knownVMs[0].name+1;
1925 if ((knownVMs[0].flag == VM_IF_SERVER_CLASS) && isServerClassMachine) {
1926 defaultVM = knownVMs[0].server_class+1;
1927 }
1928
1929 NULL_CHECK(vm1 = (*env)->NewStringUTF(env, defaultVM));
1930 (*env)->CallStaticVoidMethod(env, cls, vmErgo, isServerClassMachine, vm1);
1931 CHECK_EXCEPTION_RETURN();
1932 }
1933
1934 /* Complete the usage message and print to stderr*/
1935 (*env)->CallStaticVoidMethod(env, cls, printHelp, USE_STDERR);
1936 }
1937 return;
1938 }
1939
1940 /*
1941 * Read the jvm.cfg file and fill the knownJVMs[] array.
1942 *
1943 * The functionality of the jvm.cfg file is subject to change without
1944 * notice and the mechanism will be removed in the future.
1945 *
1946 * The lexical structure of the jvm.cfg file is as follows:
1947 *
1948 * jvmcfg := { vmLine }
1949 * vmLine := knownLine
1950 * | aliasLine
1951 * | warnLine
1952 * | ignoreLine
1953 * | errorLine
1954 * | predicateLine
1955 * | commentLine
|
359 do { \
360 if ((*env)->ExceptionOccurred(env)) { \
361 JLI_ReportExceptionDescription(env); \
362 LEAVE(); \
363 } \
364 if ((CENL_exception) == NULL) { \
365 JLI_ReportErrorMessage(JNI_ERROR); \
366 LEAVE(); \
367 } \
368 } while (JNI_FALSE)
369
370 #define CHECK_EXCEPTION_LEAVE(CEL_return_value) \
371 do { \
372 if ((*env)->ExceptionOccurred(env)) { \
373 JLI_ReportExceptionDescription(env); \
374 ret = (CEL_return_value); \
375 LEAVE(); \
376 } \
377 } while (JNI_FALSE)
378
379 #define CHECK_EXCEPTION_PRINT() \
380 do { \
381 if ((*env)->ExceptionOccurred(env)) { \
382 JLI_ReportExceptionDescription(env); \
383 } \
384 } while (JNI_FALSE)
385
386 int JNICALL
387 JavaMain(void * _args)
388 {
389 JavaMainArgs *args = (JavaMainArgs *)_args;
390 int argc = args->argc;
391 char **argv = args->argv;
392 int mode = args->mode;
393 char *what = args->what;
394 InvocationFunctions ifn = args->ifn;
395
396 JavaVM *vm = 0;
397 JNIEnv *env = 0;
398 jclass mainClass = NULL;
399 jclass appClass = NULL; // actual application class being launched
400 jmethodID mainID;
401 jobjectArray mainArgs;
402 int ret = 0;
403 jlong start, end;
404
1518 {
1519 int len = (int)JLI_StrLen(s);
1520 jbyteArray ary;
1521 jclass cls = GetLauncherHelperClass(env);
1522 NULL_CHECK0(cls);
1523 if (s == NULL)
1524 return 0;
1525
1526 ary = (*env)->NewByteArray(env, len);
1527 if (ary != 0) {
1528 jstring str = 0;
1529 (*env)->SetByteArrayRegion(env, ary, 0, len, (jbyte *)s);
1530 if (!(*env)->ExceptionOccurred(env)) {
1531 if (makePlatformStringMID == NULL) {
1532 NULL_CHECK0(makePlatformStringMID = (*env)->GetStaticMethodID(env,
1533 cls, "makePlatformString", "(Z[B)Ljava/lang/String;"));
1534 }
1535 str = (*env)->CallStaticObjectMethod(env, cls,
1536 makePlatformStringMID, USE_STDERR, ary);
1537 (*env)->DeleteLocalRef(env, ary);
1538 CHECK_EXCEPTION_PRINT();
1539 return str;
1540 }
1541 }
1542 return 0;
1543 }
1544
1545 /*
1546 * Returns a new array of Java string objects for the specified
1547 * array of platform strings.
1548 */
1549 jobjectArray
1550 NewPlatformStringArray(JNIEnv *env, char **strv, int strc)
1551 {
1552 jarray cls;
1553 jarray ary;
1554 int i;
1555
1556 NULL_CHECK0(cls = FindBootStrapClass(env, "java/lang/String"));
1557 NULL_CHECK0(ary = (*env)->NewObjectArray(env, strc, cls, 0));
1558 for (i = 0; i < strc; i++) {
1570 */
1571 static jclass
1572 LoadMainClass(JNIEnv *env, int mode, char *name)
1573 {
1574 jmethodID mid;
1575 jstring str;
1576 jobject result;
1577 jlong start, end;
1578 jclass cls = GetLauncherHelperClass(env);
1579 NULL_CHECK0(cls);
1580 if (JLI_IsTraceLauncher()) {
1581 start = CounterGet();
1582 }
1583 NULL_CHECK0(mid = (*env)->GetStaticMethodID(env, cls,
1584 "checkAndLoadMain",
1585 "(ZILjava/lang/String;)Ljava/lang/Class;"));
1586
1587 NULL_CHECK0(str = NewPlatformString(env, name));
1588 NULL_CHECK0(result = (*env)->CallStaticObjectMethod(env, cls, mid,
1589 USE_STDERR, mode, str));
1590 CHECK_EXCEPTION_PRINT();
1591
1592 if (JLI_IsTraceLauncher()) {
1593 end = CounterGet();
1594 printf("%ld micro seconds to load main class\n",
1595 (long)(jint)Counter2Micros(end-start));
1596 printf("----%s----\n", JLDEBUG_ENV_ENTRY);
1597 }
1598
1599 return (jclass)result;
1600 }
1601
1602 static jclass
1603 GetApplicationClass(JNIEnv *env)
1604 {
1605 jmethodID mid;
1606 jclass cls = GetLauncherHelperClass(env);
1607 NULL_CHECK0(cls);
1608 NULL_CHECK0(mid = (*env)->GetStaticMethodID(env, cls,
1609 "getApplicationClass",
1610 "()Ljava/lang/Class;"));
1611
1612 cls = (*env)->CallStaticObjectMethod(env, cls, mid);
1613 CHECK_EXCEPTION_PRINT();
1614 return cls;
1615 }
1616
1617 /*
1618 * For tools, convert command line args thus:
1619 * javac -cp foo:foo/"*" -J-ms32m ...
1620 * java -ms32m -cp JLI_WildcardExpandClasspath(foo:foo/"*") ...
1621 *
1622 * Takes 4 parameters, and returns the populated arguments
1623 */
1624 static void
1625 TranslateApplicationArgs(int jargc, const char **jargv, int *pargc, char ***pargv)
1626 {
1627 int argc = *pargc;
1628 char **argv = *pargv;
1629 int nargc = argc + jargc;
1630 char **nargv = JLI_MemAlloc((nargc + 1) * sizeof(char *));
1631 int i;
1632
1633 *pargc = nargc;
1634 *pargv = nargv;
1805 }
1806
1807 /*
1808 * Prints the version information from the java.version and other properties.
1809 */
1810 static void
1811 PrintJavaVersion(JNIEnv *env, jboolean extraLF)
1812 {
1813 jclass ver;
1814 jmethodID print;
1815
1816 NULL_CHECK(ver = FindBootStrapClass(env, "java/lang/VersionProps"));
1817 NULL_CHECK(print = (*env)->GetStaticMethodID(env,
1818 ver,
1819 (extraLF == JNI_TRUE) ? "println" : "print",
1820 "()V"
1821 )
1822 );
1823
1824 (*env)->CallStaticVoidMethod(env, ver, print);
1825 CHECK_EXCEPTION_PRINT();
1826 }
1827
1828 /*
1829 * Prints all the Java settings, see the java implementation for more details.
1830 */
1831 static void
1832 ShowSettings(JNIEnv *env, char *optString)
1833 {
1834 jmethodID showSettingsID;
1835 jstring joptString;
1836 jclass cls = GetLauncherHelperClass(env);
1837 NULL_CHECK(cls);
1838 NULL_CHECK(showSettingsID = (*env)->GetStaticMethodID(env, cls,
1839 "showSettings", "(ZLjava/lang/String;JJJZ)V"));
1840 NULL_CHECK(joptString = (*env)->NewStringUTF(env, optString));
1841 (*env)->CallStaticVoidMethod(env, cls, showSettingsID,
1842 USE_STDERR,
1843 joptString,
1844 (jlong)initialHeapSize,
1845 (jlong)maxHeapSize,
1846 (jlong)threadStackSize,
1847 ServerClassMachine());
1848 CHECK_EXCEPTION_PRINT();
1849 }
1850
1851 /**
1852 * List modules supported by the runtime
1853 */
1854 static void
1855 ListModules(JNIEnv *env, char *optString)
1856 {
1857 jmethodID listModulesID;
1858 jstring joptString = NULL;
1859 jclass cls = GetLauncherHelperClass(env);
1860 NULL_CHECK(cls);
1861 NULL_CHECK(listModulesID = (*env)->GetStaticMethodID(env, cls,
1862 "listModules", "(ZLjava/lang/String;)V"));
1863 NULL_CHECK(joptString = (*env)->NewStringUTF(env, optString));
1864 (*env)->CallStaticVoidMethod(env, cls, listModulesID,
1865 USE_STDERR,
1866 joptString);
1867 CHECK_EXCEPTION_PRINT();
1868 }
1869
1870 /*
1871 * Prints default usage or the Xusage message, see sun.launcher.LauncherHelper.java
1872 */
1873 static void
1874 PrintUsage(JNIEnv* env, jboolean doXUsage)
1875 {
1876 jmethodID initHelp, vmSelect, vmSynonym, vmErgo, printHelp, printXUsageMessage;
1877 jstring jprogname, vm1, vm2;
1878 int i;
1879 jclass cls = GetLauncherHelperClass(env);
1880 NULL_CHECK(cls);
1881 if (doXUsage) {
1882 NULL_CHECK(printXUsageMessage = (*env)->GetStaticMethodID(env, cls,
1883 "printXUsageMessage", "(Z)V"));
1884 (*env)->CallStaticVoidMethod(env, cls, printXUsageMessage, USE_STDERR);
1885 CHECK_EXCEPTION_PRINT();
1886 } else {
1887 NULL_CHECK(initHelp = (*env)->GetStaticMethodID(env, cls,
1888 "initHelpMessage", "(Ljava/lang/String;)V"));
1889
1890 NULL_CHECK(vmSelect = (*env)->GetStaticMethodID(env, cls, "appendVmSelectMessage",
1891 "(Ljava/lang/String;Ljava/lang/String;)V"));
1892
1893 NULL_CHECK(vmSynonym = (*env)->GetStaticMethodID(env, cls,
1894 "appendVmSynonymMessage",
1895 "(Ljava/lang/String;Ljava/lang/String;)V"));
1896 NULL_CHECK(vmErgo = (*env)->GetStaticMethodID(env, cls,
1897 "appendVmErgoMessage", "(ZLjava/lang/String;)V"));
1898
1899 NULL_CHECK(printHelp = (*env)->GetStaticMethodID(env, cls,
1900 "printHelpMessage", "(Z)V"));
1901
1902 NULL_CHECK(jprogname = (*env)->NewStringUTF(env, _program_name));
1903
1904 /* Initialize the usage message with the usual preamble */
1905 (*env)->CallStaticVoidMethod(env, cls, initHelp, jprogname);
1930 CHECK_EXCEPTION_RETURN();
1931 }
1932 }
1933
1934 /* The first known VM is the default */
1935 {
1936 jboolean isServerClassMachine = ServerClassMachine();
1937
1938 const char* defaultVM = knownVMs[0].name+1;
1939 if ((knownVMs[0].flag == VM_IF_SERVER_CLASS) && isServerClassMachine) {
1940 defaultVM = knownVMs[0].server_class+1;
1941 }
1942
1943 NULL_CHECK(vm1 = (*env)->NewStringUTF(env, defaultVM));
1944 (*env)->CallStaticVoidMethod(env, cls, vmErgo, isServerClassMachine, vm1);
1945 CHECK_EXCEPTION_RETURN();
1946 }
1947
1948 /* Complete the usage message and print to stderr*/
1949 (*env)->CallStaticVoidMethod(env, cls, printHelp, USE_STDERR);
1950 CHECK_EXCEPTION_RETURN();
1951 }
1952 return;
1953 }
1954
1955 /*
1956 * Read the jvm.cfg file and fill the knownJVMs[] array.
1957 *
1958 * The functionality of the jvm.cfg file is subject to change without
1959 * notice and the mechanism will be removed in the future.
1960 *
1961 * The lexical structure of the jvm.cfg file is as follows:
1962 *
1963 * jvmcfg := { vmLine }
1964 * vmLine := knownLine
1965 * | aliasLine
1966 * | warnLine
1967 * | ignoreLine
1968 * | errorLine
1969 * | predicateLine
1970 * | commentLine
|