LibMkKernel_jv.c

Go to the documentation of this file.

 
/* LABEL-NO */
 
#include "jni_h/jvmkkernel_MkKernel.h"
#include "LibMkKernel_private_jv.h"
 
JavaVM      *MK(cached_jvm) = NULL;
 
jclass      jclass_List;
jfieldID    jfieldID_List;
jmethodID   jmethodID_List;
 
#define defDebug0
#define defClass(v,n)     jclass     v;
#define defOAtr(v,c,n,s)  jfieldID   v;
#define defSAtr(v,c,n,s)  jfieldID   v;
#define defOMth(v,c,n,s)  jmethodID  v;
#define defSMth(v,c,n,s)  jmethodID  v;
 
#include "MkDefs_jv.h"
 
#undef defDebug0
#undef defClass
#undef defOAtr
#undef defSAtr
#undef defOMth
#undef defSMth
 
static void NS(sMkRuntimeCallback) ( MK_RT_ARGS_ONLY ) {
  // BEGIN-INIT - created by 'jv_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  NS(MkBufferListC_Init)   (MK_RT_CALL_ONLY) ;
  NS(MkBufferC_Init)       (MK_RT_CALL_ONLY) ;
  NS(MkBufferStreamC_Init) (MK_RT_CALL_ONLY) ;
  NS(MkErrorC_Init)        (MK_RT_CALL_ONLY) ;
  NS(MkLogFileC_Init)      (MK_RT_CALL_ONLY) ;
  NS(MkObjectC_Init)       (MK_RT_CALL_ONLY) ;
  NS(MkRuntimeC_Init)      (MK_RT_CALL_ONLY) ;
 
  // END-INIT - created by 'jv_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
}
 
static struct MkRuntimeCallbackS NS(sMkRuntimeCallbackData) = {0};
 
#define MkCleanupTmpl() 
#define MkSetupTmpl() 
 
// BEGIN-MkKernel - created by 'jv_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// doc-key: MkKernel,MkKernel-Enum,sco
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkKernel_ErrorE_1FromInt (JNIEnv *env, jclass class, jint value)  {
  MkRtSetup_NULL;
  enum MkErrorE value_out;
  enum MkErrorE errVal = MkErrorE_FromInt(value, &value_out);
  MkErrorC_Check(NULL, errVal)
  jobject __retVal__S = MK(pGetEnumFromString)(env,MK(Class_MkErrorE),"Ljvmkkernel/MkErrorE;",MkErrorE_ToString(value_out));
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkKernel_IdSE_1FromInt (JNIEnv *env, jclass class, jint value)  {
  MkRtSetup_NULL;
  enum MkIdSE value_out;
  enum MkErrorE errVal = MkIdSE_FromInt(value, &value_out);
  MkErrorC_Check(NULL, errVal)
  jobject __retVal__S = MK(pGetEnumFromString)(env,MK(Class_MkIdSE),"Ljvmkkernel/MkIdSE;",MkIdSE_ToString(value_out));
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkKernel_TimeoutE_1FromInt (JNIEnv *env, jclass class, jint value)  {
  MkRtSetup_NULL;
  enum MkTimeoutE value_out;
  enum MkErrorE errVal = MkTimeoutE_FromInt(value, &value_out);
  MkErrorC_Check(NULL, errVal)
  jobject __retVal__S = MK(pGetEnumFromString)(env,MK(Class_MkTimeoutE),"Ljvmkkernel/MkTimeoutE;",MkTimeoutE_ToString(value_out));
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkKernel_TypeE_1FromInt (JNIEnv *env, jclass class, jint value)  {
  MkRtSetup_NULL;
  enum MkTypeE value_out;
  enum MkErrorE errVal = MkTypeE_FromInt(value, &value_out);
  MkErrorC_Check(NULL, errVal)
  jobject __retVal__S = MK(pGetEnumFromString)(env,MK(Class_MkTypeE),"Ljvmkkernel/MkTypeE;",MkTypeE_ToString(value_out));
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkKernel,MkKernel-Enum,sm_
 
JNIEXPORT jint JNICALL Java_jvmkkernel_MkKernel_ErrorE_1ToInt (JNIEnv *env, jclass class, jobject value)  {
  MkRtSetup_NULL;
  enum MkErrorE value_e = MK(pGetEnumFromObj)(env, NS(Class_MkErrorE), value);
  JavaErrorCheck;
  MK_I32 __retVal__L = MkErrorE_ToInt(value_e);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmkkernel_MkKernel_ErrorE_1ToString (JNIEnv *env, jclass class, jobject value)  {
  MkRtSetup_NULL;
  enum MkErrorE value_e = MK(pGetEnumFromObj)(env, NS(Class_MkErrorE), value);
  JavaErrorCheck;
  MK_STRN __retVal__L = MkErrorE_ToString(value_e);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmkkernel_MkKernel_IdSE_1ToInt (JNIEnv *env, jclass class, jobject value)  {
  MkRtSetup_NULL;
  enum MkIdSE value_e = MK(pGetEnumFromObj)(env, NS(Class_MkIdSE), value);
  JavaErrorCheck;
  MK_I32 __retVal__L = MkIdSE_ToInt(value_e);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmkkernel_MkKernel_IdSE_1ToString (JNIEnv *env, jclass class, jobject value)  {
  MkRtSetup_NULL;
  enum MkIdSE value_e = MK(pGetEnumFromObj)(env, NS(Class_MkIdSE), value);
  JavaErrorCheck;
  MK_STRN __retVal__L = MkIdSE_ToString(value_e);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmkkernel_MkKernel_TimeoutE_1ToInt (JNIEnv *env, jclass class, jobject value)  {
  MkRtSetup_NULL;
  enum MkTimeoutE value_e = MK(pGetEnumFromObj)(env, NS(Class_MkTimeoutE), value);
  JavaErrorCheck;
  MK_I32 __retVal__L = MkTimeoutE_ToInt(value_e);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmkkernel_MkKernel_TimeoutE_1ToString (JNIEnv *env, jclass class, jobject value)  {
  MkRtSetup_NULL;
  enum MkTimeoutE value_e = MK(pGetEnumFromObj)(env, NS(Class_MkTimeoutE), value);
  JavaErrorCheck;
  MK_STRN __retVal__L = MkTimeoutE_ToString(value_e);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmkkernel_MkKernel_TypeE_1ToInt (JNIEnv *env, jclass class, jobject value)  {
  MkRtSetup_NULL;
  enum MkTypeE value_e = MK(pGetEnumFromObj)(env, NS(Class_MkTypeE), value);
  JavaErrorCheck;
  MK_I32 __retVal__L = MkTypeE_ToInt(value_e);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmkkernel_MkKernel_TypeE_1ToString (JNIEnv *env, jclass class, jobject value)  {
  MkRtSetup_NULL;
  enum MkTypeE value_e = MK(pGetEnumFromObj)(env, NS(Class_MkTypeE), value);
  JavaErrorCheck;
  MK_STRN __retVal__L = MkTypeE_ToString(value_e);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// MkKernel_Enum_JV_API
 
 
// doc-key: MkKernel,MkKernel-Setup-libmkkernel,sm_
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkKernel_Cleanup (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  MkCleanupTmpl();
}
 
JNIEXPORT void JNICALL Setup (JNIEnv *env, jclass class) {
  MkRtSetup_NULL;
  MkSetupTmpl();
}
 
// MkKernel_Setup_libmkkernel_JV_API
 
// END-MkKernel - created by 'jv_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// https://stackoverflow.com/questions/30026030/what-is-the-best-way-to-save-jnienv
enum MkErrorE MK(GetJniEnv)(MK_RT_ARGS JNIEnv **env) {
  enum MkErrorE did_attach_thread = MK_OK;
  *env = NULL;
  // Check if the current thread is attached to the VM
  jint get_env_result = (*MK(cached_jvm))->GetEnv(MK(cached_jvm), (void**)env, JNI_VERSION_1_6);
  if (get_env_result == JNI_EDETACHED) {
    JavaVMAttachArgs args = {JNI_VERSION_10, "libmqmsgque", NULL};
    //if ((*MK(cached_jvm))->AttachCurrentThreadAsDaemon(MK(cached_jvm), (void**)env, &args) == JNI_OK) {
    if ((*MK(cached_jvm))->AttachCurrentThread(MK(cached_jvm), (void**)env, &args) == JNI_OK) {
      did_attach_thread = MK_OK;
    } else {
      // Failed to attach thread. Throw an exception if you want to.
      did_attach_thread = MkErrorSetC_1E ("Failed to attach thread");
    }
  } else if (get_env_result == JNI_EVERSION) {
    // Unsupported JNI version. Throw an exception if you want to.
    did_attach_thread = MkErrorSetC_1E ("Unsupported JNI version");
  }
  if (*env == NULL) {
    did_attach_thread = MkErrorSetC_1E ("unable to retrieve 'JNIEnv'");
  } else if ((**env)->ExceptionCheck(*env)) {
    did_attach_thread = MkErrorSetC_1E ("exception during retrieving of 'JNIEnv'");
  }
  return did_attach_thread;
}
 
 
// MODULE
 
bool MkRuntimeSysPipeHandlerUse = false;
 
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved)
{
  JNIEnv *env;
  MK(cached_jvm) = jvm;  /* cache the JavaVM pointer */
 
  JavaErrorCheck0 ((*jvm)->GetEnv(jvm, (void*) &env, JNI_VERSION_1_6));
 
  // init "LibMqMsgque"
  MkSetup();
  MkRtSetup_NULL;
 
  //MkSysPipeHandler(MK_PIPE_KEEP);
 
  JavaErrorCheck0 ((*env)->EnsureLocalCapacity(env, 50));
 
  jclass cls;
 
#define check(v,c) if ((v=(c))==NULL) return JNI_ERR
#define defClass(v,n)     check(cls, (*env)->FindClass(env, n));\
                          JavaErrorCheck; \
                          check(v, (*env)->NewGlobalRef(env, cls)); \
                          JavaErrorCheck;
#define defOAtr(v,c,n,s)  check(v, (*env)->GetFieldID(env,c,n,s)); \
                          JavaErrorCheck;
#define defSAtr(v,c,n,s)  check(v, (*env)->GetStaticFieldID(env,c,n,s)); \
                          JavaErrorCheck;
#define defOMth(v,c,n,s)  check(v, (*env)->GetMethodID(env,c,n,s)); \
                          JavaErrorCheck;
#define defSMth(v,c,n,s)  check(v, (*env)->GetStaticMethodID(env,c,n,s)); \
                          JavaErrorCheck;
#define defDebug0         MA
 
#include "MkDefs_jv.h"
 
#undef defDebug0
#undef defClass
#undef defOAtr
#undef defSAtr
#undef defOMth
#undef defSMth
 
  // class specific initialization
  MkRuntimeCallbackAdd( MK_RT_CALL &NS(sMkRuntimeCallbackData), NS(sMkRuntimeCallback), "JvKernel" );
 
  return JNI_VERSION_10;
error:
  return JNI_ERR; /* JNI version not supported */
}
 
JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *jvm, void *reserved)
{
  JNIEnv *env;
  void *val;
  if ((*jvm)->GetEnv(jvm, &val, JNI_VERSION_1_6)) {
    return;
  }
 
  MkRtSetup_NULL;
 
  // cleanup global variables
  env = (JNIEnv*) val;
 
#define defDebug0
#define defClass(v,n)     (*env)->DeleteGlobalRef(env, v);
#define defOAtr(v,c,n,s)
#define defSAtr(v,c,n,s)
#define defOMth(v,c,n,s)
#define defSMth(v,c,n,s)
 
#include "MkDefs_jv.h"
 
#undef defDebug0
#undef defClass
#undef defOAtr
#undef defSAtr
#undef defOMth
#undef defSMth
 
  MkRuntimeCallbackDel( MK_RT_CALL &NS(sMkRuntimeCallbackData) );
 
  MkCleanup();
 
  return;
}