MkObjectC_rb.c

Go to the documentation of this file.

 
/* LABEL-INIT */
 
#define MK_BASE_CLASS   rb_cObject
#define OBJ             hdl
 
#define SetupRtFromObj_X(hdl)     MkRtSetup_O(hdl)
#define SetupRtFromObj_XN(hdl)    MkRtSetup_ON(hdl)
 
/* LABEL-START */
#define META_FILE_NAME "MkObjectC_rb.c"
 
#include  "LibMkKernel_private_rb.h"
 
#define OT_CLASS            NS(MkObjectC)
#define OT_CLASS_NAME       "MkObjectC"
 
#define OT_LNG2META(O)      MkObj(VAL2MNG(O))
 
OT_CLS_T OT_CLASS;
 
// new Class type object
static MK_TYP MkObjectCTT = NULL;
OT_OBJ_T MK(MkObjectC_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(MkObjectC_T) = {
  "MkObjectC",
  {
    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 "MkObjectC"
mk_inline OT_OBJ_T NS(LNG_CONSTR) (OT_CLS_T clazz, MK_MNG mng, int objc, VALUE* objv) {
  return MK(AtomObjCrt)(clazz,&NS(MkObjectC_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(MkObjectC_ObjNew) (MK_OBJ hdl) {
//   return MK(AtomObjNew) (MkObjectC_X2obj(hdl));
// }
// MQ: ObjNew feature: selfCreate will be called from "ObjNew->MkSelfNew" if MkObj need a SELF pointer
static MK_PTR NS(MkObjectC_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(MkObjectC_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(MkObjectC_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-MkObjectC-Type
  MkObjectCTT->selfCreate    = NS(MkObjectC_selfCreate);
  MkObjectCTT->selfDelete    = NS(MkObjectC_selfDelete);
  MkObjectCTT->selfUnlink    = NS(MkObjectC_selfUnlink);
 
  // create the RUBY class
  OT_CLASS = rb_define_class_under(OT_PKG, "MkObjectC", MK_BASE_CLASS);
  rb_undef_alloc_func(OT_CLASS);
 
  /* define the "NULL" object */
  VALUE nullO = TypedData_Wrap_Struct (OT_CLASS, &NS(MkObjectC_T), MK_NULL);
  NS(MkObjectC_MK_NULL) = nullO;
  INCR_REF(&NS(MkObjectC_MK_NULL));
}
 
#define OT_SETUP_hdl                OT_SETUP_hdl_tmpl(MkObjectC);
#define OT_SETUP_hdl__null_allow    OT_SETUP_hdl_tmpl__null_allow(MkObjectC);
#define OT_SETUP_hdl_constr         AllRtSetup_NULL; \
                                    OT_OBJ_T clazz = self; \
                                    MkObjectC_type hdl = (MkObjectC_type) &MkERROR;
#define OT_SETUP_hdl_destr          OT_SETUP_hdl_tmpl__null_allow(MkObjectC);
#define OT_SETUP_hdl_static         AllRtSetup_NULL; \
                                    __attribute__((unused)) MK_TYP hdl = MkObjectC##_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 */
 
#undef  OT_GET_CTX
#define OT_GET_CTX(hdl)           MkObjGetContext_O(hdl)
 
// BEGIN-DOC - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// doc-key: MkObjectC,MkDbg,sm_,func
#define DbgM_doc "MkObjectC.DbgM(message:string, ?debug:int32=0?, ?callfunc:string=\"MK_NULL\"?, ?lvl:int32=0?)"
 
// doc-key: MkObjectC,MkDbg,om_,func
#define DbgDump_doc "obj.DbgDump(?message:string=\"var\"?, ?callfunc:string=\"MK_NULL\"?) (const)"
#define DbgL_doc "fmtobj.DbgL(message:string, ?debug:int32=0?, ?callfunc:string=\"MK_NULL\"?, ?lvl:int32=0?) (const)"
#define DbgLogC_doc "obj.DbgLogC(?callfunc:string=\"MK_NULL\"?) (const)"
#define DbgO_doc "obj.DbgO(?callfunc:string=\"MK_NULL\"?) (const)"
#define DbgSTACK_doc "fmtobj.DbgSTACK(?skip:int32=0?, ?num:int32=-1?, ?callfunc:string=\"MK_NULL\"?) (const)"
 
// doc-key: MkObjectC,MkLog,om_,func
#define LogC_doc "fmtobj.LogC(message:string, ?debug:int32=0?, ?callfunc:string=\"MK_NULL\"?) (const)"
#define LogHEX_doc "fmtobj.LogHEX(callfunc:string, data:binary) (const)"
 
// doc-key: MkObjectC,MkObj,om_,func
#define RefGet_doc "int32 obj.RefGet()"
 
// doc-key: MkObjectC,MkObject,sc_,func
#define GetNull_doc "MkObjectC MkObjectC.GetNull()"
#define HandleResolve_doc "MkObjectC MkObjectC.HandleResolve(netHdl:MK_HDL)"
#define Instances_doc "MkObjectC MkObjectC.Instances()"
 
// doc-key: MkObjectC,MkObject,sm_,func
#define DeleteCallbackCleanup_doc "MkObjectC.DeleteCallbackCleanup(ident:string)"
#define DeleteCallbackSetup_doc "MkObjectC.DeleteCallbackSetup(ident:string, ?callback:callable=nil?, ?filter:string=\"nil\"?)"
#define HandleDeleteByNetHdl_doc "MkObjectC.HandleDeleteByNetHdl(netHdl:MK_HDL)"
 
// doc-key: MkObjectC,MkObject,oD_,func
#define Delete_doc "obj.Delete()"
 
// doc-key: MkObjectC,MkObject,od_,func
#define Dispose_doc "obj.Dispose()"
 
// doc-key: MkObjectC,MkObject,oc_,func
#define ErrorCatch_doc "MkErrorC obj.ErrorCatch(?exception:errorCode=nil?, ?callfunc:string=\"MK_NULL\"?) (const)"
#define Next_doc "MkObjectC obj.Next()"
#define Prev_doc "MkObjectC obj.Prev()"
#define ToError_doc "MkErrorC obj.ToError()"
 
// doc-key: MkObjectC,MkObject,om_,func
#define HandleDelete_doc "netObj.HandleDelete()"
#define HandleExists_doc "bool obj.HandleExists()"
#define HandleGet_doc "MK_HDL obj.HandleGet()"
#define HandleGetOfType_doc "MK_HDL obj.HandleGetOfType()"
#define HandleGetOr0_doc "MK_HDL obj.HandleGetOr0()"
#define IsNull_doc "bool obj.IsNull()"
#define Log_doc "obj.Log(?fmtobj:MkObjectC=nil?, ?debug:int32=0?, ?callfunc:string=\"MK_NULL\"?, ?lvl:int32=0?) (const)"
#define LogLong_doc "obj.LogLong(?fmtobj:MkObjectC=nil?, ?debug:int32=0?, ?callfunc:string=\"MK_NULL\"?, ?lvl:int32=0?) (const)"
#define LogShort_doc "obj.LogShort(?fmtobj:MkObjectC=nil?, ?debug:int32=0?, ?callfunc:string=\"MK_NULL\"?, ?lvl:int32=0?) (const)"
#define LogType_doc "obj.LogType(?fmtobj:MkObjectC=nil?, ?debug:int32=0?, ?callfunc:string=\"MK_NULL\"?, ?lvl:int32=0?) (const)"
#define ToName_doc "string obj.ToName() (const)"
#define ToNameOfClass_doc "string obj.ToNameOfClass()"
#define ToNameOfType_doc "string obj.ToNameOfType() (const)"
#define ToString_doc "string inst.ToString() (const)"
 
// doc-key: MkObjectC,MkSys,sm_,func
#define SysHashI32_doc "int32 MkObjectC.SysHashI32(key:string, ?length:int32=-1?)"
#define SysHashSTR_doc "string MkObjectC.SysHashSTR(key:string, ?length:int32=-1?)"
 
// doc-key: MkObjectC,MkSys,om_,func
#define SysKill_doc "fmtobj.SysKill(pid:int32, signal:int32) (const)"
 
// doc-key: MkObjectC,MkSys,omo,func
#define SysGetPid_doc "int32 fmtobj.SysGetPid() (const)"
 
// END-DOC - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// catch ignore MkErrorE
#define MkObjectErrorCatchTmpl(...)       MK(MkExceptionC_Catch)(OT_Prefix_CALL __VA_ARGS__, NULL)
#define MkObjectToNameOfClassTmpl(hdl)    rb_obj_classname(OBJ2VAL(hdl))
#define MkDbgDumpTmpl(...)                MK(DbgDumpTmpl)( MK_RT_CALL __VA_ARGS__ )
 
static enum MkErrorE MK(DbgDumpTmpl)( MK_RT_ARGS MK_OBJ const obj, MK_STRN const message, MK_STRN const callfunc)
{
  MkBufferCreateLOCAL_T(MkBuffer256C,buf,512);
  MkBufferAppendV(buf, "message = %s\n", message);
  MkBufferAppendV(buf, "intern  = %s\n", VAL2STRN(rb_inspect(OBJ2VAL(obj))));
  return MkDbgDump(obj, bufR.super.buf.storage.first.C, callfunc);
}
 
/*****************************************************************************/
/*                                                                           */
/*                                private                                    */
/*                                                                           */
/*****************************************************************************/
 
// ***************************************************************************************
 
// BEGIN-MkObjectC - created by 'rb_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// doc-key: MkObjectC,MkObjectC-Class-Export,sc_
 
static OT_ProcRet NS(MkObjectC_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_OBJ retVal = MkObjectHandleResolve (netHdl);
  OT_retObj_SET_OBJ(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MkObjectC,MkObjectC-Class-Export,om_
 
static OT_ProcRet NS(MkObjectC_HandleDelete) (MkObjectC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(HandleDelete_doc);
  OT_CHECK_NOARGS;
  MkObjectHandleDelete (hdl);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkObjectC_HandleExists) (MkObjectC_ARGS) {
  OT_SETUP_hdl__null_allow;
  OT_SETUP_NOARG(HandleExists_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MkObjectHandleExists (hdl));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkObjectC_HandleGet) (MkObjectC_ARGS) {
  OT_SETUP_hdl__null_allow;
  OT_SETUP_NOARG(HandleGet_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_HDL(MkObjectHandleGet (hdl));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkObjectC_HandleGetOfType) (MkObjectC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(HandleGetOfType_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_HDL(MkObjectHandleGetOfType (hdl));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkObjectC_HandleGetOr0) (MkObjectC_ARGS) {
  OT_SETUP_hdl__null_allow;
  OT_SETUP_NOARG(HandleGetOr0_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_HDL(MkObjectHandleGetOr0 (hdl));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MkObjectC,MkObjectC-Class-Export,sm_
 
static OT_ProcRet NS(MkObjectC_HandleDeleteByNetHdl) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(HandleDeleteByNetHdl_doc);
  MK_HDL netHdl = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NIH (netHdl))
  OT_CHECK_NOARGS;
  MkObjectHandleDeleteByNetHdl (netHdl);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// MkObjectC_Class_RB_API
 
 
// doc-key: MkObjectC,MkObjectC-Class-Introspection,oc_
 
static OT_ProcRet NS(MkObjectC_Next) (MkObjectC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Next_doc);
  OT_CHECK_NOARGS;
  MK_OBJ retVal = MkObjectNext (hdl);
  OT_retObj_SET_OBJ(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkObjectC_Prev) (MkObjectC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Prev_doc);
  OT_CHECK_NOARGS;
  MK_OBJ retVal = MkObjectPrev (hdl);
  OT_retObj_SET_OBJ(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MkObjectC,MkObjectC-Class-Introspection,sc_
 
static OT_ProcRet NS(MkObjectC_Instances) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Instances_doc);
  OT_CHECK_NOARGS;
  MK_OBJ retVal = MkObjectInstances ();
  OT_retObj_SET_OBJ(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// MkObjectC_Class_RB_API
 
 
// doc-key: MkObjectC,MkObjectC-Class-Misc,sc_
 
static OT_ProcRet NS(MkObjectC_GetNull) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(GetNull_doc);
  OT_CHECK_NOARGS;
  MK_OBJ retVal = MkObjectGetNull ();
  OT_retObj_SET_OBJ(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// MkObjectC_Class_RB_API
 
 
// doc-key: MkObjectC,MkObjectC-Dbg,om_
 
static OT_ProcRet NS(MkObjectC_DbgDump) (MkObjectC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,2,DbgDump_doc);
  MK_STRN message = "var";
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (message))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkErrorC_Check(hdl,MkDbgDumpTmpl (hdl, message, callfunc));
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkObjectC_DbgL) (MkObjectC_ARGS) {
  OT_SETUP_hdl__null_allow;
  OT_SETUP_VARARGS(1,4,DbgL_doc);
  MK_STRN message = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (message))
  MK_DBG debug = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (debug))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_I32 lvl = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (lvl))
  OT_CHECK_NOARGS;
  if (debug > MkRuntimeDebugGet()) {
    OT_retObj_SET_None;
    goto end;
  }
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkDbgL (hdl, message, debug, callfunc, lvl);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkObjectC_DbgLogC) (MkObjectC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,1,DbgLogC_doc);
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkDbgLogC (hdl, callfunc);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkObjectC_DbgO) (MkObjectC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,1,DbgO_doc);
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkDbgO (hdl, callfunc);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkObjectC_DbgSTACK) (MkObjectC_ARGS) {
  OT_SETUP_hdl__null_allow;
  OT_SETUP_VARARGS(0,3,DbgSTACK_doc);
  MK_I32 skip = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (skip))
  MK_I32 num = -1;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (num))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkDbgSTACK (hdl, skip, num, callfunc);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
// doc-key: MkObjectC,MkObjectC-Dbg,sm_
 
static OT_ProcRet NS(MkObjectC_DbgM) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_VARARGS(1,4,DbgM_doc);
  MK_STRN message = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (message))
  MK_DBG debug = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (debug))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_I32 lvl = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (lvl))
  OT_CHECK_NOARGS;
  if (debug > MkRuntimeDebugGet()) {
    OT_retObj_SET_None;
    goto end;
  }
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkDbgM (message, debug, callfunc, lvl);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
// MkObjectC_Dbg_RB_API
 
 
// doc-key: MkObjectC,MkObjectC-Log,om_
 
static OT_ProcRet NS(MkObjectC_LogC) (MkObjectC_ARGS) {
  OT_SETUP_hdl__null_allow;
  OT_SETUP_VARARGS(1,3,LogC_doc);
  MK_STRN message = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (message))
  MK_DBG debug = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (debug))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  OT_CHECK_NOARGS;
  if (debug > MkRuntimeDebugGet()) {
    OT_retObj_SET_None;
    goto end;
  }
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkLogC (hdl, message, debug, callfunc);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkObjectC_LogHEX) (MkObjectC_ARGS) {
  OT_SETUP_hdl__null_allow;
  OT_SETUP_VARARGS(1,2,LogHEX_doc);
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MkBinaryR data = {0};
  OT_CHECK_REQUIRED(OT_CHECK__ME_REF_MkBinaryR(data))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkLogHEX (hdl, callfunc, data);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkObjectC_Log) (MkObjectC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,4,Log_doc);
  MK_OBJN fmtobj = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_OBJN (fmtobj,MK_NULL_YES))
  MK_DBG debug = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (debug))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_I32 lvl = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (lvl))
  OT_CHECK_NOARGS;
  if (debug > MkRuntimeDebugGet()) {
    OT_retObj_SET_None;
    goto end;
  }
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkObjectLog (hdl, fmtobj, debug, callfunc, lvl);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkObjectC_LogLong) (MkObjectC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,4,LogLong_doc);
  MK_OBJN fmtobj = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_OBJN (fmtobj,MK_NULL_YES))
  MK_DBG debug = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (debug))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_I32 lvl = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (lvl))
  OT_CHECK_NOARGS;
  if (debug > MkRuntimeDebugGet()) {
    OT_retObj_SET_None;
    goto end;
  }
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkObjectLogLong (hdl, fmtobj, debug, callfunc, lvl);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkObjectC_LogShort) (MkObjectC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,4,LogShort_doc);
  MK_OBJN fmtobj = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_OBJN (fmtobj,MK_NULL_YES))
  MK_DBG debug = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (debug))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_I32 lvl = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (lvl))
  OT_CHECK_NOARGS;
  if (debug > MkRuntimeDebugGet()) {
    OT_retObj_SET_None;
    goto end;
  }
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkObjectLogShort (hdl, fmtobj, debug, callfunc, lvl);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkObjectC_LogType) (MkObjectC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,4,LogType_doc);
  MK_OBJN fmtobj = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_OBJN (fmtobj,MK_NULL_YES))
  MK_DBG debug = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (debug))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_I32 lvl = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (lvl))
  OT_CHECK_NOARGS;
  if (debug > MkRuntimeDebugGet()) {
    OT_retObj_SET_None;
    goto end;
  }
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkObjectLogType (hdl, fmtobj, debug, callfunc, lvl);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
// MkObjectC_Log_RB_API
 
 
// doc-key: MkObjectC,MkObjectC-Misc,oc_
 
static OT_ProcRet NS(MkObjectC_ErrorCatch) (MkObjectC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,2,ErrorCatch_doc);
  MK_EXP exception = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_EXP (exception))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MK_ERR retVal = MkObjectErrorCatchTmpl (hdl, exception, callfunc);
  OT_retObj_SET_ERR(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkObjectC_ToError) (MkObjectC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ToError_doc);
  OT_CHECK_NOARGS;
  MK_ERR retVal = MkObjectToError (hdl);
  OT_retObj_SET_ERR(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MkObjectC,MkObjectC-Misc,om_
 
static OT_ProcRet NS(MkObjectC_IsNull) (MkObjectC_ARGS) {
  OT_SETUP_hdl__null_allow;
  OT_SETUP_NOARG(IsNull_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MkObjectIsNull (hdl));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkObjectC_ToName) (MkObjectC_ARGS) {
  OT_SETUP_hdl__null_allow;
  OT_SETUP_NOARG(ToName_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MkObjectToName (hdl));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkObjectC_ToNameOfClass) (MkObjectC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ToNameOfClass_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MkObjectToNameOfClassTmpl (hdl));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkObjectC_ToNameOfType) (MkObjectC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ToNameOfType_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MkObjectToNameOfType (hdl));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkObjectC_ToString) (MkObjectC_ARGS) {
  OT_SETUP_hdl__null_allow;
  OT_SETUP_NOARG(ToString_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MkObjectToString (hdl));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// MkObjectC_Misc_RB_API
 
 
// doc-key: MkObjectC,MkObjectC-Obj,om_
 
static OT_ProcRet NS(MkObjectC_RefGet) (MkObjectC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(RefGet_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkRefGet (hdl));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// MkObjectC_Obj_RB_API
 
 
// doc-key: MkObjectC,MkObjectC-Sys,om_
 
static OT_ProcRet NS(MkObjectC_SysKill) (MkObjectC_ARGS) {
  OT_SETUP_hdl__null_allow;
  OT_SETUP_VARARGS(2,2,SysKill_doc);
  MK_I32 pid = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (pid))
  MK_I32 signal = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (signal))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkSysKill (hdl, pid, signal));
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MkObjectC,MkObjectC-Sys,omo
 
static OT_ProcRet NS(MkObjectC_SysGetPid) (MkObjectC_ARGS) {
  OT_SETUP_hdl__null_allow;
  OT_SETUP_NOARG(SysGetPid_doc);
  OT_CHECK_NOARGS;
  MK_I32 pid_out;
  MkErrorC_Check(hdl,MkSysGetPid (hdl, &pid_out));
  OT_retObj_SET_I32(pid_out);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MkObjectC,MkObjectC-Sys,sm_
 
static OT_ProcRet NS(MkObjectC_SysHashI32) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_VARARGS(1,2,SysHashI32_doc);
  MK_STRN key = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (key))
  MK_NUM length = -1;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (length))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkSysHashI32 (key, length));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkObjectC_SysHashSTR) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_VARARGS(1,2,SysHashSTR_doc);
  MK_STRN key = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (key))
  MK_NUM length = -1;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (length))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MkSysHashSTR (key, length));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// MkObjectC_Sys_RB_API
 
 
// doc-key: MkObjectC,MkObjectC-TOR,od_
 
static OT_ProcRet NS(MkObjectC_Dispose) (MkObjectC_ARGS) {
  OT_SETUP_hdl_destr;
  OT_SETUP_NOARG(Dispose_doc);
  OT_CHECK_NOARGS;
  OT_OBJECT_DISPOSE(OT_SELF);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MkObjectC,MkObjectC-TOR,oD_
 
static OT_ProcRet NS(MkObjectC_Delete) (MkObjectC_ARGS) {
  OT_SETUP_hdl_destr;
  OT_SETUP_NOARG(Delete_doc);
  OT_CHECK_NOARGS;
  OT_OBJECT_DELETE(OT_SELF);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MkObjectC,MkObjectC-TOR,sm_
 
static OT_ProcRet NS(MkObjectC_DeleteCallbackCleanup) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(DeleteCallbackCleanup_doc);
  MK_STRN ident = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (ident))
  OT_CHECK_NOARGS;
  MkObjectDeleteCallbackCleanup (ident);
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkObjectC_DeleteCallbackSetup) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_VARARGS(1,3,DeleteCallbackSetup_doc);
  MK_STRN ident = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (ident))
  OT_SETUP_CALLABLE(callback)
  OT_CHECK_OPTIONAL(OT_CHECK_CALLABLE(callback))
  MK_STRN filter = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (filter))
  OT_CHECK_NOARGS;
  MkObjectDeleteCallF fCall = (callback == NULL ? NULL : NS(ObjectDeleteCall));
  MkErrorC_Check(MK_ERROR_FORMAT,MkObjectDeleteCallbackSetup (ident, fCall, callback, NS(ObjectDeleteFree), filter));
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_CLEANUP_CALLABLE(callback)
  OT_retObj_RETURN;
}
 
// MkObjectC_TOR_RB_API
 
// END-MkObjectC - created by 'rb_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// ########################################################################################
// OVERLOAD
 
static OT_ProcRet NS(MkObjectC_to_s) (MkObjectC_ARGS) {
  OT_SETUP_hdl__null_allow
  OT_SETUP_NOARG("String obj.to_s()")
  OT_CHECK_NOARGS
  MK_STRN retVal = MkObjectToString (hdl);
  OT_retObj_SET_STRN(retVal)
  OT_retObj_RETURN
}
 
/*****************************************************************************/
/*                                                                           */
/*                                public                                     */
/*                                                                           */
/*****************************************************************************/
 
static VALUE MK(NEW)(int objc, VALUE *objv, VALUE class) 
{
  return Qnil;
}
 
static void NS(sMark) (MK_PTR mng)
{
}
 
void MK(MkObjectC_Init) (MK_RT_ARGS_ONLY) {
 
  // init type
  MkObjectCTT = MkObjectC_TT;
  S_INIT;
 
  // create the RUBY memory allocator for class MkObjectC
  rb_define_singleton_method(MK(MkObjectC), "new", MK(NEW), -1);
 
  // make class note create-able
  rb_funcall(MK(MkObjectC), rb_intern("private_class_method"), 1, STRN2VAL("new"));
  rb_define_protected_method( MK(MkObjectC), "initialize",  MK(AtomCreate),   -1);
 
  OT_METH_O ( MkObjectC, to_s,                      MkObjectC_to_s                      )
 
// BEGIN-CLASS - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// doc-key: MkObjectC,MkDbg,sm_
OT_METH_O ( MkObjectC, DbgM,                      MkObjectC_DbgM                      )
OT_METH_S ( MkObjectC, DbgM,                      MkObjectC_DbgM                      )
 
// doc-key: MkObjectC,MkObject,sc_
OT_METH_O ( MkObjectC, GetNull,                   MkObjectC_GetNull                   )
OT_METH_S ( MkObjectC, GetNull,                   MkObjectC_GetNull                   )
OT_METH_O ( MkObjectC, HandleResolve,             MkObjectC_HandleResolve             )
OT_METH_S ( MkObjectC, HandleResolve,             MkObjectC_HandleResolve             )
OT_METH_O ( MkObjectC, Instances,                 MkObjectC_Instances                 )
OT_METH_S ( MkObjectC, Instances,                 MkObjectC_Instances                 )
 
// doc-key: MkObjectC,MkObject,sm_
OT_METH_O ( MkObjectC, DeleteCallbackCleanup,     MkObjectC_DeleteCallbackCleanup     )
OT_METH_S ( MkObjectC, DeleteCallbackCleanup,     MkObjectC_DeleteCallbackCleanup     )
OT_METH_O ( MkObjectC, DeleteCallbackSetup,       MkObjectC_DeleteCallbackSetup       )
OT_METH_S ( MkObjectC, DeleteCallbackSetup,       MkObjectC_DeleteCallbackSetup       )
OT_METH_O ( MkObjectC, HandleDeleteByNetHdl,      MkObjectC_HandleDeleteByNetHdl      )
OT_METH_S ( MkObjectC, HandleDeleteByNetHdl,      MkObjectC_HandleDeleteByNetHdl      )
 
// doc-key: MkObjectC,MkSys,sm_
OT_METH_O ( MkObjectC, SysHashI32,                MkObjectC_SysHashI32                )
OT_METH_S ( MkObjectC, SysHashI32,                MkObjectC_SysHashI32                )
OT_METH_O ( MkObjectC, SysHashSTR,                MkObjectC_SysHashSTR                )
OT_METH_S ( MkObjectC, SysHashSTR,                MkObjectC_SysHashSTR                )
 
// 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: MkObjectC,MkDbg,om_
OT_METH_O ( MkObjectC, DbgDump,                   MkObjectC_DbgDump                   )
OT_METH_O ( MkObjectC, DbgL,                      MkObjectC_DbgL                      )
OT_METH_O ( MkObjectC, DbgLogC,                   MkObjectC_DbgLogC                   )
OT_METH_O ( MkObjectC, DbgO,                      MkObjectC_DbgO                      )
OT_METH_O ( MkObjectC, DbgSTACK,                  MkObjectC_DbgSTACK                  )
 
// doc-key: MkObjectC,MkLog,om_
OT_METH_O ( MkObjectC, LogC,                      MkObjectC_LogC                      )
OT_METH_O ( MkObjectC, LogHEX,                    MkObjectC_LogHEX                    )
 
// doc-key: MkObjectC,MkObj,om_
OT_METH_O ( MkObjectC, RefGet,                    MkObjectC_RefGet                    )
 
// doc-key: MkObjectC,MkObject,oD_
OT_METH_O ( MkObjectC, Delete,                    MkObjectC_Delete                    )
 
// doc-key: MkObjectC,MkObject,od_
OT_METH_O ( MkObjectC, Dispose,                   MkObjectC_Dispose                   )
 
// doc-key: MkObjectC,MkObject,oc_
OT_METH_O ( MkObjectC, ErrorCatch,                MkObjectC_ErrorCatch                )
OT_METH_O ( MkObjectC, Next,                      MkObjectC_Next                      )
OT_METH_O ( MkObjectC, Prev,                      MkObjectC_Prev                      )
OT_METH_O ( MkObjectC, ToError,                   MkObjectC_ToError                   )
 
// doc-key: MkObjectC,MkObject,om_
OT_METH_O ( MkObjectC, HandleDelete,              MkObjectC_HandleDelete              )
OT_METH_O ( MkObjectC, HandleExists,              MkObjectC_HandleExists              )
OT_METH_O ( MkObjectC, HandleGet,                 MkObjectC_HandleGet                 )
OT_METH_O ( MkObjectC, HandleGetOfType,           MkObjectC_HandleGetOfType           )
OT_METH_O ( MkObjectC, HandleGetOr0,              MkObjectC_HandleGetOr0              )
OT_METH_O ( MkObjectC, IsNull,                    MkObjectC_IsNull                    )
OT_METH_O ( MkObjectC, Log,                       MkObjectC_Log                       )
OT_METH_O ( MkObjectC, LogLong,                   MkObjectC_LogLong                   )
OT_METH_O ( MkObjectC, LogShort,                  MkObjectC_LogShort                  )
OT_METH_O ( MkObjectC, LogType,                   MkObjectC_LogType                   )
OT_METH_O ( MkObjectC, ToName,                    MkObjectC_ToName                    )
OT_METH_O ( MkObjectC, ToNameOfClass,             MkObjectC_ToNameOfClass             )
OT_METH_O ( MkObjectC, ToNameOfType,              MkObjectC_ToNameOfType              )
OT_METH_O ( MkObjectC, ToString,                  MkObjectC_ToString                  )
 
// doc-key: MkObjectC,MkSys,om_
OT_METH_O ( MkObjectC, SysKill,                   MkObjectC_SysKill                   )
 
// doc-key: MkObjectC,MkSys,omo
OT_METH_O ( MkObjectC, SysGetPid,                 MkObjectC_SysGetPid                 )
 
// END-OBJ - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
}