MkBufferListC_jv.c

Go to the documentation of this file.

 
/* LABEL-START */
#define META_FILE_NAME "MkBufferListC_jv.c"
 
#include "jni_h/jvmkkernel_MkBufferListC.h"
#include "LibMkKernel_private_jv.h"
 
 
jobject NS(MkBufferListC_ObjNew) (MK_RT_ARGS JNIEnv *env, MK_BFL hdl) {
  static MkThreadLocal jobject NS_NULL = NULL;
  return (hdl ? MK(AtomObjNew)(MK_RT_CALL env, MkBufferListC_X2obj(hdl)) : MK_GET__NS_NULL(MkBufferListC));
}
 
MK_UNUSED
static jobject NS(MkBufferListC_ObjCreate) (MK_RT_ARGS JNIEnv *env, MK_BFL hdl) {
  return MK(AtomObjCreate)(MK_RT_CALL env, MkBufferListC_X2obj(hdl));
}
 
static MK_PTR NS(MkBufferListC_selfCreate) (MK_RT_ARGS MK_OBJ obj, MK_PTR envP) {
  JNIEnv *env = (JNIEnv*) envP;
  return (*env)->NewObject(env, NS(Class_MkBufferListC), NS(MID_MkBufferListC_INIT), (jlong) obj, JNI_TRUE);
}
 
#define ClassInit \
 
//  printTxt("init: MkBufferListC");
 
/* LABEL-END */
 
 
// BEGIN-MkBufferListC - created by 'jv_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// doc-key: MkBufferListC,MkBufferListC-Append,oc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferListC_AppendLA (JNIEnv *env, jobject self, jobject args)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BAC args_hdl = (MK_BAC)pObj2Hdl(env,"MkBufferListC",args);
  JavaErrorCheck;
  MK_BFL __retVal__L = MkBufferListAppendLA(hdl, args_hdl);
  jobject __retVal__S = MK(MkBufferListC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferListC_AppendLP (JNIEnv *env, jobject self, jobject addBufL, jint position)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFL addBufL_hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",addBufL);
  JavaErrorCheck;
  MK_BFL __retVal__L = MkBufferListAppendLP(hdl, addBufL_hdl, position);
  jobject __retVal__S = MK(MkBufferListC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferListC,MkBufferListC-Append,om_
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_AppendBIN (JNIEnv *env, jobject self, jbyteArray val)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",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);
  MkBufferListAppendBIN(hdl, val_ref);
  (*env)->ReleaseByteArrayElements(env, val, (jbyte*)val_data, JNI_ABORT);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_AppendBOL (JNIEnv *env, jobject self, jboolean val)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkBufferListAppendBOL(hdl, (MK_BOL)(val?1:0));
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_AppendBUF (JNIEnv *env, jobject self, jobject val)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF val_hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",val);
  JavaErrorCheck;
  MkBufferListAppendBUF(hdl, val_hdl);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_AppendDBL (JNIEnv *env, jobject self, jdouble val)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkBufferListAppendDBL(hdl, val);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_AppendFLT (JNIEnv *env, jobject self, jfloat val)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkBufferListAppendFLT(hdl, val);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_AppendG (JNIEnv *env, jobject self, jlong val)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkBufferListAppendG(hdl, val);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_AppendI16 (JNIEnv *env, jobject self, jshort val)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkBufferListAppendI16(hdl, val);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_AppendI32 (JNIEnv *env, jobject self, jint val)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkBufferListAppendI32(hdl, val);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_AppendI64 (JNIEnv *env, jobject self, jlong val)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkBufferListAppendI64(hdl, val);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_AppendI8 (JNIEnv *env, jobject self, jbyte val)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkBufferListAppendI8(hdl, (MK_I8)(val));
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_AppendSTR (JNIEnv *env, jobject self, jstring val)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN val_ptr = (val?(*env)->GetStringUTFChars(env,val,NULL):NULL);
  JavaErrorCheck;
  MkBufferListAppendSTR(hdl, val_ptr);
  if (val_ptr) (*env)->ReleaseStringUTFChars(env,val,val_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_AppendStringR (JNIEnv *env, jobject self, jstring val)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkStringR val_ref = MkStringCreate((*env)->GetStringUTFLength(env,val),(val?(*env)->GetStringUTFChars(env,val,NULL):NULL));
  JavaErrorCheck;
  MkBufferListAppendStringR(hdl, val_ref);
  if (val_ref.ptr) (*env)->ReleaseStringUTFChars(env,val,val_ref.ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_AppendUP (JNIEnv *env, jobject self, jobject addBuf, jint position)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF addBuf_hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",addBuf);
  JavaErrorCheck;
  MkBufferListAppendUP(hdl, addBuf_hdl, position);
error:
  return;
}
 
// MkBufferListC_Append_JV_API
 
 
// doc-key: MkBufferListC,MkBufferListC-Check,oco
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferListC_CheckOptionBUF (JNIEnv *env, jobject self, jstring opt, jobject defval, jboolean onlyFirst)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF val_out;
  MK_BUF defval_hdl = (MK_BUF)pObj2Hdl__null_allow(env,defval);
  JavaErrorCheck;
  MK_STRN opt_ptr = (opt?(*env)->GetStringUTFChars(env,opt,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MkBufferListCheckOptionBUF(hdl, opt_ptr, defval_hdl, onlyFirst, &val_out);
  MkErrorC_Check(hdl, errVal)
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,val_out);
  if (opt_ptr) (*env)->ReleaseStringUTFChars(env,opt,opt_ptr);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferListC,MkBufferListC-Check,om_
 
JNIEXPORT jboolean JNICALL Java_jvmkkernel_MkBufferListC_CheckOption (JNIEnv *env, jobject self, jstring opt, jboolean onlyFirst)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN opt_ptr = (opt?(*env)->GetStringUTFChars(env,opt,NULL):NULL);
  JavaErrorCheck;
  MK_BOOL __retVal__L = MkBufferListCheckOption(hdl, opt_ptr, onlyFirst);
  jboolean __retVal__S = __retVal__L;
  if (opt_ptr) (*env)->ReleaseStringUTFChars(env,opt,opt_ptr);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferListC,MkBufferListC-Check,omo
 
JNIEXPORT jboolean JNICALL Java_jvmkkernel_MkBufferListC_CheckOptionBOL (JNIEnv *env, jobject self, jstring opt, jboolean defval, jboolean onlyFirst)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BOOL val_out;
  MK_STRN opt_ptr = (opt?(*env)->GetStringUTFChars(env,opt,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MkBufferListCheckOptionBOL(hdl, opt_ptr, defval, onlyFirst, &val_out);
  MkErrorC_Check(hdl, errVal)
  jboolean __retVal__S = val_out;
  if (opt_ptr) (*env)->ReleaseStringUTFChars(env,opt,opt_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jdouble JNICALL Java_jvmkkernel_MkBufferListC_CheckOptionDBL (JNIEnv *env, jobject self, jstring opt, jdouble defval, jboolean onlyFirst)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_DBL val_out;
  MK_STRN opt_ptr = (opt?(*env)->GetStringUTFChars(env,opt,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MkBufferListCheckOptionDBL(hdl, opt_ptr, defval, onlyFirst, &val_out);
  MkErrorC_Check(hdl, errVal)
  jdouble __retVal__S = val_out;
  if (opt_ptr) (*env)->ReleaseStringUTFChars(env,opt,opt_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jfloat JNICALL Java_jvmkkernel_MkBufferListC_CheckOptionFLT (JNIEnv *env, jobject self, jstring opt, jfloat defval, jboolean onlyFirst)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_FLT val_out;
  MK_STRN opt_ptr = (opt?(*env)->GetStringUTFChars(env,opt,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MkBufferListCheckOptionFLT(hdl, opt_ptr, defval, onlyFirst, &val_out);
  MkErrorC_Check(hdl, errVal)
  jfloat __retVal__S = val_out;
  if (opt_ptr) (*env)->ReleaseStringUTFChars(env,opt,opt_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jshort JNICALL Java_jvmkkernel_MkBufferListC_CheckOptionI16 (JNIEnv *env, jobject self, jstring opt, jshort defval, jboolean onlyFirst)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I16 val_out;
  MK_STRN opt_ptr = (opt?(*env)->GetStringUTFChars(env,opt,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MkBufferListCheckOptionI16(hdl, opt_ptr, defval, onlyFirst, &val_out);
  MkErrorC_Check(hdl, errVal)
  jshort __retVal__S = val_out;
  if (opt_ptr) (*env)->ReleaseStringUTFChars(env,opt,opt_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmkkernel_MkBufferListC_CheckOptionI32 (JNIEnv *env, jobject self, jstring opt, jint defval, jboolean onlyFirst)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I32 val_out;
  MK_STRN opt_ptr = (opt?(*env)->GetStringUTFChars(env,opt,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MkBufferListCheckOptionI32(hdl, opt_ptr, defval, onlyFirst, &val_out);
  MkErrorC_Check(hdl, errVal)
  jint __retVal__S = val_out;
  if (opt_ptr) (*env)->ReleaseStringUTFChars(env,opt,opt_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jlong JNICALL Java_jvmkkernel_MkBufferListC_CheckOptionI64 (JNIEnv *env, jobject self, jstring opt, jlong defval, jboolean onlyFirst)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I64 val_out;
  MK_STRN opt_ptr = (opt?(*env)->GetStringUTFChars(env,opt,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MkBufferListCheckOptionI64(hdl, opt_ptr, defval, onlyFirst, &val_out);
  MkErrorC_Check(hdl, errVal)
  jlong __retVal__S = val_out;
  if (opt_ptr) (*env)->ReleaseStringUTFChars(env,opt,opt_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jbyte JNICALL Java_jvmkkernel_MkBufferListC_CheckOptionI8 (JNIEnv *env, jobject self, jstring opt, jbyte defval, jboolean onlyFirst)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I8 val_out;
  MK_STRN opt_ptr = (opt?(*env)->GetStringUTFChars(env,opt,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MkBufferListCheckOptionI8(hdl, opt_ptr, (MK_I8)(defval), onlyFirst, &val_out);
  MkErrorC_Check(hdl, errVal)
  jbyte __retVal__S = (jbyte)val_out;
  if (opt_ptr) (*env)->ReleaseStringUTFChars(env,opt,opt_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmkkernel_MkBufferListC_CheckOptionSTR (JNIEnv *env, jobject self, jstring opt, jstring defval, jboolean onlyFirst)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN val_out;
  MK_STRN opt_ptr = (opt?(*env)->GetStringUTFChars(env,opt,NULL):NULL);
  JavaErrorCheck;
  MK_STRN defval_ptr = (defval?(*env)->GetStringUTFChars(env,defval,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MkBufferListCheckOptionSTR(hdl, opt_ptr, defval_ptr, onlyFirst, &val_out);
  MkErrorC_Check(hdl, errVal)
  jstring __retVal__S = JC2O(env,val_out);
  if (opt_ptr) (*env)->ReleaseStringUTFChars(env,opt,opt_ptr);
  if (defval_ptr) (*env)->ReleaseStringUTFChars(env,defval,defval_ptr);
  return __retVal__S;
error:
  return 0;
}
 
// MkBufferListC_Check_JV_API
 
 
// doc-key: MkBufferListC,MkBufferListC-Class-Export,sc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferListC_HandleResolve (JNIEnv *env, jclass class, jint netHdl)  {
  MkRtSetup_NULL;
  MK_BFL __retVal__L = MkBufferListHandleResolve(netHdl);
  jobject __retVal__S = MK(MkBufferListC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// doc-key: MkBufferListC,MkBufferListC-Class-Export,om_
 
// skip class-overload: HandleGet = MkBufferListHandleGet → MkObjectHandleGet
 
// MkBufferListC_Class_JV_API
 
 
// doc-key: MkBufferListC,MkBufferListC-Class-Introspection,oc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferListC_Next (JNIEnv *env, jobject self)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFL __retVal__L = MkBufferListNext(hdl);
  jobject __retVal__S = MK(MkBufferListC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferListC_Prev (JNIEnv *env, jobject self)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFL __retVal__L = MkBufferListPrev(hdl);
  jobject __retVal__S = MK(MkBufferListC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferListC,MkBufferListC-Class-Introspection,sc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferListC_Instances (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  MK_BFL __retVal__L = MkBufferListInstances();
  jobject __retVal__S = MK(MkBufferListC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// MkBufferListC_Class_JV_API
 
 
// doc-key: MkBufferListC,MkBufferListC-Class-Misc,sc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferListC_GetNull (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  MK_BFL __retVal__L = MkBufferListGetNull();
  jobject __retVal__S = MK(MkBufferListC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// MkBufferListC_Class_JV_API
 
 
// doc-key: MkBufferListC,MkBufferListC-Index,oc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferListC_IndexGetBUF (JNIEnv *env, jobject self, jint index)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF __retVal__L = MkBufferListIndexGetBUF(hdl, index);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferListC,MkBufferListC-Index,oco
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferListC_IndexExtract (JNIEnv *env, jobject self, jint index)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF val_out;
  enum MkErrorE errVal = MkBufferListIndexExtract(hdl, index, &val_out);
  MkErrorC_Check(hdl, errVal)
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,val_out);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferListC_IndexGet (JNIEnv *env, jobject self, jint index)  {
  MK_BFLN hdl = (MK_BFLN)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF val_out;
  enum MkErrorE errVal = MkBufferListIndexGet(hdl, index, &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: MkBufferListC,MkBufferListC-Index,om_
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_IndexDelete (JNIEnv *env, jobject self, jint index, jint numitems, jboolean doDelete)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MkBufferListIndexDelete(hdl, index, numitems, doDelete);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT jstring JNICALL Java_jvmkkernel_MkBufferListC_IndexGetSTR (JNIEnv *env, jobject self, jint index)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN __retVal__L = MkBufferListIndexGetSTR(hdl, index);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_IndexSet (JNIEnv *env, jobject self, jint index, jobject buf)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF buf_hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",buf);
  JavaErrorCheck;
  enum MkErrorE errVal = MkBufferListIndexSet(hdl, index, buf_hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_IndexSetBUF (JNIEnv *env, jobject self, jint index, jobject buf)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF buf_hdl = (MK_BUF)pObj2Hdl(env,"MkBufferC",buf);
  JavaErrorCheck;
  MkBufferListIndexSetBUF(hdl, index, buf_hdl);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_IndexSetSTR (JNIEnv *env, jobject self, jint index, jstring str)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN str_ptr = (str?(*env)->GetStringUTFChars(env,str,NULL):NULL);
  JavaErrorCheck;
  MkBufferListIndexSetSTR(hdl, index, str_ptr);
  if (str_ptr) (*env)->ReleaseStringUTFChars(env,str,str_ptr);
error:
  return;
}
 
// MkBufferListC_Index_JV_API
 
 
// doc-key: MkBufferListC,MkBufferListC-Log,om_
 
// skip class-overload: Log = MkBufferListLog → MkObjectLog
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_LogS (JNIEnv *env, jobject self, jstring varname, jobject fmtobj, jstring callfunc)  {
  MK_BFLN hdl = (MK_BFLN)pObj2Hdl(env,"MkBufferListC",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;
  MkBufferListLogS(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;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_LogSS (JNIEnv *env, jobject self, jstring varname, jobject fmtobj, jstring callfunc)  {
  MK_BFLN hdl = (MK_BFLN)pObj2Hdl(env,"MkBufferListC",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;
  MkBufferListLogSS(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;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_LogSSS (JNIEnv *env, jobject self, jstring varname, jobject fmtobj, jstring callfunc)  {
  MK_BFLN hdl = (MK_BFLN)pObj2Hdl(env,"MkBufferListC",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;
  MkBufferListLogSSS(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;
}
 
// MkBufferListC_Log_JV_API
 
 
// doc-key: MkBufferListC,MkBufferListC-Misc,sCc
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferListC_FileGlob (JNIEnv *env, jclass class, jstring pattern_match)  {
  MkRtSetup_NULL;
  MK_STRN pattern_match_ptr = (pattern_match?(*env)->GetStringUTFChars(env,pattern_match,NULL):NULL);
  JavaErrorCheck;
  MK_BFL __retVal__L = MkBufferListFileGlob(pattern_match_ptr);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferListC.FileGlob");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferListC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  if (pattern_match_ptr) (*env)->ReleaseStringUTFChars(env,pattern_match,pattern_match_ptr);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferListC,MkBufferListC-Misc,oc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferListC_PositionMerge (JNIEnv *env, jobject self, jobject source, jint position)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFL source_hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",source);
  JavaErrorCheck;
  MK_BFL __retVal__L = MkBufferListPositionMerge(hdl, source_hdl, position);
  jobject __retVal__S = MK(MkBufferListC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferListC_Reset (JNIEnv *env, jobject self)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFL __retVal__L = MkBufferListReset(hdl);
  jobject __retVal__S = MK(MkBufferListC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferListC_Sort (JNIEnv *env, jobject self)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFL __retVal__L = MkBufferListSort(hdl);
  jobject __retVal__S = MK(MkBufferListC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferListC_ToBuffer (JNIEnv *env, jobject self)  {
  MK_BFLN hdl = (MK_BFLN)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF __retVal__L = MkBufferListToBuffer(hdl);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferListC,MkBufferListC-Misc,om_
 
JNIEXPORT jint JNICALL Java_jvmkkernel_MkBufferListC_Cmp (JNIEnv *env, jobject self, jobject bfl2)  {
  MK_BFLN hdl = (MK_BFLN)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFLN bfl2_hdl = (MK_BFLN)pObj2Hdl(env,"MkBufferListC",bfl2);
  JavaErrorCheck;
  MK_I32 __retVal__L = MkBufferListCmp(hdl, bfl2_hdl);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_Copy (JNIEnv *env, jobject self, jobject src)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFLN src_hdl = (MK_BFLN)pObj2Hdl(env,"MkBufferListC",src);
  JavaErrorCheck;
  MkBufferListCopy(hdl, src_hdl);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_Move (JNIEnv *env, jobject self, jobject from)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFL from_hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",from);
  JavaErrorCheck;
  MkBufferListMove(hdl, from_hdl);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_Reserve (JNIEnv *env, jobject self, jint num)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkBufferListReserve(hdl, num);
error:
  return;
}
 
JNIEXPORT jint JNICALL Java_jvmkkernel_MkBufferListC_SearchC (JNIEnv *env, jobject self, jstring str, jint len, jint startindex)  {
  MK_BFLN hdl = (MK_BFLN)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN str_ptr = (str?(*env)->GetStringUTFChars(env,str,NULL):NULL);
  JavaErrorCheck;
  MK_NUM __retVal__L = MkBufferListSearchC(hdl, str_ptr, len, startindex);
  jint __retVal__S = __retVal__L;
  if (str_ptr) (*env)->ReleaseStringUTFChars(env,str,str_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmkkernel_MkBufferListC_Size (JNIEnv *env, jobject self)  {
  MK_BFLN hdl = (MK_BFLN)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_NUM __retVal__L = MkBufferListSizeI(hdl);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT MK_NAT_LIST JNICALL ToList (JNIEnv *env, jobject self); // skip template-required
 
// skip class-overload: ToString = MkBufferListToString → MkObjectToString
 
// MkBufferListC_Misc_JV_API
 
 
// doc-key: MkBufferListC,MkBufferListC-TOR,oC_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferListC_Merge (JNIEnv *env, jobject self)  {
  MK_BFL hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFL __retVal__L = MkBufferListMerge(hdl);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferListC.Merge");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferListC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferListC,MkBufferListC-TOR,oCx
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferListC_Dup (JNIEnv *env, jobject self)  {
  MK_BFLN hdl = (MK_BFLN)pObj2Hdl(env,"MkBufferListC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFL __retVal__L = MkBufferListDup(hdl);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferListC.Dup");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferListC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferListC,MkBufferListC-TOR,sCc
 
JNIEXPORT jlong JNICALL Java_jvmkkernel_MkBufferListC_CTOR (JNIEnv *env, jclass class, jint size)  {
  MkRtSetup_NULL;
  MK_BFL __retVal__L = MkBufferListCreate(size);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferListC.CTOR");
    goto error;
  }
  jlong __retVal__S = (jlong)__retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferListC_Create (JNIEnv *env, jclass class, jint size)  {
  MkRtSetup_NULL;
  MK_BFL __retVal__L = MkBufferListCreate(size);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferListC.Create");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferListC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferListC_CreateLA (JNIEnv *env, jclass class, jobject args)  {
  MkRtSetup_NULL;
  MK_BAC args_hdl = (MK_BAC)pObj2Hdl(env,"MkBufferListC",args);
  JavaErrorCheck;
  MK_BFL __retVal__L = MkBufferListCreateLA(args_hdl);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferListC.CreateLA");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferListC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferListC,MkBufferListC-TOR,sc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferListC_CreateTLS (JNIEnv *env, jclass class, jstring tlsName, jboolean resetB)  {
  MkRtSetup_NULL;
  MK_STRN tlsName_ptr = (tlsName?(*env)->GetStringUTFChars(env,tlsName,NULL):NULL);
  JavaErrorCheck;
  MK_BFL __retVal__L = MkBufferListCreateTLS(tlsName_ptr, resetB);
  jobject __retVal__S = MK(MkBufferListC_ObjNew)(MK_RT_CALL env,__retVal__L);
  if (tlsName_ptr) (*env)->ReleaseStringUTFChars(env,tlsName,tlsName_ptr);
  return __retVal__S;
error:
  return 0;
}
 
// MkBufferListC_TOR_JV_API
 
// END-MkBufferListC - created by 'jv_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferListC_PrivateAppendSTR (JNIEnv *env, jobject self, jstring val)  {
  return Java_jvmkkernel_MkBufferListC_AppendSTR(env, self, val);
}
 
void NS(MkBufferListC_Init)(MK_RT_ARGS_ONLY) {
  ClassInit
 
  MkBufferListC_TT->selfCreate    = NS(MkBufferListC_selfCreate);
  MkBufferListC_TT->selfUnlink    = MK(AtomSelfUnlink);
}