DiagnosticsDialog::DiagnosticsDialog(QWidget* parent):
QDialog(parent)
{
mUI.setupUi(this);
QObject::connect(
mUI.clipboardButton, SIGNAL(clicked()),
this, SLOT(copyToClipboard())
);
QObject::connect(
mUI.closeButton, SIGNAL(clicked()),
this, SLOT(hide())
);
dumpVersionInfo();
}
/* note - this cannot be static, since it's called externally by WinMain, for instance */
UDATA VMCALL gpProtectedMain(void *arg)
{
struct j9cmdlineOptions *startupOptions = (struct j9cmdlineOptions *) arg;
int argc = startupOptions->argc;
char **argv = startupOptions->argv;
J9StringBuffer *javaHome = NULL, *classPath = NULL, *bootLibraryPath = NULL, *javaLibraryPath = NULL;
J9PortLibrary *j9portLibrary = startupOptions->portLibrary;
JavaVM *jvm = NULL;
JNIEnv *env = NULL;
JavaVMInitArgs vm_args;
int rc = 1, i, javaRc = 0;
UDATA classArg = argc;
char *mainClass = NULL;
void *vmOptionsTable = NULL;
int isStandaloneJar = 0;
int isStandaloneJxe = 0;
int jxeArg = 0;
int copyrightWritten = 0;
int writeVersion = 0;
int isNameUTF = 0;
#if defined(J9VM_OPT_JXE_LOAD_SUPPORT)
void *jxeUtil = NULL;
void *jxeName = NULL;
#if defined(NEUTRINO)
int jxeSpaceArg = 0;
#endif /* NEUTRINO */
#endif /* J9VM_OPT_JXE_LOAD_SUPPORT */
#ifdef J9VM_STATIC_LINKAGE
J9StringBuffer *jclArg = NULL;
extern const char jclOption[];
extern const char *jclExtraLibs;
#endif
extern const char *jclProfile;
main_setNLSCatalog(j9portLibrary, argv);
/*
we start by scanning the command line, looking for the first arg that does not have a - in front of it. This is
taken to be the class we are trying to load. NB: skip argv[0], the exe name.
Include some lightweight integrity checking. */
for (i = 1; i < argc; i++) {
if ('-' != argv[i][0]) {
classArg = i;
mainClass = argv[i];
break;
} else if ((strcmp("-cp", argv[i]) == 0) || (strcmp("-classpath", argv[i]) == 0)) {
if ((i + 1) >= argc) {
/* "\n%s requires a parameter\n" */
j9portLibrary->nls_printf(j9portLibrary, J9NLS_ERROR, J9NLS_EXE_REQUIRES_PARM, argv[i]);
dumpHelpText(j9portLibrary, argc, argv, ©rightWritten);
return 0;
}
i++; /* Skip the next arg */
}
if (0 == strcmp("-version", argv[i])) {
writeVersion = 2;
}
if (0 == strcmp("-showversion", argv[i])) {
if(!writeVersion) {
writeVersion = 1;
}
}
if ((0 == strcmp("-help", argv[i]))||(0 == strcmp("-?", argv[i]))) {
dumpHelpText(j9portLibrary, argc, argv, ©rightWritten);
return 0;
}
if (0 == strcmp("-X", argv[i])) {
describeInternalOptions(j9portLibrary);
return 0;
}
if (strcmp("-jar", argv[i]) == 0) {
isStandaloneJar = 1;
}
#if defined(J9VM_OPT_JXE_LOAD_SUPPORT)
if (strcmp("-jxe", argv[i]) == 0) {
isStandaloneJxe = 1;
}
if (!strncmp("-jxe:", argv[i], 5)) {
classArg = i;
jxeArg = i;
break;
}
#if defined(NEUTRINO)
if (!strncmp("-jxespace:", argv[i], 10)) {
jxeSpaceArg = i;
}
#endif /* NEUTRINO */
#endif /* J9VM_OPT_JXE_LOAD_SUPPORT */
}
#ifdef J9VM_OPT_REMOTE_CONSOLE_SUPPORT
remoteConsole_parseCmdLine(j9portLibrary, classArg - 1, argv);
#endif
#ifdef J9VM_OPT_MEMORY_CHECK_SUPPORT
/* This should happen before anybody allocates memory! Otherwise, shutdown will not work properly. */
memoryCheck_parseCmdLine(j9portLibrary, classArg - 1, argv);
#endif /* J9VM_OPT_MEMORY_CHECK_SUPPORT */
#if defined(J9VM_OPT_JXE_LOAD_SUPPORT)
#if defined(NEUTRINO)
if (jxeSpaceArg) {
rc = handleNeutrinoJxeSpaceArg(j9portLibrary, jxeSpaceArg, argv);
if (rc)
goto cleanup;
}
#endif /* NEUTRINO */
#endif /* J9VM_OPT_JXE_LOAD_SUPPORT */
vmOptionsTable = NULL;
vmOptionsTableInit(j9portLibrary, &vmOptionsTable, 15);
if (NULL == vmOptionsTable)
goto cleanup;
#if defined(J9VM_OPT_JXE_LOAD_SUPPORT)
if ( jxeArg ) {
if ( vmOptionsTableAddOption(&vmOptionsTable, "_jxe", (void *) (argv[jxeArg]+5)) != J9CMDLINE_OK ) {
goto cleanup;
}
jxeUtil = main_createJxeUtilities( j9portLibrary );
if ( !jxeUtil ) {
rc = 10;
goto cleanup;
}
jxeName = argv[jxeArg]+5;
main_findMainClassAndUpdateVMOptionsTableFromJXE( j9portLibrary, &mainClass, NULL, &vmOptionsTable, jxeUtil, jxeName );
if ( !mainClass ) {
rc = 11;
goto cleanup;
}
}
if ( isStandaloneJxe ) {
if ( !jxeUtil ) {
jxeUtil = main_createJxeUtilities( j9portLibrary );
if ( !jxeUtil ) {
rc = 10;
goto cleanup;
}
if ( classArg == argc ) {
/* a jxe was not supplied with -jxe */
dumpHelpText(j9portLibrary, argc, argv, ©rightWritten);
rc = 4;
goto cleanup;
}
jxeName = argv[classArg];
main_findMainClassAndUpdateVMOptionsTableFromJXE( j9portLibrary, &mainClass, NULL, &vmOptionsTable, jxeUtil, jxeName );
if ( !mainClass ) {
rc = 11;
goto cleanup;
}
}
}
#endif /* J9VM_OPT_JXE_LOAD_SUPPORT */
#ifdef J9VM_STATIC_LINKAGE
/* on static platforms add a default -Xjcl option for the library which we're linked against */
if (NULL == (jclArg = strBufferCat(j9portLibrary, NULL, "-Xjcl:"))) {
goto cleanup;
}
if (NULL == (jclArg = strBufferCat(j9portLibrary, jclArg, jclOption))) {
goto cleanup;
}
if ( jclExtraLibs ) {
if (NULL == (jclArg = strBufferCat(j9portLibrary, jclArg, ":"))) {
goto cleanup;
}
if (NULL == (jclArg = strBufferCat(j9portLibrary, jclArg, jclExtraLibs))) {
goto cleanup;
}
}
if (vmOptionsTableAddOption(&vmOptionsTable, strBufferData(jclArg), (void *) NULL) != J9CMDLINE_OK) {
goto cleanup;
}
#else
if ( jclProfile ) {
/* when a default profile is specified add a -jcl:<profile> option */
if (vmOptionsTableParseArgs(j9portLibrary, &vmOptionsTable, 1, (char**)&jclProfile) != J9CMDLINE_OK) {
goto cleanup;
}
}
#endif
if (vmOptionsTableAddExeName(&vmOptionsTable, argv[0]) != J9CMDLINE_OK)
goto cleanup;
if (vmOptionsTableAddOption(&vmOptionsTable, "_port_library", (void *) j9portLibrary) != J9CMDLINE_OK)
goto cleanup;
/* do not substract 1 from classArg (i.e., 'classArg-1') when jxeArg is present since the 'classArg' is the -jxe: option */
if (vmOptionsTableParseArgs(j9portLibrary, &vmOptionsTable, classArg - (jxeArg?0:1), &(argv[1])) != J9CMDLINE_OK)
goto cleanup;
/* Check that the minimum required -D options have been included. If not, calculate and add the defaults */
initDefaultDefines(j9portLibrary, &vmOptionsTable, argc, argv, jxeArg, isStandaloneJxe?classArg:0, isStandaloneJar?classArg:0, &classPath, &javaHome, &bootLibraryPath, &javaLibraryPath);
vm_args.version = JNI_VERSION_1_2;
vm_args.nOptions = vmOptionsTableGetCount(&vmOptionsTable);
vm_args.options = vmOptionsTableGetOptions(&vmOptionsTable);
vm_args.ignoreUnrecognized = JNI_FALSE;
if (JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args)) {
/* "Internal VM error: Failed to create Java VM\n" */
j9portLibrary->nls_printf(j9portLibrary, J9NLS_ERROR, J9NLS_EXE_INTERNAL_VM_ERROR_CREATE_FAILED);
/* "Run %s -help for usage\n" */
j9portLibrary->nls_printf(j9portLibrary, J9NLS_INFO, J9NLS_EXE_RUN_HELP, argv[0] );
rc = 2;
if ( writeVersion ) {
dumpVersionInfo( j9portLibrary, NULL, ©rightWritten );
}
goto cleanup;
}
rc = 0;
if ( writeVersion ) {
dumpVersionInfo( j9portLibrary, env, ©rightWritten );
if ( writeVersion > 1 ) {
/* -version was on the command line, so display and exit */
goto destroy_jvm;
}
}
if (mainClass) {
if (isStandaloneJar) {
jclass jarRunner;
jclass clazz;
jmethodID mID;
jstring jStrObject;
/* using Class.forName as J2ME JCLs do not return a catchable exception from FindClass*/
mainClass = "com.ibm.oti.vm.JarRunner";
jStrObject = (*env)->NewStringUTF(env, mainClass);
if (!jStrObject) {
(*env)->ExceptionDescribe(env);
rc = 3;
goto destroy_jvm;
}
clazz = (*env)->FindClass(env, "java/lang/Class");
if (!clazz) {
(*env)->ExceptionDescribe(env);
rc = 3;
goto destroy_jvm;
}
mID = (*env)->GetStaticMethodID(env, clazz, "forName", "(Ljava/lang/String;)Ljava/lang/Class;");
if (!mID) {
(*env)->ExceptionDescribe(env);
rc = 3;
goto destroy_jvm;
}
/* should not spawn an exception if using JCL greater than J2ME */
jarRunner = (*env)->CallStaticObjectMethod(env, clazz, mID, jStrObject);
if (jarRunner) {
(*env)->DeleteLocalRef(env, jarRunner);
classArg -= 1; /* make sure that the JAR is the first argument */
} else {
(*env)->ExceptionClear(env);
/* "-jar option is not available for this class library\n" */
j9portLibrary->nls_printf(j9portLibrary, J9NLS_ERROR, J9NLS_EXE_JAR_OPTION_NOT_AVAIL );
rc = 3;
goto destroy_jvm;
}
}
javaRc = main_runJavaMain(env, mainClass, isNameUTF, (argc - (classArg + 1)), &argv[classArg + 1], j9portLibrary);
} else {
dumpHelpText(j9portLibrary, argc, argv, ©rightWritten);
rc = 4;
}
destroy_jvm:
(*jvm)->DestroyJavaVM(jvm);
cleanup:
switch (rc) {
case 1:
/* "VM startup error: Out of memory\n" */
j9portLibrary->nls_printf(j9portLibrary, J9NLS_ERROR, J9NLS_EXE_OUT_OF_MEMORY );
break;
/* case 4: help text was displayed */
/* case 3,7,8,9: various jxe msgs already printed */
#if defined(J9VM_OPT_JXE_LOAD_SUPPORT)
case 10:
/* could not create JXE Util */
j9portLibrary->nls_printf(j9portLibrary, J9NLS_ERROR, J9NLS_EXE_COULD_NOT_INITIALIZE_JXE_UTILITIES );
break;
case 11:
/* JXE did not contain a mainClass */
j9portLibrary->nls_printf(j9portLibrary, J9NLS_ERROR, J9NLS_EXE_JXE_DID_NOT_CONTAIN_STARTUP_CLASS, jxeName );
break;
#endif
}
#if defined(J9VM_OPT_JXE_LOAD_SUPPORT)
if (jxeUtil) {
main_destroyJxeUtilities(j9portLibrary, jxeUtil);
}
#endif
#ifdef J9VM_STATIC_LINKAGE
if (jclArg) {
j9portLibrary->mem_free_memory(j9portLibrary, jclArg);
}
#endif
if (classPath) {
j9portLibrary->mem_free_memory(j9portLibrary, classPath);
}
if (javaHome) {
j9portLibrary->mem_free_memory(j9portLibrary, javaHome);
}
if (bootLibraryPath) {
j9portLibrary->mem_free_memory(j9portLibrary, bootLibraryPath);
}
if (javaLibraryPath) {
j9portLibrary->mem_free_memory(j9portLibrary, javaLibraryPath);
}
if (vmOptionsTable) {
vmOptionsTableDestroy(&vmOptionsTable);
}
#ifdef J9VM_OPT_MEMORY_CHECK_SUPPORT
memoryCheck_shutdown(j9portLibrary);
#endif
return (rc ? rc : javaRc);
}
