MkBufferC_tcl.c

Go to the documentation of this file.

 
/* LABEL-START */
 
#define   META_FILE_NAME      "MkBufferC_tcl.c"
 
#include  "LibMkKernel_private_tcl.h"
 
#define   OT_CLASS            NS(MkBufferC)
#define   OT_CLASS_NAME       "MkBufferC"
 
#define   OBJECT2BUF(O)   MkAssertCastM(MkBufferC,(Tcl_ObjectGetMetadata(O, &MK(AtomMeta))))
 
// TCL class
MkThreadLocal OT_CLS_T OT_CLASS = NULL;
 
// META class
static MkThreadLocal MK_TYP MkBufferCTT = NULL;
MkThreadLocal OT_OBJ_T MK(MkBufferC_MK_NULL) = NULL;
 
// META: ObjNew feature: selfCreate will be called from "ObjNew->MkSelfNew" if MkObj need a SELF pointer
static MK_PTR NS(MkBufferC_selfCreate) (MK_RT_ARGS MK_OBJ const obj, MK_PTR const env) {
  OT_ENV_T interp = env;
  return MK(AtomCreate) (MK_RT_CALL interp,obj,OT_CLASS,NULL,NULL);
}
// META: is called when the META object is destroyed and SELF does NOT belongs to the META.
static void NS(MkBufferC_selfDelete) (MK_RT_ARGS MK_PTR selfP, MK_PTR const env) {
  OT_SELF_T selfO = selfP;
  OT_ENV_T  interp = env;
  MK(AtomDeleteHard) (MK_RT_CALL interp, selfO);
}
// META: is called when the META object is destroyed and SELF does NOT belong to the META.
static void NS(MkBufferC_selfUnlink) (MK_RT_ARGS MK_PTR selfP, MK_PTR const env) {
  OT_SELF_T selfO = selfP;
  OT_ENV_T  interp = env;
  MK(AtomUnlink) (MK_RT_CALL interp, selfO);
}
 
// ATTENTION: TCL has no "Unlink" because the "Tcl_ObjectSetMetadata(selfO,&MK(AtomMeta),NULL);" call
// also the destructor
 
#define   OT_SETUP_hdl_static_constr_pre
#define   OT_SETUP_hdl_static_constr \
  OT_SETUP_hdl_static_constr_pre; \
  OT_SETUP_hdl_static
 
#define   OT_SETUP_hdl_static     \
  int __skip=Tcl_ObjectContextSkippedArgs(objCtx); \
  AllRtSetup_NULL; \
  __attribute__((unused)) OT_SELF_T selfO = Tcl_ObjectContextObject(objCtx); \
  __attribute__((unused)) MK_TYP hdl = MkBufferC##_TT;
 
#define   OT_SETUP_hdl              SetupHdlFromMetaData_2(BUF,MK_BUF);
#define   OT_SETUP_hdl__null_allow  SetupHdlFromMetaData__null_allow_2(BUF,MK_BUF);
#define   OT_SETUP_hdl_destr        SetupHdlFromMetaData__null_allow_2(BUF,MK_BUF);
 
#define   OT_SETUP_hdl_constr_pre
#define   OT_SETUP_hdl_constr \
  OT_SETUP_hdl_constr_pre; \
  int __skip=Tcl_ObjectContextSkippedArgs(objCtx); \
  AllRtSetup_NULL; \
  MK_RT_UNUSED OT_SELF_T selfO = Tcl_ObjectContextObject(objCtx); \
  MK_BUF hdl = (MK_BUF) &MkERROR;
 
#if !defined(SetupRtFromHdl_XN)
  #define SetupRtFromHdl_XN(hdl)  AllRtSetup_XN(hdl)
  #define SetupRtFromHdl_X(hdl)   AllRtSetup_X(hdl)
#endif
 
// initialize the TCL and MO class specific object
#define   ClassInit \
  /* if not already done, initialize NEW MQ type */ \
  if (MkBufferCTT == NULL) MkBufferCTT = MkBufferSTT; \
 \
  /* protect against double call */ \
  if (MkBufferCTT->selfCreate == NS(MkBufferC_selfCreate)) return MK_OK; \
 \
  /* add "selfCreate" and "selfDelete" feature to the MQ-Class */ \
  MkBufferCTT->selfCreate    = NS(MkBufferC_selfCreate); \
  MkBufferCTT->selfDelete    = NS(MkBufferC_selfDelete); \
  MkBufferCTT->selfUnlink    = NS(MkBufferC_selfUnlink); \
 \
  /* create the TCL-class */ \
  OT_SELF_T classO = MK(ClassDef)(interp,ns,MkBufferCTT); \
  check_NULL(classO) goto error; \
  OT_CLASS = Tcl_GetObjectAsClass(classO); \
 \
  /* create the TCL static Methods */ \
  static MkThreadLocal OtUnknownS NS(sClassUnknown) = {OT_UNKNOWN_CLASS}; \
  check_LNG(MK(UnknownSetup) (interp,classO,NS(sOtClassDef),&NS(sClassUnknown))) goto error; \
 \
  /* create the TCL instance Methods */ \
  static MkThreadLocal OtUnknownS NS(sInstanceUnknown) = {OT_UNKNOWN_INSTANCE}; \
  check_LNG(MK(UnknownSetup) (interp,classO,NS(sInstanceDef),&NS(sInstanceUnknown))) goto error; \
 \
  /* define the "NULL" object */ \
  MK(MkBufferC_MK_NULL) = Tcl_GetObjectName(interp, \
    MK(AtomCreate) (MK_RT_CALL interp,  NULL /*obj*/, OT_CLASS, "MK_NULL" /*name*/, "::tclmkkernel::MkBufferC" /*ns*/) \
  ); \
  Tcl_IncrRefCount(MK(MkBufferC_MK_NULL));
 
#define VER TCL_OO_METHOD_VERSION_CURRENT
 
/* LABEL-END */
 
// BEGIN-DOC - created by 'tcl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// doc-key: MkBufferC,MkBuffer,sCc,func
#define CTOR_doc "MkBufferC [MkBufferC CTOR ?size:int32=0?]"
#define Create_doc "MkBufferC [MkBufferC Create ?size:int32=0?]"
#define Create1024_doc "MkBufferC [MkBufferC Create1024 ?size:int32=0?]"
#define Create256_doc "MkBufferC [MkBufferC Create256 ?size:int32=0?]"
#define Create64_doc "MkBufferC [MkBufferC Create64 ?size:int32=0?]"
#define CreateBIN_doc "MkBufferC [MkBufferC CreateBIN val:binary]"
#define CreateBOL_doc "MkBufferC [MkBufferC CreateBOL val:bool]"
#define CreateBUF_doc "MkBufferC [MkBufferC CreateBUF val:MkBufferC]"
#define CreateDBL_doc "MkBufferC [MkBufferC CreateDBL val:double]"
#define CreateFLT_doc "MkBufferC [MkBufferC CreateFLT val:float]"
#define CreateI16_doc "MkBufferC [MkBufferC CreateI16 val:int16]"
#define CreateI32_doc "MkBufferC [MkBufferC CreateI32 val:int32]"
#define CreateI64_doc "MkBufferC [MkBufferC CreateI64 val:int64]"
#define CreateI8_doc "MkBufferC [MkBufferC CreateI8 val:int8]"
#define CreateSTR_doc "MkBufferC [MkBufferC CreateSTR val:string]"
 
// doc-key: MkBufferC,MkBuffer,sc_,func
#define CreateTLS_doc "MkBufferC [MkBufferC CreateTLS tlsName:string ?resetB:bool=true?]"
#define GetNull_doc "MkBufferC [MkBufferC GetNull]"
#define HandleResolve_doc "MkBufferC [MkBufferC HandleResolve netHdl:MK_HDL]"
#define Instances_doc "MkBufferC [MkBufferC Instances]"
 
// doc-key: MkBufferC,MkBuffer,oC_,func
#define Merge_doc "MkBufferC [$buf Merge]"
 
// doc-key: MkBufferC,MkBuffer,oCx,func
#define Dup_doc "MkBufferC [$buf Dup] (const)"
 
// doc-key: MkBufferC,MkBuffer,oc_,func
#define AppendC_doc "MkBufferC [$buf AppendC val:string]"
#define AppendStringR_doc "MkBufferC [$buf AppendStringR val:string]"
#define Copy_doc "MkBufferC [$buf Copy srce:MkBufferC] (const)"
#define Next_doc "MkBufferC [$buf Next]"
#define Prev_doc "MkBufferC [$buf Prev]"
#define Reset_doc "MkBufferC [$buf Reset]"
#define SetBIN_doc "MkBufferC [$buf SetBIN val:binary]"
#define SetBOL_doc "MkBufferC [$buf SetBOL val:bool]"
#define SetBUF_doc "MkBufferC [$buf SetBUF val:MkBufferC]"
#define SetBinaryR_doc "MkBufferC [$buf SetBinaryR val:binary]"
#define SetDBL_doc "MkBufferC [$buf SetDBL val:double]"
#define SetFLT_doc "MkBufferC [$buf SetFLT val:float]"
#define SetI16_doc "MkBufferC [$buf SetI16 val:int16]"
#define SetI32_doc "MkBufferC [$buf SetI32 val:int32]"
#define SetI64_doc "MkBufferC [$buf SetI64 val:int64]"
#define SetI8_doc "MkBufferC [$buf SetI8 val:int8]"
#define SetSTR_doc "MkBufferC [$buf SetSTR val:string]"
#define SetStringR_doc "MkBufferC [$buf SetStringR val:string]"
#define SizeAdd_doc "MkBufferC [$buf SizeAdd size:int32]"
#define SizeNew_doc "MkBufferC [$buf SizeNew size:int32]"
#define Temp_doc "MkBufferC [$buf Temp] (const)"
 
// doc-key: MkBufferC,MkBuffer,oci,func
#define GetBFL_doc "MkBufferListC [$buf GetBFL ?val_inout:MkBufferListC=\"MK_NULL\"?] (const)"
 
// doc-key: MkBufferC,MkBuffer,oco,func
#define GetBUF_doc "MkBufferC [$buf GetBUF]"
 
// doc-key: MkBufferC,MkBuffer,om_,func
#define CastTo_doc "$buf CastTo typ:MkTypeE"
#define Cmp_doc "int32 [$buf1 Cmp buf2:MkBufferC] (const)"
#define GetType1_doc "string[1] [$buf GetType1] (const)"
#define GetType2_doc "MkTypeE [$buf GetType2] (const)"
#define GetType3_doc "string [$buf GetType3] (const)"
// skip class-overload: HandleGet → MkObjectHandleGet
#define IsLocal_doc "bool [$buf IsLocal] (const)"
// skip class-overload: Log → MkObjectLog
#define LogS_doc "$buf LogS ?varname:string=\"buf\"? ?fmtobj:MkObjectC=\"MK_NULL\"? ?callfunc:string=\"MK_NULL\"? (const)"
#define Pop_doc "int32 [$buf Pop val:string]"
#define Push_doc "int32 [$buf Push val:string]"
#define ResetFull_doc "$buf ResetFull"
// skip class-overload: ToString → MkObjectToString
 
// doc-key: MkBufferC,MkBuffer,omo,func
#define GetBIN_doc "binary [$buf GetBIN] (const)"
#define GetBOL_doc "bool [$buf GetBOL] (const)"
#define GetDBL_doc "double [$buf GetDBL] (const)"
#define GetFLT_doc "float [$buf GetFLT] (const)"
#define GetI16_doc "int16 [$buf GetI16] (const)"
#define GetI32_doc "int32 [$buf GetI32] (const)"
#define GetI64_doc "int64 [$buf GetI64] (const)"
#define GetI8_doc "int8 [$buf GetI8] (const)"
#define GetSTR_doc "string [$buf GetSTR] (const)"
#define GetStringR_doc "string [$buf GetStringR] (const)"
#define ToObject_doc "obj [$buf ToObject]"
 
// END-DOC - created by 'tcl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
/*****************************************************************************/
/*                                                                           */
/*                        O B J E C T                                        */
/*                                                                           */
/*****************************************************************************/
 
OT_ProcRet NS(MkBufferC_ToObject) (MkBufferC_ARGS);
#include "tmpl/MkBufferC_ToObject_lng.h"
 
// BEGIN-MkBufferC - created by 'tcl_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// doc-key: MkBufferC,MkBufferC-Access,oc_
 
static OT_ProcRet NS(MkBufferC_AppendC) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendC_doc);
  MK_STRN val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferAppendC (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_AppendStringR) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendStringR_doc);
  MkStringR val = {0};
  OT_CHECK_REQUIRED(OT_CHECK__ME_REF_MkStringR(val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferAppendStringR (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferC,MkBufferC-Access,om_
 
static OT_ProcRet NS(MkBufferC_Pop) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(Pop_doc);
  MK_STRN val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (val))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkBufferPop (hdl, val));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_Push) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(Push_doc);
  MK_STRN val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (val))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkBufferPush (hdl, val));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferC,MkBufferC-Access,omo
 
OT_ProcRet NS(MkBufferC_ToObject) (MkBufferC_ARGS) ; // skip template-required
 
// MkBufferC_Access_TCL_API
 
 
// doc-key: MkBufferC,MkBufferC-Class-Export,sc_
 
static OT_ProcRet NS(MkBufferC_HandleResolve) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(HandleResolve_doc);
  MK_HDL netHdl = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NIH (netHdl))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferHandleResolve (netHdl);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferC,MkBufferC-Class-Export,om_
 
// skip on class-overload: MkBufferHandleGet → MkObjectHandleGet
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MkBufferC_HandleGet) (MkBufferC_ARGS) {OT_ERROR_LNG_RETURN;}
 
// MkBufferC_Class_TCL_API
 
 
// doc-key: MkBufferC,MkBufferC-Class-Introspection,oc_
 
static OT_ProcRet NS(MkBufferC_Next) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Next_doc);
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferNext (hdl);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_Prev) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Prev_doc);
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferPrev (hdl);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferC,MkBufferC-Class-Introspection,sc_
 
static OT_ProcRet NS(MkBufferC_Instances) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Instances_doc);
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferInstances ();
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkBufferC_Class_TCL_API
 
 
// doc-key: MkBufferC,MkBufferC-Class-Misc,sc_
 
static OT_ProcRet NS(MkBufferC_GetNull) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(GetNull_doc);
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferGetNull ();
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkBufferC_Class_TCL_API
 
 
// doc-key: MkBufferC,MkBufferC-Get,oci
 
OT_ProcRet NS(MkBufferC_GetBFL) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,1,GetBFL_doc);
  MkBufferListCreateTLS_T(val_inout,10);
  OT_CHECK_OPTIONAL(OT_CHECK_BFL (val_inout,MK_NULL_YES))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferGetBFL (hdl, &val_inout));
  OT_retObj_SET_BFL(val_inout);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferC,MkBufferC-Get,oco
 
static OT_ProcRet NS(MkBufferC_GetBUF) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetBUF_doc);
  OT_CHECK_NOARGS;
  MK_BUF val_out;
  MkErrorC_Check(hdl,MkBufferGetBUF (hdl, &val_out));
  OT_retObj_SET_BUF(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferC,MkBufferC-Get,omo
 
static OT_ProcRet NS(MkBufferC_GetBIN) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetBIN_doc);
  OT_CHECK_NOARGS;
  MkBinaryR val_out;
  MkErrorC_Check(hdl,MkBufferGetBIN (hdl, &val_out));
  MkBinaryR retVal = val_out;
  OT_retObj_SET(OT_GET__ME_REF_MkBinaryR(retVal));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetBOL) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetBOL_doc);
  OT_CHECK_NOARGS;
  MK_BOL val_out;
  MkErrorC_Check(hdl,MkBufferGetBOL (hdl, &val_out));
  OT_retObj_SET_BOL(val_out == 1);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetDBL) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetDBL_doc);
  OT_CHECK_NOARGS;
  MK_DBL val_out;
  MkErrorC_Check(hdl,MkBufferGetDBL (hdl, &val_out));
  OT_retObj_SET_DBL(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetFLT) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetFLT_doc);
  OT_CHECK_NOARGS;
  MK_FLT val_out;
  MkErrorC_Check(hdl,MkBufferGetFLT (hdl, &val_out));
  OT_retObj_SET_FLT(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetI16) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetI16_doc);
  OT_CHECK_NOARGS;
  MK_I16 val_out;
  MkErrorC_Check(hdl,MkBufferGetI16 (hdl, &val_out));
  OT_retObj_SET_I16(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetI32) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetI32_doc);
  OT_CHECK_NOARGS;
  MK_I32 val_out;
  MkErrorC_Check(hdl,MkBufferGetI32 (hdl, &val_out));
  OT_retObj_SET_I32(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetI64) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetI64_doc);
  OT_CHECK_NOARGS;
  MK_I64 val_out;
  MkErrorC_Check(hdl,MkBufferGetI64 (hdl, &val_out));
  OT_retObj_SET_I64(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetI8) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetI8_doc);
  OT_CHECK_NOARGS;
  MK_I8 val_out;
  MkErrorC_Check(hdl,MkBufferGetI8 (hdl, &val_out));
  OT_retObj_SET_I8(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetSTR) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetSTR_doc);
  OT_CHECK_NOARGS;
  MK_STRN val_out;
  MkErrorC_Check(hdl,MkBufferGetSTR (hdl, &val_out));
  OT_retObj_SET_STR(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetStringR) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetStringR_doc);
  OT_CHECK_NOARGS;
  MkStringR val_out;
  MkErrorC_Check(hdl,MkBufferGetStringR (hdl, &val_out));
  MkStringR retVal = val_out;
  OT_retObj_SET(OT_GET__ME_REF_MkStringR(retVal));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkBufferC_Get_TCL_API
 
 
// doc-key: MkBufferC,MkBufferC-Info,om_
 
static OT_ProcRet NS(MkBufferC_GetType1) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetType1_doc);
  OT_CHECK_NOARGS;
  char ret_str[2] = {MkBufferGetType1 (hdl), '\0'};
  OT_retObj_SET_STR(ret_str);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetType2) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetType2_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET(OT_NEW_Mk_enum_OBJ(TypeE,MkBufferGetType2 (hdl)));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetType3) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetType3_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MkBufferGetType3 (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_IsLocal) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(IsLocal_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MkBufferIsLocal (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// skip on class-overload: MkBufferLog → MkObjectLog
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MkBufferC_Log) (MkBufferC_ARGS) {OT_ERROR_LNG_RETURN;}
 
static OT_ProcRet NS(MkBufferC_LogS) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,3,LogS_doc);
  MK_STRN varname = "buf";
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (varname))
  MK_OBJN fmtobj = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_OBJN (fmtobj,MK_NULL_YES))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkBufferLogS (hdl, varname, fmtobj, callfunc);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
// MkBufferC_Info_TCL_API
 
 
// doc-key: MkBufferC,MkBufferC-Misc,oc_
 
static OT_ProcRet NS(MkBufferC_Copy) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(Copy_doc);
  MK_BUFN srce = 0;
  OT_CHECK_REQUIRED(OT_CHECK_BUFN (srce,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCopy (hdl, srce);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_Reset) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Reset_doc);
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferReset (hdl);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SizeAdd) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SizeAdd_doc);
  MK_NUM size = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (size))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSizeAdd (hdl, size);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SizeNew) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SizeNew_doc);
  MK_NUM size = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (size))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSizeNew (hdl, size);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
OT_ProcRet NS(MkBufferC_Temp) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Temp_doc);
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferTemp (hdl);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferC,MkBufferC-Misc,om_
 
static OT_ProcRet NS(MkBufferC_CastTo) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(CastTo_doc);
  enum MkTypeE typ = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MkTypeE,typ))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferCastTo (hdl, typ));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_Cmp) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(Cmp_doc);
  MK_BUFN buf2 = 0;
  OT_CHECK_REQUIRED(OT_CHECK_BUFN (buf2,MK_NULL_NO))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkBufferCmp (hdl, buf2));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_ResetFull) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ResetFull_doc);
  OT_CHECK_NOARGS;
  MkBufferResetFull (hdl);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// skip on class-overload: MkBufferToString → MkObjectToString
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MkBufferC_ToString) (MkBufferC_ARGS) {OT_ERROR_LNG_RETURN;}
 
// MkBufferC_Misc_TCL_API
 
 
// doc-key: MkBufferC,MkBufferC-Set,oc_
 
static OT_ProcRet NS(MkBufferC_SetBIN) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetBIN_doc);
  MkBinaryR val = {0};
  OT_CHECK_REQUIRED(OT_CHECK__ME_REF_MkBinaryR(val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetBIN (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetBOL) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetBOL_doc);
  MK_BOL val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NB1 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetBOL (hdl, (MK_BOL)(val?1:0));
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetBUF) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetBUF_doc);
  MK_BUFN val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_BUFN (val,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetBUF (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetBinaryR) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetBinaryR_doc);
  MkBinaryR val = {0};
  OT_CHECK_REQUIRED(OT_CHECK__ME_REF_MkBinaryR(val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetBinaryR (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetDBL) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetDBL_doc);
  MK_DBL val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NF8 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetDBL (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetFLT) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetFLT_doc);
  MK_FLT val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NF4 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetFLT (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetI16) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetI16_doc);
  MK_I16 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI2 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetI16 (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetI32) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetI32_doc);
  MK_I32 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetI32 (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetI64) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetI64_doc);
  MK_I64 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI8 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetI64 (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetI8) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetI8_doc);
  MK_I8 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI1 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetI8 (hdl, (MK_I8)(val));
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetSTR) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetSTR_doc);
  MK_STRN val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetSTR (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetStringR) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetStringR_doc);
  MkStringR val = {0};
  OT_CHECK_REQUIRED(OT_CHECK__ME_REF_MkStringR(val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetStringR (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkBufferC_Set_TCL_API
 
 
// doc-key: MkBufferC,MkBufferC-TOR,oC_
 
static OT_ProcRet NS(MkBufferC_Merge) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Merge_doc);
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferMerge (hdl);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferC,MkBufferC-TOR,oCx
 
static OT_ProcRet NS(MkBufferC_Dup) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Dup_doc);
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferDup (hdl);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferC,MkBufferC-TOR,sCc
 
static OT_ProcRet NS(MkBufferC_CTOR) (CONSTR_ARGS) {
  OT_SETUP_hdl_constr;
  OT_SETUP_CONSTRUCTOR_ARGS(0,1,CTOR_doc);
  MK_NUM size = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (size))
  MK_BUF retVal = MkBufferCreate (NULL, size);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_CONSTR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_Create) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_VARARGS(0,1,Create_doc);
  MK_NUM size = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (size))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreate (NULL, size);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_Create1024) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_VARARGS(0,1,Create1024_doc);
  MK_NUM size = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (size))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreate1024 (size);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_Create256) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_VARARGS(0,1,Create256_doc);
  MK_NUM size = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (size))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreate256 (size);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_Create64) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_VARARGS(0,1,Create64_doc);
  MK_NUM size = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (size))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreate64 (size);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_CreateBIN) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(CreateBIN_doc);
  MkBinaryR val = {0};
  OT_CHECK_REQUIRED(OT_CHECK__ME_REF_MkBinaryR(val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreateBIN (val);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_CreateBOL) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(CreateBOL_doc);
  MK_BOL val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NB1 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreateBOL ((MK_BOL)(val?1:0));
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_CreateBUF) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(CreateBUF_doc);
  MK_BUFN val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_BUFN (val,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreateBUF (val);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_CreateDBL) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(CreateDBL_doc);
  MK_DBL val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NF8 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreateDBL (val);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_CreateFLT) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(CreateFLT_doc);
  MK_FLT val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NF4 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreateFLT (val);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_CreateI16) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(CreateI16_doc);
  MK_I16 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI2 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreateI16 (val);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_CreateI32) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(CreateI32_doc);
  MK_I32 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreateI32 (val);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_CreateI64) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(CreateI64_doc);
  MK_I64 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI8 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreateI64 (val);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_CreateI8) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(CreateI8_doc);
  MK_I8 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI1 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreateI8 ((MK_I8)(val));
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_CreateSTR) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(CreateSTR_doc);
  MK_STRN val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreateSTR (val);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferC,MkBufferC-TOR,sc_
 
static OT_ProcRet NS(MkBufferC_CreateTLS) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_VARARGS(1,2,CreateTLS_doc);
  MK_STRN tlsName = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (tlsName))
  MK_BOOL resetB = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (resetB))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreateTLS (tlsName, resetB);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkBufferC_TOR_TCL_API
 
// END-MkBufferC - created by 'tcl_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
const static Tcl_MethodType NS(sOtClassDef)[] = {
 
// BEGIN-CLASS - created by 'tcl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// doc-key: MkBufferC,MkBuffer,sCc
  {VER, "Create"              , NS(MkBufferC_Create)                    , NULL, NULL},
  {VER, "Create1024"          , NS(MkBufferC_Create1024)                , NULL, NULL},
  {VER, "Create256"           , NS(MkBufferC_Create256)                 , NULL, NULL},
  {VER, "Create64"            , NS(MkBufferC_Create64)                  , NULL, NULL},
  {VER, "CreateBIN"           , NS(MkBufferC_CreateBIN)                 , NULL, NULL},
  {VER, "CreateBOL"           , NS(MkBufferC_CreateBOL)                 , NULL, NULL},
  {VER, "CreateBUF"           , NS(MkBufferC_CreateBUF)                 , NULL, NULL},
  {VER, "CreateDBL"           , NS(MkBufferC_CreateDBL)                 , NULL, NULL},
  {VER, "CreateFLT"           , NS(MkBufferC_CreateFLT)                 , NULL, NULL},
  {VER, "CreateI16"           , NS(MkBufferC_CreateI16)                 , NULL, NULL},
  {VER, "CreateI32"           , NS(MkBufferC_CreateI32)                 , NULL, NULL},
  {VER, "CreateI64"           , NS(MkBufferC_CreateI64)                 , NULL, NULL},
  {VER, "CreateI8"            , NS(MkBufferC_CreateI8)                  , NULL, NULL},
  {VER, "CreateSTR"           , NS(MkBufferC_CreateSTR)                 , NULL, NULL},
 
// doc-key: MkBufferC,MkBuffer,sc_
  {VER, "CreateTLS"           , NS(MkBufferC_CreateTLS)                 , NULL, NULL},
  {VER, "GetNull"             , NS(MkBufferC_GetNull)                   , NULL, NULL},
  {VER, "HandleResolve"       , NS(MkBufferC_HandleResolve)             , NULL, NULL},
  {VER, "Instances"           , NS(MkBufferC_Instances)                 , NULL, NULL},
 
// END-CLASS - created by 'tcl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
  {0, NULL, NULL, NULL}
};
 
// ---------------------------------------------------------------------------------------
 
const static Tcl_MethodType NS(sInstanceDef)[] = {
 
// BEGIN-OBJ - created by 'tcl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// doc-key: MkBufferC,MkBuffer,oC_
  {VER, "<constructor>"       , NS(MkBufferC_CTOR)                      , NULL, NULL},
  {VER, "Merge"               , NS(MkBufferC_Merge)                     , NULL, NULL},
 
// doc-key: MkBufferC,MkBuffer,oCx
  {VER, "Dup"                 , NS(MkBufferC_Dup)                       , NULL, NULL},
 
// doc-key: MkBufferC,MkBuffer,oc_
  {VER, "AppendC"             , NS(MkBufferC_AppendC)                   , NULL, NULL},
  {VER, "AppendStringR"       , NS(MkBufferC_AppendStringR)             , NULL, NULL},
  {VER, "Copy"                , NS(MkBufferC_Copy)                      , NULL, NULL},
  {VER, "Next"                , NS(MkBufferC_Next)                      , NULL, NULL},
  {VER, "Prev"                , NS(MkBufferC_Prev)                      , NULL, NULL},
  {VER, "Reset"               , NS(MkBufferC_Reset)                     , NULL, NULL},
  {VER, "SetBIN"              , NS(MkBufferC_SetBIN)                    , NULL, NULL},
  {VER, "SetBOL"              , NS(MkBufferC_SetBOL)                    , NULL, NULL},
  {VER, "SetBUF"              , NS(MkBufferC_SetBUF)                    , NULL, NULL},
  {VER, "SetBinaryR"          , NS(MkBufferC_SetBinaryR)                , NULL, NULL},
  {VER, "SetDBL"              , NS(MkBufferC_SetDBL)                    , NULL, NULL},
  {VER, "SetFLT"              , NS(MkBufferC_SetFLT)                    , NULL, NULL},
  {VER, "SetI16"              , NS(MkBufferC_SetI16)                    , NULL, NULL},
  {VER, "SetI32"              , NS(MkBufferC_SetI32)                    , NULL, NULL},
  {VER, "SetI64"              , NS(MkBufferC_SetI64)                    , NULL, NULL},
  {VER, "SetI8"               , NS(MkBufferC_SetI8)                     , NULL, NULL},
  {VER, "SetSTR"              , NS(MkBufferC_SetSTR)                    , NULL, NULL},
  {VER, "SetStringR"          , NS(MkBufferC_SetStringR)                , NULL, NULL},
  {VER, "SizeAdd"             , NS(MkBufferC_SizeAdd)                   , NULL, NULL},
  {VER, "SizeNew"             , NS(MkBufferC_SizeNew)                   , NULL, NULL},
  {VER, "Temp"                , NS(MkBufferC_Temp)                      , NULL, NULL},
 
// doc-key: MkBufferC,MkBuffer,oci
  {VER, "GetBFL"              , NS(MkBufferC_GetBFL)                    , NULL, NULL},
 
// doc-key: MkBufferC,MkBuffer,oco
  {VER, "GetBUF"              , NS(MkBufferC_GetBUF)                    , NULL, NULL},
 
// doc-key: MkBufferC,MkBuffer,om_
  {VER, "CastTo"              , NS(MkBufferC_CastTo)                    , NULL, NULL},
  {VER, "Cmp"                 , NS(MkBufferC_Cmp)                       , NULL, NULL},
  {VER, "GetType1"            , NS(MkBufferC_GetType1)                  , NULL, NULL},
  {VER, "GetType2"            , NS(MkBufferC_GetType2)                  , NULL, NULL},
  {VER, "GetType3"            , NS(MkBufferC_GetType3)                  , NULL, NULL},
  // skip class-overload: MkBufferHandleGet → HandleGet, NS(MkBufferC_HandleGet)
  {VER, "IsLocal"             , NS(MkBufferC_IsLocal)                   , NULL, NULL},
  // skip class-overload: MkBufferLog → Log, NS(MkBufferC_Log)
  {VER, "LogS"                , NS(MkBufferC_LogS)                      , NULL, NULL},
  {VER, "Pop"                 , NS(MkBufferC_Pop)                       , NULL, NULL},
  {VER, "Push"                , NS(MkBufferC_Push)                      , NULL, NULL},
  {VER, "ResetFull"           , NS(MkBufferC_ResetFull)                 , NULL, NULL},
  // skip class-overload: MkBufferToString → ToString, NS(MkBufferC_ToString)
 
// doc-key: MkBufferC,MkBuffer,omo
  {VER, "GetBIN"              , NS(MkBufferC_GetBIN)                    , NULL, NULL},
  {VER, "GetBOL"              , NS(MkBufferC_GetBOL)                    , NULL, NULL},
  {VER, "GetDBL"              , NS(MkBufferC_GetDBL)                    , NULL, NULL},
  {VER, "GetFLT"              , NS(MkBufferC_GetFLT)                    , NULL, NULL},
  {VER, "GetI16"              , NS(MkBufferC_GetI16)                    , NULL, NULL},
  {VER, "GetI32"              , NS(MkBufferC_GetI32)                    , NULL, NULL},
  {VER, "GetI64"              , NS(MkBufferC_GetI64)                    , NULL, NULL},
  {VER, "GetI8"               , NS(MkBufferC_GetI8)                     , NULL, NULL},
  {VER, "GetSTR"              , NS(MkBufferC_GetSTR)                    , NULL, NULL},
  {VER, "GetStringR"          , NS(MkBufferC_GetStringR)                , NULL, NULL},
  {VER, "ToObject"            , NS(MkBufferC_ToObject)                  , NULL, NULL},
 
// END-OBJ - created by 'tcl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
  {0, NULL, NULL, NULL, NULL}
};
 
 
int NS(pMkBufferC_Init) ( MK_RT_ARGS OT_ENV_T interp, OT_NS_T ns )
{
  ClassInit
 
  MkBuffer64C_TT->selfCreate    =  NS(MkBufferC_selfCreate)  ;
  MkBuffer64C_TT->selfDelete    =  NS(MkBufferC_selfDelete)  ;
  MkBuffer64C_TT->selfUnlink    =  NS(MkBufferC_selfUnlink)  ;
  MkBuffer256C_TT->selfCreate   =  NS(MkBufferC_selfCreate)  ;
  MkBuffer256C_TT->selfDelete   =  NS(MkBufferC_selfDelete)  ;
  MkBuffer256C_TT->selfUnlink   =  NS(MkBufferC_selfUnlink)  ;
  MkBuffer1024C_TT->selfCreate  =  NS(MkBufferC_selfCreate)  ;
  MkBuffer1024C_TT->selfDelete  =  NS(MkBufferC_selfDelete)  ;
  MkBuffer1024C_TT->selfUnlink  =  NS(MkBufferC_selfUnlink)  ;
 
  return TCL_OK;
error:
  return TCL_ERROR;
}