MkObjectC_tcl.c

Go to the documentation of this file.

 
/* LABEL-INIT */
 
#define SetupRtFromHdl_X(hd)  MkRtSetup_O(hd)
#define SetupRtFromHdl_XN(hd) MkRtSetup_ON(hd)
 
/* LABEL-START */
 
#define   META_FILE_NAME      "MkObjectC_tcl.c"
 
#include  "LibMkKernel_private_tcl.h"
 
#define   OT_CLASS            NS(MkObjectC)
#define   OT_CLASS_NAME       "MkObjectC"
 
#define   OBJECT2OBJ(O)   MkAssertCastM(MkObjectC,(Tcl_ObjectGetMetadata(O, &MK(AtomMeta))))
 
// TCL class
MkThreadLocal OT_CLS_T OT_CLASS = NULL;
 
// META class
static MkThreadLocal MK_TYP MkObjectCTT = NULL;
MkThreadLocal OT_OBJ_T MK(MkObjectC_MK_NULL) = NULL;
 
// META: 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 const obj, MK_PTR const env) {
  OT_ENV_T interp = env;
  return MK(AtomCreate) (MK_RT_CALL interp,obj,OT_CLASS,NULL,NULL);
}
// META: is called when the META object is destroyed and SELF does NOT belongs to the META.
static void NS(MkObjectC_selfDelete) (MK_RT_ARGS MK_PTR selfP, MK_PTR const env) {
  OT_SELF_T selfO = selfP;
  OT_ENV_T  interp = env;
  MK(AtomDeleteHard) (MK_RT_CALL interp, selfO);
}
// META: is called when the META object is destroyed and SELF does NOT belong to the META.
static void NS(MkObjectC_selfUnlink) (MK_RT_ARGS MK_PTR selfP, MK_PTR const env) {
  OT_SELF_T selfO = selfP;
  OT_ENV_T  interp = env;
  MK(AtomUnlink) (MK_RT_CALL interp, selfO);
}
 
// ATTENTION: TCL has no "Unlink" because the "Tcl_ObjectSetMetadata(selfO,&MK(AtomMeta),NULL);" call
// also the destructor
 
#define   OT_SETUP_hdl_static_constr_pre
#define   OT_SETUP_hdl_static_constr \
  OT_SETUP_hdl_static_constr_pre; \
  OT_SETUP_hdl_static
 
#define   OT_SETUP_hdl_static     \
  int __skip=Tcl_ObjectContextSkippedArgs(objCtx); \
  AllRtSetup_NULL; \
  __attribute__((unused)) OT_SELF_T selfO = Tcl_ObjectContextObject(objCtx); \
  __attribute__((unused)) MK_TYP hdl = MkObjectC##_TT;
 
#define   OT_SETUP_hdl              SetupHdlFromMetaData_2(OBJ,MK_OBJ);
#define   OT_SETUP_hdl__null_allow  SetupHdlFromMetaData__null_allow_2(OBJ,MK_OBJ);
#define   OT_SETUP_hdl_destr        SetupHdlFromMetaData__null_allow_2(OBJ,MK_OBJ);
 
#define   OT_SETUP_hdl_constr_pre
#define   OT_SETUP_hdl_constr \
  OT_SETUP_hdl_constr_pre; \
  int __skip=Tcl_ObjectContextSkippedArgs(objCtx); \
  AllRtSetup_NULL; \
  MK_RT_UNUSED OT_SELF_T selfO = Tcl_ObjectContextObject(objCtx); \
  MK_OBJ hdl = (MK_OBJ) &MkERROR;
 
#if !defined(SetupRtFromHdl_XN)
  #define SetupRtFromHdl_XN(hdl)  AllRtSetup_XN(hdl)
  #define SetupRtFromHdl_X(hdl)   AllRtSetup_X(hdl)
#endif
 
// initialize the TCL and MO class specific object
#define   ClassInit \
  /* if not already done, initialize NEW MQ type */ \
  if (MkObjectCTT == NULL) MkObjectCTT = MkObjectSTT; \
 \
  /* protect against double call */ \
  if (MkObjectCTT->selfCreate == NS(MkObjectC_selfCreate)) return MK_OK; \
 \
  /* add "selfCreate" and "selfDelete" feature to the MQ-Class */ \
  MkObjectCTT->selfCreate    = NS(MkObjectC_selfCreate); \
  MkObjectCTT->selfDelete    = NS(MkObjectC_selfDelete); \
  MkObjectCTT->selfUnlink    = NS(MkObjectC_selfUnlink); \
 \
  /* create the TCL-class */ \
  OT_SELF_T classO = MK(ClassDef)(interp,ns,MkObjectCTT); \
  check_NULL(classO) goto error; \
  OT_CLASS = Tcl_GetObjectAsClass(classO); \
 \
  /* create the TCL static Methods */ \
  static MkThreadLocal OtUnknownS NS(sClassUnknown) = {OT_UNKNOWN_CLASS}; \
  check_LNG(MK(UnknownSetup) (interp,classO,NS(sOtClassDef),&NS(sClassUnknown))) goto error; \
 \
  /* create the TCL instance Methods */ \
  static MkThreadLocal OtUnknownS NS(sInstanceUnknown) = {OT_UNKNOWN_INSTANCE}; \
  check_LNG(MK(UnknownSetup) (interp,classO,NS(sInstanceDef),&NS(sInstanceUnknown))) goto error; \
 \
  /* define the "NULL" object */ \
  MK(MkObjectC_MK_NULL) = Tcl_GetObjectName(interp, \
    MK(AtomCreate) (MK_RT_CALL interp,  NULL /*obj*/, OT_CLASS, "MK_NULL" /*name*/, "::tclmkkernel::MkObjectC" /*ns*/) \
  ); \
  Tcl_IncrRefCount(MK(MkObjectC_MK_NULL));
 
#define VER TCL_OO_METHOD_VERSION_CURRENT
 
/* LABEL-END */
 
// BEGIN-DOC - created by 'tcl_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=\"MK_NULL\"? ?filter:string=\"MK_NULL\"?"
#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=\"MK_NULL\"? ?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=\"MK_NULL\"? ?debug:int32=0? ?callfunc:string=\"MK_NULL\"? ?lvl:int32=0? (const)"
#define LogLong_doc "$obj LogLong ?fmtobj:MkObjectC=\"MK_NULL\"? ?debug:int32=0? ?callfunc:string=\"MK_NULL\"? ?lvl:int32=0? (const)"
#define LogShort_doc "$obj LogShort ?fmtobj:MkObjectC=\"MK_NULL\"? ?debug:int32=0? ?callfunc:string=\"MK_NULL\"? ?lvl:int32=0? (const)"
#define LogType_doc "$obj LogType ?fmtobj:MkObjectC=\"MK_NULL\"? ?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 'tcl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
/*****************************************************************************/
/*                                                                           */
/*                            S T A R T                                      */
/*                                                                           */
/*****************************************************************************/
 
// overwrite "libmkkernel→MkObjectToNameOfClass_O" with "own" implementation
#define MkDbgO_O(hdl,call)                  MkLogV(hdl,call,0,"%s\n",MK(PrintLngObj)(OT_Prefix_CALL NULL,META2VAL_O(hdl)))
#define MkDbgDumpTmpl(...)                  TclDbgDump(OT_Prefix_CALL __VA_ARGS__)
#define MkObjectToNameOfClassTmpl(hdl)      OT_LNG_OBJ_CLASSNAME(META2VAL_O(hdl))
#define MkObjectErrorCatchTmpl(...)         MK(MkExceptionC_Catch)(OT_Prefix_CALL __VA_ARGS__)
 
static enum MkErrorE
TclDbgDump ( OT_Prefix_ARGS MK_OBJ const  obj, MK_STRN const  message, MK_STRN const  callfunc )
{
  Tcl_Obj * self = META2VAL_O(obj);
  MkRuntimeLogBufferPush();
    MkLogV(obj,callfunc,0,MK_COLOR_CYAN" >>> "MK_COLOR_RESET"\n");
 
    fprintf(MK_RT_REF.log.logFILE,"  > " MK_COLOR_YELLOW "%s"MK_COLOR_RESET"\n", MK(PrintLngObj)(OT_Prefix_CALL message,self));
 
    MkObjectLog(obj,NULL,0,callfunc,1);
 
    MkLogV(obj,callfunc,0,MK_COLOR_CYAN" <<< "MK_COLOR_RESET"\n");
  MkRuntimeLogBufferPop();
 
  return MK_OK;
}
 
/*****************************************************************************/
/*                                                                           */
/*                        O B J E C T                                        */
/*                                                                           */
/*****************************************************************************/
 
// BEGIN-MkObjectC - created by 'tcl_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);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkObjectC_Class_TCL_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);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkObjectC_Class_TCL_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);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkObjectC_Class_TCL_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;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
// MkObjectC_Dbg_TCL_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;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
// MkObjectC_Log_TCL_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);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkObjectC_Misc_TCL_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));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkObjectC_Obj_TCL_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;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkObjectC_Sys_TCL_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;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  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;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_CLEANUP_CALLABLE(callback)
  OT_retObj_RETURN;
}
 
// MkObjectC_TOR_TCL_API
 
// END-MkObjectC - created by 'tcl_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// ---------------------------------------------------------------------------------------
 
const static Tcl_MethodType NS(sOtClassDef)[] = {
 
// BEGIN-CLASS - created by 'tcl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// doc-key: MkObjectC,MkDbg,sm_
  {VER, "DbgM"                , NS(MkObjectC_DbgM)                      , NULL, NULL},
 
// doc-key: MkObjectC,MkObject,sc_
  {VER, "GetNull"             , NS(MkObjectC_GetNull)                   , NULL, NULL},
  {VER, "HandleResolve"       , NS(MkObjectC_HandleResolve)             , NULL, NULL},
  {VER, "Instances"           , NS(MkObjectC_Instances)                 , NULL, NULL},
 
// doc-key: MkObjectC,MkObject,sm_
  {VER, "DeleteCallbackCleanup", NS(MkObjectC_DeleteCallbackCleanup)     , NULL, NULL},
  {VER, "DeleteCallbackSetup" , NS(MkObjectC_DeleteCallbackSetup)       , NULL, NULL},
  {VER, "HandleDeleteByNetHdl", NS(MkObjectC_HandleDeleteByNetHdl)      , NULL, NULL},
 
// doc-key: MkObjectC,MkSys,sm_
  {VER, "SysHashI32"          , NS(MkObjectC_SysHashI32)                , NULL, NULL},
  {VER, "SysHashSTR"          , NS(MkObjectC_SysHashSTR)                , NULL, NULL},
 
// END-CLASS - created by 'tcl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
  {0, NULL, NULL, NULL}
};
 
 
// with ALL_INIT_AT_STARTUP - all methods will be setup at startup
#define ALL_INIT_AT_STARTUP
 
static void NS(sUnknownAllMethods) (
  OT_ENV_T interp,
  const OtUnknownS   *ukn
) {
  const Tcl_MethodType  *type   = ukn->list;
  const size_t          nmemb   = ukn->nmemb;
  const OT_CLS_T       classC  = ukn->classC;
  const OT_SELF_T       classO  = ukn->classO;
 
  for (int i=0; i<nmemb; i++) {
//printC(type[i].name)
    switch(ukn->what) {
      case OT_UNKNOWN_INSTANCE:
        if (type[i].name[0] == '<') {
          if (type[i].name[1] == 'c') {
            if (strcmp(type[i].name,"<constructor>") == 0) {
#ifdef ALL_INIT_AT_STARTUP
              Tcl_Method mth = Tcl_NewMethod(interp, classC, NULL, 1, &type[i], NULL);
              Tcl_ClassSetConstructor(interp,classC,mth);
#endif
            } else {
              goto other;
            }
          } else if (type[i].name[1] == 'd') {
            if (strcmp(type[i].name,"<destructor>") == 0) {
#ifdef ALL_INIT_AT_STARTUP
              // there are 2 destructors: 
              // -> FIRST from "MkAtomMeta"
              // -> SECOND the "<destructor>" from "MkObjectC"
              // BOTH call "MK(AtomMetaDelete)", disable SECOND and wait for errors
              //Tcl_Method mth = Tcl_NewMethod(interp, classC, NULL, 1, &type[i], clientData);
              //Tcl_ClassSetDestructor(interp,classC,mth);
#endif
            } else {
              goto other;
            }
          } else {
            goto other;
          }
        } else {
    other:
          Tcl_NewMethod(interp, classC, Tcl_NewStringObj(type[i].name,-1), 1, &type[i], NULL);
        }
      break;
      case OT_UNKNOWN_CLASS:
        Tcl_NewInstanceMethod(interp, classO, Tcl_NewStringObj(type[i].name,-1), 1, &type[i], NULL);
      break;
    }
  }
}
 
 
#ifndef ALL_INIT_AT_STARTUP
static int NS(sUnknownSort) (const void *one, const void *two) {
  return strcmp(((Tcl_MethodType*)one)->name, ((Tcl_MethodType*)two)->name);
}
 
static int NS(sUnknownSort2) (const void *one, const void *two) {
//printV("%s ? %s\n", ((MK_STRN)one), ((Tcl_MethodType*)two)->name)
  return strcmp(((MK_STRN)one), ((Tcl_MethodType*)two)->name);
}
static OT_ProcRet NS(sUnknownObjCmd) (MkObjectC_ARGS) {
  Tcl_MethodType* item = NULL;
  OT_SETUP_hdl_static
  //OT_SETUP_VARARGS(1,99,"unknown command args ...")
  OtUnknownS *ukn = clientData;
 
//printAryX(hdl, "xxx", objc, objv)
//printAryX(hdl, OT_LNG_NAME_CLASS_FROM_CONTEXT(objCtx), objc, objv)
  if (skip<objc) {
    MK_STRN key = Tcl_GetString(objv[skip]);
    item = bsearch (key, ukn->list, ukn->nmemb, sizeof(Tcl_MethodType), NS(sUnknownSort2));
  }
 
  if (item) {
    switch (ukn->what) {
      case OT_UNKNOWN_INSTANCE:
        Tcl_NewMethod(interp, ukn->classC, Tcl_NewStringObj(item->name,-1), 1, item, NULL);
      break;
      case OT_UNKNOWN_CLASS:
        Tcl_NewInstanceMethod(interp, ukn->classO, Tcl_NewStringObj(item->name,-1), 1, item, NULL);
      break;
    }
    return Tcl_EvalObjv(interp,objc,objv,0);
  } else {
    // on ERROR, init ALL METHODS first
    NS(sUnknownAllMethods)(interp,ukn);
    // and than call the "unkown"
    return Tcl_ObjectContextInvokeNext(interp,objCtx,objc,objv,skip);
  }
  return MK_OK;
}
 
#endif /* not ATT_INIT */
 
// create the "<constructor>" and count the items
int MK(UnknownSetup) (
  OT_ENV_T      interp,
  OT_SELF_T     classO,
  const Tcl_MethodType  methodsDefs[],
  OtUnknownS    *uknPtr
) {
  OT_CLS_T classC = Tcl_GetObjectAsClass(classO);
 
//printTxt(OT_LNG_NAME_FROM_CLASS(classC))
 
  // allready done?
  if (uknPtr->list != NULL) return TCL_OK;
 
  // sort the methodsDefs -> required for "bsearch" in sUnknownObjCmd
  size_t num;
  for (num=0; methodsDefs[num].version != 0; num++) { };
  *uknPtr = (OtUnknownS) {uknPtr->what, num, methodsDefs, classO, classC};
 
#ifdef ALL_INIT_AT_STARTUP
  NS(sUnknownAllMethods)(interp,uknPtr);
#else
  qsort(methodsDefs, num, sizeof(Tcl_MethodType), NS(sUnknownSort));
 
  // MA; for (int i=0; i<num; i++) { printV("[%2i] %s\n", i, methodsDefs[i].name); } /* debugging */
 
  const static Tcl_MethodType NS(sUnknownDef) = { VER, "unknown", NS(sUnknownObjCmd), NULL, NULL };
 
  switch (uknPtr->what) {
 
    case OT_UNKNOWN_CLASS: {
 
      /* add the "unknown" */
      Tcl_NewInstanceMethod(interp, classO, Tcl_NewStringObj("unknown",-1), 1, &NS(sUnknownDef), uknPtr);
 
      break;
    }
 
    case OT_UNKNOWN_INSTANCE: {
      Tcl_MethodType* item;
 
      // create MINIMUM required functions
      item = bsearch("<constructor>", uknPtr->list, uknPtr->nmemb, sizeof(Tcl_MethodType), NS(sUnknownSort2));
      if (item) {
        Tcl_Method mth = Tcl_NewMethod(interp, classC, NULL, 1, item, NULL);
        Tcl_ClassSetConstructor(interp,classC,mth);
      }
 
/*
      // there are 2 destructors, FIRST from "MkAtomMeta" and SECOND the "<destructor>" from "MkObjectC"
      // -> BOTH call "MkAtomMetaDelete"
      // disable SECOND and wait for errors
      item = bsearch("<destructor>", uknPtr->list, uknPtr->nmemb, sizeof(Tcl_MethodType), NS(sUnknownSort2));
      if (item) {
        mth = Tcl_NewMethod(interp, classC, NULL, 1, item, clientData);
        Tcl_ClassSetDestructor(interp,classC,mth);
      }
*/
 
      /* add the "unknown" */
      Tcl_NewMethod(interp, classC, Tcl_NewStringObj("unknown",-1), 1, &NS(sUnknownDef), uknPtr);
 
      break;
    }
  }
 
#endif  /* ALL_INIT_AT_STARTUP */
 
  return TCL_OK;
}
 
#undef ALL_INIT_AT_STARTUP
 
// --------------------------------------------------------------------------
 
const static Tcl_MethodType NS(sInstanceDef)[] = {
 
// BEGIN-OBJ - created by 'tcl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// doc-key: MkObjectC,MkDbg,om_
  {VER, "DbgDump"             , NS(MkObjectC_DbgDump)                   , NULL, NULL},
  {VER, "DbgL"                , NS(MkObjectC_DbgL)                      , NULL, NULL},
  {VER, "DbgLogC"             , NS(MkObjectC_DbgLogC)                   , NULL, NULL},
  {VER, "DbgO"                , NS(MkObjectC_DbgO)                      , NULL, NULL},
  {VER, "DbgSTACK"            , NS(MkObjectC_DbgSTACK)                  , NULL, NULL},
 
// doc-key: MkObjectC,MkLog,om_
  {VER, "LogC"                , NS(MkObjectC_LogC)                      , NULL, NULL},
  {VER, "LogHEX"              , NS(MkObjectC_LogHEX)                    , NULL, NULL},
 
// doc-key: MkObjectC,MkObj,om_
  {VER, "RefGet"              , NS(MkObjectC_RefGet)                    , NULL, NULL},
 
// doc-key: MkObjectC,MkObject,oD_
  {VER, "Delete"              , NS(MkObjectC_Delete)                    , NULL, NULL},
 
// doc-key: MkObjectC,MkObject,od_
  {VER, "Dispose"             , NS(MkObjectC_Dispose)                   , NULL, NULL},
 
// doc-key: MkObjectC,MkObject,oc_
  {VER, "ErrorCatch"          , NS(MkObjectC_ErrorCatch)                , NULL, NULL},
  {VER, "Next"                , NS(MkObjectC_Next)                      , NULL, NULL},
  {VER, "Prev"                , NS(MkObjectC_Prev)                      , NULL, NULL},
  {VER, "ToError"             , NS(MkObjectC_ToError)                   , NULL, NULL},
 
// doc-key: MkObjectC,MkObject,om_
  {VER, "HandleDelete"        , NS(MkObjectC_HandleDelete)              , NULL, NULL},
  {VER, "HandleExists"        , NS(MkObjectC_HandleExists)              , NULL, NULL},
  {VER, "HandleGet"           , NS(MkObjectC_HandleGet)                 , NULL, NULL},
  {VER, "HandleGetOfType"     , NS(MkObjectC_HandleGetOfType)           , NULL, NULL},
  {VER, "HandleGetOr0"        , NS(MkObjectC_HandleGetOr0)              , NULL, NULL},
  {VER, "IsNull"              , NS(MkObjectC_IsNull)                    , NULL, NULL},
  {VER, "Log"                 , NS(MkObjectC_Log)                       , NULL, NULL},
  {VER, "LogLong"             , NS(MkObjectC_LogLong)                   , NULL, NULL},
  {VER, "LogShort"            , NS(MkObjectC_LogShort)                  , NULL, NULL},
  {VER, "LogType"             , NS(MkObjectC_LogType)                   , NULL, NULL},
  {VER, "ToName"              , NS(MkObjectC_ToName)                    , NULL, NULL},
  {VER, "ToNameOfClass"       , NS(MkObjectC_ToNameOfClass)             , NULL, NULL},
  {VER, "ToNameOfType"        , NS(MkObjectC_ToNameOfType)              , NULL, NULL},
  {VER, "ToString"            , NS(MkObjectC_ToString)                  , NULL, NULL},
 
// doc-key: MkObjectC,MkSys,om_
  {VER, "SysKill"             , NS(MkObjectC_SysKill)                   , NULL, NULL},
 
// doc-key: MkObjectC,MkSys,omo
  {VER, "SysGetPid"           , NS(MkObjectC_SysGetPid)                 , NULL, NULL},
 
// END-OBJ - created by 'tcl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
  {0, NULL, NULL, NULL, NULL}
};
 
 
int NS(pMkObjectC_Init) ( MK_RT_ARGS OT_ENV_T interp, OT_NS_T ns)
{
  ClassInit
 
  return TCL_OK;
error:
  return TCL_ERROR;
}
 
// ########################################################################################
// OVERLOAD