MkObjectC_jv.c

Go to the documentation of this file.

 
/* LABEL-START */
#define META_FILE_NAME "MkObjectC_jv.c"
 
#include "jni_h/jvmkkernel_MkObjectC.h"
#include "LibMkKernel_private_jv.h"
 
 
jobject NS(MkObjectC_ObjNew) (MK_RT_ARGS JNIEnv *env, MK_OBJ hdl) {
  static MkThreadLocal jobject NS_NULL = NULL;
  return (hdl ? MK(AtomObjNew)(MK_RT_CALL env, MkObjectC_X2obj(hdl)) : MK_GET__NS_NULL(MkObjectC));
}
 
MK_UNUSED
static jobject NS(MkObjectC_ObjCreate) (MK_RT_ARGS JNIEnv *env, MK_OBJ hdl) {
  return MK(AtomObjCreate)(MK_RT_CALL env, MkObjectC_X2obj(hdl));
}
 
static MK_PTR NS(MkObjectC_selfCreate) (MK_RT_ARGS MK_OBJ obj, MK_PTR envP) {
  JNIEnv *env = (JNIEnv*) envP;
  return (*env)->NewObject(env, NS(Class_MkObjectC), NS(MID_MkObjectC_INIT), (jlong) obj, JNI_TRUE);
}
 
#define ClassInit \
 
//  printTxt("init: MkObjectC");
 
/* LABEL-END */
 
 
void NS(AtomSelfUnlink) (MK_RT_ARGS MK_PTR ptr, MK_PTR envP) {
  if (!envP) return;
  JNIEnv *env = (JNIEnv*) envP;
  jobject self = (jobject) ptr;
#ifndef META_STRONG_REF
  if ((*env)->IsSameObject(env,self,NULL)) goto end;
#endif
//X0(pObj2Hdl(env, self))
  (*env)->SetLongField(env,self,NS(FID_MkObjectC_hdl),0);
  JavaErrorReport
end: MK_UNUSED
#if META_STRONG_REF
  (*env)->DeleteGlobalRef(env, self);
#else
  (*env)->DeleteWeakGlobalRef(env, self);
#endif
}
 
JNIEXPORT jlong JNICALL Java_jvmkkernel_MkObjectC_atomCreate
  (JNIEnv * env, jclass class, jlong mng, jobject self)
{
  if (mng == 0L) {
    (*env)->ThrowNew(env, NS(Class_MkInitError), "MkObjectC");
    goto error;
  }
  MK_OBJ hdl = MkObj((MK_MNG)mng);
  if (hdl == NULL) {
    (*env)->ThrowNew(env, NS(Class_RuntimeException), "MkObjectC: signature check failed");
    goto error;
  }
#if META_STRONG_REF
  MK_PTR ref = (MK_PTR) (*env)->NewGlobalRef(env, self);
#else
  MK_PTR ref = (MK_PTR) (*env)->NewWeakGlobalRef(env, self);
#endif
  if ((*env)->IsSameObject(env,ref,NULL)) {
#if META_STRONG_REF
    (*env)->ThrowNew(env, NS(Class_RuntimeException), "MkObjectC: unable to create 'NewGlobalRef'");
#else
    (*env)->ThrowNew(env, NS(Class_RuntimeException), "MkObjectC: unable to create 'NewWeakGlobalRef'");
#endif
    goto error;
  }
  MkRefIncrSelf(hdl,ref,env);
  return mng;
error:
  return 0;
}
 
JNIEXPORT jlong JNICALL Java_jvmkkernel_MkObjectC_atomDelete
  (JNIEnv * env, jclass class, jlong mng)
{
  MK_OBJ obj = MkObj((MK_PTR)mng);
  if (obj == NULL) return 0;
  MkRtSetup_ON(obj);
//printXTxt(obj,MkObjectToName(obj))
  MkRefDecrWithUnlinkSelf(obj);
  return 0;
}
 
#define MkDbgDumpTmpl(obj,msg,cal)  NS(printObj)(MK_RT_CALL env,NULL,self,cal,msg)
 
static enum MkErrorE NS(printObj)(MK_RT_ARGS JNIEnv *env, MK_MNG mng, jobject val, MK_STRN caller, MK_STRN txt) {
  MK_OBJ fmt = mng ? MkObj(mng) : MK_ERROR_DEFAULT;
  if (val == NULL) {
    MkLogC(fmt, "NULL\n", 0, caller);
  } else {
    MK_OBJ obj = NULL;
    if (OT_LNG_OBJ_CLASS_IS(val,MK(Class_MkObjectC))) {
      obj = (MK_OBJ)pObj2Hdl__null_allow(env,val);
      if (fmt == MK_ERROR_DEFAULT && obj != NULL) fmt = obj;
      MkLogV(fmt, caller, 0, 
          "DUMP %s: { jval=%p }\n", (txt?txt:"printObj"), val
      );
    } else {
      MkLogV(fmt, caller, 0, 
          "DUMP %s: { jval=%p }\n", (txt?txt:"printObj"), val
      );
    }
    if (obj) MkObjectLogShort(obj,NULL,0,caller,1);
    jstring ret = (*env)->CallStaticObjectMethod(env, MK(Class_MkKernel), MK(MID_MkKernel_dump), val);
    JavaErrorCheck;
    if (ret) {
      jboolean isCopy;
      MK_STRN retCC = (*env)->GetStringUTFChars(env,ret,&isCopy);
      MK_STR retC  = isCopy ? (MK_STR) retCC : strdup(retCC);
      JavaErrorCheck;
      MK_STR start = strtok(retC,META_EOL);
      while (start != NULL) {
        MkLogV(fmt, caller, 0, "  | %s\n", start);
        start = strtok(NULL,META_EOL);
      }
      if (retC) (*env)->ReleaseStringUTFChars(env,ret,retCC);
      if (!isCopy) free(retC);
    }
  }
  return MK_OK;
error:
  OT_ERROR_LNG_2_META(mng);
  return MK_ERROR;
} 
 
#define MkObjectErrorCatchTmpl(...)    MK(MkExceptionC_Catch) (env,__VA_ARGS__, NULL)
 
 
// BEGIN-MkObjectC - created by 'jv_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// doc-key: MkObjectC,MkObjectC-Class-Export,sc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkObjectC_HandleResolve (JNIEnv *env, jclass class, jint netHdl)  {
  MkRtSetup_NULL;
  MK_OBJ __retVal__L = MkObjectHandleResolve(netHdl);
  jobject __retVal__S = MK(MkObjectC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// doc-key: MkObjectC,MkObjectC-Class-Export,om_
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkObjectC_HandleDelete (JNIEnv *env, jobject self)  {
  MK_OBJ hdl = (MK_OBJ)pObj2Hdl(env,"MkObjectC",self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  MkObjectHandleDelete(hdl);
error:
  return;
}
 
JNIEXPORT jboolean JNICALL Java_jvmkkernel_MkObjectC_HandleExists (JNIEnv *env, jobject self)  {
  MK_OBJ hdl = (MK_OBJ)pObj2Hdl__null_allow(env,self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  MK_BOOL __retVal__L = MkObjectHandleExists(hdl);
  jboolean __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmkkernel_MkObjectC_HandleGet (JNIEnv *env, jobject self)  {
  MK_OBJ hdl = (MK_OBJ)pObj2Hdl__null_allow(env,self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  MK_HDL __retVal__L = MkObjectHandleGet(hdl);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmkkernel_MkObjectC_HandleGetOfType (JNIEnv *env, jobject self)  {
  MK_OBJ hdl = (MK_OBJ)pObj2Hdl(env,"MkObjectC",self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  MK_HDL __retVal__L = MkObjectHandleGetOfType(hdl);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmkkernel_MkObjectC_HandleGetOr0 (JNIEnv *env, jobject self)  {
  MK_OBJ hdl = (MK_OBJ)pObj2Hdl__null_allow(env,self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  MK_HDL __retVal__L = MkObjectHandleGetOr0(hdl);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkObjectC,MkObjectC-Class-Export,sm_
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkObjectC_HandleDeleteByNetHdl (JNIEnv *env, jclass class, jint netHdl)  {
  MkRtSetup_NULL;
  MkObjectHandleDeleteByNetHdl(netHdl);
}
 
// MkObjectC_Class_JV_API
 
 
// doc-key: MkObjectC,MkObjectC-Class-Introspection,oc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkObjectC_Next (JNIEnv *env, jobject self)  {
  MK_OBJ hdl = (MK_OBJ)pObj2Hdl(env,"MkObjectC",self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  MK_OBJ __retVal__L = MkObjectNext(hdl);
  jobject __retVal__S = MK(MkObjectC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkObjectC_Prev (JNIEnv *env, jobject self)  {
  MK_OBJ hdl = (MK_OBJ)pObj2Hdl(env,"MkObjectC",self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  MK_OBJ __retVal__L = MkObjectPrev(hdl);
  jobject __retVal__S = MK(MkObjectC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkObjectC,MkObjectC-Class-Introspection,sc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkObjectC_Instances (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  MK_OBJ __retVal__L = MkObjectInstances();
  jobject __retVal__S = MK(MkObjectC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// MkObjectC_Class_JV_API
 
 
// doc-key: MkObjectC,MkObjectC-Class-Misc,sc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkObjectC_GetNull (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  MK_OBJ __retVal__L = MkObjectGetNull();
  jobject __retVal__S = MK(MkObjectC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// MkObjectC_Class_JV_API
 
 
// doc-key: MkObjectC,MkObjectC-Dbg,om_
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkObjectC_DbgDump (JNIEnv *env, jobject self, jstring message, jstring callfunc)  {
  MK_OBJN hdl = (MK_OBJN)pObj2Hdl(env,"MkObjectC",self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  if (callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  MK_STRN message_ptr = (message?(*env)->GetStringUTFChars(env,message,NULL):NULL);
  JavaErrorCheck;
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MkDbgDumpTmpl(hdl, message_ptr, callfunc_ptr);
  MkErrorC_Check(hdl, errVal)
  if (message_ptr) (*env)->ReleaseStringUTFChars(env,message,message_ptr);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkObjectC_DbgL (JNIEnv *env, jobject self, jstring message, jint debug, jstring callfunc, jint lvl)  {
  MK_OBJN hdl = (MK_OBJN)pObj2Hdl__null_allow(env,self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  if (callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  if (debug > (jint)(MkRuntimeDebugGet())) {return;}
  MK_STRN message_ptr = (message?(*env)->GetStringUTFChars(env,message,NULL):NULL);
  JavaErrorCheck;
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  MkDbgL(hdl, message_ptr, debug, callfunc_ptr, lvl);
  if (message_ptr) (*env)->ReleaseStringUTFChars(env,message,message_ptr);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkObjectC_DbgLogC (JNIEnv *env, jobject self, jstring callfunc)  {
  MK_OBJN hdl = (MK_OBJN)pObj2Hdl(env,"MkObjectC",self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  if (callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  MkDbgLogC(hdl, callfunc_ptr);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkObjectC_DbgO (JNIEnv *env, jobject self, jstring callfunc)  {
  MK_OBJN hdl = (MK_OBJN)pObj2Hdl(env,"MkObjectC",self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  if (callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  MkDbgO(hdl, callfunc_ptr);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkObjectC_DbgSTACK (JNIEnv *env, jobject self, jint skip, jint num, jstring callfunc)  {
  MK_OBJN hdl = (MK_OBJN)pObj2Hdl__null_allow(env,self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  if (callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  MkDbgSTACK(hdl, skip, num, callfunc_ptr);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
error:
  return;
}
 
// doc-key: MkObjectC,MkObjectC-Dbg,sm_
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkObjectC_DbgM (JNIEnv *env, jclass class, jstring message, jint debug, jstring callfunc, jint lvl)  {
  MkRtSetup_NULL;
  if (callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  if (debug > (jint)(MkRuntimeDebugGet())) {return;}
  MK_STRN message_ptr = (message?(*env)->GetStringUTFChars(env,message,NULL):NULL);
  JavaErrorCheck;
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  MkDbgM(message_ptr, debug, callfunc_ptr, lvl);
  if (message_ptr) (*env)->ReleaseStringUTFChars(env,message,message_ptr);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
error:
  return;
}
 
// MkObjectC_Dbg_JV_API
 
 
// doc-key: MkObjectC,MkObjectC-Log,om_
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkObjectC_LogC (JNIEnv *env, jobject self, jstring message, jint debug, jstring callfunc)  {
  MK_OBJN hdl = (MK_OBJN)pObj2Hdl__null_allow(env,self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  if (callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  if (debug > (jint)(MkRuntimeDebugGet())) {return;}
  MK_STRN message_ptr = (message?(*env)->GetStringUTFChars(env,message,NULL):NULL);
  JavaErrorCheck;
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  MkLogC(hdl, message_ptr, debug, callfunc_ptr);
  if (message_ptr) (*env)->ReleaseStringUTFChars(env,message,message_ptr);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkObjectC_LogHEX (JNIEnv *env, jobject self, jstring callfunc, jbyteArray data)  {
  MK_OBJN hdl = (MK_OBJN)pObj2Hdl__null_allow(env,self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  if (callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  MK_BINN data_data = (MK_BINN) (*env)->GetByteArrayElements(env, data, NULL);
  JavaErrorCheck;
  MK_SIZE data_size = (MK_SIZE) (*env)->GetArrayLength (env, data);
  JavaErrorCheck;
  MkBinaryR data_ref = MkBinaryCreate(data_size,data_data);
  MkLogHEX(hdl, callfunc_ptr, data_ref);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
  (*env)->ReleaseByteArrayElements(env, data, (jbyte*)data_data, JNI_ABORT);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkObjectC_Log (JNIEnv *env, jobject self, jobject fmtobj, jint debug, jstring callfunc, jint lvl)  {
  MK_OBJN hdl = (MK_OBJN)pObj2Hdl(env,"MkObjectC",self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  MK_OBJN fmtobj_hdl = (MK_OBJN)pObj2Hdl__null_allow(env,fmtobj);
  JavaErrorCheck;
  if (callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  if (debug > (jint)(MkRuntimeDebugGet())) {return;}
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  MkObjectLog(hdl, fmtobj_hdl, debug, callfunc_ptr, lvl);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkObjectC_LogLong (JNIEnv *env, jobject self, jobject fmtobj, jint debug, jstring callfunc, jint lvl)  {
  MK_OBJN hdl = (MK_OBJN)pObj2Hdl(env,"MkObjectC",self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  MK_OBJN fmtobj_hdl = (MK_OBJN)pObj2Hdl__null_allow(env,fmtobj);
  JavaErrorCheck;
  if (callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  if (debug > (jint)(MkRuntimeDebugGet())) {return;}
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  MkObjectLogLong(hdl, fmtobj_hdl, debug, callfunc_ptr, lvl);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkObjectC_LogShort (JNIEnv *env, jobject self, jobject fmtobj, jint debug, jstring callfunc, jint lvl)  {
  MK_OBJN hdl = (MK_OBJN)pObj2Hdl(env,"MkObjectC",self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  MK_OBJN fmtobj_hdl = (MK_OBJN)pObj2Hdl__null_allow(env,fmtobj);
  JavaErrorCheck;
  if (callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  if (debug > (jint)(MkRuntimeDebugGet())) {return;}
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  MkObjectLogShort(hdl, fmtobj_hdl, debug, callfunc_ptr, lvl);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkObjectC_LogType (JNIEnv *env, jobject self, jobject fmtobj, jint debug, jstring callfunc, jint lvl)  {
  MK_OBJN hdl = (MK_OBJN)pObj2Hdl(env,"MkObjectC",self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  MK_OBJN fmtobj_hdl = (MK_OBJN)pObj2Hdl__null_allow(env,fmtobj);
  JavaErrorCheck;
  if (callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  if (debug > (jint)(MkRuntimeDebugGet())) {return;}
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  MkObjectLogType(hdl, fmtobj_hdl, debug, callfunc_ptr, lvl);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
error:
  return;
}
 
// MkObjectC_Log_JV_API
 
 
// doc-key: MkObjectC,MkObjectC-Misc,oc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkObjectC_ErrorCatch (JNIEnv *env, jobject self, jthrowable exception, jstring callfunc)  {
  MK_OBJN hdl = (MK_OBJN)pObj2Hdl(env,"MkObjectC",self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  if (callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  MK_ERR __retVal__L = MkObjectErrorCatchTmpl(hdl, exception, callfunc_ptr);
  jobject __retVal__S = MK(MkErrorC_ObjNew)(MK_RT_CALL env,__retVal__L);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkObjectC_ToError (JNIEnv *env, jobject self)  {
  MK_OBJ hdl = (MK_OBJ)pObj2Hdl(env,"MkObjectC",self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  MK_ERR __retVal__L = MkObjectToError(hdl);
  jobject __retVal__S = MK(MkErrorC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkObjectC,MkObjectC-Misc,om_
 
JNIEXPORT jboolean JNICALL Java_jvmkkernel_MkObjectC_IsNull (JNIEnv *env, jobject self)  {
  MK_OBJ hdl = (MK_OBJ)pObj2Hdl__null_allow(env,self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  MK_BOOL __retVal__L = MkObjectIsNull(hdl);
  jboolean __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmkkernel_MkObjectC_ToName (JNIEnv *env, jobject self)  {
  MK_OBJN hdl = (MK_OBJN)pObj2Hdl__null_allow(env,self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  MK_STRN __retVal__L = MkObjectToName(hdl);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmkkernel_MkObjectC_ToNameOfClass (JNIEnv *env, jobject self) ; // skip template-required
 
JNIEXPORT jstring JNICALL Java_jvmkkernel_MkObjectC_ToNameOfType (JNIEnv *env, jobject self)  {
  MK_OBJN hdl = (MK_OBJN)pObj2Hdl(env,"MkObjectC",self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  MK_STRN __retVal__L = MkObjectToNameOfType(hdl);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmkkernel_MkObjectC_ToString (JNIEnv *env, jobject self)  {
  MK_OBJN hdl = (MK_OBJN)pObj2Hdl__null_allow(env,self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  MK_STRN __retVal__L = MkObjectToString(hdl);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// MkObjectC_Misc_JV_API
 
 
// doc-key: MkObjectC,MkObjectC-Obj,om_
 
JNIEXPORT jint JNICALL Java_jvmkkernel_MkObjectC_RefGet (JNIEnv *env, jobject self)  {
  MK_OBJ hdl = (MK_OBJ)pObj2Hdl(env,"MkObjectC",self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  MK_I32 __retVal__L = MkRefGet(hdl);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
// MkObjectC_Obj_JV_API
 
 
// doc-key: MkObjectC,MkObjectC-Sys,om_
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkObjectC_SysKill (JNIEnv *env, jobject self, jint pid, jint signal)  {
  MK_OBJN hdl = (MK_OBJN)pObj2Hdl__null_allow(env,self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  enum MkErrorE errVal = MkSysKill(hdl, pid, signal);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
// doc-key: MkObjectC,MkObjectC-Sys,omo
 
JNIEXPORT jint JNICALL Java_jvmkkernel_MkObjectC_SysGetPid (JNIEnv *env, jobject self)  {
  MK_OBJN hdl = (MK_OBJN)pObj2Hdl__null_allow(env,self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  MK_I32 pid_out;
  enum MkErrorE errVal = MkSysGetPid(hdl, &pid_out);
  MkErrorC_Check(hdl, errVal)
  jint __retVal__S = pid_out;
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkObjectC,MkObjectC-Sys,sm_
 
JNIEXPORT jint JNICALL Java_jvmkkernel_MkObjectC_SysHashI32 (JNIEnv *env, jclass class, jstring key, jint length)  {
  MkRtSetup_NULL;
  MK_STRN key_ptr = (key?(*env)->GetStringUTFChars(env,key,NULL):NULL);
  JavaErrorCheck;
  MK_I32 __retVal__L = MkSysHashI32(key_ptr, length);
  jint __retVal__S = __retVal__L;
  if (key_ptr) (*env)->ReleaseStringUTFChars(env,key,key_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmkkernel_MkObjectC_SysHashSTR (JNIEnv *env, jclass class, jstring key, jint length)  {
  MkRtSetup_NULL;
  MK_STRN key_ptr = (key?(*env)->GetStringUTFChars(env,key,NULL):NULL);
  JavaErrorCheck;
  MK_STRN __retVal__L = MkSysHashSTR(key_ptr, length);
  jstring __retVal__S = JC2O(env,__retVal__L);
  if (key_ptr) (*env)->ReleaseStringUTFChars(env,key,key_ptr);
  return __retVal__S;
error:
  return 0;
}
 
// MkObjectC_Sys_JV_API
 
 
// doc-key: MkObjectC,MkObjectC-TOR,od_
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkObjectC_Dispose (JNIEnv *env, jobject self)  {
  MK_OBJ hdl = (MK_OBJ)pObj2Hdl(env,"MkObjectC",self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  (*env)->CallObjectMethod(env,self,NS(MID_MkObjectC_Dispose),JNI_TRUE);
error:
  return;
}
 
// doc-key: MkObjectC,MkObjectC-TOR,oD_
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkObjectC_Delete (JNIEnv *env, jobject self)  {
  MK_OBJ hdl = (MK_OBJ)pObj2Hdl(env,"MkObjectC",self);
  JavaErrorCheck;
  MkRtSetup_O(hdl);
  (*env)->CallObjectMethod(env,self,NS(MID_MkObjectC_Dispose),JNI_TRUE);
error:
  return;
}
 
// doc-key: MkObjectC,MkObjectC-TOR,sm_
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkObjectC_DeleteCallbackCleanup (JNIEnv *env, jclass class, jstring ident)  {
  MkRtSetup_NULL;
  MK_STRN ident_ptr = (ident?(*env)->GetStringUTFChars(env,ident,NULL):NULL);
  JavaErrorCheck;
  MkObjectDeleteCallbackCleanup(ident_ptr);
  if (ident_ptr) (*env)->ReleaseStringUTFChars(env,ident,ident_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkObjectC_DeleteCallbackSetup (JNIEnv *env, jclass class, jstring ident, jobject callback, jstring filter)  {
  MkRtSetup_NULL;
  MkObjectDeleteCallF fCall = NS(ObjectDeleteCall);
  MK_STRN ident_ptr = (ident?(*env)->GetStringUTFChars(env,ident,NULL):NULL);
  JavaErrorCheck;
  MK_CBP callback_ptr = MK(ProcCreate)(MK_RT_CALL env, callback, NULL, NS(MID_callback), true);
  JavaErrorCheck;
  if (callback_ptr == NULL) fCall = NULL;
  MK_STRN filter_ptr = (filter?(*env)->GetStringUTFChars(env,filter,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MkObjectDeleteCallbackSetup(ident_ptr, fCall, callback_ptr, NS(ObjectDeleteFree), filter_ptr);
  MkErrorC_Check(NULL, errVal)
  if (ident_ptr) (*env)->ReleaseStringUTFChars(env,ident,ident_ptr);
  if (filter_ptr) (*env)->ReleaseStringUTFChars(env,filter,filter_ptr);
error:
  return;
}
 
// MkObjectC_TOR_JV_API
 
// END-MkObjectC - created by 'jv_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// ########################################################################################
// OVERLOAD
 
JNIEXPORT jstring JNICALL Java_jvmkkernel_MkObjectC_ToNameOfClass (JNIEnv *env, jobject self) {
  jclass cs = (*env)->GetObjectClass(env, self);
  return (*env)->CallObjectMethod(env, cs, NS(MID_Class_getName));
}
 
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
void NS(MkObjectC_Init)(MK_RT_ARGS_ONLY) {
  ClassInit
 
  MkObjectC_TT->selfCreate     = NS(MkObjectC_selfCreate);
  MkObjectC_TT->selfUnlink     = MK(AtomSelfUnlink);
}