jnilib.c

Go to the documentation of this file.

#include "jnilib.h"
/* #include <assert.h> */
#include <stdarg.h>

#ifdef __cplusplus
extern "C" {
#endif

#define CLS_JNILIB "at/fhv/sgr/jnilib/JNILIB"

#define CLASSPATH_PARAM "-Djava.class.path="

#define DEFAULT_CLASSPATH "."

#ifdef __cplusplus /* __GNUC__ && __cplusplus */
   #define createJvm createJvmCPP 
   #define JNILIB_PARAM_JVM 
   #define JNILIB_PARAM_END_JVM 
   #define JNILIB_JAVAVM (jvm->jvm.jvm) 
   #define JNILIB_PARAM_JAVAVM 
   #define JNILIB_GETJAVAVM getJavaVM() 
   #define JNILIB_GETJAVAVM_PARAM 
   #define JNILIB_ENV getJNIEnv() 
   #define JNILIB_PARAM_ENV 
   #define JNILIB_PARAM_END_ENV 
#else
   #define createJvm createJvmC 
   #define JNILIB_PARAM_JVM jvm, 
   #define JNILIB_PARAM_END_JVM jvm 
   #define JNILIB_JAVAVM (*(jvm->jvm.jvm)) 
   #define JNILIB_PARAM_JAVAVM jvm->jvm.jvm 
   #define JNILIB_GETJAVAVM (*getJavaVM()) 
   #define JNILIB_GETJAVAVM_PARAM getJavaVM(), 
   #define JNILIB_ENV (*(getJNIEnv())) 
   #define JNILIB_PARAM_ENV getJNIEnv(), 
   #define JNILIB_PARAM_END_ENV getJNIEnv() 
#endif

JavaVM* javavm = NULL;

void createJvmC(Jvm_* jvm);
void createJvmCPP(JvmCPP_* jvm);

jint startJvm(Jvm* jvm);
void setJvmClasspath(Jvm* jvm, const char* cp);

void initJvm(Jvm* jvm, const char* classpath) {
   createJvm(jvm);
   setJvmClasspath(jvm, classpath);
   startJvm(jvm);
}

JavaVM* getJavaVM() {
   /* assert(javavm == NULL); */
   if (javavm == NULL) {
      fprintf(stdout, "Java Virtual Machine not created!\nError in file %s at line #%d!\nThe Programm wil terminate!\n", __FILE__, __LINE__);
      abort();
   }
   return javavm;
}

JNIEnv* getJNIEnv() {
   JNIEnv* env;
   /* assert(javavm != NULL); */
   if (javavm == NULL) {
      fprintf(stdout, "Java Virtual Machine not created!\nError in file %s at line #%d!\nThe Programm wil terminate!\n", __FILE__, __LINE__);
      abort();
   }
   JNILIB_GETJAVAVM->AttachCurrentThread(JNILIB_GETJAVAVM_PARAM (void **)&env, NULL);
   return env;
}

void setJvmClasspath(Jvm* jvm, const char* cp) {
   jvm->jvm.classpath = cp;
}

jint startJvm(Jvm* jvm) {
   int ret = 0;
   JavaVMOption options[3];
   char classpath[1024];

   /* let only create one Jvm */
   /* assert(javavm == NULL); */
   if (javavm != NULL) {
      fprintf(stdout, "Java Virtual Machine already created!\nError in file %s at line #%d!\nThe Programm wil terminate!\n", __FILE__, __LINE__);
      abort();
   }

   jvm->jvm.vm_args.version = JNI_VERSION_1_4;

#ifdef DEBUG
   jvm->jvm.vm_args.nOptions = 2;
#else
   jvm->jvm.vm_args.nOptions = 1;
#endif

   sprintf(classpath, "%s%s", CLASSPATH_PARAM, jvm->jvm.classpath);

   options[0].optionString = classpath;
   options[0].extraInfo = (void*)"";

   /* For Developement */
   options[1].optionString = "-Xcheck:jni";
   options[1].extraInfo = (void*)"";
   options[2].optionString = "-verbose:jni";
   options[2].extraInfo = (void*)"";

   jvm->jvm.vm_args.options = options;
   jvm->jvm.vm_args.ignoreUnrecognized = JNI_TRUE;
   
   /* Not needed anymore since JAVA 2 SDK release 1.2
   if ((ret = JNI_GetDefaultJavaVMInitArgs(&(jvm->jvm.vm_args))) != 0) {
      fprintf(stderr, "JNI Version not supported\n");
      return ret;
   }*/
   
   if ((ret = JNI_CreateJavaVM(&(jvm->jvm.jvm), (void**)&(jvm->jvm.env), &(jvm->jvm.vm_args))) < 0) {
      fprintf(stderr, "Can't create Java VM\nReturn Code: %d\n", ret);
      return ret;
   }

   javavm = jvm->jvm.jvm;

   return ret;
}

jint destroyJvm(Jvm* jvm) {
   return JNILIB_JAVAVM->DestroyJavaVM(JNILIB_PARAM_JAVAVM);
}

void createJvm_(Jvm_* jvm) {
   jvm->destroyJvm = &destroyJvm;

   setJvmClasspath((Jvm*)jvm, DEFAULT_CLASSPATH);
}

void createJvmCPP(JvmCPP_* jvm) {
   jvm->functions = (Jvm_*)malloc(sizeof(Jvm_));
   createJvm_(jvm->functions);
}

void createJvmC(Jvm_* jvm) {
   createJvm_(jvm);
}

jclass findClass(const char* strclass) {
   jclass ret;
   ret = JNILIB_ENV->FindClass(JNILIB_PARAM_ENV strclass);

   exception();

   if (ret == NULL) {
      fprintf(stderr, "Could not find Class: %s\n", strclass);
   } else {
      ret = (jclass)createGlobalReference(ret);
   }

   return ret;
}

jclass getObjectClass(jobject obj) {
   jclass ret;
   ret = JNILIB_ENV->GetObjectClass(JNILIB_PARAM_ENV obj);
   return (jclass)createGlobalReference(ret);
}

jmethodID findStaticMethod(jclass cls, const char* method, const char* signature) {
   jmethodID ret;
   ret = JNILIB_ENV->GetStaticMethodID(JNILIB_PARAM_ENV cls, method, signature);
   if (ret == NULL) {
      fprintf(stderr, "Could not find static Method: %s\n", method);
   }
   return ret;
}

jfieldID findStaticField(jclass cls, const char* field, const char* signature) {
   jfieldID ret;
   ret = JNILIB_ENV->GetStaticFieldID(JNILIB_PARAM_ENV cls, field, signature);
   if (ret == NULL) {
      fprintf(stderr, "Could not find static Field: %s\n", field);
   }
   return ret;
}

jmethodID findMethod(jclass cls, const char* method, const char* signature) {
   jmethodID ret;
   ret = JNILIB_ENV->GetMethodID(JNILIB_PARAM_ENV cls, method, signature);
   if (ret == NULL) {
      fprintf(stderr, "Could not find Method: %s\n", method);
   }
   return ret;
}

jint registerNatives(jclass cls, const JNINativeMethod* nm, jint nMethods) {
   jint ret;
   ret = JNILIB_ENV->RegisterNatives(JNILIB_PARAM_ENV cls, nm, nMethods);
   if (ret != 0) {
      fprintf(stderr, "Could not register Method: %s\n", nm->name);
   }
   return ret;
}

void deleteLocalReference(jobject obj) {
   JNILIB_ENV->DeleteLocalRef(JNILIB_PARAM_ENV obj);
}

void deleteGlobalReference(jobject obj) {
   JNILIB_ENV->DeleteGlobalRef(JNILIB_PARAM_ENV obj);
}

jobject createGlobalReference(jobject obj) {
   jobject ret;
   ret = JNILIB_ENV->NewGlobalRef(JNILIB_PARAM_ENV obj);
   deleteLocalReference(obj);
   return ret;
}

jboolean isSameObject(jobject obj1, jobject obj2) {
   return JNILIB_ENV->IsSameObject(JNILIB_PARAM_ENV obj1, obj2);
}

jboolean exception() {
   jthrowable exc;

   exc = JNILIB_ENV->ExceptionOccurred(JNILIB_PARAM_END_ENV);
   if (exc) {
      /* We don't do much with the exception, except that
      we print a debug message for it and clear it */
      JNILIB_ENV->ExceptionDescribe(JNILIB_PARAM_END_ENV);
      JNILIB_ENV->ExceptionClear(JNILIB_PARAM_END_ENV);
      deleteLocalReference(exc);
   }
   return (exc != NULL);
}

jstring createJString(const char* str) {
   static jclass clsstring = NULL;
   static jmethodID mid = NULL;
   jstring result = NULL;
   jbyteArray bytes = 0;
   jsize len;

   if (clsstring == NULL) {
      clsstring = findClass("java/lang/String");
      mid = findMethod(clsstring, "<init>", "([B)V");
   }

   if (JNILIB_ENV->EnsureLocalCapacity(JNILIB_PARAM_ENV 2) < 0) {
      return NULL; /* out of memory error */
   }

   len = (jsize)strlen(str);
   bytes = JNILIB_ENV->NewByteArray(JNILIB_PARAM_ENV len);
   if (bytes != NULL) {
      JNILIB_ENV->SetByteArrayRegion(JNILIB_PARAM_ENV bytes, 0, len, (jbyte *)str);
      result = (jstring) newObject(clsstring, mid, bytes);
      deleteLocalReference(bytes);
   } /* else fall through */
   return result;
}

char* convertJString(jstring jstr) {
   static jclass clsstring = NULL;
   static jmethodID mid = NULL;
   jbyteArray bytes = NULL;
   jthrowable exc;
   char *result = NULL;

   if (jstr == NULL) {
      return "";
   }

   if (clsstring == NULL) {
      clsstring = findClass("java/lang/String");
      mid = findMethod(clsstring, "getBytes", "()[B");
   }

   if (JNILIB_ENV->EnsureLocalCapacity(JNILIB_PARAM_ENV 2) < 0) {
      return "OUT OF MEMORY"; /* out of memory error */
   }
   bytes = (jbyteArray) callObjectMethod(jstr, mid);
   exc = JNILIB_ENV->ExceptionOccurred(JNILIB_PARAM_END_ENV);
   if (!exc) {
      jint len = JNILIB_ENV->GetArrayLength(JNILIB_PARAM_ENV bytes);
      result = (char *)malloc(len + 1);
      if (result == 0) {
         throwByName("java/lang/OutOfMemoryError", 0);
      } else {
         JNILIB_ENV->GetByteArrayRegion(JNILIB_PARAM_ENV bytes, 0, len, (jbyte *)result);
         result[len] = 0; /* NULL-terminate */
      }
   }
   deleteLocalReference(exc);
   deleteLocalReference(bytes);
   return result;
}

void throwByName(const char *name, const char *msg) {
   jclass cls = findClass((char*)name);
   /* if cls is NULL, an exception has already been thrown */
   if (cls != NULL) {
      JNILIB_ENV->ThrowNew(JNILIB_PARAM_ENV cls, msg);
   }
   /* free the local ref */
   deleteLocalReference(cls);
}

void jnisleep(jint ms) {
   static jclass cls = NULL;
   static jmethodID mjnisleep = NULL;

   if (cls == NULL) {
      cls = findClass(CLS_JNILIB);
      mjnisleep = findStaticMethod(cls, "sleep", "(I)V");
   }
   callStaticVoidMethod(cls, mjnisleep, ms);
}

jobject newObject(jclass cls, jmethodID mid, ...) {
   jobject ret;
   va_list args;

   va_start(args, mid);

   ret = JNILIB_ENV->NewObjectV(JNILIB_PARAM_ENV cls, mid, args);

   ret = createGlobalReference(ret);

   va_end(args);
   return ret;
}

jobject newObjectBySignature(jclass cls, const char* signature, ...) {
   jobject ret;
   va_list args;
   jmethodID mid;

   va_start(args, signature);
   mid = findMethod(cls, "<init>", signature);

   ret = JNILIB_ENV->NewObjectV(JNILIB_PARAM_ENV cls, mid, args);

   ret = createGlobalReference(ret);

   va_end(args);
   return ret;
}

void callStaticVoidMethod(jclass cls, jmethodID mid, ...) {
   va_list args;

   va_start(args, mid);

   JNILIB_ENV->CallStaticVoidMethodV(JNILIB_PARAM_ENV cls, mid, args);

   va_end(args);
}

void callVoidMethod(jobject obj, jmethodID mid, ...) {
   va_list args;

   va_start(args, mid);

   JNILIB_ENV->CallVoidMethodV(JNILIB_PARAM_ENV obj, mid, args);

   va_end(args);
}

jboolean callBooleanMethod(jobject obj, jmethodID mid, ...) {
   jboolean ret;
   va_list args;

   va_start(args, mid);

   ret = JNILIB_ENV->CallBooleanMethodV(JNILIB_PARAM_ENV obj, mid, args);

   va_end(args);
   return ret;
}

jbyte callByteMethod(jobject obj, jmethodID mid, ...) {
   jbyte ret;
   va_list args;

   va_start(args, mid);

   ret = JNILIB_ENV->CallByteMethodV(JNILIB_PARAM_ENV obj, mid, args);

   va_end(args);
   return ret;
}

jchar callCharMethod(jobject obj, jmethodID mid, ...) {
   jchar ret;
   va_list args;

   va_start(args, mid);

   ret = JNILIB_ENV->CallCharMethodV(JNILIB_PARAM_ENV obj, mid, args);

   va_end(args);
   return ret;
}

jshort callShortMethod(jobject obj, jmethodID mid, ...) {
   jshort ret;
   va_list args;

   va_start(args, mid);

   ret = JNILIB_ENV->CallShortMethodV(JNILIB_PARAM_ENV obj, mid, args);

   va_end(args);
   return ret;
}

jint callStaticIntMethod(jclass cls, jmethodID mid, ...) {
   jint ret;
   va_list args;

   va_start(args, mid);

   ret = JNILIB_ENV->CallStaticIntMethodV(JNILIB_PARAM_ENV cls, mid, args);

   va_end(args);
   return ret;
}

jint callIntMethod(jobject obj, jmethodID mid, ...) {
   jint ret;
   va_list args;

   va_start(args, mid);

   ret = JNILIB_ENV->CallIntMethodV(JNILIB_PARAM_ENV obj, mid, args);

   va_end(args);
   return ret;
}

jlong callLongMethod(jobject obj, jmethodID mid, ...) {
   jlong ret;
   va_list args;

   va_start(args, mid);

   ret = JNILIB_ENV->CallLongMethodV(JNILIB_PARAM_ENV obj, mid, args);

   va_end(args);
   return ret;
}

jfloat callFloatMethod(jobject obj, jmethodID mid, ...) {
   jfloat ret;
   va_list args;

   va_start(args, mid);

   ret = JNILIB_ENV->CallFloatMethodV(JNILIB_PARAM_ENV obj, mid, args);

   va_end(args);
   return ret;
}

jdouble callDoubleMethod(jobject obj, jmethodID mid, ...) {
   jdouble ret;
   va_list args;

   va_start(args, mid);

   ret = JNILIB_ENV->CallDoubleMethodV(JNILIB_PARAM_ENV obj, mid, args);

   va_end(args);
   return ret;
}

jobject callStaticObjectMethod(jclass cls, jmethodID mid, ...) {
   jobject ret;
   va_list args;

   va_start(args, mid);

   ret = JNILIB_ENV->CallStaticObjectMethodV(JNILIB_PARAM_ENV cls, mid, args);

   va_end(args);
   return ret;
}

jobject callObjectMethod(jobject obj, jmethodID mid, ...) {
   jobject ret;
   va_list args;

   va_start(args, mid);

   ret = JNILIB_ENV->CallObjectMethodV(JNILIB_PARAM_ENV obj, mid, args);

   va_end(args);
   return ret;
}

void callVoidMethodByName(jobject obj, const char* method, const char* signature, ...) {
   va_list args;
   jclass cls;
   jmethodID mid;

   va_start(args, signature);
   cls = getObjectClass(obj);
   mid = findMethod(cls, method, signature);

   JNILIB_ENV->CallVoidMethodV(JNILIB_PARAM_ENV obj, mid, args);

   deleteGlobalReference(cls);

   va_end(args);
}

jboolean callBooleanMethodByName(jobject obj, const char* method, const char* signature, ...) {
   jboolean ret;
   va_list args;
   jclass cls;
   jmethodID mid;

   va_start(args, signature);
   cls = getObjectClass(obj);
   mid = findMethod(cls, method, signature);

   ret = JNILIB_ENV->CallBooleanMethodV(JNILIB_PARAM_ENV obj, mid, args);

   deleteGlobalReference(cls);

   va_end(args);
   return ret;
}

jbyte callByteMethodByName(jobject obj, const char* method, const char* signature, ...) {
   jbyte ret;
   va_list args;
   jclass cls;
   jmethodID mid;

   va_start(args, signature);
   cls = getObjectClass(obj);
   mid = findMethod(cls, method, signature);

   ret = JNILIB_ENV->CallByteMethodV(JNILIB_PARAM_ENV obj, mid, args);

   deleteGlobalReference(cls);

   va_end(args);
   return ret;
}

jchar callCharMethodByName(jobject obj, const char* method, const char* signature, ...) {
   jchar ret;
   va_list args;
   jclass cls;
   jmethodID mid;

   va_start(args, signature);
   cls = getObjectClass(obj);
   mid = findMethod(cls, method, signature);

   ret = JNILIB_ENV->CallCharMethodV(JNILIB_PARAM_ENV obj, mid, args);

   deleteGlobalReference(cls);

   va_end(args);
   return ret;
}

jshort callShortMethodByName(jobject obj, const char* method, const char* signature, ...) {
   jshort ret;
   va_list args;
   jclass cls;
   jmethodID mid;

   va_start(args, signature);
   cls = getObjectClass(obj);
   mid = findMethod(cls, method, signature);

   ret = JNILIB_ENV->CallShortMethodV(JNILIB_PARAM_ENV obj, mid, args);

   deleteGlobalReference(cls);

   va_end(args);
   return ret;
}

jint callIntMethodByName(jobject obj, const char* method, const char* signature, ...) {
   jint ret;
   va_list args;
   jclass cls;
   jmethodID mid;

   va_start(args, signature);
   cls = getObjectClass(obj);
   mid = findMethod(cls, method, signature);

   ret = JNILIB_ENV->CallIntMethodV(JNILIB_PARAM_ENV obj, mid, args);

   deleteGlobalReference(cls);

   va_end(args);
   return ret;
}

jlong callLongMethodByName(jobject obj, const char* method, const char* signature, ...) {
   jlong ret;
   va_list args;
   jclass cls;
   jmethodID mid;

   va_start(args, signature);
   cls = getObjectClass(obj);
   mid = findMethod(cls, method, signature);

   ret = JNILIB_ENV->CallLongMethodV(JNILIB_PARAM_ENV obj, mid, args);

   deleteGlobalReference(cls);

   va_end(args);
   return ret;
}

jfloat callFloatMethodByName(jobject obj, const char* method, const char* signature, ...) {
   jfloat ret;
   va_list args;
   jclass cls;
   jmethodID mid;

   va_start(args, signature);
   cls = getObjectClass(obj);
   mid = findMethod(cls, method, signature);

   ret = JNILIB_ENV->CallFloatMethodV(JNILIB_PARAM_ENV obj, mid, args);

   deleteGlobalReference(cls);

   va_end(args);
   return ret;
}

jdouble callDoubleMethodByName(jobject obj, const char* method, const char* signature, ...) {
   jdouble ret;
   va_list args;
   jclass cls;
   jmethodID mid;

   va_start(args, signature);
   cls = getObjectClass(obj);
   mid = findMethod(cls, method, signature);

   ret = JNILIB_ENV->CallDoubleMethodV(JNILIB_PARAM_ENV obj, mid, args);

   deleteGlobalReference(cls);

   va_end(args);
   return ret;
}

jobject callObjectMethodByName(jobject obj, const char* method, const char* signature, ...) {
   jobject ret;
   va_list args;
   jclass cls;
   jmethodID mid;
   cls = getObjectClass(obj);
   mid = findMethod(cls, method, signature);

   va_start(args, signature);

   ret = JNILIB_ENV->CallObjectMethodV(JNILIB_PARAM_ENV obj, mid, args);

   deleteGlobalReference(cls);

   va_end(args);
   return ret;
}

jint getStaticIntFieldByName(const char* strclass, const char* strfield) {
   jint ret;
   jclass cls;
   jfieldID fid;

   cls = findClass(strclass);
   fid = findStaticField(cls, strfield, "I");

   ret = JNILIB_ENV->GetStaticIntField(JNILIB_PARAM_ENV cls, fid);

   deleteGlobalReference(cls);

   return ret;
}

jobject getStaticObjectFieldByName(const char* strclass, const char* strfield, const char* signature) {
   jobject ret;
   jclass cls;
   jfieldID fid;

   cls = findClass(strclass);
   fid = findStaticField(cls, strfield, signature);

   ret = JNILIB_ENV->GetStaticObjectField(JNILIB_PARAM_ENV cls, fid);

   deleteGlobalReference(cls);

   return ret;
}

#ifdef __cplusplus
}/* extern "C" */
#endif

/* end of file jnilib.c */

---