void CreateJavaVM(char *classpath, jint (JNICALL *printfn)(FILE *fp, const char *format, va_list args)) { #ifdef USE_JDK12 if (!gJavaVM && !gJavaEnv) { JavaVMOption options[2]; JavaVMInitArgs vm_args; int nOptions = 1; options[0].name = "classpath"; if (!classpath) options[0].value.p = getenv("CLASSPATH"); else options[0].value.p = classpath; if (printfn) { options[1].name = "vfprintf"; options[1].value.p = printfn; nOptions++; } vm_args.version = JNI_VERSION_1_2; vm_args.options = options; vm_args.nOptions = nOptions; vm_args.result = NULL; JNI_CreateJavaVM(&gJavaVM, (void **)&gJavaEnv, (void *)&vm_args); assert(gJavaVM && gJavaEnv); } #else if (!gJavaVM && !gJavaEnv) { JDK1_1InitArgs vm_args; JNI_GetDefaultJavaVMInitArgs(&vm_args); if (!classpath) vm_args.classpath = getenv("CLASSPATH"); else vm_args.classpath = classpath; if (printfn) vm_args.vfprintf = printfn; JNI_CreateJavaVM(&gJavaVM, &gJavaEnv, &vm_args); assert(gJavaVM && gJavaEnv); } #endif }
int main(int argc,char **argv) { JavaVMOption options[1]; JNIEnv *env; JavaVM *jvm; JavaVMInitArgs vm_args; long status; jclass cls; jmethodID mid; options[0].optionString = "-Djava.class.path=."; memset(&vm_args,0,sizeof(vm_args)); vm_args.version = JNI_VERSION_1_2; vm_args.nOptions = 1; vm_args.options = options; status = JNI_CreateJavaVM(&jvm,(void **) &env,&vm_args); if (status != JNI_ERR) { cls = (*env)->FindClass(env,"Hello"); if (cls != 0) { mid = (*env)->GetStaticMethodID(env,cls,"sayHello","()V");\ if (mid != 0) { (*env)->CallStaticVoidMethod(env,cls,mid,NULL); } } } (*jvm)->DestroyJavaVM(jvm); return 0; }
JavaInterface::JavaInterface( const char *pzComponentPath, const char *pzComponentSettings) : BaseInterface(pzComponentPath, pzComponentSettings) { if (m_jvm) return; JNIEnv *env; #ifdef _WIN32 MS_JDK1_1InitArgs vm_args; JNI_GetDefaultJavaVMInitArgs(&vm_args); vm_args.nVersion = 0x00010001; vm_args.pcszClasspath = (char *)(const char *)m_strComponentPath; int nRet = JNI_CreateJavaVM(&m_jvm, &env, &vm_args); if (nRet < 0) { throw GException("JavaIntegration", 1,nRet); } #else #ifdef _DYNAMIC_JAVA_LINK_ JavaVMInitArgs vm_args; void *dllHandle = _OPENLIB("libjvm.so"); if (dllHandle) { JavaVMOption options[3]; GString strTemp; strTemp.Format("-Djava.class.path=%s",(const char *)m_strComponentPath); options[0].optionString = "-Djava.compiler=NONE"; // disable JIT options[1].optionString = (char *)(const char *)strTemp; vm_args.options = options; vm_args.version = JNI_VERSION_1_2; vm_args.nOptions = 2; vm_args.ignoreUnrecognized = JNI_FALSE; void *pfn2 = 0; ExceptionHandlerScope duration; XML_TRY { pfn2 = (void *)_PROCADDRESS(dllHandle, "JNI_CreateJavaVM"); } XML_CATCH(ex) { throw GException("JavaIntegration", 6, getenv("LD_LIBRARY_PATH")); } if (pfn2) { cout << "Creating VM\n"; int nRet = ((fnJNI_CreateJavaVM)pfn2)(&m_jvm, (void **) &env, &vm_args); if (nRet < 0) { throw GException("JavaIntegration", 1,nRet); } else { cout << "Created Java Interpreter\n"; } } } else { throw GException("JavaIntegration", 5, getenv("LD_LIBRARY_PATH"));
JNIEnv* createJVM(){ if(globalE) { return globalE; } int exitCode = 0; int optionsCount = 0; JavaVMOption options[5]; #ifdef BOOT_JAR options[optionsCount++].optionString = const_cast<char*>("-Xbootclasspath:[bootJar]"); #else options[optionsCount++].optionString = const_cast<char*>("-Davian.bootimage=bootimageBin"); options[optionsCount++].optionString = const_cast<char*>("-Davian.codeimage=codeimageBin"); #endif #ifdef BOOTSTRAP_SO options[optionsCount++].optionString = const_cast<char*>(BOOTSTRAP_SO); #endif void* env; JavaVMInitArgs vmArgs; vmArgs.version = JNI_VERSION_1_2; vmArgs.ignoreUnrecognized = JNI_TRUE; vmArgs.nOptions = optionsCount; vmArgs.options = options; JNI_CreateJavaVM(&vm, &env, &vmArgs); globalE = static_cast<JNIEnv*>(env); return globalE; }
/// Creates the Java virtual machine. /// Returns 1 on success and 0 on failure. int create_jvm(char *classpath) { if (jvm == NULL) { JavaVMOption options[3]; JavaVMInitArgs vm_args; char destination[200]; strcpy(destination, "-Djava.class.path="); strcat(destination, classpath); options[0].optionString = destination; options[1].optionString = "-Xms256m"; options[2].optionString = "-Xmx1024m"; vm_args.version = JNI_VERSION_1_2; vm_args.nOptions = 3; vm_args.options = options; long status = JNI_CreateJavaVM(&jvm, (void **) &env, &vm_args); if (status != JNI_OK) { last_error = ERROR_COULD_NOT_CREATE_VM; return FAILURE; } return SUCCESS; } return FAILURE; }
static JNIEnv* _create_jvm(JavaVM** jvm) { #define __OPT_CLASSPATH "-Djava.class.path=" JNIEnv* jenv; JavaVMInitArgs jvmargs; JavaVMOption jvmopt; char cp[4096]; /* class path : 4096 is enough size */ const char* cpenv; /* class path env value */ /* -1 to remove trailing 0 */ memcpy(cp, __OPT_CLASSPATH, sizeof(__OPT_CLASSPATH)-1); cpenv = getenv("CLASSPATH"); if (!cpenv) { cpenv = "./yljfe.jar"; } strcpy(cp + sizeof(__OPT_CLASSPATH) - 1, cpenv); jvmopt.optionString = cp; jvmargs.version = JNI_VERSION_1_6; jvmargs.nOptions = 1; jvmargs.options = &jvmopt; jvmargs.ignoreUnrecognized = 0; if (0 > JNI_CreateJavaVM(jvm, (void**)&jenv, &jvmargs)) { /* error case */ return NULL; } return jenv; #undef __OPT_CLASSPATH }
static void create_jvm() { int i, option_count; JavaVMInitArgs vm_args; option_count = vmArgsCount + ((classPath != NULL) ? 1 : 0); vm_args.version = JNI_VERSION_1_4; vm_args.ignoreUnrecognized = JNI_FALSE; vm_args.nOptions = option_count; vm_args.options = calloc(option_count, sizeof(JavaVMOption)); for (i = 0; i < vmArgsCount; i++) { vm_args.options[i].optionString = vmArgs[i]; vm_args.options[i].extraInfo = NULL; } if (classPath != NULL) { vm_args.options[i].optionString = create_class_path_option(classPath); vm_args.options[i].extraInfo = NULL; } if (JNI_CreateJavaVM(&jvm, (void**)&mainEnv, &vm_args) != 0) errx(50, "JNI_CreateJavaVM() failed"); mainClass = (*mainEnv)->FindClass(mainEnv, className); if (mainClass == NULL) errx(50, "Main class not found: %s", className); mainMethod = (*mainEnv)->GetStaticMethodID(mainEnv, mainClass, "main", "([Ljava/lang/String;)V"); if (mainMethod == NULL) errx(50, "Main method not found in: %s", className); shutdownMethod = (*mainEnv)->GetStaticMethodID(mainEnv, mainClass, "shutdown", "()V"); if (shutdownMethod == NULL) errx(50, "Shutdown method not found in: %s", className); reloadMethod = (*mainEnv)->GetStaticMethodID(mainEnv, mainClass, "reload", "()V"); (*mainEnv)->ExceptionClear(mainEnv); /* Ignore possible exception caused by missing reload() */ }
int create_destroy_jvm() { JavaVMOption options[3]; JavaVMInitArgs vm_args; JNIEnv *env; JavaVM *jvm; long status; options[0].optionString = "-Xms512m"; options[1].optionString = "-Xmx512m"; // options[2].optionString = "-verbose"; memset(&vm_args, 0, sizeof(vm_args)); vm_args.version = JNI_VERSION_1_8; vm_args.nOptions = 2; vm_args.options = options; vm_args.ignoreUnrecognized = JNI_TRUE; status = JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args); if (status != JNI_ERR) { printf("jvm is created: %p\n", env); sleep(3); status = (*jvm)->DestroyJavaVM(jvm); printf("jvm is destroyed (%d)\n", status); sleep(3); } else { perror("fail to create jvm"); } return 0; }
static JSBool default_create_java_vm(SystemJavaVM* *jvm, JNIEnv* *initialEnv, void* initargs) { jint err; const char* user_classpath = (const char*)initargs; char* full_classpath = NULL; /* No Java VM supplied, so create our own */ JDK1_1InitArgs vm_args; memset(&vm_args, 0, sizeof(vm_args)); /* Magic constant indicates JRE version 1.1 */ vm_args.version = 0x00010001; JNI_GetDefaultJavaVMInitArgs(&vm_args); /* Prepend the classpath argument to the default JVM classpath */ if (user_classpath) { #if defined(XP_UNIX) || defined(XP_BEOS) full_classpath = JS_smprintf("%s:%s", user_classpath, vm_args.classpath); #else full_classpath = JS_smprintf("%s;%s", user_classpath, vm_args.classpath); #endif if (!full_classpath) { return JS_FALSE; } vm_args.classpath = (char*)full_classpath; } err = JNI_CreateJavaVM((JavaVM**)jvm, initialEnv, &vm_args); if (full_classpath) JS_smprintf_free(full_classpath); return err == 0; }
Jvm::Jvm(const std::vector<std::string>& options, JNIVersion jniVersion) : jvm(NULL), env(NULL), voidClass("V"), booleanClass("Z"), byteClass("B"), charClass("C"), shortClass("S"), intClass("I"), longClass("J"), floatClass("F"), doubleClass("D"), stringClass(JClass::forName("java/lang/String")) { JavaVMInitArgs vmArgs; vmArgs.version = jniVersion; vmArgs.ignoreUnrecognized = false; JavaVMOption* opts = new JavaVMOption[options.size()]; for (int i = 0; i < options.size(); i++) { opts[i].optionString = const_cast<char*>(options[i].c_str()); } vmArgs.nOptions = options.size(); vmArgs.options = opts; int result = JNI_CreateJavaVM(&jvm, (void**) &env, &vmArgs); assure(result != JNI_ERR, env); delete[] opts; }
void helper::init_jvm(JNIEnv* &jnienv, JavaVM* &javavm) { JavaVMInitArgs vm_args; //set $CLASSPATH std::string op_str = "-Djava.class.path="; op_str += getenv("CLASSPATH"); op_str += ":"; op_str += getenv("SAGA_LOCATION"); op_str += "/share/sra/classes"; JavaVMOption options[1]; options[0].optionString = const_cast<char *>(op_str.c_str()); vm_args.version = JNI_VERSION_1_6; vm_args.options = options; vm_args.nOptions = 1; vm_args.ignoreUnrecognized = true; SAGA_LOG_CRITICAL("Java VM generate\n"); int result = JNI_CreateJavaVM(&javavm, (void **)&jnienv, &vm_args); SAGA_LOG_CRITICAL("helper:: create jvm \n"); if(result != 0){ std::string str_buf = "init_jvm:" + result?"true":"false"; SAGA_LOG_CRITICAL(str_buf.c_str()); SAGA_LOG_CRITICAL(" jvm is already created. "); } }
void create_jvm(JavaVM** jvm, JNIEnv** env) { std::vector<std::string> opt_strs{ // "-verbose:jni", // "-verbose:class", "-Dswing.useSystemFontSettings=true", }; std::vector<JavaVMOption> options; for (auto const& o_s : opt_strs) { JavaVMOption jop; jop.optionString = const_cast<char*>(o_s.c_str()); jop.extraInfo = nullptr; options.push_back(jop); }; JavaVMInitArgs vm_args; vm_args.version = JNI_VERSION_1_8; vm_args.nOptions = options.size(); vm_args.options = &*options.begin(); vm_args.ignoreUnrecognized = false; JNI_CreateJavaVM(jvm, reinterpret_cast<void**>(env), &vm_args); if ((nullptr == *jvm) || (nullptr == *env)) { std::cerr << "failed to create JavaVM" << std::endl; exit(EXIT_FAILURE); } }
int main(void) { JavaVMInitArgs vmargs; JavaVM *vm; void *env; JavaVMOption myoptions[1]; /* set up libtool/libltdl dlopen emulation */ LTDL_SET_PRELOADED_SYMBOLS(); myoptions[0].optionString = concatString("-Xbootclasspath:", getenv("BOOTCLASSPATH")); vmargs.version = JNI_VERSION_1_2; if (JNI_GetDefaultJavaVMInitArgs (&vmargs) < 0) { fprintf(stderr, " Cannot retrieve default arguments\n"); return 1; } vmargs.nOptions = 1; vmargs.options = myoptions; if (JNI_CreateJavaVM (&vm, &env, &vmargs) < 0) { fprintf(stderr, " Cannot create the Java VM\n"); return 1; } (*vm)->DestroyJavaVM(vm); return 0; }
static caddr_t java_vm_create (JNIEnv ** java_vm_env) { JavaVMInitArgs vm_args; JavaVMOption options[5]; jint res; caddr_t classpath_opt = NULL; int inx; char *classpath = NULL; if (!classpath) { classpath=getenv ("CLASSPATH"); } if (!classpath) { classpath= "."; } classpath_opt = dk_alloc_box (strlen (classpath) + 20, DV_SHORT_STRING); sprintf (classpath_opt, "-Djava.class.path=%s", classpath); options[0].optionString = classpath_opt; vm_args.nOptions = 1; vm_args.version = JNI_VERSION_1_2; vm_args.options = options; vm_args.ignoreUnrecognized = JNI_FALSE; res = JNI_CreateJavaVM (&java_vm, (void **) java_vm_env, &vm_args); if (res < 0) return srv_make_new_error ("42000", "JV002", "Can't create the Java VM"); else return NULL; }
/*-------------------------------------------------------------------------* * NAME * create_vm - create a jvm * PARAMETER * argc - number of arguments for the jvm * argv - arguments for the jvm * * RETURN * * NULL - jvm could not be created * else - jvm has been created * * EXTERNAL * * DESCRIPTION *-------------------------------------------------------------------------*/ JNIEnv* create_vm(int argc, char** argv) { JavaVM* jvm; JNIEnv* env; JavaVMInitArgs args; int i = 0; JavaVMOption* options = (JavaVMOption*)malloc(argc*sizeof(JavaVMOption)); /* There is a new JNI_VERSION_1_4, but it doesn't add anything for the purposes of our example. */ args.version = JNI_VERSION_1_2; args.nOptions = argc; for(i=0; i < argc; i++) { /*printf("jvm_args[%d] = %s\n", i, argv[i]);*/ options[i].optionString = argv[i]; } args.options = options; args.ignoreUnrecognized = JNI_FALSE; #ifdef DARWIN /* ** for darwin there exists no JNI_CreateJavaVM, Why not maybe a fix in the future ??? */ i = JNI_CreateJavaVM_Impl(&jvm, (void **)&env, &args); #else i = JNI_CreateJavaVM(&jvm, (void **)&env, &args); #endif if(i<0) { fprintf(stderr,"can not create JVM (error code %d)\n", i); env = NULL; } free(options); return env; }
int main(int argc, char **argv) { printf("----> SPACE RACCOONS - We will save you!!!!1\n"); JavaVM *jvm; JNIEnv *env; JavaVMInitArgs vm_args; JavaVMOption options[4]; options[0].optionString = "-Xms512M"; options[1].optionString = "-Xmx1024M"; options[2].optionString = "-Djava.class.path=com.spaceraccoons.client.jar"; options[3].optionString = "-Dvisualvm.display.name=SpaceRaccoons"; vm_args.version = JNI_VERSION_1_6; vm_args.options = options; vm_args.nOptions = 4; vm_args.ignoreUnrecognized = true; printf("Initializing Java virtual machine...\n"); if ((JNI_CreateJavaVM(&jvm, &env, &vm_args)) != JNI_OK) { // Initialization of the JavaVM failed! :-( printf("Initialization of the JavaVM has failed."); return EXIT_FAILURE; } return EXIT_SUCCESS; }
int main(int argc, char * argv[]){ JavaVMInitArgs vm_args; JavaVMOption *options; jint res; options = (JavaVMOption*)malloc(sizeof(JavaVMOption)); options[0].optionString = "-Djava.class.path=."; vm_args.version = 0x00010002; vm_args.options = options; vm_args.nOptions = 1; vm_args.ignoreUnrecognized = JNI_FALSE; res = JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args); if (res != JNI_OK){ printf("JNI_CreateJavaVM: %d\n", res); return 1; } printf("Java Initialized\n"); jobject driver = load_driver("postgresql-9.4-1201.jdbc41.jar", "org.postgresql.Driver"); if (driver != NULL){ print_version(driver); connect(driver, "jdbc:postgresql:pilif", "pilif", NULL); (*env)->DeleteLocalRef(env, driver); driver = NULL; } (*jvm)->DestroyJavaVM(jvm); printf("Java destroyed\n"); return 0; }
int main(int argc, char** argv) { (void)argc; (void)argv; VirtualMachine vm; vm.LoadFile("script.as"); vm.Call("void main()"); JavaVM *jvm; /* denotes a Java VM */ JNIEnv *env; /* pointer to native method interface */ JavaVMInitArgs vm_args; /* JDK/JRE 6 VM initialization arguments */ JavaVMOption* options = new JavaVMOption[1]; options[0].optionString = "-Djava.class.path=/usr/lib/java"; vm_args.version = JNI_VERSION_1_6; vm_args.nOptions = 1; vm_args.options = options; vm_args.ignoreUnrecognized = false; /* load and initialize a Java VM, return a JNI interface * pointer in env */ JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args); delete options; /* invoke the Main.test method using the JNI */ jclass cls = env->FindClass("Main"); jmethodID mid = env->GetStaticMethodID(cls, "test", "(I)V"); env->CallStaticVoidMethod(cls, mid, 100); /* We are done. */ jvm->DestroyJavaVM(); std::cout << "Hello World! (C++)" << std::endl; }
int test_createJVM() { JavaVMInitArgs jvm_args; JavaVMOption jvm_options[4]; char* classPathArg = test_buildClassPath(); int numJVMOptions = 0; jvm_options[numJVMOptions].optionString = classPathArg; numJVMOptions++; char maxHeapOptions[64]; bool passMaxHeapToJVM = true; int maxHeapEnvvarMB = 4096; jvm_options[numJVMOptions].optionString = (char *) "-Xmx1024m"; numJVMOptions++; jvm_args.version = JNI_VERSION_1_6; jvm_args.options = jvm_options; jvm_args.nOptions = numJVMOptions; jvm_args.ignoreUnrecognized = 1; int ret = JNI_CreateJavaVM(&gp_jvm, (void**)&_tlp_jenv, &jvm_args); free(classPathArg); return ret; }
int main(int argc, char* argv[]) { JNIEnv *env; JavaVM *jvm; jint res; if(argc!=2) { printf("Debe pasar la clase a ejecutar por parametro\n"); printf("Ejemplo: invocationinterface clase\n"); return(-1); } JavaVMInitArgs vm_args; JavaVMOption options[2]; options[0].optionString ="-Djava.class.path=/opt/jdk1.5.0_09/lib:.:/home/javi/cursojni/netbeans/MetodosInstancia/build/classes"; options[0].extraInfo = NULL; options[1].optionString="-Djava.library.path=/home/javi/cursojni/eclipse/MetodosInstancia/Debug"; options[1].extraInfo = NULL; vm_args.version = JNI_VERSION_1_2; vm_args.options = options; vm_args.nOptions = 2; vm_args.ignoreUnrecognized = JNI_FALSE; // Create the Java VM res = JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args); if (res < 0) { fprintf(stderr, "Can't create Java VM\n"); return(1); } printf("Resultado de crear la vm %d\n", res); jclass cls = (*env)->FindClass(env, argv[1]); if (cls == NULL) { printf("No se encuentra la clase %s\n", argv[1]); goto destroy; } jmethodID mid = (*env)->GetStaticMethodID(env, cls, "main","([Ljava/lang/String;)V"); if (mid == NULL) { printf("La clase no contiene metodo main\n"); goto destroy; } jstring jstr = (*env)->NewStringUTF(env, " desde JNI!"); if (jstr == NULL) { goto destroy; } jclass stringClass = (*env)->FindClass(env, "java/lang/String"); jobjectArray args = (*env)->NewObjectArray(env, 1, stringClass, jstr); if (args == NULL) { goto destroy; } (*env)->CallStaticVoidMethod(env, cls, mid, args); destroy: if ((*env)->ExceptionOccurred(env)) { (*env)->ExceptionDescribe(env); } (*jvm)->DestroyJavaVM(jvm); return(0); }
void initJVM() { if (_pVMJvm != NULL) return; JNIEnv* pVMEnv = NULL; #ifdef _WIN32 HMODULE handle = LoadLibraryA(_jrePath.c_str()); #else void *handle = dlopen(_jrePath.c_str(), RTLD_NOW); #endif if (handle == NULL) throw std::runtime_error("initJVM: unable to load libjvm."); JNI_GetCreatedJavaVMs_t JNI_GetCreatedJavaVMs = (JNI_GetCreatedJavaVMs_t) LoadSym(handle, "JNI_GetCreatedJavaVMs"); if (JNI_GetCreatedJavaVMs == NULL) JNI_GetCreatedJavaVMs = (JNI_GetCreatedJavaVMs_t) LoadSym(handle, "JNI_GetCreatedJavaVMs_Impl"); if (JNI_GetCreatedJavaVMs == NULL) throw std::runtime_error("initJVM: unable to find method JNI_GetCreatedJavaVMs."); // try to get an already created JVM jsize nbVMs = 0; JNI_GetCreatedJavaVMs(&_pVMJvm, 1, &nbVMs); if (nbVMs == 0) { // Else : create a new JVM setClassPath(); jint nbOptions = (jint) _options.size(); JavaVMOption *aOptions = new JavaVMOption[nbOptions]; for (jint i = 0; i < nbOptions; ++i) aOptions[i].optionString = (char*) _options[i].c_str(); JavaVMInitArgs oVMArgs; memset(&oVMArgs, 0, sizeof(oVMArgs)); oVMArgs.version = JNI_VERSION_1_6; oVMArgs.nOptions = nbOptions; oVMArgs.options = aOptions; JNI_CreateJavaVM_t JNI_CreateJavaVM = (JNI_CreateJavaVM_t) LoadSym(handle, "JNI_CreateJavaVM"); if (JNI_CreateJavaVM == NULL) JNI_CreateJavaVM = (JNI_CreateJavaVM_t) LoadSym(handle, "JNI_CreateJavaVM_Impl"); if (JNI_CreateJavaVM == NULL) throw std::runtime_error("initJVM: unable to find method JNI_CreateJavaVM."); jint result = JNI_CreateJavaVM(&_pVMJvm, (void**) &pVMEnv, (void*) &oVMArgs); if (result != 0) { std::ostringstream oss; oss << "initJVM: can't create new JVM (" << result << ")."; throw std::runtime_error(oss.str()); } delete[] aOptions; } }
void com::tecnyse::integration::JNIBridge::start() { std::string jvm_class_path; const size_t nb_jars = jars.size(); if ( nb_jars == 0 ) { jvm_class_path = ""; } else { jvm_class_path = "-Djava.class.path="; for ( size_t i = 0; i < nb_jars; i++ ) { jvm_class_path += jars[ i ]; #if defined(WINDOWS) jvm_class_path += ";"; #else jvm_class_path += ":"; #endif } } const std::string str_java_library_path = buildLibraryPath(); const size_t nb_of_options = jvm_args.size() + 2; JavaVMOption* options = new JavaVMOption[nb_of_options]; options[ 0 ].optionString = const_cast<char*>( jvm_class_path.c_str() ); options[ 1 ].optionString = const_cast<char*>( str_java_library_path.c_str() ); int index = 2; for ( std::vector<std::string>::iterator it = jvm_args.begin(); it != jvm_args.end(); ++it ) { options[ index++ ].optionString = const_cast<char*>( it->c_str() ); } JavaVMInitArgs vm_args; vm_args.version = JNI_VERSION_1_6; vm_args.options = options; vm_args.nOptions = nb_of_options; vm_args.ignoreUnrecognized = JNI_TRUE; for ( int i = 0; i < nb_of_options; ++i ) { std::cout << "JVM Option: " << options[ i ].optionString << std::endl; } //Create the JVM JNIEnv* jni_env; jint result = JNI_CreateJavaVM(&running_jvm_instance, reinterpret_cast<void**>(&jni_env), &vm_args); if ( result < 0 ) { throw std::runtime_error( "Could not launch the JVM" ); } std::cout << "JVM loaded" << std::endl; printProperties(); }
/* * This function instantiates a java virtual machine so as to access * to the 3D animation facilities of MBSysPad. */ JNIEnv* create_vm(void) { int res; JavaVM* jvm; JNIEnv* env; JavaVMInitArgs args; JavaVMOption options[2]; // the following parameter should be adapted depending on the version of the JDK args.version = JNI_VERSION; // number of argument to pass to the jvm args.nOptions = 2; // path to the jar file containing mbsyspad bynary code options[0].optionString = "-Djava.class.path="JAR_PATH; // path to the folder containing additional libraries, in particular the java3D native file (libj3dcore-ogl.so for linux) options[1].optionString = "-Djava.library.path="JAVA3D_PATH; args.options = options; args.ignoreUnrecognized = JNI_FALSE; res = JNI_CreateJavaVM(&jvm, (void **)&env, &args); if (res < 0) { switch ( res ) { case -1: fprintf(stderr, "/* unknown error */\n"); break; case -2: fprintf(stderr, "/* thread detached from the VM */\n"); break; case -3: fprintf(stderr, "/* JNI version error */\n"); break; case -4: fprintf(stderr, "/* not enough memory */\n"); break; case -5: fprintf(stderr, "/* VM already created */\n"); break; case -6: fprintf(stderr, "/* invalid arguments */\n"); break; default: fprintf(stderr, "Can't create Java VM\n"); } exit(1); } return env; }
int main(int ac, const char** av) { JavaVMInitArgs vmArgs; vmArgs.version = JNI_VERSION_1_2; vmArgs.nOptions = 1; vmArgs.ignoreUnrecognized = JNI_TRUE; JavaVMOption options[1]; vmArgs.options = options; options[0].optionString = const_cast<char*>("-Xbootclasspath:[bootJar]"); JavaVM* vm; void* env; JNI_CreateJavaVM(&vm, &env, &vmArgs); JNIEnv* e = static_cast<JNIEnv*>(env); char mainClass[256]; getMainClass(mainClass, sizeof(mainClass)); jclass c = e->FindClass(mainClass); if (not e->ExceptionCheck()) { jmethodID m = e->GetStaticMethodID(c, "main", "([Ljava/lang/String;)V"); if (not e->ExceptionCheck()) { jclass stringClass = e->FindClass("java/lang/String"); if (not e->ExceptionCheck()) { jobjectArray a = e->NewObjectArray(ac - 1, stringClass, 0); if (not e->ExceptionCheck()) { for (int i = 1; i < ac; ++i) { e->SetObjectArrayElement(a, i - 1, e->NewStringUTF(av[i])); } e->CallStaticVoidMethod(c, m, a); } else fprintf(stderr, "Couldn't create array\n"); } else fprintf(stderr, "java.lang.String not found\n"); } else fprintf(stderr, "main method not found\n"); } else fprintf(stderr, "Main class not found\n"); int exitCode = 0; if (e->ExceptionCheck()) { exitCode = -1; e->ExceptionDescribe(); e->ExceptionClear(); } vm->DestroyJavaVM(); return exitCode; }
void Java::initialize() { logger->Java("Java::initialize(): creating jvm in thread %d", syscall(SYS_gettid)); vm_args.version = JNI_VERSION_1_4; options[0].optionString = "-Djava.compiler=NONE"; // disable JIT // This is where we need the path to the Roblets, jars etc. No use in settings $CLASSPATH in bash, its ignored! options[1].optionString = "-Djava.class.path=./:../:/usr/local/src/service_robot/mobiled/genrob/jni/:/usr/local/src/servicerobot/mobiled/roblet/jni/:../../genrob/jni/:../../genrob/genControl/:genRob.genControl.jar:genRob.genControl.client.jar:genRob.genPath.jar:uhh.fbi.tams.pathplanner.jar:org.roblet.jar:uhh.fbi.tams.iowarrior.unit.jar:/usr/src/politbuero/mobiled/genrob/genMap/"; // user classes options[2].optionString = "-Djava.library.path=/opt/sun-jdk-1.6.0.03/jre/lib/"; // set native library path options[2].optionString = "-Djava.library.path=/usr/lib/java/jre/lib/"; // set native library path options[3].optionString = "-verbose:none"; // jni/class/... vm_args.version = JNI_VERSION_1_2; vm_args.options = options; vm_args.nOptions = 4; vm_args.ignoreUnrecognized = FALSE; // load and initialize a Java VM, return a JNI interface pointer in env if(JNI_CreateJavaVM(&jvm, (void **)&env, &vm_args) == JNI_ERR) abort("Java::Java(): JNI_CreateJavaVM() failed."); else logger->Java("Java::Java(): JNI_CreateJavaVM() succeeded."); robletObstacles = env->FindClass("RobletObstacles"); if(env->ExceptionOccurred()) env->ExceptionDescribe(); if(robletObstacles == 0) abort("Java::Java(): Java class RobletObstacles not found"); robletObstaclesMethodAdd = env->GetStaticMethodID(robletObstacles, "add", "([I[II)V"); if(robletObstaclesMethodAdd == 0) abort("Java::Java(): Java method RobletObstacles::add() not found."); robletObstaclesMethodRemove = env->GetStaticMethodID(robletObstacles, "remove", "([I[I)V"); if(robletObstaclesMethodRemove == 0) abort("Java::Java(): Java method RobletObstacles::remove() not found."); robletPath = env->FindClass("RobletPath"); if(env->ExceptionOccurred()) env->ExceptionDescribe(); if(robletPath == 0) abort("Java::Java(): Java class RobletPath not found"); robletPathMethodGetPath = env->GetStaticMethodID(robletPath, "getPath", "(IIIII)[I"); if(robletPathMethodGetPath == 0) abort("Java::Java(): Java method RobletPath::getPath() not found."); robletLaserMarks = env->FindClass("RobletLaserMarks"); if(env->ExceptionOccurred()) env->ExceptionDescribe(); if(robletLaserMarks == 0) abort("Java::Java(): Java class RobletLaserMarks not found"); robletLaserMarksMethodGet = env->GetStaticMethodID(robletLaserMarks, "get", "()[I"); if(robletLaserMarksMethodGet == 0) abort("Java::Java(): Java method RobletLaserMarks::get() not found."); robletIoWarrior = env->FindClass("RobletIOWarrior"); if(env->ExceptionOccurred()) env->ExceptionDescribe(); if(robletIoWarrior == 0) abort("Java::Java(): Java class RobletIOWarrior not found"); robletIoWarriorMethodSetPort = env->GetStaticMethodID(robletIoWarrior, "setPort", "(IZ)V"); if(env->ExceptionOccurred()) env->ExceptionDescribe(); if(robletIoWarriorMethodSetPort == 0) abort("Java::Java(): Java method RobletIOWarrior::setPort() not found."); }
int init_testing_framework () { JavaVM *jvm; JDK1_1InitArgs vm_args; vm_args.version = 0x00010001; JNI_GetDefaultJavaVMInitArgs (&vm_args); vm_args.classpath = getenv ("CLASSPATH"); if (JNI_CreateJavaVM (&jvm, &env, &vm_args) < 0) return -1; test_class = (*env)->FindClass (env, "gnu/test/Test"); if (test_class == NULL) { fprintf (stderr, "Unable to locate gnu.test.Test\n"); return -1; } test_class = (*env)->NewGlobalRef (env, test_class); result_class = (*env)->FindClass (env, "gnu/test/Result"); if (result_class == NULL) { fprintf (stderr, "Unable to locate gnu.test.Result\n"); return -1; } result_class = (*env)->NewGlobalRef (env, result_class); test_mid = (*env)->GetMethodID (env, test_class, "test", "()Lgnu/test/Result;"); test_name_mid = (*env)->GetMethodID (env, test_class, "getName", "()Ljava/lang/String;"); if (test_mid == NULL || test_name_mid == NULL) { fprintf (stderr, "Malformed gnu.test.Test class\n"); return -1; } result_name_mid = (*env)->GetMethodID (env, result_class, "getName", "()Ljava/lang/String;"); result_msg_mid = (*env)->GetMethodID (env, result_class, "getMsg", "()Ljava/lang/String;"); if (result_name_mid == NULL || result_msg_mid == NULL) { fprintf (stderr, "Malformed gnu.test.Result class\n"); return -1; } gh_new_procedure1_0 ("test", perform_test); return 0; }
int main() { JavaVMOption options[2]; JavaVMInitArgs vm_args; JavaVM *jvm; JNIEnv *env; long status; jclass class_Welcome; jclass class_String; jobjectArray args; jmethodID id_main; #ifdef _WINDOWS HINSTANCE hjvmlib; CreateJavaVM_t createJavaVM; #endif options[0].optionString = "-Djava.class.path=."; memset(&vm_args, 0, sizeof(vm_args)); vm_args.version = JNI_VERSION_1_2; vm_args.nOptions = 1; vm_args.options = options; #ifdef _WINDOWS hjvmlib = loadJVMLibrary(); createJavaVM = (CreateJavaVM_t) GetProcAddress(hjvmlib, "JNI_CreateJavaVM"); status = (*createJavaVM)(&jvm, (void **) &env, &vm_args); #else status = JNI_CreateJavaVM(&jvm, (void **) &env, &vm_args); #endif if (status == JNI_ERR) { fprintf(stderr, "Error creating VM\n"); return 1; } class_Welcome = (*env)->FindClass(env, "Welcome"); id_main = (*env)->GetStaticMethodID(env, class_Welcome, "main", "([Ljava/lang/String;)V"); class_String = (*env)->FindClass(env, "java/lang/String"); args = (*env)->NewObjectArray(env, 0, class_String, NULL); (*env)->CallStaticVoidMethod(env, class_Welcome, id_main, args); (*jvm)->DestroyJavaVM(jvm); return 0; }
bool initialize() { #ifdef KROSS_JVM_INTERPRETER_DEBUG krossdebug("JVMInterpreter initialize"); #endif jint res = JNI_CreateJavaVM( &jvm, (void **)&env, &vm_args ); if(res < 0) return false; //Create classloader jclass clclass = env->FindClass( "org/kde/kdebindings/java/krossjava/KrossClassLoader" ); if (clclass == 0) { krosswarning( "Class 'KrossClassLoader' not found! Is kross.jar accessible?" ); return false; } addclass = env->GetMethodID(clclass, "addClass", "(Ljava/lang/String;[B)Ljava/lang/String;"); newinst = env->GetMethodID(clclass, "newInstance", "(Ljava/lang/String;)Ljava/lang/Object;"); addurl = env->GetMethodID(clclass, "addURL", "(Ljava/net/URL;)V"); addextension = env->GetMethodID(clclass, "addExtension", "(Ljava/lang/String;J)Lorg/kde/kdebindings/java/krossjava/KrossQExtension;"); if (addclass == 0 || newinst == 0 || addurl == 0 || addextension == 0) { krosswarning("Classloader method not found!"); return false; } jmethodID ctor = env->GetMethodID(clclass, "<init>", "()V"); if (ctor == 0) { krosswarning("Classloader constructor not found!"); return false; } jobject loaderweak = env->NewObject(clclass, ctor); if (loaderweak == 0) { krosswarning("Could not create classloader!"); return false; } classloader = env->NewGlobalRef(loaderweak); jclass proxy = env->FindClass("org/kde/kdebindings/java/krossjava/KrossQExtension"); JNINativeMethod nativeMethod[2]; nativeMethod[0].name = "invokeNative"; nativeMethod[0].signature = "(JLjava/lang/String;ILjava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;"; nativeMethod[0].fnPtr = (void*) callQMethod; nativeMethod[1].name = "connect"; nativeMethod[1].signature = "(JLjava/lang/String;Ljava/lang/Object;Ljava/lang/reflect/Method;)Z"; nativeMethod[1].fnPtr = (void*) callConnect; env->RegisterNatives(proxy, nativeMethod, 2); handleException(); return true; }
int jni_jvm_create(JNIEnv **env, const char *clspath, const char *jvmOptionPath) { if (jvm != NULL) return -1; char classPathOptions[2048] = "-Djava.class.path="; strcat(classPathOptions, clspath); std::vector<char *> optionStrings; std::ifstream optionStream(jvmOptionPath, std::ifstream::in); if (optionStream.is_open()) { optionStrings.reserve(20); while (optionStream.good()) { char *option = new char[128]; optionStream.getline(option, 128); char *p = option + strlen(option) - 1; if (p >= option && *p == '\r') *p = 0; if (strlen(option) < 1) continue; optionStrings.push_back(option); } optionStream.close(); } JavaVMOption *options = new JavaVMOption[optionStrings.size() + 2]; options[0].optionString = classPathOptions; options[1].optionString = "-Djava.library.path=./plugins"; for (unsigned int i = 0; i < optionStrings.size(); i++) { options[i + 2].optionString = optionStrings[i]; } JavaVMInitArgs vm_args; vm_args.version = JNI_VERSION_1_8; vm_args.options = options; vm_args.nOptions = (jint) (optionStrings.size() + 2); vm_args.ignoreUnrecognized = JNI_FALSE; jint res = JNI_CreateJavaVM(&jvm, (void **) env, &vm_args); for (unsigned int i = 0; i < optionStrings.size(); i++) { delete[] optionStrings.at(i); } delete[] options; if (res < 0) return -3; return 0; }
JNIEnv* create_vm () { JavaVM* jvm; JNIEnv* env; JavaVMInitArgs args; JavaVMOption options[1]; args.version = JNI_VERSION_1_4; args.nOptions = 1; options[0].optionString = "-Djava.class.path=/Users/felipecruz/Projects/mestrado/compiladores/jvm_study"; args.options = options; args.ignoreUnrecognized = JNI_FALSE; JNI_CreateJavaVM (&jvm, (void **)&env, &args); return env; }