MkBufferC_atl.c

Go to the documentation of this file.

 
/* LABEL-START */
 
#define   META_FILE_NAME      "MkBufferC_atl.c"
 
#include  "LibMkKernel_private_atl.h"
 
#define   OT_CLASS            amkrt->AtlMkBufferC
#define   OT_NULL             amkrt->AtlMkBufferC_MK_NULL
#define   OT_CLASS_NAME       "MkBufferC"
 
#define   SELF2HDL(O)         MkBuf(VAL2MNG(O))
 
// LNG: class
// -> moved to LibMkKernel_atl.h → OT_MK_RT_S → AtlMkKernelCTT;
 
// META: ObjNew feature: called to return a new or an already existing ATL-SELF-Object
// -> moved to LibMkKernel_atl.h → MkKernelC_ObjNew
 
// 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) {
  SETUP_amkrt(env);
  return AtomMake(obj,OT_CLASS,NULL,NULL,env);
}
 
// META: called if MkObj must be destroyed and if the SELF is still alive → goal: destroy the SELF
static void NS(MkBufferC_selfDelete) (MK_RT_ARGS MK_PTR selfP, MK_PTR const env) {
  OT_SELF_T selfO = selfP;
  SETUP_amkrt(env);
  MK(AtomDeleteHard) (OT_MK_CALL selfO);
}
 
// META: called to destroy link from SELF to META
static void NS(MkBufferC_selfUnlink) (MK_RT_ARGS MK_PTR selfP, MK_PTR const env) {
  OT_SELF_T selfO = selfP;
  SETUP_amkrt(env);
  return MK(AtomUnlink) (OT_MK_CALL selfO);
}
 
#define OT_SETUP_hdl                  SetupHdlFromMetaData_2(MK_BUF)
#define OT_SETUP_hdl__null_allow      SetupHdlFromMetaData__null_allow_2(MK_BUF)
#define OT_SETUP_hdl_destr            SetupHdlFromMetaData__null_allow_2(MK_BUF)
#define OT_SETUP_hdl_constr           SetupHdlConstr(MkBufferC)
#define OT_SETUP_hdl_static_constr    OT_SETUP_hdl_static
#define OT_SETUP_hdl_static           SetupHdlStatic(MkBufferC)
 
#define OT_retObj_CONSTR(x)           OT_retObj_SET(AtomInit(OT_SELF,MkBufferC_X2obj(x),amkrt))
 
// initialize the ATL and META class specific object
#define   ClassInit \
  /* if not already done, initialize NEW META 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 META-Class */ \
  MkBufferCTT->selfCreate    = NS(MkBufferC_selfCreate); \
  MkBufferCTT->selfDelete    = NS(MkBufferC_selfDelete); \
  MkBufferCTT->selfUnlink    = NS(MkBufferC_selfUnlink); \
 \
  /* create the ATL-class */ \
  OT_CLASS = AltClassDef(MkBufferCTT,&amkrt->AtlMkBufferC_NS); \
    if (OT_CLASS == NULL) goto error; \
    OT_REF_INCR(OT_CLASS); \
 \
  /* create the ATL static Methods */ \
  check_LNG(AtlUnknownSetup (NS(sOtClassDef),amkrt)) goto error; \
 \
  /* create the ATL instance Methods */ \
  check_LNG(AtlUnknownSetup (NS(sInstanceDef),amkrt)) goto error; \
 \
  /* after class was modified, recompile the class */ \
  RL_init(2, recompile, RL_T(0,RecompileN)); RL_O(1,OT_CLASS) ; \
    int retI = RL_EvalEx(0); \
      if (retI != TCL_OK) return retI; \
 \
  /* define the "NULL" object */ \
  OT_NULL = AtomCreateNULL(OT_CLASS, "::MkBufferC::MK_NULL", (MK_PTR)amkrt); \
    if (OT_NULL == NULL) goto error; \
    OT_REF_INCR(OT_NULL);
/* LABEL-END */
 
// BEGIN-DOC - created by 'atl_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 [MkBufferC::Merge $buf]"
 
// doc-key: MkBufferC,MkBuffer,oCx,func
#define Dup_doc "MkBufferC [MkBufferC::Dup $buf] (const)"
 
// doc-key: MkBufferC,MkBuffer,oc_,func
#define AppendC_doc "MkBufferC [MkBufferC::AppendC $buf val:string]"
#define AppendStringR_doc "MkBufferC [MkBufferC::AppendStringR $buf val:string]"
#define Copy_doc "MkBufferC [MkBufferC::Copy $buf srce:MkBufferC] (const)"
#define Next_doc "MkBufferC [MkBufferC::Next $buf]"
#define Prev_doc "MkBufferC [MkBufferC::Prev $buf]"
#define Reset_doc "MkBufferC [MkBufferC::Reset $buf]"
#define SetBIN_doc "MkBufferC [MkBufferC::SetBIN $buf val:binary]"
#define SetBOL_doc "MkBufferC [MkBufferC::SetBOL $buf val:bool]"
#define SetBUF_doc "MkBufferC [MkBufferC::SetBUF $buf val:MkBufferC]"
#define SetBinaryR_doc "MkBufferC [MkBufferC::SetBinaryR $buf val:binary]"
#define SetDBL_doc "MkBufferC [MkBufferC::SetDBL $buf val:double]"
#define SetFLT_doc "MkBufferC [MkBufferC::SetFLT $buf val:float]"
#define SetI16_doc "MkBufferC [MkBufferC::SetI16 $buf val:int16]"
#define SetI32_doc "MkBufferC [MkBufferC::SetI32 $buf val:int32]"
#define SetI64_doc "MkBufferC [MkBufferC::SetI64 $buf val:int64]"
#define SetI8_doc "MkBufferC [MkBufferC::SetI8 $buf val:int8]"
#define SetSTR_doc "MkBufferC [MkBufferC::SetSTR $buf val:string]"
#define SetStringR_doc "MkBufferC [MkBufferC::SetStringR $buf val:string]"
#define SizeAdd_doc "MkBufferC [MkBufferC::SizeAdd $buf size:int32]"
#define SizeNew_doc "MkBufferC [MkBufferC::SizeNew $buf size:int32]"
#define Temp_doc "MkBufferC [MkBufferC::Temp $buf] (const)"
 
// doc-key: MkBufferC,MkBuffer,oci,func
#define GetBFL_doc "MkBufferListC [MkBufferC::GetBFL $buf ?val_inout:MkBufferListC=NULL?] (const)"
 
// doc-key: MkBufferC,MkBuffer,oco,func
#define GetBUF_doc "MkBufferC [MkBufferC::GetBUF $buf]"
 
// doc-key: MkBufferC,MkBuffer,om_,func
#define CastTo_doc "MkBufferC::CastTo $buf typ:MkTypeE"
#define Cmp_doc "int32 [MkBufferC::Cmp $buf1 buf2:MkBufferC] (const)"
#define GetType1_doc "string[1] [MkBufferC::GetType1 $buf] (const)"
#define GetType2_doc "MkTypeE [MkBufferC::GetType2 $buf] (const)"
#define GetType3_doc "string [MkBufferC::GetType3 $buf] (const)"
// skip class-overload: HandleGet → MkObjectHandleGet
#define IsLocal_doc "bool [MkBufferC::IsLocal $buf] (const)"
// skip class-overload: Log → MkObjectLog
#define LogS_doc "MkBufferC::LogS $buf ?varname:string=\"buf\"? ?fmtobj:MkObjectC=NULL? ?callfunc:string=\"MK_NULL\"? (const)"
#define Pop_doc "int32 [MkBufferC::Pop $buf val:string]"
#define Push_doc "int32 [MkBufferC::Push $buf val:string]"
#define ResetFull_doc "MkBufferC::ResetFull $buf"
// skip class-overload: ToString → MkObjectToString
 
// doc-key: MkBufferC,MkBuffer,omo,func
#define GetBIN_doc "binary [MkBufferC::GetBIN $buf] (const)"
#define GetBOL_doc "bool [MkBufferC::GetBOL $buf] (const)"
#define GetDBL_doc "double [MkBufferC::GetDBL $buf] (const)"
#define GetFLT_doc "float [MkBufferC::GetFLT $buf] (const)"
#define GetI16_doc "int16 [MkBufferC::GetI16 $buf] (const)"
#define GetI32_doc "int32 [MkBufferC::GetI32 $buf] (const)"
#define GetI64_doc "int64 [MkBufferC::GetI64 $buf] (const)"
#define GetI8_doc "int8 [MkBufferC::GetI8 $buf] (const)"
#define GetSTR_doc "string [MkBufferC::GetSTR $buf] (const)"
#define GetStringR_doc "string [MkBufferC::GetStringR $buf] (const)"
#define ToObject_doc "obj [MkBufferC::ToObject $buf]"
 
// END-DOC - created by 'atl_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 'atl_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_ATL_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_ATL_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_ATL_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_ATL_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_ATL_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_ATL_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_ATL_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_ATL_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_ATL_API
 
// END-MkBufferC - created by 'atl_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
static const OtObjProcDefS NS(sOtClassDef)[] = {
 
  // BEGIN-CLASS - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // doc-key: MkBufferC,MkBuffer,sCc
  { "::MkBufferC::Create"        , NS(MkBufferC_Create)        },
  { "::MkBufferC::Create1024"    , NS(MkBufferC_Create1024)    },
  { "::MkBufferC::Create256"     , NS(MkBufferC_Create256)     },
  { "::MkBufferC::Create64"      , NS(MkBufferC_Create64)      },
  { "::MkBufferC::CreateBIN"     , NS(MkBufferC_CreateBIN)     },
  { "::MkBufferC::CreateBOL"     , NS(MkBufferC_CreateBOL)     },
  { "::MkBufferC::CreateBUF"     , NS(MkBufferC_CreateBUF)     },
  { "::MkBufferC::CreateDBL"     , NS(MkBufferC_CreateDBL)     },
  { "::MkBufferC::CreateFLT"     , NS(MkBufferC_CreateFLT)     },
  { "::MkBufferC::CreateI16"     , NS(MkBufferC_CreateI16)     },
  { "::MkBufferC::CreateI32"     , NS(MkBufferC_CreateI32)     },
  { "::MkBufferC::CreateI64"     , NS(MkBufferC_CreateI64)     },
  { "::MkBufferC::CreateI8"      , NS(MkBufferC_CreateI8)      },
  { "::MkBufferC::CreateSTR"     , NS(MkBufferC_CreateSTR)     },
 
  // doc-key: MkBufferC,MkBuffer,sc_
  { "::MkBufferC::CreateTLS"     , NS(MkBufferC_CreateTLS)     },
  { "::MkBufferC::GetNull"       , NS(MkBufferC_GetNull)       },
  { "::MkBufferC::HandleResolve" , NS(MkBufferC_HandleResolve) },
  { "::MkBufferC::Instances"     , NS(MkBufferC_Instances)     },
 
  // END-CLASS - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
  { NULL }
};
 
// ---------------------------------------------------------------------------------------
 
static const OtObjProcDefS NS(sInstanceDef)[] = {
 
  // BEGIN-OBJ - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // doc-key: MkBufferC,MkBuffer,oC_
  { "::MkBufferC::MkBufferC"     , NS(MkBufferC_CTOR)          },
  { "::MkBufferC::Merge"         , NS(MkBufferC_Merge)         },
 
  // doc-key: MkBufferC,MkBuffer,oCx
  { "::MkBufferC::Dup"           , NS(MkBufferC_Dup)           },
 
  // doc-key: MkBufferC,MkBuffer,oc_
  { "::MkBufferC::AppendC"       , NS(MkBufferC_AppendC)       },
  { "::MkBufferC::AppendStringR" , NS(MkBufferC_AppendStringR) },
  { "::MkBufferC::Copy"          , NS(MkBufferC_Copy)          },
  { "::MkBufferC::Next"          , NS(MkBufferC_Next)          },
  { "::MkBufferC::Prev"          , NS(MkBufferC_Prev)          },
  { "::MkBufferC::Reset"         , NS(MkBufferC_Reset)         },
  { "::MkBufferC::SetBIN"        , NS(MkBufferC_SetBIN)        },
  { "::MkBufferC::SetBOL"        , NS(MkBufferC_SetBOL)        },
  { "::MkBufferC::SetBUF"        , NS(MkBufferC_SetBUF)        },
  { "::MkBufferC::SetBinaryR"    , NS(MkBufferC_SetBinaryR)    },
  { "::MkBufferC::SetDBL"        , NS(MkBufferC_SetDBL)        },
  { "::MkBufferC::SetFLT"        , NS(MkBufferC_SetFLT)        },
  { "::MkBufferC::SetI16"        , NS(MkBufferC_SetI16)        },
  { "::MkBufferC::SetI32"        , NS(MkBufferC_SetI32)        },
  { "::MkBufferC::SetI64"        , NS(MkBufferC_SetI64)        },
  { "::MkBufferC::SetI8"         , NS(MkBufferC_SetI8)         },
  { "::MkBufferC::SetSTR"        , NS(MkBufferC_SetSTR)        },
  { "::MkBufferC::SetStringR"    , NS(MkBufferC_SetStringR)    },
  { "::MkBufferC::SizeAdd"       , NS(MkBufferC_SizeAdd)       },
  { "::MkBufferC::SizeNew"       , NS(MkBufferC_SizeNew)       },
  { "::MkBufferC::Temp"          , NS(MkBufferC_Temp)          },
 
  // doc-key: MkBufferC,MkBuffer,oci
  { "::MkBufferC::GetBFL"        , NS(MkBufferC_GetBFL)        },
 
  // doc-key: MkBufferC,MkBuffer,oco
  { "::MkBufferC::GetBUF"        , NS(MkBufferC_GetBUF)        },
 
  // doc-key: MkBufferC,MkBuffer,om_
  { "::MkBufferC::CastTo"        , NS(MkBufferC_CastTo)        },
  { "::MkBufferC::Cmp"           , NS(MkBufferC_Cmp)           },
  { "::MkBufferC::GetType1"      , NS(MkBufferC_GetType1)      },
  { "::MkBufferC::GetType2"      , NS(MkBufferC_GetType2)      },
  { "::MkBufferC::GetType3"      , NS(MkBufferC_GetType3)      },
  // skip class-overload: HandleGet → MkObjectHandleGet
  { "::MkBufferC::IsLocal"       , NS(MkBufferC_IsLocal)       },
  // skip class-overload: Log → MkObjectLog
  { "::MkBufferC::LogS"          , NS(MkBufferC_LogS)          },
  { "::MkBufferC::Pop"           , NS(MkBufferC_Pop)           },
  { "::MkBufferC::Push"          , NS(MkBufferC_Push)          },
  { "::MkBufferC::ResetFull"     , NS(MkBufferC_ResetFull)     },
  // skip class-overload: ToString → MkObjectToString
 
  // doc-key: MkBufferC,MkBuffer,omo
  { "::MkBufferC::GetBIN"        , NS(MkBufferC_GetBIN)        },
  { "::MkBufferC::GetBOL"        , NS(MkBufferC_GetBOL)        },
  { "::MkBufferC::GetDBL"        , NS(MkBufferC_GetDBL)        },
  { "::MkBufferC::GetFLT"        , NS(MkBufferC_GetFLT)        },
  { "::MkBufferC::GetI16"        , NS(MkBufferC_GetI16)        },
  { "::MkBufferC::GetI32"        , NS(MkBufferC_GetI32)        },
  { "::MkBufferC::GetI64"        , NS(MkBufferC_GetI64)        },
  { "::MkBufferC::GetI8"         , NS(MkBufferC_GetI8)         },
  { "::MkBufferC::GetSTR"        , NS(MkBufferC_GetSTR)        },
  { "::MkBufferC::GetStringR"    , NS(MkBufferC_GetStringR)    },
  { "::MkBufferC::ToObject"      , NS(MkBufferC_ToObject)      },
 
  // END-OBJ - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
  { NULL }
};
 
 
int NS(pMkBufferC_Init) ( OT_MK_ARGS 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;
}