MkObjectC_atl.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_atl.c"
 
#include  "LibMkKernel_private_atl.h"
 
#define   OT_CLASS            amkrt->AtlMkObjectC
#define   OT_NULL             amkrt->AtlMkObjectC_MK_NULL
#define   OT_CLASS_NAME       "MkObjectC"
 
#define   SELF2HDL(O)         MkObj(VAL2MNG(O))
 
// LNG: class
// -> moved to LibMkKernel_atl.h → OT_MK_RT_S → AtlMkKernelCTT;
 
// META: ObjNew feature: called to return a new or an already existing ATL-SELF-Object
// -> moved to LibMkKernel_atl.h → MkKernelC_ObjNew
 
// 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) {
  SETUP_amkrt(env);
  return AtomMake(obj,OT_CLASS,NULL,NULL,env);
}
 
// META: called if MkObj must be destroyed and if the SELF is still alive → goal: destroy the SELF
static void NS(MkObjectC_selfDelete) (MK_RT_ARGS MK_PTR selfP, MK_PTR const env) {
  OT_SELF_T selfO = selfP;
  SETUP_amkrt(env);
  MK(AtomDeleteHard) (OT_MK_CALL selfO);
}
 
// META: called to destroy link from SELF to META
static void NS(MkObjectC_selfUnlink) (MK_RT_ARGS MK_PTR selfP, MK_PTR const env) {
  OT_SELF_T selfO = selfP;
  SETUP_amkrt(env);
  return MK(AtomUnlink) (OT_MK_CALL selfO);
}
 
#define OT_SETUP_hdl                  SetupHdlFromMetaData_2(MK_OBJ)
#define OT_SETUP_hdl__null_allow      SetupHdlFromMetaData__null_allow_2(MK_OBJ)
#define OT_SETUP_hdl_destr            SetupHdlFromMetaData__null_allow_2(MK_OBJ)
#define OT_SETUP_hdl_constr           SetupHdlConstr(MkObjectC)
#define OT_SETUP_hdl_static_constr    OT_SETUP_hdl_static
#define OT_SETUP_hdl_static           SetupHdlStatic(MkObjectC)
 
#define OT_retObj_CONSTR(x)           OT_retObj_SET(AtomInit(OT_SELF,MkObjectC_X2obj(x),amkrt))
 
// initialize the ATL and META class specific object
#define   ClassInit \
  /* if not already done, initialize NEW META 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 META-Class */ \
  MkObjectCTT->selfCreate    = NS(MkObjectC_selfCreate); \
  MkObjectCTT->selfDelete    = NS(MkObjectC_selfDelete); \
  MkObjectCTT->selfUnlink    = NS(MkObjectC_selfUnlink); \
 \
  /* create the ATL-class */ \
  OT_CLASS = AltClassDef(MkObjectCTT,&amkrt->AtlMkObjectC_NS); \
    if (OT_CLASS == NULL) goto error; \
    OT_REF_INCR(OT_CLASS); \
 \
  /* create the ATL static Methods */ \
  check_LNG(AtlUnknownSetup (NS(sOtClassDef),amkrt)) goto error; \
 \
  /* create the ATL instance Methods */ \
  check_LNG(AtlUnknownSetup (NS(sInstanceDef),amkrt)) goto error; \
 \
  /* after class was modified, recompile the class */ \
  RL_init(2, recompile, RL_T(0,RecompileN)); RL_O(1,OT_CLASS) ; \
    int retI = RL_EvalEx(0); \
      if (retI != TCL_OK) return retI; \
 \
  /* define the "NULL" object */ \
  OT_NULL = AtomCreateNULL(OT_CLASS, "::MkObjectC::MK_NULL", (MK_PTR)amkrt); \
    if (OT_NULL == NULL) goto error; \
    OT_REF_INCR(OT_NULL);
/* LABEL-END */
 
// BEGIN-DOC - created by 'atl_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 "MkObjectC::DbgDump $obj ?message:string=\"var\"? ?callfunc:string=\"MK_NULL\"? (const)"
#define DbgL_doc "MkObjectC::DbgL $fmtobj message:string ?debug:int32=0? ?callfunc:string=\"MK_NULL\"? ?lvl:int32=0? (const)"
#define DbgLogC_doc "MkObjectC::DbgLogC $obj ?callfunc:string=\"MK_NULL\"? (const)"
#define DbgO_doc "MkObjectC::DbgO $obj ?callfunc:string=\"MK_NULL\"? (const)"
#define DbgSTACK_doc "MkObjectC::DbgSTACK $fmtobj ?skip:int32=0? ?num:int32=-1? ?callfunc:string=\"MK_NULL\"? (const)"
 
// doc-key: MkObjectC,MkLog,om_,func
#define LogC_doc "MkObjectC::LogC $fmtobj message:string ?debug:int32=0? ?callfunc:string=\"MK_NULL\"? (const)"
#define LogHEX_doc "MkObjectC::LogHEX $fmtobj callfunc:string data:binary (const)"
 
// doc-key: MkObjectC,MkObj,om_,func
#define RefGet_doc "int32 [MkObjectC::RefGet $obj]"
 
// 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=NULL? ?filter:string=\"NULL\"?"
#define HandleDeleteByNetHdl_doc "MkObjectC::HandleDeleteByNetHdl netHdl:MK_HDL"
 
// doc-key: MkObjectC,MkObject,oD_,func
#define Delete_doc "MkObjectC::Delete $obj"
 
// doc-key: MkObjectC,MkObject,od_,func
#define Dispose_doc "MkObjectC::Dispose $obj"
 
// doc-key: MkObjectC,MkObject,oc_,func
#define ErrorCatch_doc "MkErrorC [MkObjectC::ErrorCatch $obj ?exception:errorCode=NULL? ?callfunc:string=\"MK_NULL\"?] (const)"
#define Next_doc "MkObjectC [MkObjectC::Next $obj]"
#define Prev_doc "MkObjectC [MkObjectC::Prev $obj]"
#define ToError_doc "MkErrorC [MkObjectC::ToError $obj]"
 
// doc-key: MkObjectC,MkObject,om_,func
#define HandleDelete_doc "MkObjectC::HandleDelete $netObj"
#define HandleExists_doc "bool [MkObjectC::HandleExists $obj]"
#define HandleGet_doc "MK_HDL [MkObjectC::HandleGet $obj]"
#define HandleGetOfType_doc "MK_HDL [MkObjectC::HandleGetOfType $obj]"
#define HandleGetOr0_doc "MK_HDL [MkObjectC::HandleGetOr0 $obj]"
#define IsNull_doc "bool [MkObjectC::IsNull $obj]"
#define Log_doc "MkObjectC::Log $obj ?fmtobj:MkObjectC=NULL? ?debug:int32=0? ?callfunc:string=\"MK_NULL\"? ?lvl:int32=0? (const)"
#define LogLong_doc "MkObjectC::LogLong $obj ?fmtobj:MkObjectC=NULL? ?debug:int32=0? ?callfunc:string=\"MK_NULL\"? ?lvl:int32=0? (const)"
#define LogShort_doc "MkObjectC::LogShort $obj ?fmtobj:MkObjectC=NULL? ?debug:int32=0? ?callfunc:string=\"MK_NULL\"? ?lvl:int32=0? (const)"
#define LogType_doc "MkObjectC::LogType $obj ?fmtobj:MkObjectC=NULL? ?debug:int32=0? ?callfunc:string=\"MK_NULL\"? ?lvl:int32=0? (const)"
#define ToName_doc "string [MkObjectC::ToName $obj] (const)"
#define ToNameOfClass_doc "string [MkObjectC::ToNameOfClass $obj]"
#define ToNameOfType_doc "string [MkObjectC::ToNameOfType $obj] (const)"
#define ToString_doc "string [MkObjectC::ToString $inst] (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 "MkObjectC::SysKill $fmtobj pid:int32 signal:int32 (const)"
 
// doc-key: MkObjectC,MkSys,omo,func
#define SysGetPid_doc "int32 [MkObjectC::SysGetPid $fmtobj] (const)"
 
// END-DOC - created by 'atl_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(PrintObj)(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 )
{
  OT_OBJ_T self = META2VAL_O(obj);
  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(PrintObj)(OT_Prefix_CALL message,self));
 
  MkObjectLog(obj,NULL,0,callfunc,1);
 
  MkLogV(obj,callfunc,0,MK_COLOR_CYAN" <<< "MK_COLOR_RESET"\n");
 
  return MK_OK;
}
 
/*****************************************************************************/
/*                                                                           */
/*                        O B J E C T                                        */
/*                                                                           */
/*****************************************************************************/
 
// BEGIN-MkObjectC - created by 'atl_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_ATL_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_ATL_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_ATL_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_ATL_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_ATL_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_ATL_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_ATL_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_ATL_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_ATL_API
 
// END-MkObjectC - created by 'atl_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// ---------------------------------------------------------------------------------------
 
static const OtObjProcDefS NS(sOtClassDef)[] = {
 
  // BEGIN-CLASS - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // doc-key: MkObjectC,MkDbg,sm_
  { "::MkObjectC::DbgM"                  , NS(MkObjectC_DbgM)                  },
 
  // doc-key: MkObjectC,MkObject,sc_
  { "::MkObjectC::GetNull"               , NS(MkObjectC_GetNull)               },
  { "::MkObjectC::HandleResolve"         , NS(MkObjectC_HandleResolve)         },
  { "::MkObjectC::Instances"             , NS(MkObjectC_Instances)             },
 
  // doc-key: MkObjectC,MkObject,sm_
  { "::MkObjectC::DeleteCallbackCleanup" , NS(MkObjectC_DeleteCallbackCleanup) },
  { "::MkObjectC::DeleteCallbackSetup"   , NS(MkObjectC_DeleteCallbackSetup)   },
  { "::MkObjectC::HandleDeleteByNetHdl"  , NS(MkObjectC_HandleDeleteByNetHdl)  },
 
  // doc-key: MkObjectC,MkSys,sm_
  { "::MkObjectC::SysHashI32"            , NS(MkObjectC_SysHashI32)            },
  { "::MkObjectC::SysHashSTR"            , NS(MkObjectC_SysHashSTR)            },
 
  // END-CLASS - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
  { NULL }
};
 
// --------------------------------------------------------------------------
 
static const OtObjProcDefS NS(sInstanceDef)[] = {
 
  // BEGIN-OBJ - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // doc-key: MkObjectC,MkDbg,om_
  { "::MkObjectC::DbgDump"               , NS(MkObjectC_DbgDump)               },
  { "::MkObjectC::DbgL"                  , NS(MkObjectC_DbgL)                  },
  { "::MkObjectC::DbgLogC"               , NS(MkObjectC_DbgLogC)               },
  { "::MkObjectC::DbgO"                  , NS(MkObjectC_DbgO)                  },
  { "::MkObjectC::DbgSTACK"              , NS(MkObjectC_DbgSTACK)              },
 
  // doc-key: MkObjectC,MkLog,om_
  { "::MkObjectC::LogC"                  , NS(MkObjectC_LogC)                  },
  { "::MkObjectC::LogHEX"                , NS(MkObjectC_LogHEX)                },
 
  // doc-key: MkObjectC,MkObj,om_
  { "::MkObjectC::RefGet"                , NS(MkObjectC_RefGet)                },
 
  // doc-key: MkObjectC,MkObject,oD_
  { "::MkObjectC::~MkObjectC"            , NS(MkObjectC_Delete)                },
 
  // doc-key: MkObjectC,MkObject,od_
  { "::MkObjectC::Dispose"               , NS(MkObjectC_Dispose)               },
 
  // doc-key: MkObjectC,MkObject,oc_
  { "::MkObjectC::ErrorCatch"            , NS(MkObjectC_ErrorCatch)            },
  { "::MkObjectC::Next"                  , NS(MkObjectC_Next)                  },
  { "::MkObjectC::Prev"                  , NS(MkObjectC_Prev)                  },
  { "::MkObjectC::ToError"               , NS(MkObjectC_ToError)               },
 
  // doc-key: MkObjectC,MkObject,om_
  { "::MkObjectC::HandleDelete"          , NS(MkObjectC_HandleDelete)          },
  { "::MkObjectC::HandleExists"          , NS(MkObjectC_HandleExists)          },
  { "::MkObjectC::HandleGet"             , NS(MkObjectC_HandleGet)             },
  { "::MkObjectC::HandleGetOfType"       , NS(MkObjectC_HandleGetOfType)       },
  { "::MkObjectC::HandleGetOr0"          , NS(MkObjectC_HandleGetOr0)          },
  { "::MkObjectC::IsNull"                , NS(MkObjectC_IsNull)                },
  { "::MkObjectC::Log"                   , NS(MkObjectC_Log)                   },
  { "::MkObjectC::LogLong"               , NS(MkObjectC_LogLong)               },
  { "::MkObjectC::LogShort"              , NS(MkObjectC_LogShort)              },
  { "::MkObjectC::LogType"               , NS(MkObjectC_LogType)               },
  { "::MkObjectC::ToName"                , NS(MkObjectC_ToName)                },
  { "::MkObjectC::ToNameOfClass"         , NS(MkObjectC_ToNameOfClass)         },
  { "::MkObjectC::ToNameOfType"          , NS(MkObjectC_ToNameOfType)          },
  { "::MkObjectC::ToString"              , NS(MkObjectC_ToString)              },
 
  // doc-key: MkObjectC,MkSys,om_
  { "::MkObjectC::SysKill"               , NS(MkObjectC_SysKill)               },
 
  // doc-key: MkObjectC,MkSys,omo
  { "::MkObjectC::SysGetPid"             , NS(MkObjectC_SysGetPid)             },
 
  // END-OBJ - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
  { NULL }
};
 
 
int NS(pMkObjectC_Init) ( OT_MK_ARGS OT_NS_T ns)
{
  ClassInit
 
  return TCL_OK;
error:
  return TCL_ERROR;
}
 
// ########################################################################################
// OVERLOAD