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); }