MkObjectC_py.c

Go to the documentation of this file.

 
/* LABEL-INIT */
 
#define SetupRtFromObj_X(hdl)     MkRtSetup_O(hdl)
#define SetupRtFromObj_XN(hdl)    MkRtSetup_ON(hdl)
 
/* LABEL-START */
 
#define META_FILE_NAME              "MkObjectC_py.c"
 
#include "LibMkKernel_private_py.h"
 
// PY class
#define OT_CLASS                    (&NS(MkObjectCR))
#define OT_CLASS_NAME               "MkObjectC"
 
#define OT_LNG2META(O)              MkObj(VAL2MNG(O))
 
#define OT_retObj_CONSTR(mng)       OT_retObj_SET(NS(MkObjectC_CTOR)(MK_RT_CALL (PyTypeObject*)class,mng))
 
#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         MK_RT_UNUSED AllRtSetup_NULL; \
                                    MK_OBJ hdl = (MK_OBJ) OT_CLASS;
#define OT_SETUP_hdl_destr          OT_SETUP_hdl_tmpl__null_allow(MkObjectC)
#define OT_SETUP_hdl_static         MK_RT_UNUSED 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
 
// MO class
#undef MkObjectCTT
#define MkObjectCTT MK(MkKernelThreadState).MkObjectCTT
/* MkObjectC_MK_NULL defined in LibMkKernel_py.h */
 
__attribute__((unused)) mk_inline
OT_OBJ_T NS(MkObjectC_CTOR) (MK_RT_ARGS OT_CLS_T type, MK_OBJ hdl) {
  return MK(AtomCreate)(MK_RT_CALL type,MkObjectC_X2obj(hdl));
}
 
// helper: mk_dbg_color_ln(MK_COLOR_YELLOW,"hdl<%p>, self<%p>", obj, self);
 
// 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) {
  return MK(AtomCreate) (MK_RT_CALL OT_CLASS,obj);
}
// 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 self, MK_PTR const env) {
  MK(AtomDeleteHard) (MK_RT_CALL OT_SELF);
}
// META: called to destroy link from SELF to META
static void NS(MkObjectC_selfUnlink) (MK_RT_ARGS MK_PTR self, MK_PTR const env) {
  MkObjectC_Obj *selfO = (MkObjectC_Obj*) self;
  selfO->hdl = NULL;
}
 
// initialize the PY and MO 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); \
  \
  if (!PyType_HasFeature(OT_CLASS,Py_TPFLAGS_READY)) { \
    NS(MkObjectCR).tp_base = MkObjectC_base; \
    OtErrorCheckLng (PyType_Ready(OT_CLASS)); \
  } \
  OtErrorCheckLng(PyModule_AddObjectRef(m, "MkObjectC", (PyObject *)OT_CLASS)); \
  \
  /* define the "NULL" object */ \
  MkObjectC_MK_NULL = Py_NewRef(MK(AtomCreate) (MK_RT_CALL OT_CLASS, NULL /*obj*/));
 
/* LABEL-END */
 
#define MqDbgO_O(hdl,frm)                   printXSObj(hdl,frm,OBJ2VAL(hdl))
#define MkObjectErrorCatchTmpl(...)         MK(MkExceptionC_Catch)(OT_Prefix_CALL __VA_ARGS__)
#define MkObjectToNameOfClassTmpl(hdl)      OT_LNG_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, formatObj("intern  =", OT_SELF_O(obj)));
  return MkDbgDump(obj, bufR.super.buf.storage.first.C, callfunc);
}
 
 
// BEGIN-DOC - created by 'py_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=None?, ?filter:string=\"None\"?)"
#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=None?, ?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=None?, ?debug:int32=0?, ?callfunc:string=\"MK_NULL\"?, ?lvl:int32=0?) (const)"
#define LogLong_doc "obj.LogLong(?fmtobj:MkObjectC=None?, ?debug:int32=0?, ?callfunc:string=\"MK_NULL\"?, ?lvl:int32=0?) (const)"
#define LogShort_doc "obj.LogShort(?fmtobj:MkObjectC=None?, ?debug:int32=0?, ?callfunc:string=\"MK_NULL\"?, ?lvl:int32=0?) (const)"
#define LogType_doc "obj.LogType(?fmtobj:MkObjectC=None?, ?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 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// -----------------------------------------------------------------------------
 
// vim: Marker(s)
// BEGIN-MkObjectC - created by 'py_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_PY_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_PY_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_PY_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_PY_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_PY_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_PY_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_PY_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_PY_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_PY_API
 
// END-MkObjectC - created by 'py_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// vim: Marker(o)
 
static PyMethodDef NS(MkObjectC_Methods)[] = {
 
  // BEGIN-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // doc-key: MkObjectC,MkDbg,sm_
  { "DbgM"                  , (PyCFunction) NS(MkObjectC_DbgM)                  , METH_VARARGS|METH_CLASS , DbgM_doc },
 
  // doc-key: MkObjectC,MkObject,sc_
  { "GetNull"               , (PyCFunction) NS(MkObjectC_GetNull)               , METH_NOARGS|METH_CLASS  , GetNull_doc },
  { "HandleResolve"         , (PyCFunction) NS(MkObjectC_HandleResolve)         , METH_O|METH_CLASS       , HandleResolve_doc },
  { "Instances"             , (PyCFunction) NS(MkObjectC_Instances)             , METH_NOARGS|METH_CLASS  , Instances_doc },
 
  // doc-key: MkObjectC,MkObject,sm_
  { "DeleteCallbackCleanup" , (PyCFunction) NS(MkObjectC_DeleteCallbackCleanup) , METH_O|METH_CLASS       , DeleteCallbackCleanup_doc },
  { "DeleteCallbackSetup"   , (PyCFunction) NS(MkObjectC_DeleteCallbackSetup)   , METH_VARARGS|METH_CLASS , DeleteCallbackSetup_doc },
  { "HandleDeleteByNetHdl"  , (PyCFunction) NS(MkObjectC_HandleDeleteByNetHdl)  , METH_O|METH_CLASS       , HandleDeleteByNetHdl_doc },
 
  // doc-key: MkObjectC,MkSys,sm_
  { "SysHashI32"            , (PyCFunction) NS(MkObjectC_SysHashI32)            , METH_VARARGS|METH_CLASS , SysHashI32_doc },
  { "SysHashSTR"            , (PyCFunction) NS(MkObjectC_SysHashSTR)            , METH_VARARGS|METH_CLASS , SysHashSTR_doc },
 
  // END-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
  // BEGIN-OBJ - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // doc-key: MkObjectC,MkDbg,om_
  { "DbgDump"               , (PyCFunction) NS(MkObjectC_DbgDump)               , METH_VARARGS            , DbgDump_doc },
  { "DbgL"                  , (PyCFunction) NS(MkObjectC_DbgL)                  , METH_VARARGS            , DbgL_doc },
  { "DbgLogC"               , (PyCFunction) NS(MkObjectC_DbgLogC)               , METH_VARARGS            , DbgLogC_doc },
  { "DbgO"                  , (PyCFunction) NS(MkObjectC_DbgO)                  , METH_VARARGS            , DbgO_doc },
  { "DbgSTACK"              , (PyCFunction) NS(MkObjectC_DbgSTACK)              , METH_VARARGS            , DbgSTACK_doc },
 
  // doc-key: MkObjectC,MkLog,om_
  { "LogC"                  , (PyCFunction) NS(MkObjectC_LogC)                  , METH_VARARGS            , LogC_doc },
  { "LogHEX"                , (PyCFunction) NS(MkObjectC_LogHEX)                , METH_VARARGS            , LogHEX_doc },
 
  // doc-key: MkObjectC,MkObj,om_
  { "RefGet"                , (PyCFunction) NS(MkObjectC_RefGet)                , METH_NOARGS             , RefGet_doc },
 
  // doc-key: MkObjectC,MkObject,oD_
  { "Delete"                , (PyCFunction) NS(MkObjectC_Delete)                , METH_NOARGS             , Delete_doc },
 
  // doc-key: MkObjectC,MkObject,od_
  { "Dispose"               , (PyCFunction) NS(MkObjectC_Dispose)               , METH_NOARGS             , Dispose_doc },
 
  // doc-key: MkObjectC,MkObject,oc_
  { "ErrorCatch"            , (PyCFunction) NS(MkObjectC_ErrorCatch)            , METH_VARARGS            , ErrorCatch_doc },
  { "Next"                  , (PyCFunction) NS(MkObjectC_Next)                  , METH_NOARGS             , Next_doc },
  { "Prev"                  , (PyCFunction) NS(MkObjectC_Prev)                  , METH_NOARGS             , Prev_doc },
  { "ToError"               , (PyCFunction) NS(MkObjectC_ToError)               , METH_NOARGS             , ToError_doc },
 
  // doc-key: MkObjectC,MkObject,om_
  { "HandleDelete"          , (PyCFunction) NS(MkObjectC_HandleDelete)          , METH_NOARGS             , HandleDelete_doc },
  { "HandleExists"          , (PyCFunction) NS(MkObjectC_HandleExists)          , METH_NOARGS             , HandleExists_doc },
  { "HandleGet"             , (PyCFunction) NS(MkObjectC_HandleGet)             , METH_NOARGS             , HandleGet_doc },
  { "HandleGetOfType"       , (PyCFunction) NS(MkObjectC_HandleGetOfType)       , METH_NOARGS             , HandleGetOfType_doc },
  { "HandleGetOr0"          , (PyCFunction) NS(MkObjectC_HandleGetOr0)          , METH_NOARGS             , HandleGetOr0_doc },
  { "IsNull"                , (PyCFunction) NS(MkObjectC_IsNull)                , METH_NOARGS             , IsNull_doc },
  { "Log"                   , (PyCFunction) NS(MkObjectC_Log)                   , METH_VARARGS            , Log_doc },
  { "LogLong"               , (PyCFunction) NS(MkObjectC_LogLong)               , METH_VARARGS            , LogLong_doc },
  { "LogShort"              , (PyCFunction) NS(MkObjectC_LogShort)              , METH_VARARGS            , LogShort_doc },
  { "LogType"               , (PyCFunction) NS(MkObjectC_LogType)               , METH_VARARGS            , LogType_doc },
  { "ToName"                , (PyCFunction) NS(MkObjectC_ToName)                , METH_NOARGS             , ToName_doc },
  { "ToNameOfClass"         , (PyCFunction) NS(MkObjectC_ToNameOfClass)         , METH_NOARGS             , ToNameOfClass_doc },
  { "ToNameOfType"          , (PyCFunction) NS(MkObjectC_ToNameOfType)          , METH_NOARGS             , ToNameOfType_doc },
  { "ToString"              , (PyCFunction) NS(MkObjectC_ToString)              , METH_NOARGS             , ToString_doc },
 
  // doc-key: MkObjectC,MkSys,om_
  { "SysKill"               , (PyCFunction) NS(MkObjectC_SysKill)               , METH_VARARGS            , SysKill_doc },
 
  // doc-key: MkObjectC,MkSys,omo
  { "SysGetPid"             , (PyCFunction) NS(MkObjectC_SysGetPid)             , METH_NOARGS             , SysGetPid_doc },
 
  // END-OBJ - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
    {NULL, NULL, 0, NULL}        /* Sentinel */
};
 
 
/*
  if (MkRefIsLocked(obj)) {
    obj = MkObjMerge (obj);
    if (obj == NULL) {
      PyErr_Format(PyExc_RuntimeError, "MergeError: '%s.Merge()' return a NULL pointer",type->tp_name);
      return NULL;
    }
  } else if (MkRefGet(obj) > 0 && obj->self != NULL) {
    return Py_NewRef(obj->self);
  } else if (obj->self != NULL) {
//printSTACK0();
    PyErr_Format(PyExc_RuntimeError,
      "InternalError: '%s' 'obj->self != NULL' with 'obj->ref == 0'", type->tp_name
    );
    return NULL;
  }
  return NS(AtomCreate)(MK_RT_CALL type,obj,useSelf);
}
*/
 
// ***********************************************************************************
 
static void
MkObjectC_Dealloc(OT_OBJ_T self)
{
  MK_MNG mng = VAL2MNG(self);
  if (mng) {
    MK_OBJ obj = MkObj(mng);
    check_NULL(obj) goto end;
    MkRtSetup_ON(obj);
 
  #ifdef LOG_REF
    if (self) printLngObj(self)
  #endif
 
    // delete link between MQ and PYTHON
    obj = MkRefDecrWithoutSelf(obj);
  }
end:
  Py_TYPE(self)->tp_free(self);
}
 
PyObject *
MkObjectC_Str(OT_LNG_OBJ_T self)
{
  OT_SETUP_hdl__null_allow
  MK_STRN str = MkObjectToString(hdl);
  return STRN2VAL(str);
}
 
int NS(sMkObjectC_init)(CONSTR_ARGS)
{
  return 0;
}
 
// ########################################################################################
// OVERLOAD
 
 
void MkObjectC_SelfIncr ( MK_RT_ARGS MK_PTR self, MK_PTR const env )
{
  Py_INCREF(self);
}
 
void MkObjectC_SelfDecr ( MK_RT_ARGS MK_PTR self, MK_PTR const env )
{
  Py_CLEAR(self);
}
 
OT_CLASS_TYPE_REF NS(MkObjectCR) = {
    PyVarObject_HEAD_INIT(NULL, 0)
    .tp_name        = "pymkkernel.MkObjectC",
    .tp_doc         = "PyMkKernel MkObjectC Type",
    .tp_basicsize   = sizeof(MkObjectC_Obj),
    .tp_dealloc     = MkObjectC_Dealloc,
    .tp_methods     = NS(MkObjectC_Methods),
    .tp_flags       = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    .tp_str         = (reprfunc) MkObjectC_Str,
    .tp_init        = (initproc) NS(sMkObjectC_init)
  };
 
int NS(pMkObjectC_Init) ( MK_RT_ARGS PyObject* m)
{
/*
  NS(MkObjectCR) = (PyTypeObject) {
    PyVarObject_HEAD_INIT(NULL, 0)
    .tp_name        = "pymkkernel.MkObjectC",
    .tp_doc         = "PyMkKernel MkObjectC Type",
    .tp_basicsize   = sizeof(MkObjectC_Obj),
    .tp_dealloc     = MkObjectC_Dealloc,
    .tp_methods     = NS(MkObjectC_Methods),
    .tp_flags       = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    .tp_str         = (reprfunc) MkObjectC_Str,
    .tp_init        = (initproc) NS(sMkObjectC_init)
  };
*/
 
  // attention this is NOT thread-safe because pymkkernel is NOT thread-safe.
  // a threaded application require this PER THREAD and not once
  MK_RT_REF.fSelfIncr = MkObjectC_SelfIncr;
  MK_RT_REF.fSelfDecr = MkObjectC_SelfDecr;
  MK_RT_REF.MkSelfIncrOnCacheB = true;
 
  ClassInit
 
  return 0;
error:
  return -1;
}
 
// vim: nowrap