MkBufferC_jv.c

Go to the documentation of this file.

 
/* LABEL-START */
#define META_FILE_NAME "MkBufferC_jv.c"
 
#include "jni_h/jvmkkernel_MkBufferC.h"
#include "LibMkKernel_private_jv.h"
 
 
jobject NS(MkBufferC_ObjNew) (MK_RT_ARGS JNIEnv *env, MK_BUF hdl) {
  static MkThreadLocal jobject NS_NULL = NULL;
  return (hdl ? MK(AtomObjNew)(MK_RT_CALL env, MkBufferC_X2obj(hdl)) : MK_GET__NS_NULL(MkBufferC));
}
 
MK_UNUSED
static jobject NS(MkBufferC_ObjCreate) (MK_RT_ARGS JNIEnv *env, MK_BUF hdl) {
  return MK(AtomObjCreate)(MK_RT_CALL env, MkBufferC_X2obj(hdl));
}
 
static MK_PTR NS(MkBufferC_selfCreate) (MK_RT_ARGS MK_OBJ obj, MK_PTR envP) {
  JNIEnv *env = (JNIEnv*) envP;
  return (*env)->NewObject(env, NS(Class_MkBufferC), NS(MID_MkBufferC_INIT), (jlong) obj, JNI_TRUE);
}
 
#define ClassInit \
 
//  printTxt("init: MkBufferC");
 
/* LABEL-END */
 
 
// BEGIN-MkBufferC - created by 'jv_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// doc-key: MkBufferC,MkBufferC-Access,oc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_AppendC (JNIEnv *env, jobject self, jstring val)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN val_ptr = (val?(*env)->GetStringUTFChars(env,val,NULL):NULL);
  JavaErrorCheck;
  MK_BUF __retVal__L = MkBufferAppendC(hdl, val_ptr);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  if (val_ptr) (*env)->ReleaseStringUTFChars(env,val,val_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_AppendStringR (JNIEnv *env, jobject self, jstring val)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkStringR val_ref = MkStringCreate((*env)->GetStringUTFLength(env,val),(val?(*env)->GetStringUTFChars(env,val,NULL):NULL));
  JavaErrorCheck;
  MK_BUF __retVal__L = MkBufferAppendStringR(hdl, val_ref);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  if (val_ref.ptr) (*env)->ReleaseStringUTFChars(env,val,val_ref.ptr);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferC,MkBufferC-Access,om_
 
JNIEXPORT jint JNICALL Java_jvmkkernel_MkBufferC_Pop (JNIEnv *env, jobject self, jstring val)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN val_ptr = (val?(*env)->GetStringUTFChars(env,val,NULL):NULL);
  JavaErrorCheck;
  MK_NUM __retVal__L = MkBufferPop(hdl, val_ptr);
  jint __retVal__S = __retVal__L;
  if (val_ptr) (*env)->ReleaseStringUTFChars(env,val,val_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmkkernel_MkBufferC_Push (JNIEnv *env, jobject self, jstring val)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN val_ptr = (val?(*env)->GetStringUTFChars(env,val,NULL):NULL);
  JavaErrorCheck;
  MK_NUM __retVal__L = MkBufferPush(hdl, val_ptr);
  jint __retVal__S = __retVal__L;
  if (val_ptr) (*env)->ReleaseStringUTFChars(env,val,val_ptr);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferC,MkBufferC-Access,omo
 
JNIEXPORT MK_NAT_OBJECT JNICALL ToObject (JNIEnv *env, jobject self); // skip template-required
 
// MkBufferC_Access_JV_API
 
 
// doc-key: MkBufferC,MkBufferC-Class-Export,sc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_HandleResolve (JNIEnv *env, jclass class, jint netHdl)  {
  MkRtSetup_NULL;
  MK_BUF __retVal__L = MkBufferHandleResolve(netHdl);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// doc-key: MkBufferC,MkBufferC-Class-Export,om_
 
// skip class-overload: HandleGet = MkBufferHandleGet → MkObjectHandleGet
 
// MkBufferC_Class_JV_API
 
 
// doc-key: MkBufferC,MkBufferC-Class-Introspection,oc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_Next (JNIEnv *env, jobject self)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF __retVal__L = MkBufferNext(hdl);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_Prev (JNIEnv *env, jobject self)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF __retVal__L = MkBufferPrev(hdl);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferC,MkBufferC-Class-Introspection,sc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_Instances (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  MK_BUF __retVal__L = MkBufferInstances();
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// MkBufferC_Class_JV_API
 
 
// doc-key: MkBufferC,MkBufferC-Class-Misc,sc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_GetNull (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  MK_BUF __retVal__L = MkBufferGetNull();
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// MkBufferC_Class_JV_API
 
 
// doc-key: MkBufferC,MkBufferC-Get,oci
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_GetBFL (JNIEnv *env, jobject self, jobject val_inout)  {
  MK_BUFN hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFL val_inout_hdl = (MK_BFL)pObj2Hdl__null_allow(env,val_inout);
  JavaErrorCheck;
  enum MkErrorE errVal = MkBufferGetBFL(hdl, &val_inout_hdl);
  MkErrorC_Check(hdl, errVal)
  jobject __retVal__S = MK(MkBufferListC_ObjNew)(MK_RT_CALL env,val_inout_hdl);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferC,MkBufferC-Get,oco
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_GetBUF (JNIEnv *env, jobject self)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF val_out;
  enum MkErrorE errVal = MkBufferGetBUF(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,val_out);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferC,MkBufferC-Get,omo
 
JNIEXPORT jbyteArray JNICALL Java_jvmkkernel_MkBufferC_GetBIN (JNIEnv *env, jobject self)  {
  MK_BUFN hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkBinaryR val_out_ref;
  enum MkErrorE errVal = MkBufferGetBIN(hdl, &val_out_ref);
  MkErrorC_Check(hdl, errVal)
  const jsize val_out_size = (jsize) val_out_ref.size;
  const jbyte *val_out_byte = (jbyte*) val_out_ref.data;
  jbyteArray val_out = (*env)->NewByteArray(env, val_out_size);
  JavaErrorCheck;
  (*env)->SetByteArrayRegion(env,val_out,0,val_out_size,val_out_byte);
  JavaErrorCheck;
  jbyteArray __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jboolean JNICALL Java_jvmkkernel_MkBufferC_GetBOL (JNIEnv *env, jobject self)  {
  MK_BUFN hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BOL val_out;
  enum MkErrorE errVal = MkBufferGetBOL(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jboolean __retVal__S = val_out != 0;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jdouble JNICALL Java_jvmkkernel_MkBufferC_GetDBL (JNIEnv *env, jobject self)  {
  MK_BUFN hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_DBL val_out;
  enum MkErrorE errVal = MkBufferGetDBL(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jdouble __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jfloat JNICALL Java_jvmkkernel_MkBufferC_GetFLT (JNIEnv *env, jobject self)  {
  MK_BUFN hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_FLT val_out;
  enum MkErrorE errVal = MkBufferGetFLT(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jfloat __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jshort JNICALL Java_jvmkkernel_MkBufferC_GetI16 (JNIEnv *env, jobject self)  {
  MK_BUFN hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I16 val_out;
  enum MkErrorE errVal = MkBufferGetI16(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jshort __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmkkernel_MkBufferC_GetI32 (JNIEnv *env, jobject self)  {
  MK_BUFN hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I32 val_out;
  enum MkErrorE errVal = MkBufferGetI32(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jint __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jlong JNICALL Java_jvmkkernel_MkBufferC_GetI64 (JNIEnv *env, jobject self)  {
  MK_BUFN hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I64 val_out;
  enum MkErrorE errVal = MkBufferGetI64(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jlong __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jbyte JNICALL Java_jvmkkernel_MkBufferC_GetI8 (JNIEnv *env, jobject self)  {
  MK_BUFN hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I8 val_out;
  enum MkErrorE errVal = MkBufferGetI8(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jbyte __retVal__S = (jbyte)val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmkkernel_MkBufferC_GetSTR (JNIEnv *env, jobject self)  {
  MK_BUFN hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN val_out;
  enum MkErrorE errVal = MkBufferGetSTR(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jstring __retVal__S = JC2O(env,val_out);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmkkernel_MkBufferC_GetStringR (JNIEnv *env, jobject self)  {
  MK_BUFN hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkStringR val_out_ref;
  enum MkErrorE errVal = MkBufferGetStringR(hdl, &val_out_ref);
  MkErrorC_Check(hdl, errVal)
  jstring val_out = (*env)->NewStringUTF(env, val_out_ref.ptr);
  JavaErrorCheck;
  jstring __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
// MkBufferC_Get_JV_API
 
 
// doc-key: MkBufferC,MkBufferC-Info,om_
 
JNIEXPORT jchar JNICALL Java_jvmkkernel_MkBufferC_GetType1 (JNIEnv *env, jobject self)  {
  MK_BUFN hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRB __retVal__L = MkBufferGetType1(hdl);
  jchar __retVal__S = (jchar) __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_GetType2 (JNIEnv *env, jobject self)  {
  MK_BUFN hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkTypeE __retVal__L = MkBufferGetType2(hdl);
  jobject __retVal__S = MK(pGetEnumFromString)(env,MK(Class_MkTypeE),"Ljvmkkernel/MkTypeE;",MkTypeE_ToString(__retVal__L));
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmkkernel_MkBufferC_GetType3 (JNIEnv *env, jobject self)  {
  MK_BUFN hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN __retVal__L = MkBufferGetType3(hdl);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jboolean JNICALL Java_jvmkkernel_MkBufferC_IsLocal (JNIEnv *env, jobject self)  {
  MK_BUFN hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BOOL __retVal__L = MkBufferIsLocal(hdl);
  jboolean __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
// skip class-overload: Log = MkBufferLog → MkObjectLog
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferC_LogS (JNIEnv *env, jobject self, jstring varname, jobject fmtobj, jstring callfunc)  {
  MK_BUFN hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(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);}
  MK_STRN varname_ptr = (varname?(*env)->GetStringUTFChars(env,varname,NULL):NULL);
  JavaErrorCheck;
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  MkBufferLogS(hdl, varname_ptr, fmtobj_hdl, callfunc_ptr);
  if (varname_ptr) (*env)->ReleaseStringUTFChars(env,varname,varname_ptr);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
error:
  return;
}
 
// MkBufferC_Info_JV_API
 
 
// doc-key: MkBufferC,MkBufferC-Misc,oc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_Copy (JNIEnv *env, jobject self, jobject srce)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUFN srce_hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",srce);
  JavaErrorCheck;
  MK_BUF __retVal__L = MkBufferCopy(hdl, srce_hdl);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_Reset (JNIEnv *env, jobject self)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF __retVal__L = MkBufferReset(hdl);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_SizeAdd (JNIEnv *env, jobject self, jint size)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF __retVal__L = MkBufferSizeAdd(hdl, size);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_SizeNew (JNIEnv *env, jobject self, jint size)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF __retVal__L = MkBufferSizeNew(hdl, size);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_Temp (JNIEnv *env, jobject self)  {
  MK_BUFN hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF __retVal__L = MkBufferTemp(hdl);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferC,MkBufferC-Misc,om_
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferC_CastTo (JNIEnv *env, jobject self, jobject typ)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkTypeE typ_e = MK(pGetEnumFromObj)(env, NS(Class_MkTypeE), typ);
  JavaErrorCheck;
  enum MkErrorE errVal = MkBufferCastTo(hdl, typ_e);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT jint JNICALL Java_jvmkkernel_MkBufferC_Cmp (JNIEnv *env, jobject self, jobject buf2)  {
  MK_BUFN hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUFN buf2_hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",buf2);
  JavaErrorCheck;
  MK_I32 __retVal__L = MkBufferCmp(hdl, buf2_hdl);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferC_ResetFull (JNIEnv *env, jobject self)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkBufferResetFull(hdl);
error:
  return;
}
 
// skip class-overload: ToString = MkBufferToString → MkObjectToString
 
// MkBufferC_Misc_JV_API
 
 
// doc-key: MkBufferC,MkBufferC-Set,oc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_SetBIN (JNIEnv *env, jobject self, jbyteArray val)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BINN val_data = (MK_BINN) (*env)->GetByteArrayElements(env, val, NULL);
  JavaErrorCheck;
  MK_SIZE val_size = (MK_SIZE) (*env)->GetArrayLength (env, val);
  JavaErrorCheck;
  MkBinaryR val_ref = MkBinaryCreate(val_size,val_data);
  MK_BUF __retVal__L = MkBufferSetBIN(hdl, val_ref);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  (*env)->ReleaseByteArrayElements(env, val, (jbyte*)val_data, JNI_ABORT);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_SetBOL (JNIEnv *env, jobject self, jboolean val)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF __retVal__L = MkBufferSetBOL(hdl, (MK_BOL)(val?1:0));
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_SetBUF (JNIEnv *env, jobject self, jobject val)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUFN val_hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",val);
  JavaErrorCheck;
  MK_BUF __retVal__L = MkBufferSetBUF(hdl, val_hdl);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_SetBinaryR (JNIEnv *env, jobject self, jbyteArray val)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BINN val_data = (MK_BINN) (*env)->GetByteArrayElements(env, val, NULL);
  JavaErrorCheck;
  MK_SIZE val_size = (MK_SIZE) (*env)->GetArrayLength (env, val);
  JavaErrorCheck;
  MkBinaryR val_ref = MkBinaryCreate(val_size,val_data);
  MK_BUF __retVal__L = MkBufferSetBinaryR(hdl, val_ref);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  (*env)->ReleaseByteArrayElements(env, val, (jbyte*)val_data, JNI_ABORT);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_SetDBL (JNIEnv *env, jobject self, jdouble val)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF __retVal__L = MkBufferSetDBL(hdl, val);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_SetFLT (JNIEnv *env, jobject self, jfloat val)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF __retVal__L = MkBufferSetFLT(hdl, val);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_SetI16 (JNIEnv *env, jobject self, jshort val)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF __retVal__L = MkBufferSetI16(hdl, val);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_SetI32 (JNIEnv *env, jobject self, jint val)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF __retVal__L = MkBufferSetI32(hdl, val);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_SetI64 (JNIEnv *env, jobject self, jlong val)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF __retVal__L = MkBufferSetI64(hdl, val);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_SetI8 (JNIEnv *env, jobject self, jbyte val)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF __retVal__L = MkBufferSetI8(hdl, (MK_I8)(val));
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_SetSTR (JNIEnv *env, jobject self, jstring val)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN val_ptr = (val?(*env)->GetStringUTFChars(env,val,NULL):NULL);
  JavaErrorCheck;
  MK_BUF __retVal__L = MkBufferSetSTR(hdl, val_ptr);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  if (val_ptr) (*env)->ReleaseStringUTFChars(env,val,val_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_SetStringR (JNIEnv *env, jobject self, jstring val)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkStringR val_ref = MkStringCreate((*env)->GetStringUTFLength(env,val),(val?(*env)->GetStringUTFChars(env,val,NULL):NULL));
  JavaErrorCheck;
  MK_BUF __retVal__L = MkBufferSetStringR(hdl, val_ref);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  if (val_ref.ptr) (*env)->ReleaseStringUTFChars(env,val,val_ref.ptr);
  return __retVal__S;
error:
  return 0;
}
 
// MkBufferC_Set_JV_API
 
 
// doc-key: MkBufferC,MkBufferC-TOR,oC_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_Merge (JNIEnv *env, jobject self)  {
  MK_BUF hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF __retVal__L = MkBufferMerge(hdl);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferC.Merge");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferC,MkBufferC-TOR,oCx
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_Dup (JNIEnv *env, jobject self)  {
  MK_BUFN hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF __retVal__L = MkBufferDup(hdl);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferC.Dup");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferC,MkBufferC-TOR,sCc
 
JNIEXPORT jlong JNICALL Java_jvmkkernel_MkBufferC_CTOR (JNIEnv *env, jclass class, jint size)  {
  MkRtSetup_NULL;
  MK_BUF __retVal__L = MkBufferCreate(NULL, size);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferC.CTOR");
    goto error;
  }
  jlong __retVal__S = (jlong)__retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_Create (JNIEnv *env, jclass class, jint size)  {
  MkRtSetup_NULL;
  MK_BUF __retVal__L = MkBufferCreate(NULL, size);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferC.Create");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_Create1024 (JNIEnv *env, jclass class, jint size)  {
  MkRtSetup_NULL;
  MK_BUF __retVal__L = MkBufferCreate1024(size);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferC.Create1024");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_Create256 (JNIEnv *env, jclass class, jint size)  {
  MkRtSetup_NULL;
  MK_BUF __retVal__L = MkBufferCreate256(size);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferC.Create256");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_Create64 (JNIEnv *env, jclass class, jint size)  {
  MkRtSetup_NULL;
  MK_BUF __retVal__L = MkBufferCreate64(size);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferC.Create64");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_CreateBIN (JNIEnv *env, jclass class, jbyteArray val)  {
  MkRtSetup_NULL;
  MK_BINN val_data = (MK_BINN) (*env)->GetByteArrayElements(env, val, NULL);
  JavaErrorCheck;
  MK_SIZE val_size = (MK_SIZE) (*env)->GetArrayLength (env, val);
  JavaErrorCheck;
  MkBinaryR val_ref = MkBinaryCreate(val_size,val_data);
  MK_BUF __retVal__L = MkBufferCreateBIN(val_ref);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferC.CreateBIN");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  (*env)->ReleaseByteArrayElements(env, val, (jbyte*)val_data, JNI_ABORT);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_CreateBOL (JNIEnv *env, jclass class, jboolean val)  {
  MkRtSetup_NULL;
  MK_BUF __retVal__L = MkBufferCreateBOL((MK_BOL)(val?1:0));
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferC.CreateBOL");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_CreateBUF (JNIEnv *env, jclass class, jobject val)  {
  MkRtSetup_NULL;
  MK_BUFN val_hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",val);
  JavaErrorCheck;
  MK_BUF __retVal__L = MkBufferCreateBUF(val_hdl);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferC.CreateBUF");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_CreateDBL (JNIEnv *env, jclass class, jdouble val)  {
  MkRtSetup_NULL;
  MK_BUF __retVal__L = MkBufferCreateDBL(val);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferC.CreateDBL");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_CreateFLT (JNIEnv *env, jclass class, jfloat val)  {
  MkRtSetup_NULL;
  MK_BUF __retVal__L = MkBufferCreateFLT(val);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferC.CreateFLT");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_CreateI16 (JNIEnv *env, jclass class, jshort val)  {
  MkRtSetup_NULL;
  MK_BUF __retVal__L = MkBufferCreateI16(val);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferC.CreateI16");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_CreateI32 (JNIEnv *env, jclass class, jint val)  {
  MkRtSetup_NULL;
  MK_BUF __retVal__L = MkBufferCreateI32(val);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferC.CreateI32");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_CreateI64 (JNIEnv *env, jclass class, jlong val)  {
  MkRtSetup_NULL;
  MK_BUF __retVal__L = MkBufferCreateI64(val);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferC.CreateI64");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_CreateI8 (JNIEnv *env, jclass class, jbyte val)  {
  MkRtSetup_NULL;
  MK_BUF __retVal__L = MkBufferCreateI8((MK_I8)(val));
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferC.CreateI8");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_CreateSTR (JNIEnv *env, jclass class, jstring val)  {
  MkRtSetup_NULL;
  MK_STRN val_ptr = (val?(*env)->GetStringUTFChars(env,val,NULL):NULL);
  JavaErrorCheck;
  MK_BUF __retVal__L = MkBufferCreateSTR(val_ptr);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferC.CreateSTR");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  if (val_ptr) (*env)->ReleaseStringUTFChars(env,val,val_ptr);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferC,MkBufferC-TOR,sc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferC_CreateTLS (JNIEnv *env, jclass class, jstring tlsName, jboolean resetB)  {
  MkRtSetup_NULL;
  MK_STRN tlsName_ptr = (tlsName?(*env)->GetStringUTFChars(env,tlsName,NULL):NULL);
  JavaErrorCheck;
  MK_BUF __retVal__L = MkBufferCreateTLS(tlsName_ptr, resetB);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  if (tlsName_ptr) (*env)->ReleaseStringUTFChars(env,tlsName,tlsName_ptr);
  return __retVal__S;
error:
  return 0;
}
 
// MkBufferC_TOR_JV_API
 
// END-MkBufferC - created by 'jv_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
void NS(MkBufferC_Init)(MK_RT_ARGS_ONLY) {
  ClassInit
 
  MkBufferC_TT->selfCreate      =  NS(MkBufferC_selfCreate) ;
  MkBufferC_TT->selfUnlink      =  MK(AtomSelfUnlink) ;
 
  MkBuffer64C_TT->selfCreate    =  NS(MkBufferC_selfCreate) ;
  MkBuffer64C_TT->selfUnlink    =  MK(AtomSelfUnlink) ;
 
  MkBuffer256C_TT->selfCreate   =  NS(MkBufferC_selfCreate) ;
  MkBuffer256C_TT->selfUnlink   =  MK(AtomSelfUnlink) ;
 
  MkBuffer1024C_TT->selfCreate  =  NS(MkBufferC_selfCreate) ;
  MkBuffer1024C_TT->selfUnlink  =  MK(AtomSelfUnlink) ;
}