MkBufferListC_rb.c

Go to the documentation of this file.

 
/* LABEL-START */
#define META_FILE_NAME "MkBufferListC_rb.c"
 
#include  "LibMkKernel_private_rb.h"
 
#define OT_CLASS            NS(MkBufferListC)
#define OT_CLASS_NAME       "MkBufferListC"
 
#define OT_LNG2META(O)      MkBfl(VAL2MNG(O))
 
OT_CLS_T OT_CLASS;
 
// new Class type object
static MK_TYP MkBufferListCTT = NULL;
OT_OBJ_T MK(MkBufferListC_MK_NULL) = 0;
 
// GS marker in "Data_Wrap_Struct"
static void  NS(sMark)    (MK_PTR);
 
// ruby datatype of the wrapped struct
static rb_data_type_t NS(MkBufferListC_T) = {
  "MkBufferListC",
  {
    NS(sMark),
    MK(AtomDeleteSoft),
    0, /* dsize */
    0, /* reserved[1] */
  },
  NULL, /* parent */
  NULL, /* data */
  RUBY_TYPED_FREE_IMMEDIATELY
};
 
// >>THIS<< is a Phase-1-CONSTRUCTOR: a constructor which create the SELF object
// A Phase-2-CONSTRUCTOR is a constructor which configure an already existing object
// DO: create a new SELF and link this SELF with the MQ-Object "mng"
// clazz is the toplevel "subclass" or "MkBufferListC"
mk_inline OT_OBJ_T NS(LNG_CONSTR) (OT_CLS_T clazz, MK_MNG mng, int objc, VALUE* objv) {
  return MK(AtomObjCrt)(clazz,&NS(MkBufferListC_T),mng,objc,objv);
}
// MQ: ObjNew feature: called to return a new or an already existing RUBY-SELF-Object
// -> moved to: msgque_rb.h
// OT_OBJ_T NS(MkBufferListC_ObjNew) (MK_BFL hdl) {
//   return MK(AtomObjNew) (MkBufferListC_X2obj(hdl));
// }
// MQ: ObjNew feature: selfCreate will be called from "ObjNew->MkSelfNew" if MkObj need a SELF pointer
static MK_PTR NS(MkBufferListC_selfCreate) (MK_RT_ARGS MK_OBJ obj, MK_PTR envP) {
  OT_OBJ_T self = NS(LNG_CONSTR) (OT_CLASS, obj, 0, NULL);
  return VAL2PTR(self);
}
// MQ: called on instance-destruction for a "selfCreate" instance → goal: destroy the SELF
static void NS(MkBufferListC_selfDelete) (MK_RT_ARGS MK_PTR ptr, MK_PTR envP) {
  OT_OBJECT_DELETE_HARD(PTR2VAL(ptr));
}
// MQ: called to destroy link from SELF to META
static void NS(MkBufferListC_selfUnlink) (MK_RT_ARGS MK_PTR ptr, MK_PTR envP) {
  OT_OBJ_T self =  PTR2VAL(ptr);
  RDATA(self)->data = NULL;
}
// initialize the RUBY and MO class specific object
#define S_INIT NS(sInit)(MK_RT_CALL_ONLY)
static void NS(sInit)(MK_RT_ARGS_ONLY) {
 
  // add "selfCreate" and "selfDelete" feature to the MQ-MkBufferListC-Type
  MkBufferListCTT->selfCreate    = NS(MkBufferListC_selfCreate);
  MkBufferListCTT->selfDelete    = NS(MkBufferListC_selfDelete);
  MkBufferListCTT->selfUnlink    = NS(MkBufferListC_selfUnlink);
 
  // create the RUBY class
  OT_CLASS = rb_define_class_under(OT_PKG, "MkBufferListC", MK_BASE_CLASS);
  rb_undef_alloc_func(OT_CLASS);
 
  /* define the "NULL" object */
  VALUE nullO = TypedData_Wrap_Struct (OT_CLASS, &NS(MkBufferListC_T), MK_NULL);
  NS(MkBufferListC_MK_NULL) = nullO;
  INCR_REF(&NS(MkBufferListC_MK_NULL));
}
 
#define OT_SETUP_hdl                OT_SETUP_hdl_tmpl(MkBufferListC);
#define OT_SETUP_hdl__null_allow    OT_SETUP_hdl_tmpl__null_allow(MkBufferListC);
#define OT_SETUP_hdl_constr         AllRtSetup_NULL; \
                                    OT_OBJ_T clazz = self; \
                                    MkBufferListC_type hdl = (MkBufferListC_type) &MkERROR;
#define OT_SETUP_hdl_destr          OT_SETUP_hdl_tmpl__null_allow(MkBufferListC);
#define OT_SETUP_hdl_static         AllRtSetup_NULL; \
                                    __attribute__((unused)) MK_TYP hdl = MkBufferListC##_TT;
#define OT_SETUP_hdl_static_constr  OT_SETUP_hdl_static
 
#if !defined(SetupRtFromObj_X)
  #define SetupRtFromObj_X(hdl)     AllRtSetup_X(hdl)
  #define SetupRtFromObj_XN(hdl)    AllRtSetup_XN(hdl)
#endif
 
/* LABEL-END */
 
// BEGIN-DOC - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// doc-key: MkBufferListC,MkBufferList,sCc,func
#define Create_doc "MkBufferListC MkBufferListC.Create(?size:int32=0?)"
#define CreateLA_doc "MkBufferListC MkBufferListC.CreateLA(args:MkBufferListC...)"
#define FileGlob_doc "MkBufferListC MkBufferListC.FileGlob(pattern_match:string)"
#define new_doc "MkBufferListC MkBufferListC.new(?size:int32=0?)"
 
// doc-key: MkBufferListC,MkBufferList,sc_,func
#define CreateTLS_doc "MkBufferListC MkBufferListC.CreateTLS(tlsName:string, ?resetB:bool=true?)"
#define GetNull_doc "MkBufferListC MkBufferListC.GetNull()"
#define HandleResolve_doc "MkBufferListC MkBufferListC.HandleResolve(netHdl:MK_HDL)"
#define Instances_doc "MkBufferListC MkBufferListC.Instances()"
 
// doc-key: MkBufferListC,MkBufferList,oC_,func
#define Merge_doc "MkBufferListC bfl.Merge()"
 
// doc-key: MkBufferListC,MkBufferList,oCx,func
#define Dup_doc "MkBufferListC bfl.Dup() (const)"
 
// doc-key: MkBufferListC,MkBufferList,oc_,func
#define AppendLA_doc "MkBufferListC bfl.AppendLA(args:MkBufferListC...)"
#define AppendLP_doc "MkBufferListC bfl.AppendLP(addBufL:MkBufferListC, ?position:int32=-1?)"
#define IndexGetBUF_doc "MkBufferC bfl.IndexGetBUF(index:int32)"
#define Next_doc "MkBufferListC bfl.Next()"
#define PositionMerge_doc "MkBufferListC bfl.PositionMerge(source:MkBufferListC, position:int32)"
#define Prev_doc "MkBufferListC bfl.Prev()"
#define Reset_doc "MkBufferListC bfl.Reset()"
#define Sort_doc "MkBufferListC bfl.Sort()"
#define ToBuffer_doc "MkBufferC bfl.ToBuffer() (const)"
 
// doc-key: MkBufferListC,MkBufferList,oco,func
#define CheckOptionBUF_doc "MkBufferC bfl.CheckOptionBUF(opt:string, ?defval:MkBufferC=nil?, ?onlyFirst:bool=true?)"
#define IndexExtract_doc "MkBufferC bfl.IndexExtract(?index:int32=0?)"
#define IndexGet_doc "MkBufferC bfl.IndexGet(index:int32) (const)"
 
// doc-key: MkBufferListC,MkBufferList,om_,func
#define AppendBIN_doc "bfl.AppendBIN(val:binary)"
#define AppendBOL_doc "bfl.AppendBOL(val:bool)"
#define AppendBUF_doc "bfl.AppendBUF(val:MkBufferC)"
#define AppendDBL_doc "bfl.AppendDBL(val:double)"
#define AppendFLT_doc "bfl.AppendFLT(val:float)"
#define AppendG_doc "bfl.AppendG(val:long)"
#define AppendI16_doc "bfl.AppendI16(val:int16)"
#define AppendI32_doc "bfl.AppendI32(val:int32)"
#define AppendI64_doc "bfl.AppendI64(val:int64)"
#define AppendI8_doc "bfl.AppendI8(val:int8)"
#define AppendSTR_doc "bfl.AppendSTR(val:string)"
#define AppendStringR_doc "bfl.AppendStringR(val:string)"
#define AppendUP_doc "bfl.AppendUP(addBuf:MkBufferC, ?position:int32=-1?)"
#define CheckOption_doc "bool bfl.CheckOption(opt:string, ?onlyFirst:bool=false?)"
#define Cmp_doc "int32 bfl.Cmp(bfl2:MkBufferListC) (const)"
#define Copy_doc "bfl.Copy(src:MkBufferListC) (const)"
// skip class-overload: HandleGet → MkObjectHandleGet
#define IndexDelete_doc "bfl.IndexDelete(index:int32, ?numitems:int32=1?, ?doDelete:bool=true?)"
#define IndexGetSTR_doc "string bfl.IndexGetSTR(index:int32)"
#define IndexSet_doc "bfl.IndexSet(index:int32, buf:MkBufferC)"
#define IndexSetBUF_doc "bfl.IndexSetBUF(index:int32, buf:MkBufferC)"
#define IndexSetSTR_doc "bfl.IndexSetSTR(index:int32, str:string)"
// skip class-overload: Log → MkObjectLog
#define LogS_doc "bfl.LogS(?varname:string=\"bfl\"?, ?fmtobj:MkObjectC=nil?, ?callfunc:string=\"MK_NULL\"?) (const)"
#define LogSS_doc "bfl.LogSS(?varname:string=\"bfl\"?, ?fmtobj:MkObjectC=nil?, ?callfunc:string=\"MK_NULL\"?) (const)"
#define LogSSS_doc "bfl.LogSSS(?varname:string=\"bfl\"?, ?fmtobj:MkObjectC=nil?, ?callfunc:string=\"MK_NULL\"?) (const)"
#define Move_doc "to.Move(from:MkBufferListC)"
#define Reserve_doc "bfl.Reserve(num:int32)"
#define SearchC_doc "int32 bfl.SearchC(str:string, ?len:int32=-1?, ?startindex:int32=0?) (const)"
#define Size_doc "int32 bfl.Size() (const)"
#define ToList_doc "[list...] bfl.ToList() (const)"
// skip class-overload: ToString → MkObjectToString
 
// doc-key: MkBufferListC,MkBufferList,omo,func
#define CheckOptionBOL_doc "bool bfl.CheckOptionBOL(opt:string, ?defval:bool=false?, ?onlyFirst:bool=true?)"
#define CheckOptionDBL_doc "double bfl.CheckOptionDBL(opt:string, ?defval:double=0?, ?onlyFirst:bool=true?)"
#define CheckOptionFLT_doc "float bfl.CheckOptionFLT(opt:string, ?defval:float=0?, ?onlyFirst:bool=true?)"
#define CheckOptionI16_doc "int16 bfl.CheckOptionI16(opt:string, ?defval:int16=0?, ?onlyFirst:bool=true?)"
#define CheckOptionI32_doc "int32 bfl.CheckOptionI32(opt:string, ?defval:int32=0?, ?onlyFirst:bool=true?)"
#define CheckOptionI64_doc "int64 bfl.CheckOptionI64(opt:string, ?defval:int64=0?, ?onlyFirst:bool=true?)"
#define CheckOptionI8_doc "int8 bfl.CheckOptionI8(opt:string, ?defval:int8=0?, ?onlyFirst:bool=true?)"
#define CheckOptionSTR_doc "string bfl.CheckOptionSTR(opt:string, ?defval:string=\"\"?, ?onlyFirst:bool=true?)"
 
// END-DOC - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// ---------------------------------------------------------------------------------------
 
 
OT_ProcRet MK(MkBufferListC_ToList) (MkBufferListC_ARGS);
#include "tmpl/MkBufferListC_ToList_lng.h"
 
// BEGIN-MkBufferListC - created by 'rb_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// doc-key: MkBufferListC,MkBufferListC-Append,oc_
 
static OT_ProcRet NS(MkBufferListC_AppendLA) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,99,AppendLA_doc);
  MkBufferListCreateTLS_T(args,10);
  OT_CHECK_REQUIRED(OT_CHECK_BAC (args))
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListAppendLA (hdl, args);
  OT_retObj_SET_BFL(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendLP) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,2,AppendLP_doc);
  MkBufferListCreateTLS_T(addBufL,10);
  OT_CHECK_REQUIRED(OT_CHECK_BFL (addBufL,MK_NULL_NO))
  MK_NUM position = -1;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (position))
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListAppendLP (hdl, addBufL, position);
  OT_retObj_SET_BFL(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-Append,om_
 
static OT_ProcRet NS(MkBufferListC_AppendBIN) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendBIN_doc);
  MkBinaryR val = {0};
  OT_CHECK_REQUIRED(OT_CHECK__ME_REF_MkBinaryR(val))
  OT_CHECK_NOARGS;
  MkBufferListAppendBIN (hdl, val);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendBOL) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendBOL_doc);
  MK_BOL val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NB1 (val))
  OT_CHECK_NOARGS;
  MkBufferListAppendBOL (hdl, (MK_BOL)(val?1:0));
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendBUF) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendBUF_doc);
  MK_BUF val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_BUF (val,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkBufferListAppendBUF (hdl, val);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendDBL) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendDBL_doc);
  MK_DBL val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NF8 (val))
  OT_CHECK_NOARGS;
  MkBufferListAppendDBL (hdl, val);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendFLT) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendFLT_doc);
  MK_FLT val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NF4 (val))
  OT_CHECK_NOARGS;
  MkBufferListAppendFLT (hdl, val);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendG) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendG_doc);
  MK_LONG val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NIL (val))
  OT_CHECK_NOARGS;
  MkBufferListAppendG (hdl, val);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendI16) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendI16_doc);
  MK_I16 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI2 (val))
  OT_CHECK_NOARGS;
  MkBufferListAppendI16 (hdl, val);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendI32) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendI32_doc);
  MK_I32 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (val))
  OT_CHECK_NOARGS;
  MkBufferListAppendI32 (hdl, val);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendI64) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendI64_doc);
  MK_I64 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI8 (val))
  OT_CHECK_NOARGS;
  MkBufferListAppendI64 (hdl, val);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendI8) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendI8_doc);
  MK_I8 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI1 (val))
  OT_CHECK_NOARGS;
  MkBufferListAppendI8 (hdl, (MK_I8)(val));
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendSTR) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendSTR_doc);
  MK_STRN val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (val))
  OT_CHECK_NOARGS;
  MkBufferListAppendSTR (hdl, val);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendStringR) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendStringR_doc);
  MkStringR val = {0};
  OT_CHECK_REQUIRED(OT_CHECK__ME_REF_MkStringR(val))
  OT_CHECK_NOARGS;
  MkBufferListAppendStringR (hdl, val);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendUP) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,2,AppendUP_doc);
  MK_BUF addBuf = 0;
  OT_CHECK_REQUIRED(OT_CHECK_BUF (addBuf,MK_NULL_NO))
  MK_NUM position = -1;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (position))
  OT_CHECK_NOARGS;
  MkBufferListAppendUP (hdl, addBuf, position);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// MkBufferListC_Append_RB_API
 
 
// doc-key: MkBufferListC,MkBufferListC-Check,oco
 
static OT_ProcRet NS(MkBufferListC_CheckOptionBUF) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,CheckOptionBUF_doc);
  MK_STRN opt = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (opt))
  MK_BUF defval = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_BUF (defval,MK_NULL_YES))
  MK_BOOL onlyFirst = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (onlyFirst))
  OT_CHECK_NOARGS;
  MK_BUF val_out;
  MkErrorC_Check(hdl,MkBufferListCheckOptionBUF (hdl, opt, defval, onlyFirst, &val_out));
  OT_retObj_SET_BUF(val_out);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-Check,om_
 
static OT_ProcRet NS(MkBufferListC_CheckOption) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,2,CheckOption_doc);
  MK_STRN opt = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (opt))
  MK_BOOL onlyFirst = false;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (onlyFirst))
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MkBufferListCheckOption (hdl, opt, onlyFirst));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-Check,omo
 
static OT_ProcRet NS(MkBufferListC_CheckOptionBOL) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,CheckOptionBOL_doc);
  MK_STRN opt = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (opt))
  MK_BOOL defval = false;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (defval))
  MK_BOOL onlyFirst = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (onlyFirst))
  OT_CHECK_NOARGS;
  MK_BOOL val_out;
  MkErrorC_Check(hdl,MkBufferListCheckOptionBOL (hdl, opt, defval, onlyFirst, &val_out));
  OT_retObj_SET_BOL(val_out);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_CheckOptionDBL) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,CheckOptionDBL_doc);
  MK_STRN opt = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (opt))
  MK_DBL defval = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NF8 (defval))
  MK_BOOL onlyFirst = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (onlyFirst))
  OT_CHECK_NOARGS;
  MK_DBL val_out;
  MkErrorC_Check(hdl,MkBufferListCheckOptionDBL (hdl, opt, defval, onlyFirst, &val_out));
  OT_retObj_SET_DBL(val_out);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_CheckOptionFLT) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,CheckOptionFLT_doc);
  MK_STRN opt = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (opt))
  MK_FLT defval = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NF4 (defval))
  MK_BOOL onlyFirst = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (onlyFirst))
  OT_CHECK_NOARGS;
  MK_FLT val_out;
  MkErrorC_Check(hdl,MkBufferListCheckOptionFLT (hdl, opt, defval, onlyFirst, &val_out));
  OT_retObj_SET_FLT(val_out);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_CheckOptionI16) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,CheckOptionI16_doc);
  MK_STRN opt = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (opt))
  MK_I16 defval = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI2 (defval))
  MK_BOOL onlyFirst = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (onlyFirst))
  OT_CHECK_NOARGS;
  MK_I16 val_out;
  MkErrorC_Check(hdl,MkBufferListCheckOptionI16 (hdl, opt, defval, onlyFirst, &val_out));
  OT_retObj_SET_I16(val_out);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_CheckOptionI32) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,CheckOptionI32_doc);
  MK_STRN opt = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (opt))
  MK_I32 defval = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (defval))
  MK_BOOL onlyFirst = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (onlyFirst))
  OT_CHECK_NOARGS;
  MK_I32 val_out;
  MkErrorC_Check(hdl,MkBufferListCheckOptionI32 (hdl, opt, defval, onlyFirst, &val_out));
  OT_retObj_SET_I32(val_out);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_CheckOptionI64) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,CheckOptionI64_doc);
  MK_STRN opt = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (opt))
  MK_I64 defval = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI8 (defval))
  MK_BOOL onlyFirst = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (onlyFirst))
  OT_CHECK_NOARGS;
  MK_I64 val_out;
  MkErrorC_Check(hdl,MkBufferListCheckOptionI64 (hdl, opt, defval, onlyFirst, &val_out));
  OT_retObj_SET_I64(val_out);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_CheckOptionI8) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,CheckOptionI8_doc);
  MK_STRN opt = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (opt))
  MK_I8 defval = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI1 (defval))
  MK_BOOL onlyFirst = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (onlyFirst))
  OT_CHECK_NOARGS;
  MK_I8 val_out;
  MkErrorC_Check(hdl,MkBufferListCheckOptionI8 (hdl, opt, (MK_I8)(defval), onlyFirst, &val_out));
  OT_retObj_SET_I8(val_out);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_CheckOptionSTR) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,CheckOptionSTR_doc);
  MK_STRN opt = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (opt))
  MK_STRN defval = "";
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (defval))
  MK_BOOL onlyFirst = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (onlyFirst))
  OT_CHECK_NOARGS;
  MK_STRN val_out;
  MkErrorC_Check(hdl,MkBufferListCheckOptionSTR (hdl, opt, defval, onlyFirst, &val_out));
  OT_retObj_SET_STR(val_out);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// MkBufferListC_Check_RB_API
 
 
// doc-key: MkBufferListC,MkBufferListC-Class-Export,sc_
 
static OT_ProcRet NS(MkBufferListC_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_BFL retVal = MkBufferListHandleResolve (netHdl);
  OT_retObj_SET_BFL(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-Class-Export,om_
 
// skip on class-overload: MkBufferListHandleGet → MkObjectHandleGet
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MkBufferListC_HandleGet) (MkBufferListC_ARGS) {OT_ERROR_LNG_RETURN;}
 
// MkBufferListC_Class_RB_API
 
 
// doc-key: MkBufferListC,MkBufferListC-Class-Introspection,oc_
 
static OT_ProcRet NS(MkBufferListC_Next) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Next_doc);
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListNext (hdl);
  OT_retObj_SET_BFL(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_Prev) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Prev_doc);
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListPrev (hdl);
  OT_retObj_SET_BFL(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-Class-Introspection,sc_
 
static OT_ProcRet NS(MkBufferListC_Instances) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Instances_doc);
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListInstances ();
  OT_retObj_SET_BFL(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// MkBufferListC_Class_RB_API
 
 
// doc-key: MkBufferListC,MkBufferListC-Class-Misc,sc_
 
static OT_ProcRet NS(MkBufferListC_GetNull) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(GetNull_doc);
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListGetNull ();
  OT_retObj_SET_BFL(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// MkBufferListC_Class_RB_API
 
 
// doc-key: MkBufferListC,MkBufferListC-Index,oc_
 
static OT_ProcRet NS(MkBufferListC_IndexGetBUF) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(IndexGetBUF_doc);
  MK_NUM index = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (index))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferListIndexGetBUF (hdl, index);
  OT_retObj_SET_BUF(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-Index,oco
 
static OT_ProcRet NS(MkBufferListC_IndexExtract) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,1,IndexExtract_doc);
  MK_NUM index = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (index))
  OT_CHECK_NOARGS;
  MK_BUF val_out;
  MkErrorC_Check(hdl,MkBufferListIndexExtract (hdl, index, &val_out));
  OT_retObj_SET_BUF(val_out);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_IndexGet) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(IndexGet_doc);
  MK_NUM index = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (index))
  OT_CHECK_NOARGS;
  MK_BUF val_out;
  MkErrorC_Check(hdl,MkBufferListIndexGet (hdl, index, &val_out));
  OT_retObj_SET_BUF(val_out);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-Index,om_
 
static OT_ProcRet NS(MkBufferListC_IndexDelete) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,IndexDelete_doc);
  MK_NUM index = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (index))
  MK_NUM numitems = 1;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (numitems))
  MK_BOOL doDelete = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (doDelete))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferListIndexDelete (hdl, index, numitems, doDelete));
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_IndexGetSTR) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(IndexGetSTR_doc);
  MK_NUM index = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (index))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MkBufferListIndexGetSTR (hdl, index));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_IndexSet) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,2,IndexSet_doc);
  MK_NUM index = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (index))
  MK_BUF buf = 0;
  OT_CHECK_REQUIRED(OT_CHECK_BUF (buf,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferListIndexSet (hdl, index, buf));
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_IndexSetBUF) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,2,IndexSetBUF_doc);
  MK_NUM index = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (index))
  MK_BUF buf = 0;
  OT_CHECK_REQUIRED(OT_CHECK_BUF (buf,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkBufferListIndexSetBUF (hdl, index, buf);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_IndexSetSTR) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,2,IndexSetSTR_doc);
  MK_NUM index = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (index))
  MK_STRN str = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (str))
  OT_CHECK_NOARGS;
  MkBufferListIndexSetSTR (hdl, index, str);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// MkBufferListC_Index_RB_API
 
 
// doc-key: MkBufferListC,MkBufferListC-Log,om_
 
// skip on class-overload: MkBufferListLog → MkObjectLog
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MkBufferListC_Log) (MkBufferListC_ARGS) {OT_ERROR_LNG_RETURN;}
 
static OT_ProcRet NS(MkBufferListC_LogS) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,3,LogS_doc);
  MK_STRN varname = "bfl";
  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;}
  MkBufferListLogS (hdl, varname, fmtobj, callfunc);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_LogSS) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,3,LogSS_doc);
  MK_STRN varname = "bfl";
  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;}
  MkBufferListLogSS (hdl, varname, fmtobj, callfunc);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_LogSSS) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,3,LogSSS_doc);
  MK_STRN varname = "bfl";
  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;}
  MkBufferListLogSSS (hdl, varname, fmtobj, callfunc);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
// MkBufferListC_Log_RB_API
 
 
// doc-key: MkBufferListC,MkBufferListC-Misc,sCc
 
static OT_ProcRet NS(MkBufferListC_FileGlob) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(FileGlob_doc);
  MK_STRN pattern_match = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (pattern_match))
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListFileGlob (pattern_match);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferListC);
  }
  OT_retObj_SET_BFL(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-Misc,oc_
 
static OT_ProcRet NS(MkBufferListC_PositionMerge) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,2,PositionMerge_doc);
  MkBufferListCreateTLS_T(source,10);
  OT_CHECK_REQUIRED(OT_CHECK_BFL (source,MK_NULL_NO))
  MK_NUM position = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (position))
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListPositionMerge (hdl, source, position);
  OT_retObj_SET_BFL(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_Reset) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Reset_doc);
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListReset (hdl);
  OT_retObj_SET_BFL(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_Sort) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Sort_doc);
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListSort (hdl);
  OT_retObj_SET_BFL(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_ToBuffer) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ToBuffer_doc);
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferListToBuffer (hdl);
  OT_retObj_SET_BUF(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-Misc,om_
 
static OT_ProcRet NS(MkBufferListC_Cmp) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(Cmp_doc);
  MkBufferListCreateTLS_T(bfl2,10);
  OT_CHECK_REQUIRED(OT_CHECK_BFLN (bfl2,MK_NULL_NO))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkBufferListCmp (hdl, bfl2));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_Copy) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(Copy_doc);
  MkBufferListCreateTLS_T(src,10);
  OT_CHECK_REQUIRED(OT_CHECK_BFLN (src,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkBufferListCopy (hdl, src);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_Move) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(Move_doc);
  MkBufferListCreateTLS_T(from,10);
  OT_CHECK_REQUIRED(OT_CHECK_BFL (from,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkBufferListMove (hdl, from);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_Reserve) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(Reserve_doc);
  MK_NUM num = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (num))
  OT_CHECK_NOARGS;
  MkBufferListReserve (hdl, num);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_SearchC) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,SearchC_doc);
  MK_STRN str = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (str))
  MK_NUM len = -1;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (len))
  MK_NUM startindex = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (startindex))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkBufferListSearchC (hdl, str, len, startindex));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_Size) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Size_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkBufferListSizeI (hdl));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
OT_ProcRet NS(MkBufferListC_ToList) (MkBufferListC_ARGS) ; // skip template-required
 
// skip on class-overload: MkBufferListToString → MkObjectToString
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MkBufferListC_ToString) (MkBufferListC_ARGS) {OT_ERROR_LNG_RETURN;}
 
// MkBufferListC_Misc_RB_API
 
 
// doc-key: MkBufferListC,MkBufferListC-TOR,oC_
 
static OT_ProcRet NS(MkBufferListC_Merge) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Merge_doc);
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListMerge (hdl);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferListC);
  }
  OT_retObj_SET_BFL(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-TOR,oCx
 
static OT_ProcRet NS(MkBufferListC_Dup) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Dup_doc);
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListDup (hdl);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferListC);
  }
  OT_retObj_SET_BFL(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-TOR,sCc
 
static OT_ProcRet NS(MkBufferListC_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_BFL retVal = MkBufferListCreate (size);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferListC);
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_SET_BFL(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_CreateLA) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_VARARGS(0,99,CreateLA_doc);
  MkBufferListCreateTLS_T(args,10);
  OT_CHECK_REQUIRED(OT_CHECK_BAC (args))
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListCreateLA (args);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferListC);
  }
  OT_retObj_SET_BFL(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_new) (CONSTR_ARGS) {
  OT_SETUP_hdl_constr;
  OT_SETUP_CONSTRUCTOR_ARGS(0,1,new_doc);
  MK_NUM size = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (size))
  MK_BFL retVal = MkBufferListCreate (size);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferListC);
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_CONSTR(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-TOR,sc_
 
static OT_ProcRet NS(MkBufferListC_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_BFL retVal = MkBufferListCreateTLS (tlsName, resetB);
  OT_retObj_SET_BFL(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// MkBufferListC_TOR_RB_API
 
// END-MkBufferListC - created by 'rb_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
/*****************************************************************************/
/*                                                                           */
/*                                public                                     */
/*                                                                           */
/*****************************************************************************/
 
static void NS(sMark) (MK_PTR mng)
{
  MK_BFL bfl = MkBfl(mng);
  if (bfl == NULL) return;
 
  MK_BUF *run = bfl->data;
  MK_BUF *end = bfl->data+bfl->cursize;
 
  for (;run<end;run++) {
    if ((*run) != NULL && MkOBJ_R(*run).self != NULL) {
      rb_gc_mark((VALUE)MkOBJ_R(*run).self);
    }
  }
}
 
void MK(MkBufferListC_Init) (MK_RT_ARGS_ONLY) {
 
  // init type
  MkBufferListCTT = MkBufferListC_TT;
  S_INIT;
 
  // make class note create-able
  //rb_funcall(MK(MkBufferListC), rb_intern("private_class_method"), 1, STRN2VAL("new"));
 
// BEGIN-CLASS - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// doc-key: MkBufferListC,MkBufferList,sCc
OT_METH_S ( MkBufferListC, Create,                    MkBufferListC_Create                )
OT_METH_S ( MkBufferListC, CreateLA,                  MkBufferListC_CreateLA              )
OT_METH_S ( MkBufferListC, FileGlob,                  MkBufferListC_FileGlob              )
OT_METH_C ( MkBufferListC, new,                       MkBufferListC_new                   )
 
// doc-key: MkBufferListC,MkBufferList,sc_
OT_METH_O ( MkBufferListC, CreateTLS,                 MkBufferListC_CreateTLS             )
OT_METH_S ( MkBufferListC, CreateTLS,                 MkBufferListC_CreateTLS             )
OT_METH_O ( MkBufferListC, GetNull,                   MkBufferListC_GetNull               )
OT_METH_S ( MkBufferListC, GetNull,                   MkBufferListC_GetNull               )
OT_METH_O ( MkBufferListC, HandleResolve,             MkBufferListC_HandleResolve         )
OT_METH_S ( MkBufferListC, HandleResolve,             MkBufferListC_HandleResolve         )
OT_METH_O ( MkBufferListC, Instances,                 MkBufferListC_Instances             )
OT_METH_S ( MkBufferListC, Instances,                 MkBufferListC_Instances             )
 
// END-CLASS - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// BEGIN-OBJ - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// doc-key: MkBufferListC,MkBufferList,oC_
OT_METH_O ( MkBufferListC, Merge,                     MkBufferListC_Merge                 )
 
// doc-key: MkBufferListC,MkBufferList,oCx
OT_METH_O ( MkBufferListC, Dup,                       MkBufferListC_Dup                   )
 
// doc-key: MkBufferListC,MkBufferList,oc_
OT_METH_O ( MkBufferListC, AppendLA,                  MkBufferListC_AppendLA              )
OT_METH_O ( MkBufferListC, AppendLP,                  MkBufferListC_AppendLP              )
OT_METH_O ( MkBufferListC, IndexGetBUF,               MkBufferListC_IndexGetBUF           )
OT_METH_O ( MkBufferListC, Next,                      MkBufferListC_Next                  )
OT_METH_O ( MkBufferListC, PositionMerge,             MkBufferListC_PositionMerge         )
OT_METH_O ( MkBufferListC, Prev,                      MkBufferListC_Prev                  )
OT_METH_O ( MkBufferListC, Reset,                     MkBufferListC_Reset                 )
OT_METH_O ( MkBufferListC, Sort,                      MkBufferListC_Sort                  )
OT_METH_O ( MkBufferListC, ToBuffer,                  MkBufferListC_ToBuffer              )
 
// doc-key: MkBufferListC,MkBufferList,oco
OT_METH_O ( MkBufferListC, CheckOptionBUF,            MkBufferListC_CheckOptionBUF        )
OT_METH_O ( MkBufferListC, IndexExtract,              MkBufferListC_IndexExtract          )
OT_METH_O ( MkBufferListC, IndexGet,                  MkBufferListC_IndexGet              )
 
// doc-key: MkBufferListC,MkBufferList,om_
OT_METH_O ( MkBufferListC, AppendBIN,                 MkBufferListC_AppendBIN             )
OT_METH_O ( MkBufferListC, AppendBOL,                 MkBufferListC_AppendBOL             )
OT_METH_O ( MkBufferListC, AppendBUF,                 MkBufferListC_AppendBUF             )
OT_METH_O ( MkBufferListC, AppendDBL,                 MkBufferListC_AppendDBL             )
OT_METH_O ( MkBufferListC, AppendFLT,                 MkBufferListC_AppendFLT             )
OT_METH_O ( MkBufferListC, AppendG,                   MkBufferListC_AppendG               )
OT_METH_O ( MkBufferListC, AppendI16,                 MkBufferListC_AppendI16             )
OT_METH_O ( MkBufferListC, AppendI32,                 MkBufferListC_AppendI32             )
OT_METH_O ( MkBufferListC, AppendI64,                 MkBufferListC_AppendI64             )
OT_METH_O ( MkBufferListC, AppendI8,                  MkBufferListC_AppendI8              )
OT_METH_O ( MkBufferListC, AppendSTR,                 MkBufferListC_AppendSTR             )
OT_METH_O ( MkBufferListC, AppendStringR,             MkBufferListC_AppendStringR         )
OT_METH_O ( MkBufferListC, AppendUP,                  MkBufferListC_AppendUP              )
OT_METH_O ( MkBufferListC, CheckOption,               MkBufferListC_CheckOption           )
OT_METH_O ( MkBufferListC, Cmp,                       MkBufferListC_Cmp                   )
OT_METH_O ( MkBufferListC, Copy,                      MkBufferListC_Copy                  )
// skip class-overload: MkBufferListHandleGet → HandleGet, MkBufferListC_HandleGet
OT_METH_O ( MkBufferListC, IndexDelete,               MkBufferListC_IndexDelete           )
OT_METH_O ( MkBufferListC, IndexGetSTR,               MkBufferListC_IndexGetSTR           )
OT_METH_O ( MkBufferListC, IndexSet,                  MkBufferListC_IndexSet              )
OT_METH_O ( MkBufferListC, IndexSetBUF,               MkBufferListC_IndexSetBUF           )
OT_METH_O ( MkBufferListC, IndexSetSTR,               MkBufferListC_IndexSetSTR           )
// skip class-overload: MkBufferListLog → Log, MkBufferListC_Log
OT_METH_O ( MkBufferListC, LogS,                      MkBufferListC_LogS                  )
OT_METH_O ( MkBufferListC, LogSS,                     MkBufferListC_LogSS                 )
OT_METH_O ( MkBufferListC, LogSSS,                    MkBufferListC_LogSSS                )
OT_METH_O ( MkBufferListC, Move,                      MkBufferListC_Move                  )
OT_METH_O ( MkBufferListC, Reserve,                   MkBufferListC_Reserve               )
OT_METH_O ( MkBufferListC, SearchC,                   MkBufferListC_SearchC               )
OT_METH_O ( MkBufferListC, Size,                      MkBufferListC_Size                  )
OT_METH_O ( MkBufferListC, ToList,                    MkBufferListC_ToList                )
// skip class-overload: MkBufferListToString → ToString, MkBufferListC_ToString
 
// doc-key: MkBufferListC,MkBufferList,omo
OT_METH_O ( MkBufferListC, CheckOptionBOL,            MkBufferListC_CheckOptionBOL        )
OT_METH_O ( MkBufferListC, CheckOptionDBL,            MkBufferListC_CheckOptionDBL        )
OT_METH_O ( MkBufferListC, CheckOptionFLT,            MkBufferListC_CheckOptionFLT        )
OT_METH_O ( MkBufferListC, CheckOptionI16,            MkBufferListC_CheckOptionI16        )
OT_METH_O ( MkBufferListC, CheckOptionI32,            MkBufferListC_CheckOptionI32        )
OT_METH_O ( MkBufferListC, CheckOptionI64,            MkBufferListC_CheckOptionI64        )
OT_METH_O ( MkBufferListC, CheckOptionI8,             MkBufferListC_CheckOptionI8         )
OT_METH_O ( MkBufferListC, CheckOptionSTR,            MkBufferListC_CheckOptionSTR        )
 
// END-OBJ - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
}