MkBufferListC_def_mk.h

Go to the documentation of this file.

 
/* LABEL-START */
// empty
/* LABEL-END */
 
#pragma once
 
#include "LibMkKernel_mk.h"
 
BEGIN_MK_C_DECLS
 
// BEGIN-Class-Doc-Order - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// external
 
// END-Class-Doc-Order - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// MARK_C ==================================================================
 
 
struct MkBufferListS {
  // BEGIN-MkBufferListS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
  } super;
 
  // END-MkBufferListS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
  // instance attributes
  MK_NUM size;            
  MK_NUM cursize;         
  MK_NUM allocsize;       
  MK_BUF * data;          
#define MkBufferListS_bls_size 32        
  MK_BUF bls[MkBufferListS_bls_size] ;   
};
 
// MARK_D ==================================================================
// BEGIN-MkBufferListS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkBufferListC_SIGNATURE        (MkObjectC_SIGNATURE ^ (2u<<10))
  #define MkBufferListC_MASK             (((1u<<22)-1)<<10)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkBufferListC_X2bfl(x)         (x)
  #define MkBufferListC_X2obj(x)         MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkBufferListS MkBufferListCR;
  __parser__(ignore) typedef const struct MkBufferListS MkBufferListCNR;
  #define MkBufferListC_T                (&MK_RT_REF._MkBufferListC_T)
  #define MkBufferListC_TT               (MkTYP(MkBufferListC_T))
  #define MkBufferListST                 MkBufferListC_T
  #define MkBufferListSTT                (MkTYP(MkBufferListST))
  #define MkBufferListC_type             MK_BFL
  #define MkBufferListCT_X(instance)     ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
  #define MkBufferListCTT_X(instance)    (MkOBJ_R(instance).type)
  #define MkBufferListCT_TT(typ)         ( (struct MkSuperTypeS *) (typ) )
  #define MkBufferListC_NS               MK
  #define MkBufferListCTT                MkBufferListCTT
  #define MkBufferListCT                 ( (struct MkSuperTypeS *) MkBufferListCTT )
 
 
// TypeCheck --------------------------------------------------------------
 
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wattributes"
 
  __parser__(class=MkBufferListC,static,hide)
  MK_ATTR_STATIC
  mk_inline bool MkBflCheck (MK_MNGN mng) {
    return MkSanitizeCheck(MkBufferListC,mng);
  }
 
  __parser__(class=MkBufferListC,static,hide)
  MK_ATTR_STATIC
  mk_inline bool MkBflCheckO (MK_OBJN obj) {
    return MkSanitizeCheckO(MkBufferListC,obj);
  }
 
  #pragma GCC diagnostic pop
  #define MkBufferListC_Check(mng)       MkBflCheck(mng)
 
 
// RunTimeCast --------------------------------------------------------------
 
  __parser__(class=MkBufferListC,hide,static)
  META_ATTRIBUTE_SANITIZE
  MK_ATTR_STATIC
  mk_inline MK_BFL MkBfl(MK_MNG mng) {
    return (MkBflCheck(mng) ? (MK_BFL)mng : NULL);
  }
 
  __parser__(class=MkBufferListC,hide,static)
  META_ATTRIBUTE_SANITIZE
  MK_ATTR_STATIC
  mk_inline MK_BFLN MkBflN(MK_MNGN mng) {
    return (MkBflCheck(mng) ? (MK_BFLN)mng : NULL);
  }
 
  #define MkBflRaise(_bfl) if (!_MkCheckX(MkBufferListC,_bfl)) { \
    MkErrorSetC_1E("'MkBufferListC' hdl is NULL"); \
    goto error ; \
  }
 
  #define   MkBFL_R(x)        (*(x)).super.bfl
  #define   MkBFL(x)          (&MkBFL_R(x))
 
 
  __parser__pop__;
// MkBufferListC_Class_Define_C_API
 
// END-MkBufferListS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// MARK_C ==================================================================
 
// =========================================================================
// BEGIN-MkBufferListS-Export - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
 
__parser__push__(doc-group=_ignore_,doc-index=Class,doc-name=Export,class=MkBufferListC);
 
__parser__(class-overload=MkObjectHandleGet)
MK_ATTR_RT_INSTANCE
mk_inline MK_HDL MK_DECL MkBufferListHandleGet_RT ( 
  MK_PARSER_RT
  MK_BFL const bfl  __parser__(null-allowed)
) {
  return MkObjectHandleGet(bfl?MkOBJ(bfl):NULL);
}
 
__parser__(flags=new)
MK_ATTR_RT_STATIC
mk_inline MK_BFL MkBufferListHandleResolve_RT (
  MK_PARSER_RT
  MK_HDL const netHdl 
) {
  return MkBfl(MkObjectHandleResolve(netHdl));
}
 
#define MkBufferListHandleResolve_e(netHdl) ({ \
  MK_HDL tmpHdl=netHdl; \
  MK_BFL tmp; \
  if (tmpHdl==0) { \
    tmp=NULL; \
  } else { \
    tmp=MkBufferListHandleResolve(tmpHdl); \
    if (tmp==NULL) { \
      MkErrorSetC_1_NULL("ERROR: 'MkBufferListC' handle is 'NULL'"); \
      goto error; \
    }; \
  }; \
  tmp; \
})
 
__parser__pop__;
 
// Class export & import
 
  __parser__(flags=new,doc-group=_ignore_,doc-index=Class,doc-name=Misc,class=MkBufferListC,null-return-allow)
  MK_ATTR_STATIC
  mk_inline MK_BFL MkBufferListGetNull ( void ) {
    return (MK_BFL)MK_NULL;
  }
// MkBufferListC - Misc - function
 
// MkBufferListC_Class_C_API
 
// END-MkBufferListS-Export - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// =========================================================================
// BEGIN-Class-Introspection
// END-Class-Introspection
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__push__(doc-group=TOR);
 
// [MkBufferListCreate_RT]
__parser__(constructor,lng-constr)
MK_EXTERN MK_BFL MK_DECL MkBufferListCreate_RT (
  MK_PARSER_RT
  MK_NUM const size      __parser__(default=0)
) MK_ATTR_RT_STATIC;
// [MkBufferListCreate_RT]
 
MK_EXTERN MK_BFL MK_DECL MkBufferListCreateTLS_RT (
  MK_PARSER_RT
  MK_STRN const tlsName ,
  bool    const resetB    __parser__(default=true)
) MK_ATTR_RT_STATIC;
 
__parser__(constructor,macro)
void MkBufferListCreateTLS_T(MK_MACRO_TYP name, MK_NUM const num) MK_ATTR_STATIC ;
// [MkBufferListCreateTLS_T]
#define MkBufferListCreateTLS_T(name,num)                     \
  static MkThreadLocal struct MkBufferListS name##R = {0};    \
  MK_BFL name = &name##R;                                     \
  if (likely(__MkCheckX(MkBufferListC,&name##R))) {           \
    MkBufferListReserve_RT(MK_RT_CALL name,num);              \
  } else {                                                    \
    MkBufferListInit_RT(MK_RT_CALL name,num);                 \
    MkRefIncr_1X(name);                                       \
  }
// [MkBufferListCreateTLS_T]
 
__parser__(constructor,macro)
void MkBufferListCreateSTATIC_T(MK_MACRO_TYP name, MK_NUM const num) MK_ATTR_STATIC ;
// [MkBufferListCreateSTATIC_T]
#define MkBufferListCreateSTATIC_T(name,num)       \
  static struct MkBufferListS name##R = {0};       \
  struct MkBufferListS * const name = &name##R;    \
  if (__MkCheckX(MkBufferListC,&name##R)) {        \
    MkBufferListReset_RT(MK_RT_CALL name);         \
  } else {                                         \
    MkBufferListInit_RT(MK_RT_CALL name,num);      \
  }
// [MkBufferListCreateSTATIC_T]
 
__parser__(constructor,macro)
void MkBufferListCreateLOCAL_T(MK_MACRO_TYP name, MK_NUM const num) MK_ATTR_STATIC ;
// [MkBufferListCreateLOCAL_T]
#define MkBufferListCreateLOCAL_T(name,num)        \
  struct MkBufferListS name##R = {0};              \
  struct MkBufferListS * const name = &name##R;    \
  MkBufferListInit_RT(MK_RT_CALL name, num)
// [MkBufferListCreateLOCAL_T]
 
__parser__(constructor,macro)
void MkBufferListCreateTLS_inout_T(MK_MACRO_TYP name, MK_NUM const num, MK_BFL * inout) MK_ATTR_STATIC ;
// [MkBufferListCreateTLS_inout_T]
#define MkBufferListCreateTLS_inout_T(name,num,inout)                    \
  static MkThreadLocal struct MkBufferListS __hidden_##name##R = {0};    \
  MK_BFL name = *inout != NULL ? *inout : &__hidden_##name##R;           \
  if (likely(__MkCheckX(MkBufferListC,name))) {                          \
    MkBufferListReserve_RT(MK_RT_CALL name,num);                         \
  } else {                                                               \
    MkBufferListInit_RT(MK_RT_CALL name,num);                            \
    MkRefIncr_1X(name);                                                  \
  }
// [MkBufferListCreateTLS_inout_T]
 
__parser__(constructor,arg-type-vcv=argc@argv)
MK_EXTERN MK_BFL MK_DECL MkBufferListCreateVC_RT (
  MK_PARSER_RT
  MK_NUM const argc,
  MK_STRN const *argv __parser__(in)
) MK_ATTR_RT_STATIC ;
 
__parser__(constructor)
MK_EXTERN MK_BFL MK_DECL MkBufferListCreateVAL_RT (
  MK_PARSER_RT
  MK_STRN const arg0,
  va_list var_list
) MK_ATTR_RT_STATIC ;
 
__parser__(constructor)
MK_EXTERN MK_BFL MK_DECL MkBufferListCreateVA_RT (
  MK_PARSER_RT
  MK_STRN const arg0,
  ...
) MK_ATTR_RT_STATIC ;
 
__parser__(constructor,static)
MK_EXTERN MK_BFL MK_DECL MkBufferListCreateLA_RT (
  MK_PARSER_RT
  MK_BAC const args
) MK_ATTR_RT_INSTANCE ;
 
__parser__(constructor)
MK_EXTERN MK_BFL MK_DECL MkBufferListDup_RT (
  MK_PARSER_RT
  MK_BFLN const bfl
) MK_ATTR_RT_INSTANCE;
 
__parser__(constructor)
MK_EXTERN MK_BFL MK_DECL MkBufferListMerge_RT (
  MK_PARSER_RT
  MK_BFL const bfl
) MK_ATTR_RT_INSTANCE;
 
__parser__(internal)
MK_EXTERN void MK_DECL MkBufferListInit_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_NUM const num
) MK_ATTR_RT_INSTANCE;
 
__parser__(internal)
MK_EXTERN void MK_DECL MkBufferListFree_RT (
  MK_PARSER_RT
  MK_BFL  const bfl
) MK_ATTR_RT_INSTANCE;
 
__parser__(destructor)
MK_EXTERN void MK_DECL MkBufferListDelete_RT (
  MK_PARSER_RT
  MK_BFL bfl
) MK_ATTR_RT_INSTANCE;
 
__parser__pop__; // TOR
 
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__push__(doc-group=Misc);
 
__parser__(doc-sort=a0)
MK_EXTERN void MK_DECL MkBufferListMove_RT (
  MK_PARSER_RT
  MK_BFL const to,
  MK_BFL const from
) MK_ATTR_RT_INSTANCE;
 
__parser__(const,doc-sort=a1)
MK_EXTERN void MK_DECL MkBufferListCopy_RT (
  MK_PARSER_RT
  MK_BFL  const bfl,
  MK_BFLN const src
) MK_ATTR_RT_INSTANCE;
 
__parser__(doc-sort=a2)
MK_EXTERN MK_BFL MK_DECL MkBufferListPositionMerge_RT (
  MK_PARSER_RT
  MK_BFL  const bfl,
  MK_BFL  const source,
  MK_NUM position
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_NUM MK_DECL MkBufferListSearchC_RT (
  MK_PARSER_RT
  MK_BFLN const bfl,
  MK_STRN const str,
  MK_NUM const len            __parser__(default=-1),
  MK_NUM const startindex     __parser__(default=0)
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BFL MK_DECL MkBufferListReset_RT (
  MK_PARSER_RT
  MK_BFL bfl
) MK_ATTR_RT_INSTANCE;
 
__parser__(class-overload=MkObjectToString)
MK_EXTERN MK_STRN MK_DECL MkBufferListToString_RT (
  MK_PARSER_RT
  MK_BFLN const bfl
) MK_ATTR_RT_INSTANCE;
 
__parser__(template-required,no-rpc,keep,no-static)
MK_EXTERN MK_NAT_LIST MK_DECL MkBufferListToList_RT (
  MK_PARSER_RT
  MK_BFLN const bfl
) MK_ATTR_RT_INSTANCE;
 
__parser__(internal,template-required)
MK_EXTERN MK_STRN_A MK_DECL MkBufferListToStringList_RT (
  MK_PARSER_RT
  MK_BFLN const bfl,
  bool const    unique
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BUF MK_DECL MkBufferListToBuffer_RT (
  MK_PARSER_RT
  MK_BFLN const bfl
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_I32 MK_DECL MkBufferListCmp_RT (
  MK_PARSER_RT
  MK_BFLN const bfl,
  MK_BFLN const bfl2
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BFL MK_DECL MkBufferListSort_RT (
  MK_PARSER_RT
  MK_BFL const bfl
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN void MK_DECL MkBufferListReserve_RT (
  MK_PARSER_RT
  MK_BFL const  bfl,
  MK_NUM const  num
) MK_ATTR_RT_INSTANCE;
 
__parser__(inline=MkBufferListSizeI)
MK_EXTERN MK_NUM MK_DECL MkBufferListSize_RT (
  MK_PARSER_RT
  MK_BFLN const bfl
) MK_ATTR_RT_INSTANCE;
 
#define MkBufferListSizeI(bfl) (bfl)->cursize
 
__parser__(constructor)
MK_EXTERN MK_BFL MK_DECL MkBufferListFileGlob_RT (
  MK_PARSER_RT
  MK_STRN const pattern_match
) MK_ATTR_RT_STATIC;
 
__parser__pop__; // Misc
 
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__push__(doc-group=Append);
 
MK_EXTERN MK_BFL MK_DECL MkBufferListAppendLP_RT (
  MK_PARSER_RT
  MK_BFL const  bfl,
  MK_BFL const  addBufL,
  MK_NUM        position    __parser__(default=-1)
) MK_ATTR_RT_INSTANCE;
 
__parser__(arg-type-vcv=argc@argv)
MK_EXTERN MK_BFL MK_DECL MkBufferListAppendVC_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_NUM const argc,
  MK_STRN const * const argv
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BFL MK_DECL MkBufferListAppendVAL_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_STRN arg0,
  va_list var_list
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BFL MK_DECL MkBufferListAppendVA_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_STRN arg0,
  ...
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BFL MK_DECL MkBufferListAppendLA_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_BAC const args
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN void MK_DECL
MkBufferListAppendI8_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_I8 const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN void MK_DECL
MkBufferListAppendBOL_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_BOL const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN void MK_DECL
MkBufferListAppendI16_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_I16 const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN void MK_DECL
MkBufferListAppendI32_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_I32 const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN void MK_DECL
MkBufferListAppendFLT_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_FLT const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN void MK_DECL
MkBufferListAppendI64_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_I64 const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN void MK_DECL
MkBufferListAppendG_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_LONG const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN void MK_DECL
MkBufferListAppendDBL_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_DBL const val
) MK_ATTR_RT_INSTANCE;
 
__parser__(flags=public-internal)
MK_EXTERN void MK_DECL
MkBufferListAppendSTR_RT (
  MK_PARSER_RT
  MK_BFL  const bfl,
  MK_STRN const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN void MK_DECL
MkBufferListAppendBIN_RT (
  MK_PARSER_RT
  MK_BFL  const bfl,
  MkBinaryR const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN void MK_DECL
MkBufferListAppendBUF_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_BUF const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN void MK_DECL MkBufferListAppendUP_RT (
  MK_PARSER_RT
  MK_BFL const  bfl,
  MK_BUF const  addBuf,
  MK_NUM        position    __parser__(default=-1)
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN void MK_DECL MkBufferListAppendVL_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_FST const printfmt,
  va_list var_list
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN void MK_DECL
MkBufferListAppendV_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_FST const printfmt,
  ...
) MK_ATTR_RT_INSTANCE MK_RT_ATTR_FORMAT_2;
 
MK_EXTERN void MK_DECL
MkBufferListAppendStringR_RT (
  MK_PARSER_RT
  MK_BFL  const bfl,
  MkStringR const val
) MK_ATTR_RT_INSTANCE;
 
__parser__pop__; // Append
 
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__push__(doc-group=Check);
 
MK_EXTERN bool MK_DECL MkBufferListCheckOption_RT (
  MK_PARSER_RT
  MK_BFL  const bfl,
  MK_STRN const opt,
  bool const onlyFirst      __parser__(default=false)
) MK_ATTR_RT_INSTANCE;
 
// [MkBufferListCheckOptionBOL-example]
MK_EXTERN enum MkErrorE MK_DECL MkBufferListCheckOptionBOL_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_STRN const opt,
  bool const defval         __parser__(default=false),
  bool const onlyFirst      __parser__(default=true),
  bool * const val_out
) MK_ATTR_RT_INSTANCE;
// [MkBufferListCheckOptionBOL-example]
 
#define  MkBufferListCheckOptionO_3E(bfl,opt,val_out)   MkErrorCheck(MkBufferListCheckOptionBOL(bfl,opt,false,true,val_out))
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferListCheckOptionI8_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_STRN const opt,
  MK_I8 const defval       __parser__(default=0),
  bool const onlyFirst      __parser__(default=true),
  MK_I8 * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferListCheckOptionI16_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_STRN const opt,
  MK_I16 const defval       __parser__(default=0),
  bool const onlyFirst      __parser__(default=true),
  MK_I16 * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferListCheckOptionI32_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_STRN const opt,
  MK_I32 const defval       __parser__(default=0),
  bool const onlyFirst      __parser__(default=true),
  MK_I32 * const val_out
) MK_ATTR_RT_INSTANCE;
 
#define MkBufferListCheckOptionI_3E(bfl,opt,val_out) MkErrorCheck(MkBufferListCheckOptionI32(bfl,opt,0,true,val_out))
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferListCheckOptionFLT_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_STRN const opt,
  MK_FLT const defval       __parser__(default=0),
  bool const onlyFirst      __parser__(default=true),
  MK_FLT * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferListCheckOptionI64_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_STRN const opt,
  MK_I64 const defval       __parser__(default=0),
  bool const onlyFirst      __parser__(default=true),
  MK_I64 * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferListCheckOptionDBL_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_STRN const opt,
  MK_DBL const defval       __parser__(default=0),
  bool const onlyFirst      __parser__(default=true),
  MK_DBL * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferListCheckOptionSTR_RT (
  MK_PARSER_RT
  MK_BFL    const bfl,
  MK_STRN   const opt,
  MK_STRN   const defval      __parser__(default=S#""),
  bool      const onlyFirst   __parser__(default=true),
  MK_STRN * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferListCheckOptionBUF_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_STRN const opt,
  MK_BUF const defval         __parser__(default=NULL),
  bool const onlyFirst        __parser__(default=true),
  MK_BUF * const val_out
) MK_ATTR_RT_INSTANCE;
 
__parser__pop__; // Check
 
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__push__(doc-group=Index);
 
__parser__(doc-sort=a0)
MK_EXTERN enum MkErrorE MK_DECL MkBufferListIndexDelete_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  const MK_NUM index,
  const MK_NUM numitems   __parser__(default=1),
  const bool doDelete     __parser__(default=true)
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferListIndexExtract_RT (
  MK_PARSER_RT
  MK_BFL const    bfl,
  MK_NUM const    index       __parser__(default=0),
  MK_BUF * const  val_out
) MK_ATTR_RT_INSTANCE;
 
__parser__(doc-sort=get-0)
MK_EXTERN enum MkErrorE MK_DECL MkBufferListIndexGet_RT (
  MK_PARSER_RT
  MK_BFLN const bfl,
  MK_NUM const index,
  MK_BUF * const val_out
) MK_ATTR_RT_INSTANCE;
 
__parser__(doc-sort=set-0)
MK_EXTERN enum MkErrorE MK_DECL MkBufferListIndexSet_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_NUM const index,
  MK_BUF const buf
) MK_ATTR_RT_INSTANCE;
 
__parser__(no-type-extension,doc-sort=get-1)
MK_EXTERN MK_BUF MK_DECL MkBufferListIndexGetBUF_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_NUM       index
) MK_ATTR_RT_INSTANCE;
 
 
__parser__(no-type-extension,doc-sort=set-1)
MK_EXTERN void MK_DECL MkBufferListIndexSetBUF_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_NUM const index,
  MK_BUF const buf
) MK_ATTR_RT_INSTANCE;
 
__parser__(no-type-extension,doc-sort=get-2)
MK_EXTERN MK_STRN MK_DECL MkBufferListIndexGetSTR_RT (
  MK_PARSER_RT
  MK_BFL const bfl,
  MK_NUM const index
) MK_ATTR_RT_INSTANCE;
 
__parser__(no-type-extension,doc-sort=set-2)
MK_EXTERN void MK_DECL MkBufferListIndexSetSTR_RT (
  MK_PARSER_RT
  MK_BFL  const bfl,
  MK_NUM  const index,
  MK_STRN const str
) MK_ATTR_RT_INSTANCE;
 
__parser__pop__; // Index
 
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__push__(doc-group=Log);
 
__parser__(const,class-overload=MkObjectLog)
MK_EXTERN void MK_DECL MkBufferListLog_RT (
  MK_PARSER_RT
  MK_BFLN        bfl       ,
  MK_OBJN const  fmtobj    __parser__(default=NULL),
  MK_DBG  const  debug     __parser__(default=0),
  MK_STRN const  callfunc  __parser__(default=F#FUNC),
  MK_I32  const  lvl       __parser__(default=0)
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN void MK_DECL MkBufferListLogS_RT (
  MK_PARSER_RT
  MK_BFLN const   bfl         ,
  MK_STRN const   varname     __parser__(default=S#"bfl"),
  MK_OBJN         fmtobj      __parser__(default=NULL),
  MK_STRN const   callfunc    __parser__(default=F#FUNC)
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN void MK_DECL MkBufferListLogSS_RT (
  MK_PARSER_RT
  MK_BFLN const bfl,
  MK_STRN const varname     __parser__(default=S#"bfl"),
  MK_OBJN       fmtobj      __parser__(default=NULL),
  MK_STRN const callfunc    __parser__(default=F#FUNC)
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN void MK_DECL MkBufferListLogSSS_RT (
  MK_PARSER_RT
  MK_BFLN const bfl,
  MK_STRN const varname     __parser__(default=S#"bfl"),
  MK_OBJN       fmtobj      __parser__(default=NULL),
  MK_STRN const callfunc    __parser__(default=F#FUNC)
) MK_ATTR_RT_INSTANCE;
 
__parser__pop__;
 
 
END_MK_C_DECLS