MkBufferStreamC_jv.c

Go to the documentation of this file.

 
/* LABEL-START */
#define META_FILE_NAME "MkBufferStreamC_jv.c"
 
#include "jni_h/jvmkkernel_MkBufferStreamC.h"
#include "LibMkKernel_private_jv.h"
 
 
jobject NS(MkBufferStreamC_ObjNew) (MK_RT_ARGS JNIEnv *env, MK_BUS hdl) {
  static MkThreadLocal jobject NS_NULL = NULL;
  return (hdl ? MK(AtomObjNew)(MK_RT_CALL env, MkBufferStreamC_X2obj(hdl)) : MK_GET__NS_NULL(MkBufferStreamC));
}
 
MK_UNUSED
static jobject NS(MkBufferStreamC_ObjCreate) (MK_RT_ARGS JNIEnv *env, MK_BUS hdl) {
  return MK(AtomObjCreate)(MK_RT_CALL env, MkBufferStreamC_X2obj(hdl));
}
 
static MK_PTR NS(MkBufferStreamC_selfCreate) (MK_RT_ARGS MK_OBJ obj, MK_PTR envP) {
  JNIEnv *env = (JNIEnv*) envP;
  return (*env)->NewObject(env, NS(Class_MkBufferStreamC), NS(MID_MkBufferStreamC_INIT), (jlong) obj, JNI_TRUE);
}
 
#define ClassInit \
 
//  printTxt("init: MkBufferStreamC");
 
/* LABEL-END */
 
 
// BEGIN-MkBufferStreamC - created by 'jv_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Class-Export,sc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferStreamC_HandleResolve (JNIEnv *env, jclass class, jint netHdl)  {
  MkRtSetup_NULL;
  MK_BUS __retVal__L = MkBufferStreamHandleResolve(netHdl);
  jobject __retVal__S = MK(MkBufferStreamC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Class-Export,om_
 
// skip class-overload: HandleGet = MkBufferStreamHandleGet → MkObjectHandleGet
 
// MkBufferStreamC_Class_JV_API
 
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Class-Introspection,oc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferStreamC_Next (JNIEnv *env, jobject self)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUS __retVal__L = MkBufferStreamNext(hdl);
  jobject __retVal__S = MK(MkBufferStreamC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferStreamC_Prev (JNIEnv *env, jobject self)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUS __retVal__L = MkBufferStreamPrev(hdl);
  jobject __retVal__S = MK(MkBufferStreamC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Class-Introspection,sc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferStreamC_Instances (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  MK_BUS __retVal__L = MkBufferStreamInstances();
  jobject __retVal__S = MK(MkBufferStreamC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// MkBufferStreamC_Class_JV_API
 
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Class-Misc,sc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferStreamC_GetNull (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  MK_BUS __retVal__L = MkBufferStreamGetNull();
  jobject __retVal__S = MK(MkBufferStreamC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// MkBufferStreamC_Class_JV_API
 
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Misc,oc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferStreamC_Copy (JNIEnv *env, jobject self, jobject src)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUSN src_hdl = (MK_BUSN)pObj2Hdl(env,"MkBufferStreamC",src);
  JavaErrorCheck;
  MK_BUS __retVal__L = MkBufferStreamCopy(hdl, src_hdl);
  jobject __retVal__S = MK(MkBufferStreamC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferStreamC_Reset (JNIEnv *env, jobject self)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUS __retVal__L = MkBufferStreamReset(hdl);
  jobject __retVal__S = MK(MkBufferStreamC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferStreamC_ToBFL (JNIEnv *env, jobject self)  {
  MK_BUSN hdl = (MK_BUSN)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFL __retVal__L = MkBufferStreamToBFL(hdl);
  jobject __retVal__S = MK(MkBufferListC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Misc,om_
 
// skip class-overload: Log = MkBufferStreamLog → MkObjectLog
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferStreamC_PosToStart (JNIEnv *env, jobject self)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkBufferStreamPosToStart(hdl);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferStreamC_ResetFull (JNIEnv *env, jobject self)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkBufferStreamResetFull(hdl);
error:
  return;
}
 
// skip class-overload: ToString = MkBufferStreamToString → MkObjectToString
 
// MkBufferStreamC_Misc_JV_API
 
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Read,oci
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferStreamC_ReadALL (JNIEnv *env, jobject self, jobject val_inout)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFL val_inout_hdl = (MK_BFL)pObj2Hdl__null_allow(env,val_inout);
  JavaErrorCheck;
  enum MkErrorE errVal = MkBufferStreamReadALL(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: MkBufferStreamC,MkBufferStreamC-Read,oco
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferStreamC_ReadBFL (JNIEnv *env, jobject self)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFL val_out;
  enum MkErrorE errVal = MkBufferStreamReadBFL(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jobject __retVal__S = MK(MkBufferListC_ObjNew)(MK_RT_CALL env,val_out);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferStreamC_ReadBUF (JNIEnv *env, jobject self)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF val_out;
  enum MkErrorE errVal = MkBufferStreamReadBUF(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: MkBufferStreamC,MkBufferStreamC-Read,om_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferStreamC_ReadGetNextType (JNIEnv *env, jobject self)  {
  MK_BUSN hdl = (MK_BUSN)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkTypeE __retVal__L = MkBufferStreamReadGetNextType(hdl);
  jobject __retVal__S = MK(pGetEnumFromString)(env,MK(Class_MkTypeE),"Ljvmkkernel/MkTypeE;",MkTypeE_ToString(__retVal__L));
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmkkernel_MkBufferStreamC_ReadGetNumItems (JNIEnv *env, jobject self)  {
  MK_BUSN hdl = (MK_BUSN)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_NUM __retVal__L = MkBufferStreamReadGetNumItems(hdl);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jboolean JNICALL Java_jvmkkernel_MkBufferStreamC_ReadItemExists (JNIEnv *env, jobject self)  {
  MK_BUSN hdl = (MK_BUSN)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BOOL __retVal__L = MkBufferStreamReadItemExists(hdl);
  jboolean __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferStreamC_ReadL_1END (JNIEnv *env, jobject self)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MkBufferStreamReadL_END(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferStreamC_ReadL_1START (JNIEnv *env, jobject self, jobject buf)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF buf_hdl = (MK_BUF)pObj2Hdl__null_allow(env,buf);
  JavaErrorCheck;
  enum MkErrorE errVal = MkBufferStreamReadL_START(hdl, buf_hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferStreamC_ReadUndo (JNIEnv *env, jobject self)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MkBufferStreamReadUndo(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Read,omo
 
JNIEXPORT jbyteArray JNICALL Java_jvmkkernel_MkBufferStreamC_ReadBIN (JNIEnv *env, jobject self)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkBinaryR val_out_ref;
  enum MkErrorE errVal = MkBufferStreamReadBIN(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_MkBufferStreamC_ReadBOL (JNIEnv *env, jobject self)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BOL val_out;
  enum MkErrorE errVal = MkBufferStreamReadBOL(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jboolean __retVal__S = val_out != 0;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jdouble JNICALL Java_jvmkkernel_MkBufferStreamC_ReadDBL (JNIEnv *env, jobject self)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_DBL val_out;
  enum MkErrorE errVal = MkBufferStreamReadDBL(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jdouble __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jfloat JNICALL Java_jvmkkernel_MkBufferStreamC_ReadFLT (JNIEnv *env, jobject self)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_FLT val_out;
  enum MkErrorE errVal = MkBufferStreamReadFLT(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jfloat __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmkkernel_MkBufferStreamC_ReadI32 (JNIEnv *env, jobject self)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I32 val_out;
  enum MkErrorE errVal = MkBufferStreamReadI32(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jint __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jlong JNICALL Java_jvmkkernel_MkBufferStreamC_ReadI64 (JNIEnv *env, jobject self)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I64 val_out;
  enum MkErrorE errVal = MkBufferStreamReadI64(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jlong __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jbyte JNICALL Java_jvmkkernel_MkBufferStreamC_ReadI8 (JNIEnv *env, jobject self)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I8 val_out;
  enum MkErrorE errVal = MkBufferStreamReadI8(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jbyte __retVal__S = (jbyte)val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jlong JNICALL Java_jvmkkernel_MkBufferStreamC_ReadLONG (JNIEnv *env, jobject self)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_LONG val_out;
  enum MkErrorE errVal = MkBufferStreamReadLONG(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jlong __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmkkernel_MkBufferStreamC_ReadSTR (JNIEnv *env, jobject self)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN val_out;
  enum MkErrorE errVal = MkBufferStreamReadSTR(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jstring __retVal__S = JC2O(env,val_out);
  return __retVal__S;
error:
  return 0;
}
 
// MkBufferStreamC_Read_JV_API
 
 
// doc-key: MkBufferStreamC,MkBufferStreamC-TOR,oC_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferStreamC_Merge (JNIEnv *env, jobject self)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUS __retVal__L = MkBufferStreamMerge(hdl);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferStreamC.Merge");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferStreamC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferStreamC,MkBufferStreamC-TOR,oCx
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferStreamC_Dup (JNIEnv *env, jobject self)  {
  MK_BUSN hdl = (MK_BUSN)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUS __retVal__L = MkBufferStreamDup(hdl);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferStreamC.Dup");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferStreamC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferStreamC,MkBufferStreamC-TOR,sCc
 
JNIEXPORT jlong JNICALL Java_jvmkkernel_MkBufferStreamC_CTOR (JNIEnv *env, jclass class, jint size)  {
  MkRtSetup_NULL;
  MK_BUS __retVal__L = MkBufferStreamCreate(NULL, size);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferStreamC.CTOR");
    goto error;
  }
  jlong __retVal__S = (jlong)__retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferStreamC_Create (JNIEnv *env, jclass class, jint size)  {
  MkRtSetup_NULL;
  MK_BUS __retVal__L = MkBufferStreamCreate(NULL, size);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferStreamC.Create");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferStreamC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferStreamC_Create1024 (JNIEnv *env, jclass class, jint size)  {
  MkRtSetup_NULL;
  MK_BUS __retVal__L = MkBufferStreamCreate1024(size);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferStreamC.Create1024");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferStreamC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferStreamC_Create16384 (JNIEnv *env, jclass class, jint size)  {
  MkRtSetup_NULL;
  MK_BUS __retVal__L = MkBufferStreamCreate16384(size);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferStreamC.Create16384");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferStreamC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferStreamC_Create256 (JNIEnv *env, jclass class, jint size)  {
  MkRtSetup_NULL;
  MK_BUS __retVal__L = MkBufferStreamCreate256(size);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferStreamC.Create256");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferStreamC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferStreamC_Create64 (JNIEnv *env, jclass class, jint size)  {
  MkRtSetup_NULL;
  MK_BUS __retVal__L = MkBufferStreamCreate64(size);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MkBufferStreamC.Create64");
    goto error;
  }
  jobject __retVal__S = MK(MkBufferStreamC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MkBufferStreamC,MkBufferStreamC-TOR,sc_
 
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkBufferStreamC_CreateTLS (JNIEnv *env, jclass class, jstring tlsName, jboolean resetB)  {
  MkRtSetup_NULL;
  MK_STRN tlsName_ptr = (tlsName?(*env)->GetStringUTFChars(env,tlsName,NULL):NULL);
  JavaErrorCheck;
  MK_BUS __retVal__L = MkBufferStreamCreateTLS(tlsName_ptr, resetB);
  jobject __retVal__S = MK(MkBufferStreamC_ObjNew)(MK_RT_CALL env,__retVal__L);
  if (tlsName_ptr) (*env)->ReleaseStringUTFChars(env,tlsName,tlsName_ptr);
  return __retVal__S;
error:
  return 0;
}
 
// MkBufferStreamC_TOR_JV_API
 
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Write,om_
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferStreamC_WriteBFL (JNIEnv *env, jobject self, jobject bfl)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFLN bfl_hdl = (MK_BFLN)pObj2Hdl(env,"MkBufferListC",bfl);
  JavaErrorCheck;
  enum MkErrorE errVal = MkBufferStreamWriteBFL(hdl, bfl_hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferStreamC_WriteBIN (JNIEnv *env, jobject self, jbyteArray val)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",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);
  enum MkErrorE errVal = MkBufferStreamWriteBIN(hdl, val_ref);
  MkErrorC_Check(hdl, errVal)
  (*env)->ReleaseByteArrayElements(env, val, (jbyte*)val_data, JNI_ABORT);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferStreamC_WriteBOL (JNIEnv *env, jobject self, jboolean val)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MkBufferStreamWriteBOL(hdl, (MK_BOL)(val?1:0));
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferStreamC_WriteBUF (JNIEnv *env, jobject self, jobject val)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUFN val_hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",val);
  JavaErrorCheck;
  enum MkErrorE errVal = MkBufferStreamWriteBUF(hdl, val_hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferStreamC_WriteBUS_1FLAT (JNIEnv *env, jobject self, jobject add)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUSN add_hdl = (MK_BUSN)pObj2Hdl(env,"MkBufferStreamC",add);
  JavaErrorCheck;
  enum MkErrorE errVal = MkBufferStreamWriteBUS_FLAT(hdl, add_hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferStreamC_WriteDBL (JNIEnv *env, jobject self, jdouble val)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MkBufferStreamWriteDBL(hdl, val);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferStreamC_WriteFLT (JNIEnv *env, jobject self, jfloat val)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MkBufferStreamWriteFLT(hdl, val);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferStreamC_WriteHDL (JNIEnv *env, jobject self, jint val)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MkBufferStreamWriteHDL(hdl, val);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferStreamC_WriteI32 (JNIEnv *env, jobject self, jint val)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MkBufferStreamWriteI32(hdl, val);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferStreamC_WriteI64 (JNIEnv *env, jobject self, jlong val)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MkBufferStreamWriteI64(hdl, val);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferStreamC_WriteI8 (JNIEnv *env, jobject self, jbyte val)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MkBufferStreamWriteI8(hdl, (MK_I8)(val));
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferStreamC_WriteLONG (JNIEnv *env, jobject self, jlong val)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MkBufferStreamWriteLONG(hdl, val);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferStreamC_WriteL_1END (JNIEnv *env, jobject self)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MkBufferStreamWriteL_END(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferStreamC_WriteL_1FLAT (JNIEnv *env, jobject self, jobject bfl)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFL bfl_hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",bfl);
  JavaErrorCheck;
  enum MkErrorE errVal = MkBufferStreamWriteL_FLAT(hdl, bfl_hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferStreamC_WriteL_1START (JNIEnv *env, jobject self)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MkBufferStreamWriteL_START(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmkkernel_MkBufferStreamC_WriteSTR (JNIEnv *env, jobject self, jstring val, jint len)  {
  MK_BUS hdl = (MK_BUS)pObj2Hdl(env,"MkBufferStreamC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN val_ptr = (val?(*env)->GetStringUTFChars(env,val,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MkBufferStreamWriteSTR(hdl, val_ptr, len);
  MkErrorC_Check(hdl, errVal)
  if (val_ptr) (*env)->ReleaseStringUTFChars(env,val,val_ptr);
error:
  return;
}
 
// MkBufferStreamC_Write_JV_API
 
// END-MkBufferStreamC - created by 'jv_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
void NS(MkBufferStreamC_Init)(MK_RT_ARGS_ONLY) {
  ClassInit
 
  MkBufferStreamC_TT->selfCreate    =  NS(MkBufferStreamC_selfCreate)  ;
  MkBufferStreamC_TT->selfUnlink    =  MK(AtomSelfUnlink)    ;
 
  MkBufferStream256C_TT->selfCreate   =  NS(MkBufferStreamC_selfCreate)  ;
  MkBufferStream256C_TT->selfUnlink   =  MK(AtomSelfUnlink)    ;
 
  MkBufferStream64C_TT->selfCreate    =  NS(MkBufferStreamC_selfCreate)  ;
  MkBufferStream64C_TT->selfUnlink    =  MK(AtomSelfUnlink)    ;
 
  MkBufferStream1024C_TT->selfCreate  =  NS(MkBufferStreamC_selfCreate)  ;
  MkBufferStream1024C_TT->selfUnlink  =  MK(AtomSelfUnlink)    ;
}