LibMkKernel_rb.h

Go to the documentation of this file.

 
#pragma once
 
#include "ruby.h"
 
#include "nhi1_config.h"
#include "debug_mk.h"
 
#include "LibMkKernel_mk.h"
 
#include "tmpl/mk_type_S_lng.h"
 
/*****************************************************************************/
/*                                                                           */
/*                              Macro_API                                    */
/*                                                                           */
/*****************************************************************************/
 
// BEGIN-HEADER - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
#undef HEADER
#define HEADER
 
// If the source of libmkkernel is direct used in an external library
// (without dynamic linking) and this library should *not* export
// the symbol's of libmkkernel then the flag META_IGNORE_EXTERN have
// to be set
#undef MK_RB_EXTERN
#if defined(META_IGNORE_EXTERN)
#   define MK_RB_EXTERN
#elif defined(PIC)
   // does we build a DLL ?
#  if defined(DLL_EXPORT)
       // does we build the libmkkernel library ?
#      if defined(MK_RB_BUILD_DLL)
#        define MK_RB_EXTERN __declspec(dllexport)
#      else
#        define MK_RB_EXTERN __declspec(dllimport)
#      endif
#  else
   // no DLL - architecture specific extern specifier
#    define MK_RB_EXTERN __attribute__ ((visibility("default")))
#  endif
#else
#   define MK_RB_EXTERN
#endif
 
// external data lookup
#undef MK_RB_EXTERN_DATA
#if defined(META_PRIVATE)
#  define MK_RB_EXTERN_DATA extern
#elif defined(META_IGNORE_EXTERN)
#  define MK_RB_EXTERN_DATA extern
#elif defined(PIC)
   // does we build a DLL ?
#  if defined(DLL_EXPORT)
       // does we build the libmkkernel library ?
#      if defined(MK_RB_BUILD_DLL)
#        define MK_RB_EXTERN_DATA __declspec(dllexport)
#      else
#        define MK_RB_EXTERN_DATA __declspec(dllimport)
#      endif
#  else
   // no DLL - architecture specific extern specifier
#    define MK_RB_EXTERN_DATA __attribute__ ((visibility("default"))) extern
#  endif
#else
#  define MK_RB_EXTERN_DATA extern
#endif
 
#undef MK
#define MK(n) rbmkkernel_ ## n
#undef NS
#define NS(n) rbmkkernel_ ## n
 
// END-HEADER - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
#undef OT_PKG
#define OT_PKG                            MK(MkKernel)
 
// LNG ******************************************************************************
 
#define OT_OBJ_T                          VALUE
#define OT_ENUM_T                     VALUE
#define OT_CLS_T                    VALUE
 
#define OT_LNG_NULL                       Qnil
#define OT_LNG_UNDEF                      Qundef
#define OT_LNG_IS_NULL(val)               RB_NIL_OR_UNDEF_P(val)
#define OT_LNG_RETURN(ret,cmd)            ret=cmd
 
#define OT_LNG_NAME_FROM_OBJ(obj)         VAL2STRN(obj)
#define OT_LNG_NAME_FROM_CLASS(cls)       rb_class2name(cls)
#define OT_LNG_OBJ_CLASSNAME(obj)         rb_obj_classname(obj)
 
#define OT_LNG_OBJV(idx)                  objv[idx]
 
#define OT_LNG_OBJ_CLASS_IS(obj,cls)      (rb_obj_is_kind_of(obj,cls) == Qtrue)
#define OT_OBJ_TO_CLASS(str)              str
#define OT_OBJ_TO_ENUM(str)               NS(str)
 
#define OT_LNG_OBJECT_IS(obj)             OT_LNG_OBJ_CLASS_IS(obj,MK(MkObjectC))
 
/*
#define OT_LNG_ARRAY_LEN(ary)       rb_array_len(ary)
#define OT_LNG_ARRAY_IDX(ary,idx)   rb_ary_entry(ary,idx)
#define OT_LNG_ARRAY_PUSH(ary,val)  rb_ary_push(ary,val)
 
#define OT_LNG_I32_IS(obj)          (rb_check_to_int(objV) != Qnil)
 
#define OT_OBJ_TYPE_STRING(obj)     rb_obj_classname(obj)
*/
 
#define OT_LNG_NULL_IS(obj)               (!RB_TEST(obj))
 
#define OT_LNG_OBJ_ENUM_IS(obj,enm)       (rb_obj_is_kind_of(obj,enm) == Qtrue)
#define OT_LNG_ENUM_NAME(enm)             OT_LNG_NAME_FROM_CLASS(enm) 
#define OT_ENUM_TO_I32(o,e)           o = rb_funcallv(o,MK(id_to_i),0,NULL)
#define OT_ENUM_TO_I32_2(o,e)         o = rb_funcallv(o,MK(id_to_i),0,NULL)
 
#define OT_LNG_ARRAY_IS(o)                (RB_TYPE_P(o,T_ARRAY))
//#define OT_LNG_ARRAY_IS(ary)              (TYPE(ary) == T_ARRAY)
 
#define OT_LNG_STRN_PRE(cs,obj)            MK_STRN cs = VAL2STRN(obj)
#define OT_LNG_STRN_POST(cs,obj)
 
#define OT_LNG_LONG_IS(obj)               (CHECK_LONG(obj) || CHECK_STRING(obj))   // from "high"
#define OT_LNG_I32_IS(obj)                (CHECK_LONG(obj) || CHECK_STRING(obj))    // from "high"
 
#define OT_LNG_SKIP_TYPE                  int
 
/*****************************************************************************/
/*                                                                           */
/*                              Class_API                                    */
/*                                                                           */
/*****************************************************************************/
 
#define LNG_ARGS                  int objc, VALUE *objv, VALUE self
#define LNG_ARGS_CALL             objc, objv, self
 
#define CONSTR_ARGS               LNG_ARGS
#define CONSTR_ARGS_CALL          LNG_ARGS_CALL
 
#define OtClass_ARGS              int objc, VALUE *objv, VALUE self
#define OtClass_ARGS_CALL         objc, objv, self
 
 
#define OT_OBJECT_DELETE_SOFT(obj)  MK(AtomDeleteSoft)(VAL2MNG(obj));
// RUBY does NOT support HARD destructor
#define OT_OBJECT_DELETE_HARD(obj)  MK(AtomDeleteHard)(MK_RT_CALL obj);
#define OT_OBJECT_DELETE(obj)       MK(AtomDelete)(MK_RT_CALL hdl);
#define OT_OBJECT_DISPOSE(obj)      MK(AtomDispose)(MK_RT_CALL hdl);
 
#if !defined(MK_BASE_CLASS)
# define MK_BASE_CLASS MK(MkObjectC)
#endif
 
// called from ALL "*_ObjNew" style functions
mk_inline VALUE MK(AtomObjNew)      (MK_RT_ARGS MK_OBJ obj) ;
mk_inline void  MK(AtomDeleteSoft)  (MK_MNG);
mk_inline void  MK(AtomDeleteHard)  (MK_RT_ARGS OT_OBJ_T);
mk_inline void  MK(AtomDelete)      (MK_RT_ARGS MK_MNG);
mk_inline void  MK(AtomDispose)     (MK_RT_ARGS MK_MNG);
 
MK_RB_EXTERN_DATA OT_CLS_T MK(MkKernel); 
MK_RB_EXTERN_DATA OT_CLS_T MK(InitError); 
 
// BEGIN-CLASS - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// ----------------------------------------------------------------------
// class: MkBufferListC
 
  MK_RB_EXTERN_DATA OT_CLS_T   MK(MkBufferListC); 
  #define MkBufferListC_lngO       MK(MkBufferListC)
  #define MkBufferListC_base       MK(MkObjectC)
 
  // MK_NULL singelton
  MK_RB_EXTERN_DATA OT_OBJ_T         MK(MkBufferListC_MK_NULL); 
  #define MkBufferListC_MK_NULL          MK(MkBufferListC_MK_NULL)
 
  // arguments
  #define MkBufferListC_ARGS                LNG_ARGS
  #define MkBufferListC_ARGS_CALL           LNG_ARGS_CALL
 
  // return object
  #define  OT_retObj_SET_BFL(nat)  retObj  =  MK(MkBufferListC_ObjNew) (MK_RT_CALL nat)
 
  // new object
  #define OT_TMP_BFL_OBJ(val)  MK(MkBufferListC_ObjNew)(MK_RT_CALL val)
  MK_ARTIFICIAL
  mk_inline OT_OBJ_T MK(MkBufferListC_ObjNew) (MK_RT_ARGS MkBufferListC_type hdl) {
      return hdl ? MK(AtomObjNew) (MK_RT_CALL MkBufferListC_X2obj(hdl)) : MkBufferListC_MK_NULL;
  }
 
  // cast from LNG to MQ
  #define VAL2BFL(val) ((MK_BFL)DATA_PTR(val))
 
// ----------------------------------------------------------------------
// class: MkBufferC
 
  MK_RB_EXTERN_DATA OT_CLS_T   MK(MkBufferC); 
  #define MkBufferC_lngO       MK(MkBufferC)
  #define MkBufferC_base       MK(MkObjectC)
 
  // MK_NULL singelton
  MK_RB_EXTERN_DATA OT_OBJ_T         MK(MkBufferC_MK_NULL); 
  #define MkBufferC_MK_NULL          MK(MkBufferC_MK_NULL)
 
  // arguments
  #define MkBufferC_ARGS                LNG_ARGS
  #define MkBufferC_ARGS_CALL           LNG_ARGS_CALL
 
  // return object
  #define  OT_retObj_SET_BUF(nat)  retObj  =  MK(MkBufferC_ObjNew) (MK_RT_CALL nat)
 
  // new object
  #define OT_TMP_BUF_OBJ(val)  MK(MkBufferC_ObjNew)(MK_RT_CALL val)
  MK_ARTIFICIAL
  mk_inline OT_OBJ_T MK(MkBufferC_ObjNew) (MK_RT_ARGS MkBufferC_type hdl) {
      return hdl ? MK(AtomObjNew) (MK_RT_CALL MkBufferC_X2obj(hdl)) : MkBufferC_MK_NULL;
  }
 
  // cast from LNG to MQ
  #define VAL2BUF(val) ((MK_BUF)DATA_PTR(val))
 
// ----------------------------------------------------------------------
// class: MkBufferStreamC
 
  MK_RB_EXTERN_DATA OT_CLS_T   MK(MkBufferStreamC); 
  #define MkBufferStreamC_lngO       MK(MkBufferStreamC)
  #define MkBufferStreamC_base       MK(MkObjectC)
 
  // MK_NULL singelton
  MK_RB_EXTERN_DATA OT_OBJ_T         MK(MkBufferStreamC_MK_NULL); 
  #define MkBufferStreamC_MK_NULL          MK(MkBufferStreamC_MK_NULL)
 
  // arguments
  #define MkBufferStreamC_ARGS                LNG_ARGS
  #define MkBufferStreamC_ARGS_CALL           LNG_ARGS_CALL
 
  // return object
  #define  OT_retObj_SET_BUS(nat)  retObj  =  MK(MkBufferStreamC_ObjNew) (MK_RT_CALL nat)
 
  // new object
  #define OT_TMP_BUS_OBJ(val)  MK(MkBufferStreamC_ObjNew)(MK_RT_CALL val)
  MK_ARTIFICIAL
  mk_inline OT_OBJ_T MK(MkBufferStreamC_ObjNew) (MK_RT_ARGS MkBufferStreamC_type hdl) {
      return hdl ? MK(AtomObjNew) (MK_RT_CALL MkBufferStreamC_X2obj(hdl)) : MkBufferStreamC_MK_NULL;
  }
 
  // cast from LNG to MQ
  #define VAL2BUS(val) ((MK_BUS)DATA_PTR(val))
 
// ----------------------------------------------------------------------
// class: MkErrorC
 
  MK_RB_EXTERN_DATA OT_CLS_T   MK(MkErrorC); 
  #define MkErrorC_lngO       MK(MkErrorC)
  #define MkErrorC_base       MK(MkObjectC)
 
  // MK_NULL singelton
  MK_RB_EXTERN_DATA OT_OBJ_T         MK(MkErrorC_MK_NULL); 
  #define MkErrorC_MK_NULL          MK(MkErrorC_MK_NULL)
 
  // arguments
  #define MkErrorC_ARGS                LNG_ARGS
  #define MkErrorC_ARGS_CALL           LNG_ARGS_CALL
 
  // return object
  #define  OT_retObj_SET_ERR(nat)  retObj  =  MK(MkErrorC_ObjNew) (MK_RT_CALL nat)
 
  // new object
  #define OT_TMP_ERR_OBJ(val)  MK(MkErrorC_ObjNew)(MK_RT_CALL val)
  MK_ARTIFICIAL
  mk_inline OT_OBJ_T MK(MkErrorC_ObjNew) (MK_RT_ARGS MkErrorC_type hdl) {
      return hdl ? MK(AtomObjNew) (MK_RT_CALL MkErrorC_X2obj(hdl)) : MkErrorC_MK_NULL;
  }
 
  // cast from LNG to MQ
  #define VAL2ERR(val) ((MK_ERR)DATA_PTR(val))
 
// ----------------------------------------------------------------------
// class: MkLogFileC
 
  MK_RB_EXTERN_DATA OT_CLS_T   MK(MkLogFileC); 
  #define MkLogFileC_lngO       MK(MkLogFileC)
  #define MkLogFileC_base       MK(MkObjectC)
 
  // MK_NULL singelton
  MK_RB_EXTERN_DATA OT_OBJ_T         MK(MkLogFileC_MK_NULL); 
  #define MkLogFileC_MK_NULL          MK(MkLogFileC_MK_NULL)
 
  // arguments
  #define MkLogFileC_ARGS                LNG_ARGS
  #define MkLogFileC_ARGS_CALL           LNG_ARGS_CALL
 
  // return object
  #define  OT_retObj_SET_LFL(nat)  retObj  =  MK(MkLogFileC_ObjNew) (MK_RT_CALL nat)
 
  // new object
  #define OT_TMP_LFL_OBJ(val)  MK(MkLogFileC_ObjNew)(MK_RT_CALL val)
  MK_ARTIFICIAL
  mk_inline OT_OBJ_T MK(MkLogFileC_ObjNew) (MK_RT_ARGS MkLogFileC_type hdl) {
      return hdl ? MK(AtomObjNew) (MK_RT_CALL MkLogFileC_X2obj(hdl)) : MkLogFileC_MK_NULL;
  }
 
  // cast from LNG to MQ
  #define VAL2LFL(val) ((MK_LFL)DATA_PTR(val))
 
// ----------------------------------------------------------------------
// class: MkObjectC
 
  MK_RB_EXTERN_DATA OT_CLS_T   MK(MkObjectC); 
  #define MkObjectC_lngO       MK(MkObjectC)
  #define MkObjectC_base       NULL
 
  // MK_NULL singelton
  MK_RB_EXTERN_DATA OT_OBJ_T         MK(MkObjectC_MK_NULL); 
  #define MkObjectC_MK_NULL          MK(MkObjectC_MK_NULL)
 
  // arguments
  #define MkObjectC_ARGS                LNG_ARGS
  #define MkObjectC_ARGS_CALL           LNG_ARGS_CALL
 
  // return object
  #define  OT_retObj_SET_OBJ(nat)  retObj  =  MK(MkObjectC_ObjNew) (MK_RT_CALL nat)
 
  // new object
  #define OT_TMP_OBJ_OBJ(val)  MK(MkObjectC_ObjNew)(MK_RT_CALL val)
  MK_ARTIFICIAL
  mk_inline OT_OBJ_T MK(MkObjectC_ObjNew) (MK_RT_ARGS MkObjectC_type hdl) {
      return hdl ? MK(AtomObjNew) (MK_RT_CALL MkObjectC_X2obj(hdl)) : MkObjectC_MK_NULL;
  }
 
  // cast from LNG to MQ
  #define VAL2OBJ(val) ((MK_OBJ)DATA_PTR(val))
 
// ----------------------------------------------------------------------
// class: MkRuntimeC
 
  MK_RB_EXTERN_DATA OT_CLS_T   MK(MkRuntimeC); 
  #define MkRuntimeC_lngO       MK(MkRuntimeC)
  #define MkRuntimeC_base       MK(MkObjectC)
 
  // MK_NULL singelton
  MK_RB_EXTERN_DATA OT_OBJ_T         MK(MkRuntimeC_MK_NULL); 
  #define MkRuntimeC_MK_NULL          MK(MkRuntimeC_MK_NULL)
 
  // arguments
  #define MkRuntimeC_ARGS                LNG_ARGS
  #define MkRuntimeC_ARGS_CALL           LNG_ARGS_CALL
 
  // return object
  #define  OT_retObj_SET_RT(nat)  retObj  =  MK(MkRuntimeC_ObjNew) (MK_RT_CALL nat)
 
  // new object
  #define OT_TMP_RT_OBJ(val)  MK(MkRuntimeC_ObjNew)(MK_RT_CALL val)
  MK_ARTIFICIAL
  mk_inline OT_OBJ_T MK(MkRuntimeC_ObjNew) (MK_RT_ARGS MkRuntimeC_type hdl) {
      return hdl ? MK(AtomObjNew) (MK_RT_CALL MkRuntimeC_X2obj(hdl)) : MkRuntimeC_MK_NULL;
  }
 
  // cast from LNG to MQ
  #define VAL2RT(val) ((MK_RT)DATA_PTR(val))
 
// END-CLASS - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
/*****************************************************************************/
/*                                                                           */
/*                               lng_basic                                   */
/*                                                                           */
/*****************************************************************************/
 
#define OT_ProcRet                VALUE
#define MK_CONTEXT_S              hdl
 
#define OT_METH_P(c,s,f)          rb_define_private_method   (NS(c),#s,NS(f),-1);
#define OT_METH_C(c,s,f)          rb_define_singleton_method (NS(c),#s,NS(f),-1);
#define OT_METH_S(c,s,f)          rb_define_singleton_method (NS(c),#s,NS(f),-1);
#define OT_METH_O(c,s,f)          rb_define_method           (NS(c),#s,NS(f),-1);
 
//RUBY does NOT support DTOR
//#define OT_METH_D(c,s,f)          rb_define_method           (MK(c),#s,MK(f),-1);
 
 
//#define OT_SETUP_VARARGS(d)       VALUE retObj=Qundef; int __skip=0; static const MK_STRN doc-group=d;
//#define OT_SETUP_ONEARG(d)        VALUE retObj=Qundef; int __skip=0; static const MK_STRN doc-group=d;
//#define OT_SETUP_NOARG(d)         VALUE retObj=Qundef; int __skip=0; static const MK_STRN doc-group=d;
 
#define OT_SETUP_ALL(d)                                     \
    VALUE retObj=Qundef;                                    \
    int __skip=0;                                           \
    __attribute__((unused)) const static char __doc[]=d;    \
    __attribute__((unused)) VALUE frame=0;
 
#define OT_SETUP_CONSTRUCTOR_ARGS(min,max,d)    \
    OT_SETUP_ALL(d)                             \
    OT_CHECK_NUM_ARGS(min,99);                  \
 
#define OT_SETUP_VARARGS(min,max,d)    \
    OT_SETUP_ALL(d)                    \
    OT_CHECK_NUM_ARGS(min,max);        \
 
#define OT_SETUP_ONEARG(d)     \
    OT_SETUP_ALL(d)            \
    OT_CHECK_NUM_ARGS(1,1);    \
 
#define OT_SETUP_NOARG(d)      \
    OT_SETUP_ALL(d)            \
    OT_CHECK_NUM_ARGS(0,0);    \
 
#define OT_FRAME_CLEANUP          // cleanup by garbage collection.
 
#define SETUP_ARGS                MK_RT_ARGS LNG_ARGS
#define SETUP_ARGS_CALL           MK_RT_CALL LNG_ARGS_CALL
          
#define OT_SELF                   self
#define OT_RET_SELF               OT_SELF
#if !defined(OBJ)
  #ifdef __SANITIZE_ADDRESS__
    #define OBJ                   ((MK_OBJ)hdl)
  #else
    #define OBJ                   &hdl->obj
  #endif
#endif
 
/*printV("NULL !! selfL: %lx, type=%x, type->data=%p\n",OT_SELF,TYPE(OT_SELF),RTYPEDDATA_DATA(OT_SELF)); */
/* MkPanicC_2M(NULL,"'" #cls "C' hdl is NULL"); */
/* rb_raise(MK(InitError), "'" #cls "' hdl is NULL"); */
 
#define OT_SETUP_hdl_tmpl(cls)                                                               \
  cls##_type hdl = cls##_VAL2(OT_SELF);                                                      \
  if (hdl == NULL) {                                                                         \
    OT_ERROR_VAR_DEFAULT(MK(InitError),"'%s' hdl is NULL",OT_LNG_OBJ_CLASSNAME(OT_SELF));    \
  }                                                                                          \
  SetupRtFromObj_XN(hdl);                                                                    \
 
#define OT_SETUP_hdl_tmpl__null_allow(cls)                                                   \
  cls##_type hdl = cls##_VAL2(OT_SELF);                                                      \
  SetupRtFromObj_X(hdl);                                                                     \
 
#define OT_SETUP_doc              __attribute__((unused)) const char *__doc = __func__;
 
#define OT_retObj_SET(val)        retObj = (val);
#define OT_retObj_SET_None        retObj = Qnil;
#define OT_retObj_SET_Error       retObj = Qundef;
#define OT_retObj_SET_List        retObj = rb_ary_new();
#define OT_retObj_APPEND(var)     rb_ary_push(retObj,var);
#define OT_retObj_RETURN          return retObj;
 
#define OT_retObj_SET_BOL(nat)      retObj = BOL2VAL(nat);
#define OT_retObj_SET_I8(nat)       retObj = I82VAL(nat);
#define OT_retObj_SET_I16(nat)      retObj = I162VAL(nat);
#define OT_retObj_SET_I32(nat)      retObj = INT2VAL(nat);
#define OT_retObj_SET_I64(nat)      retObj = I642VAL(nat);
#define OT_retObj_SET_FLT(nat)      retObj = FLT2VAL(nat);
#define OT_retObj_SET_DBL(nat)      retObj = DBL2VAL(nat);
#define OT_retObj_SET_BIN(nat,len)  retObj = BIN2VAL(nat,len);
#define OT_retObj_SET_STR(nat)      retObj = STRN2VAL(nat);
#define OT_retObj_SET_STRN(nat)     retObj = STRN2VAL(nat);
#define OT_retObj_SET_LONG(nat)     retObj = LONG2VAL(nat);
#define OT_retObj_SET_HDL(nat)      retObj = HDL2VAL(nat);
 
// METHOD CALL **********************************************************************
 
#define OT_MK_CALL_0(obj,cls,meth,ret)   {          \
  static __thread ID methid = 0;                   \
  if (methid == 0) methid = rb_intern(#meth);      \
  ret = rb_funcallv(cls##_constr(obj),methid,0,NULL);    \
}
 
#define OT_MK_CALL_0_0(ret,obj,cls,meth)      ret = rb_funcallv(obj,meth,0,NULL)
 
// CONSTR *****************************************************************************
 
#define OT_retObj_CONSTR(mng)       OT_retObj_SET(NS(LNG_CONSTR)(clazz,mng,objc-__skip,objv+__skip))
#define OT_CONSTRUCTOR_POST(x)
 
// error ******************************************************************************
 
#define OT_ERROR_LNG_RETURN \
  rb_raise(rb_eRuntimeError,    "%s", "not implemented"); \
  MK_UNREACHABLE;
 
#define OT_ERROR_SOFT_CONSTRUCTOR(clazz)   \
  rb_raise(MK(InitError),       "InitSoftError: '%s' soft constructor return 'NULL' pointer", #clazz); \
  MK_UNREACHABLE;
 
#define OT_ERROR_CONSTRUCTOR(clazz)   \
  rb_raise(MK(InitError),       "'%s' constructor return 'NULL' pointer", #clazz); \
  MK_UNREACHABLE;
 
#define OT_ERROR_TYPE(str)            \
  rb_raise(rb_eTypeError,       "%s", str); \
  MK_UNREACHABLE;
 
#define OT_ERROR_RUNTIME(clazz, str)  \
  rb_raise(rb_eRuntimeError,    "in class %s: %s.", #clazz, str); \
  MK_UNREACHABLE;
 
                                                                                                                   
// !! attention → always jumps to error                                                                            
#define OT_ERROR_NUMARGS(...)                   \
  MkErrorC_CheckD(WrongNumArgs(__VA_ARGS__));   \
  MK_UNREACHABLE;                               \
 
#define MkErrorC_Check(mng,PROC)          \
  if (unlikely(MkErrorCheckI(PROC))) {    \
    OT_ERROR_META_2_LNG(mng);               \
    MK_UNREACHABLE;                       \
  }                                       \
 
#define MkErrorC_CheckD(PROC)             \
  if (unlikely(MkErrorCheckI(PROC))) {    \
    OT_ERROR_META_2_LNG(hdl);               \
    MK_UNREACHABLE;                       \
  }                                       \
 
#define check_META(code)              if (MkErrorCheckI(code))
 
#define OT_ERROR_VAR_DEFAULT(exp,...) do {    \
  char buf[512];                              \
  ruby_snprintf(buf,512,__VA_ARGS__);         \
  rb_raise(exp,buf);                          \
  MK_UNREACHABLE;                             \
} while (0)
 
// new object ******************************************************************************
 
#define OT_TMP_BOL_OBJ(val)       BOL2VAL(val)
#define OT_TMP_I8_OBJ(val)       I82VAL(val)
#define OT_TMP_I16_OBJ(val)       I162VAL(val)
#define OT_TMP_I32_OBJ(val)       INT2VAL(val)
#define OT_TMP_I64_OBJ(val)       I642VAL(val)
#define OT_TMP_FLT_OBJ(val)       FLT2VAL(val)
#define OT_TMP_DBL_OBJ(val)       DBL2VAL(val)
#define OT_TMP_BIN_OBJ(val,len)   BIN2VAL(val,len)
#define OT_TMP_STR_OBJ(val)       STRN2VAL(val)
 
// check *********************************************************************************
 
#define OT_Prefix_ARGS      MK_RT_ARGS
#define OT_Prefix_CALL      MK_RT_CALL
 
#define OT_Check_ARGS         SETUP_ARGS,     MK_MNG hdl, MK_STRN const arg, int *skipP
#define OT_Check_CALL(arg)    SETUP_ARGS_CALL,       hdl,               arg,     &__skip
#define OT_Check_CALL2(arg)   SETUP_ARGS_CALL,       hdl,               arg,     skipP
 
#define OT_CHECK_OPTIONAL(val)                  if (__skip < objc) {val}
#define OT_CHECK_REQUIRED(val)                  val
 
#define OT_CHECK_NUM_ARGS(min,max)                        \
  if ((objc-__skip) < min || (objc-__skip) > max) {       \
    OT_ERROR_NUMARGS(hdl, __skip, objc, min, max, "");    \
  }                                                       \
 
#define OT_CHECK_NOARGS                                     \
  if (__skip != objc) {                                     \
    OT_ERROR_NUMARGS(hdl, __skip, objc, -999, +999, "");    \
  }                                                         \
 
#define OT_CHECK_BNP(val,len)                                 \
  if (__skip >= objc) {                                       \
    OT_ERROR_NUMARGS(hdl, __skip, objc, -999, +999, #val);    \
  } else {                                                    \
    OT_OBJ_T nat = objv[__skip++];                            \
    val = (MK_BIN)  RSTRING_PTR(nat);                         \
    len = (MK_SIZE) RSTRING_LEN(nat);                         \
  }                                                           \
 
#define OT_CHECK_BCP(val)                                     \
  if (__skip >= objc) {                                       \
    OT_ERROR_NUMARGS(hdl, __skip, objc, -999, +999, #val);    \
  } else {                                                    \
    OT_OBJ_T nat = objv[__skip++];                            \
    val = (MK_BINN) RSTRING_PTR(nat);                         \
  }                                                           \
 
#define OT_GET_CONSTR_NAME(ctor) OT_LNG_NAME_FROM_OBJ((OT_OBJ_T)ctor)
 
/*****************************************************************************/
/*                                                                           */
/*                              debugging                                    */
/*                                                                           */
/*****************************************************************************/
 
MK_RB_EXTERN void   MK(_printObj)           (MK_RT_ARGS OT_OBJ_T,MK_STRN);
 
#define             printLngObj(val)        MK(_printObj)(MK_RT_CALL val,__func__);
 
// enums ******************************************************************************
 
#include "tmpl/mk_misc_check_lng.h" 
 
mk_inline VALUE MK(OtNewInstanceWithOneArg)(VALUE type, VALUE arg) {
  VALUE args[1];
  args[0] = arg;
  VALUE ret = rb_class_new_instance(1,args,type);
  return ret;
}
 
#define OT_NEW_Mk_enum_OBJ(typ,i)  MK(OtNewInstanceWithOneArg)(MK(Mk##typ),INT2VAL(i))
typedef VALUE(*MK(procCallF))(VALUE args);
 
struct MkCallS {
  VALUE               procCallback;
  VALUE               procArgs;
  bool                procNeedSelf;
  MK_I32              procArity;
  enum  {
    MkCallS_undef           = 0,
    MkCallS_own_method          = 1,
    MkCallS_other_method    = 2,
    MkCallS_unbound_method  = 3,
    MkCallS_proc            = 4,
  }                   procType;
  MK(procCallF)       procCall;
  bool                isAlloc;
  MK_MNG              hdl;
  MK_RT               mkrt;
};
 
MK_EXTERN void NS(CallFree) (MK_PTR* callP);
MK_EXTERN void NS(CallFreeOnce) (MK_PTR* callP);
 
// BEGIN-enum - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
MK_RB_EXTERN_DATA VALUE MK(MkErrorE);
MK_RB_EXTERN_DATA VALUE MK(MkIdSE);
MK_RB_EXTERN_DATA VALUE MK(MkTimeoutE);
MK_RB_EXTERN_DATA VALUE MK(MkTypeE);
 
// END-enum - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// class ******************************************************************************
 
// object 2 native *************************************************************************
 
#include "tmpl/mk_misc_ObjAs_lng.h"
 
#define OT_CHECK_LNGTMPL(val,func) MkErrorC_CheckD (func(OT_Check_CALL(#val),&val));
 
#define OT_CHECK_bool(val)      OT_CHECK_LNGTMPL(val,MK(Obj_AsBOOL))
#define OT_CHECK_NB1(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsBOL))
#define OT_CHECK_NI1(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsI8))
#define OT_CHECK_NI2(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsI16))
#define OT_CHECK_NI4(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsI32))
#define OT_CHECK_NI8(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsI64))
#define OT_CHECK_NF4(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsFLT))
#define OT_CHECK_NF8(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsDBL))
#define OT_CHECK_NIL(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsLONG))
#define OT_CHECK_STRN(val)      OT_CHECK_LNGTMPL(val,MK(Obj_AsSTRN))
 
MK_RB_EXTERN enum MkErrorE MK(Obj_AsSTR_COPY)    (OT_Check_ARGS,MK_STR,size_t);
#define OT_CHECK_C_COPY(val,size)  MkErrorCheck (MK(Obj_AsSTR_COPY)(OT_Check_CALL(#val),val,size));
 
// isc nspection *************************************************************************
 
#define OT_GET_CALL_PROC        MK(Get_Call_Proc)   (1,&frame)
#define OT_GET_CALL_FILE        MK(Get_Call_Script) (1,&frame)
#define OT_GET_CALL_LINE        MK(Get_Call_Line)   (1,&frame)
 
MK_RB_EXTERN  MK_STRN   MK(Get_Call_Proc)       (int,VALUE*);
MK_RB_EXTERN  MK_STRN   MK(Get_Call_Script)     (int,VALUE*);
MK_RB_EXTERN  MK_I32    MK(Get_Call_Line)       (int,VALUE*);
MK_RB_EXTERN  void      MK(Get_Call_All)        (int,MK_STRN*,MK_STRN*,MK_I32*);
void    MK(Get_Call_Stack)      (MK_RT_ARGS MK_ERR const, int);
void    MK(printLNG_STACK)      (MK_RT_ARGS MK_MNG mng);
 
#define OT_GET_CALL_ALL \
  MK_STRN proc,file; MK_I32 line; MK(Get_Call_All)(0,&proc,&file,&line);
 
/*****************************************************************************/
/*                                                                           */
/*                                 functions                                 */
/*                                                                           */
/*****************************************************************************/
 
// from misc_lng.c
MK_RB_EXTERN  void    MK(MkExceptionC_Raise)  (OT_Prefix_ARGS MK_MNGN const, MK_STRN const, MK_STRN const, MK_I32);
MK_RB_EXTERN  MK_ERR  MK(MkExceptionC_Catch)  (OT_Prefix_ARGS MK_MNG const, MK_EXP const, MK_STRN const, MK_STRN const);
 
#define OT_ERROR_META_2_LNG(m)      MK(MkExceptionC_Raise)  (OT_Prefix_CALL m, __doc, __FILE__, __LINE__)
#define OT_ERROR_LNG_2_META(m)      MK(MkExceptionC_Catch)  (OT_Prefix_CALL m, NULL, __func__, NULL)
#define OT_ERROR_LNG_2_META_2(m,s)  MK(MkExceptionC_Catch)  (OT_Prefix_CALL m, NULL, __func__, s)
 
// from MkBufferListC_rb.c
OT_ProcRet      MK(MkBufferListC_ToList)         (MkBufferListC_ARGS);
 
#define NIL_Check(v)        if (NIL_P(v)) goto error;
 
/*****************************************************************************/
/*                                                                           */
/*                                 ref counting                              */
/*                                                                           */
/*****************************************************************************/
 
# define INCR_REG(val)       rb_ary_push(MK(globalRef),val)
# define DECR_REG(val)       rb_ary_delete(MK(globalRef),val)
 
# define INCR_REF(valP)       rb_gc_register_address(valP)
# define DECR_REF(valP)       rb_gc_unregister_address(valP)
 
MK_RB_EXTERN_DATA OT_OBJ_T MK(globalRef);
MK_RB_EXTERN_DATA OT_OBJ_T MK(cEnum);
 
/*****************************************************************************/
/*                                                                           */
/*                                 definition's                              */
/*                                                                           */
/*****************************************************************************/
 
#define VAL2I8(val)         (MK_I8)NUM2CHR(val)
#define VAL2BOL(val)        (MK_BOL)MK(_VAL2BOL)(val)
#define VAL2SRT(val)        (MK_I16)NUM2SHORT(val)
#define VAL2I32(val)        (MK_I32)NUM2INT(val)
#define VAL2I64(val)        (MK_I64)NUM2LL(val)
#define VAL2FLT(val)        (MK_FLT)NUM2DBL(val)
#define VAL2DBL(val)        (MK_DBL)NUM2DBL(val)
#define VAL2STRN(val)       (MK_STRN)RSTRING_PTR(rb_obj_as_string(val))
#define VAL2BIN(val)        (MK_BINN)RSTRING_PTR(val),RSTRING_LEN(val)
#define VAL2PTR(val)        (MK_PTR)(val)
#define VAL2REF(val)        (MK_PTR)(val)
#define VAL2LONG(val)       NUM2LONG(val)
#define VAL2MNG(val)        (MK_MNG)DATA_PTR(val)
 
#define PTR2VAL(nat)        MK(_PTR2VAL)(nat)
#define OBJ2VAL(nat)        ((OT_OBJ_T)((MK_OBJ)nat)->self)
#define I82VAL(nat)         INT2FIX((MK_I8)nat)
#define BOL2VAL(nat)        ((nat)?Qtrue:Qfalse)
#define I162VAL(nat)        INT2FIX((MK_I16)nat)
#define INT2VAL(nat)        INT2NUM((MK_I32)nat)
#define I642VAL(nat)        LL2NUM((MK_I64)nat)
#define FLT2VAL(nat)        DBL2NUM((double)nat)
#define DBL2VAL(nat)        DBL2NUM((double)nat)
#define STRN2VAL(nat)       MK(_STRN2VAL)(nat)
#define BIN2VAL(ptr,len)    rb_str_new((const char*)ptr,(long)len)
#define STR2VAL(ptr,len)    rb_str_new((const char*)ptr,(long)len)
#define LONG2VAL(nat)       LONG2FIX(nat)
#define HDL2VAL(nat)        INT2NUM(nat)
 
 
// *********************************************************************************************
 
mk_inline bool     MK(_VAL2BOL)  (OT_OBJ_T val) {return RTEST(val); }
mk_inline OT_OBJ_T MK(_PTR2VAL)  (MK_PTR nat)   {return (nat != NULL ? (OT_OBJ_T)(nat) : Qnil);}
MK_RB_EXTERN_DATA VALUE MK(NULL_STR);
MK_ARTIFICIAL mk_inline OT_OBJ_T MK(_STRN2VAL) (MK_STRN val)  {
  // mark=MK_NULL
  if (val==MK_NULL) {
    return MK(NULL_STR);
  } else {
    return rb_str_new_cstr(val);
  }
}
 
/*****************************************************************************/
/*                                                                           */
/*                          reference                                        */
/*                                                                           */
/*****************************************************************************/
 
#define ME_REF_MkBinaryR                MkBinaryR
#define OT_GET__ME_REF_MkBinaryR(b)     BIN2VAL(b.data,(int)b.size)
#define VAL2MkBinaryR(_obj) ({                                           \
  OT_OBJ_T obj=_obj;                                                     \
  MK_BIN bin=NULL;                                                       \
  MK_SIZE len=0;                                                         \
  if (!OT_LNG_IS_NULL(obj)) {                                            \
    if (RB_TYPE_P(obj, T_STRING)) {                                      \
      bin = (MK_BIN)RSTRING_PTR(obj);                                    \
      len = (MK_SIZE)RSTRING_LEN(obj);                                   \
    } else {                                                             \
      OT_ERROR_TYPE("parameter '" #_obj "' must be a 'byte-array'.");    \
    }                                                                    \
  }                                                                      \
  MkBinaryCreate(len,bin);                                               \
})
#define OT_CHECK__ME_REF_MkBinaryR(val)                      \
  if (__skip >= objc) {                                      \
    OT_ERROR_NUMARGS(hdl,__skip, objc, -999, +999, #val);    \
  } else {                                                   \
    val=VAL2MkBinaryR(objv[__skip++]);                       \
  }
 
#define ME_REF_MkStringR                MkStringR
#define OT_GET__ME_REF_MkStringR(b)     STR2VAL(b.ptr,b.len)
#define VAL2MkStringR(_obj) ({        \
  OT_OBJ_T obj=_obj;                  \
  MK_STRN str=NULL;                   \
  MK_NUM len=0;                       \
  if (!OT_LNG_IS_NULL(obj)) {         \
    str=RSTRING_PTR(obj);             \
    len=RSTRING_LENINT(obj);          \
  }                                   \
  MkStringCreate(len,str);            \
})
#define OT_CHECK__ME_REF_MkStringR(val)                      \
  if (__skip >= objc) {                                      \
    OT_ERROR_NUMARGS(hdl,__skip, objc, -999, +999, #val);    \
  } else {                                                   \
    val=VAL2MkStringR(objv[__skip++]);                       \
  }
 
/*****************************************************************************/
/*                                                                           */
/*                                  Misc's                                   */
/*                                                                           */
/*****************************************************************************/
 
MK_RB_EXTERN_DATA  ID MK(id_clone);
MK_RB_EXTERN_DATA  ID MK(id_unbind);
MK_RB_EXTERN_DATA  ID MK(id_bind);
MK_RB_EXTERN_DATA  ID MK(id_receiver);
MK_RB_EXTERN_DATA  ID MK(id_enum_attr);
MK_RB_EXTERN_DATA  ID MK(id_to_i);
 
// called from ALL "*_ObjNew" style functions
mk_inline VALUE MK(AtomObjNew) (MK_RT_ARGS MK_OBJ obj)
{
  if (obj == NULL) return Qnil;
  #define __doc  "AtomObjNew"
  MK_PTR self = NULL;
  MkErrorC_Check(obj, MkSelfNew(obj,&self,NULL))
  return (VALUE) self;
  #undef __doc
}
 
// called from ALL "LNG_CONSTR" style functions
mk_inline VALUE MK(AtomObjCrt) (OT_CLS_T clazz, MK_PTR type, MK_MNG mng, int objc, VALUE* objv)
{
  OT_OBJ_T self = TypedData_Wrap_Struct (clazz, type, mng);
  rb_obj_call_init(self, objc, objv);
  rb_gc_register_mark_object(self);
  return self;
}
 
mk_inline VALUE MK(AtomCreate) (MkObjectC_ARGS) 
{
  MK_MNG mng = VAL2MNG(self);
  if (mng == 0L) {
    rb_raise(rb_eRuntimeError, "MkObjectC: the constructor has a NULL pointer");
    MK_UNREACHABLE;
  }
  MK_OBJ obj = MkObj((MK_MNG)mng);
  if (obj == NULL) {
    rb_raise(rb_eRuntimeError, "MkObjectC: signature check failed");
    MK_UNREACHABLE;
  }
  MK_PTR ref = VAL2PTR(self);
  if (ref == NULL) {
    rb_raise(rb_eRuntimeError, "MkObjectC: unable to create 'NewGlobalRef'");
    MK_UNREACHABLE;
  }
  MkRefIncrSelf(obj,ref,NULL);
  // incr GC reference of SELF → decr in "AtomDeleteHard"
  INCR_REF((VALUE*)&obj->self);
  return Qnil;
}
 
// RUBY object is still alive
// called by: "Delete" as pseudo-DTOR
mk_inline void MK(AtomDeleteHard) (MK_RT_ARGS OT_OBJ_T self)
{
  if (OT_LNG_IS_NULL(self)) return;
  // self
  MK_MNG mng = VAL2MNG(self);
  if (mng == NULL) return;
  // object
  MK_OBJ obj = MkObj(mng);
  if (obj == NULL) return;
  // delete link between SELF and META
    // MkSelfUnlink(obj); → this does NOT work because the "self" is already NULL
  DATA_PTR(self) = NULL;
  // decr GC reference of SELF → incr in "AtomCreate"
  DECR_REF((VALUE*)&obj->self);
  // delete link between META and RELF
  MkRefDecrWithoutSelf(obj);
}
 
// RUBY object is already dead
// called by: Data_Wrap_Struct on real object deletion
mk_inline void MK(AtomDeleteSoft) (MK_MNG mng) 
{
  MK_OBJ obj = MkObj(mng);
//printXV(obj,"111111111111111111 → mng=%p, obj=%p, self=%#lx\n", mng , obj, (obj?OBJ2VAL(obj):0))
  if (obj == NULL) return;
  MkRtSetup_ON(obj);
 
//  if (MkBflCheck(obj)) {
//    printTxt(MkObjectToName(obj));
//    printSTACK_1(obj);
//  }
 
  // delete link between MQ and RUBY
//printV("mng<%p>, valid<%d>\n",mng,MkObjCheck(mng))
  MkRefDecrWithoutSelf(obj);
}
 
// RUBY object is still alive
// called by: "Delete" as pseudo-DTOR
mk_inline void MK(AtomDelete) (MK_RT_ARGS MK_MNG mng)
{
  // object
  MK_OBJ obj = MkObj(mng);
  if (obj == NULL) return;
  // delete link between META and RUBY
  MkRefDecrWithUnlinkSelf(obj);
}
 
// RUBY object is still alive
// called by: "Dispose" as pseudo-DTOR
mk_inline void MK(AtomDispose) (MK_RT_ARGS MK_MNG mng)
{
  // object
  MK_OBJ obj = MkObj(mng);
  if (obj == NULL) return;
  // delete link between META and RUBY
  MkRefDecrWithUnlinkSelf(obj);
}
 
#undef HEADER