Beispiel #1
1
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
}
Beispiel #2
1
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"));
Beispiel #4
0
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;
}
Beispiel #5
0
/// 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;
}
Beispiel #6
0
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
}
Beispiel #7
0
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() */
}
Beispiel #8
0
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;
}
Beispiel #9
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;
}
Beispiel #10
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;
}
Beispiel #11
0
	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. ");
		}
	}
Beispiel #12
0
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);
  }
}
Beispiel #13
0
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;
}
Beispiel #15
0
/*-------------------------------------------------------------------------*
 * 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;
}
Beispiel #16
0
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;
}
Beispiel #17
0
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;
}
Beispiel #18
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;
}
Beispiel #20
0
   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;
}
Beispiel #25
0
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.");
}
Beispiel #26
0
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;
}
Beispiel #27
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;
    }
Beispiel #29
0
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;
}