LibMkKernel_py.h

Go to the documentation of this file.

 
#pragma once
 
#include <Python.h>
 
#include "nhi1_config.h"
#include "debug_mk.h"
 
#include "LibMkKernel_mk.h"
 
#include "tmpl/mk_type_S_lng.h"
 
#if !defined(META_FILE_NAME)
  #define META_FILE_NAME  (__builtin_strrchr(__FILE__, '/') ? __builtin_strrchr(__FILE__, '/') + 1 : __FILE__)
#endif
 
/*****************************************************************************/
/*                                                                           */
/*                              Macro_API                                    */
/*                                                                           */
/*****************************************************************************/
 
// BEGIN-HEADER - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
#undef HEADER
#define HEADER
 
// If the source of libmkkernel is direct used in an external library
// (without dynamic linking) and this library should *not* export
// the symbol's of libmkkernel then the flag META_IGNORE_EXTERN have
// to be set
#undef MK_PY_EXTERN
#if defined(META_IGNORE_EXTERN)
#   define MK_PY_EXTERN
#elif defined(PIC)
   // does we build a DLL ?
#  if defined(DLL_EXPORT)
       // does we build the libmkkernel library ?
#      if defined(MK_PY_BUILD_DLL)
#        define MK_PY_EXTERN __declspec(dllexport)
#      else
#        define MK_PY_EXTERN __declspec(dllimport)
#      endif
#  else
   // no DLL - architecture specific extern specifier
#    define MK_PY_EXTERN __attribute__ ((visibility("default")))
#  endif
#else
#   define MK_PY_EXTERN
#endif
 
// external data lookup
#undef MK_PY_EXTERN_DATA
#if defined(META_PRIVATE)
#  define MK_PY_EXTERN_DATA extern
#elif defined(META_IGNORE_EXTERN)
#  define MK_PY_EXTERN_DATA extern
#elif defined(PIC)
   // does we build a DLL ?
#  if defined(DLL_EXPORT)
       // does we build the libmkkernel library ?
#      if defined(MK_PY_BUILD_DLL)
#        define MK_PY_EXTERN_DATA __declspec(dllexport)
#      else
#        define MK_PY_EXTERN_DATA __declspec(dllimport)
#      endif
#  else
   // no DLL - architecture specific extern specifier
#    define MK_PY_EXTERN_DATA __attribute__ ((visibility("default"))) extern
#  endif
#else
#  define MK_PY_EXTERN_DATA extern
#endif
 
#undef MK
#define MK(n) pymkkernel_ ## n
#undef NS
#define NS(n) pymkkernel_ ## n
 
// END-HEADER - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
#define OT_ProcRet            PyObject*
 
#define CONSTR_ARGS           PyTypeObject *class, PyObject *objv, PyObject *kwd
#define CONSTR_ARGS_CALL      class, objv
 
#define OtClass_ARGS          PyObject *class, PyObject *objv
#define OtClass_ARGS_CALL     class, objv
 
// LNG ******************************************************************************
 
typedef PyObject*                         OT_OBJ_T;
typedef PyTypeObject*                     OT_ENUM_T;
typedef PyTypeObject                      OT_CLS_TR;
typedef PyTypeObject*                     OT_CLS_T;
 
/*
#define OT_OBJ_T                          PyObject*
#define OT_ENUM_T                         PyTypeObject*
#define OT_CLS_TR                         PyTypeObject
#define OT_CLS_T                          PyTypeObject*
#define OT_LNG_OBJ_T                      MkObjectC_Obj*
*/
 
#define OT_LNG_NULL                       Py_None
#define OT_LNG_UNDEF                      Py_None
#define OT_LNG_IS_NULL(val)               Py_IsNone(val)
#define OT_LNG_RETURN(ret,cmd)            ret=cmd
 
#define OT_LNG_NAME_FROM_CLASS(cls)       (cls)->tp_name
 
#define OT_LNG_OBJ_CLASSNAME(obj)         Py_TYPE(obj)->tp_name
 
#define OT_LNG_OBJV(skip)                 OT_TUPLE_GET_ITEM(objv,skip)
 
#define OT_LNG_OBJ_CLASS_IS(val,cls)      PyObject_TypeCheck(val,cls)
#define OT_OBJ_TO_CLASS(ptr)              ptr
#define OT_OBJ_TO_ENUM(str)               str ## _lngO
 
#define OT_LNG_OBJECT_IS(objV)            PyObject_TypeCheck(objV,MkObjectC_lngO)
 
/*****************************************************************************/
/*                                                                           */
/*                              Module API                                   */
/*                                                                           */
/*****************************************************************************/
 
// BEGIN-CLASS-DEC - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
int NS(pMkObjectC_Init)       (MK_RT_ARGS OT_OBJ_T) ;
int NS(pMkBufferC_Init)       (MK_RT_ARGS OT_OBJ_T) ;
int NS(pMkBufferStreamC_Init) (MK_RT_ARGS OT_OBJ_T) ;
int NS(pMkBufferListC_Init)   (MK_RT_ARGS OT_OBJ_T) ;
int NS(pMkLogFileC_Init)      (MK_RT_ARGS OT_OBJ_T) ;
int NS(pMkErrorC_Init)        (MK_RT_ARGS OT_OBJ_T) ;
int NS(pMkRuntimeC_Init)      (MK_RT_ARGS OT_OBJ_T) ;
 
// END-CLASS-DEC - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
typedef struct {
  // BEGIN-EnumThreadState - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  PyTypeObject* MkErrorE;
  PyTypeObject* MkIdSE;
  PyTypeObject* MkTimeoutE;
  PyTypeObject* MkTypeE;
 
  // END-EnumThreadState - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
  // BEGIN-ClassThreadState - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  MK_TYP MkObjectCTT;
  MK_TYP MkBufferCTT;
  MK_TYP MkBufferStreamCTT;
  MK_TYP MkBufferListCTT;
  MK_TYP MkLogFileCTT;
  MK_TYP MkErrorCTT;
  MK_TYP MkRuntimeCTT;
 
  // END-ClassThreadState - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
  // BEGIN-ClassThreadStateNull - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  PyObject* MkObjectC_MK_NULL;
  PyObject* MkBufferC_MK_NULL;
  PyObject* MkBufferStreamC_MK_NULL;
  PyObject* MkBufferListC_MK_NULL;
  PyObject* MkLogFileC_MK_NULL;
  PyObject* MkErrorC_MK_NULL;
  PyObject* MkRuntimeC_MK_NULL;
 
  // END-ClassThreadStateNull - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  PyObject* InitError;
  PyObject* InitSoftError;
  PyObject* MkExceptionC;
  PyObject* emptyTuple;
  PyObject* inspect_stack;
 
} MkKernelThreadStateS;
 
MK_PY_EXTERN_DATA MkThreadLocal MkKernelThreadStateS MK(MkKernelThreadState);
 
/*****************************************************************************/
/*                                                                           */
/*                              Class_API                                    */
/*                                                                           */
/*****************************************************************************/
 
//#define OT_CLASS_TYPE_REF MkThreadLocal OT_CLS_TR
#define OT_CLASS_TYPE_REF OT_CLS_TR
 
// atom ******************************************************************************
 
mk_inline    PyObject* MK(AtomObjNew)      (MK_RT_ARGS OT_CLS_T, MK_OBJ );
mk_inline    PyObject* MK(AtomCreate)      (MK_RT_ARGS OT_CLS_T, MK_OBJ );
mk_inline    void      MK(AtomDispose)     (MK_RT_ARGS MK_MNG);
mk_inline    void      MK(AtomDelete)      (MK_RT_ARGS MK_MNG);
mk_inline    void      MK(AtomDeleteHard)  (MK_RT_ARGS OT_OBJ_T);
 
#define OT_REF_INCR(_obj)             Py_INCREF(_obj)
#define OT_REF_INCR_AND_RETURN(_obj)  ({ OT_REF_INCR(_obj); _obj;})
#define OT_REF_DECR_AND_NULL(_obj)    Py_CLEAR(_obj)
 
// BEGIN-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// ----------------------------------------------------------------------
// class: MkBufferListC
 
  // class struct
  typedef struct MkBufferListC_Obj {
    PyObject_HEAD
      MK_BFL hdl;
  } MkBufferListC_Obj;
 
  MK_PY_EXTERN_DATA OT_CLASS_TYPE_REF MK(MkBufferListCR);
  #define MkBufferListC_lngO         (&MK(MkBufferListCR))
  #define MkBufferListC_base         (&MK(MkObjectCR))
 
  // MK_NULL singelton
  #define MkBufferListC_MK_NULL      MK(MkKernelThreadState).MkBufferListC_MK_NULL
 
  // arguments
  #define MkBufferListC_ARGS         MkBufferListC_Obj *self, PyObject *objv
  #define MkBufferListC_ARGS_CALL    self, objv
 
  // return object
  #define  OT_retObj_SET_BFL(nat)  retObj  =  MK(MkBufferListC_ObjNew) (MK_RT_CALL &MK(MkBufferListCR),nat)
 
  // new objec
  #define OT_TMP_BFL_OBJ(val)  MK(MkBufferListC_ObjNew)(MK_RT_CALL &MK(MkBufferListCR),val)
  MK_ARTIFICIAL
  mk_inline OT_OBJ_T MK(MkBufferListC_ObjNew)  ( MK_RT_ARGS OT_CLS_T type, MK_BFL hdl ) {
    return hdl ? MK(AtomObjNew)(MK_RT_CALL type,MkBufferListC_X2obj(hdl)) : Py_NewRef(MkBufferListC_MK_NULL);
  }
 
  // cast from LNG to MQ
  #define VAL2BFL(val) ((MkBufferListC_Obj*) (val))->hdl
 
// ----------------------------------------------------------------------
// class: MkBufferC
 
  // class struct
  typedef struct MkBufferC_Obj {
    PyObject_HEAD
      MK_BUF hdl;
  } MkBufferC_Obj;
 
  MK_PY_EXTERN_DATA OT_CLASS_TYPE_REF MK(MkBufferCR);
  #define MkBufferC_lngO         (&MK(MkBufferCR))
  #define MkBufferC_base         (&MK(MkObjectCR))
 
  // MK_NULL singelton
  #define MkBufferC_MK_NULL      MK(MkKernelThreadState).MkBufferC_MK_NULL
 
  // arguments
  #define MkBufferC_ARGS         MkBufferC_Obj *self, PyObject *objv
  #define MkBufferC_ARGS_CALL    self, objv
 
  // return object
  #define  OT_retObj_SET_BUF(nat)  retObj  =  MK(MkBufferC_ObjNew) (MK_RT_CALL &MK(MkBufferCR),nat)
 
  // new objec
  #define OT_TMP_BUF_OBJ(val)  MK(MkBufferC_ObjNew)(MK_RT_CALL &MK(MkBufferCR),val)
  MK_ARTIFICIAL
  mk_inline OT_OBJ_T MK(MkBufferC_ObjNew)  ( MK_RT_ARGS OT_CLS_T type, MK_BUF hdl ) {
    return hdl ? MK(AtomObjNew)(MK_RT_CALL type,MkBufferC_X2obj(hdl)) : Py_NewRef(MkBufferC_MK_NULL);
  }
 
  // cast from LNG to MQ
  #define VAL2BUF(val) ((MkBufferC_Obj*) (val))->hdl
 
// ----------------------------------------------------------------------
// class: MkBufferStreamC
 
  // class struct
  typedef struct MkBufferStreamC_Obj {
    PyObject_HEAD
      MK_BUS hdl;
  } MkBufferStreamC_Obj;
 
  MK_PY_EXTERN_DATA OT_CLASS_TYPE_REF MK(MkBufferStreamCR);
  #define MkBufferStreamC_lngO         (&MK(MkBufferStreamCR))
  #define MkBufferStreamC_base         (&MK(MkObjectCR))
 
  // MK_NULL singelton
  #define MkBufferStreamC_MK_NULL      MK(MkKernelThreadState).MkBufferStreamC_MK_NULL
 
  // arguments
  #define MkBufferStreamC_ARGS         MkBufferStreamC_Obj *self, PyObject *objv
  #define MkBufferStreamC_ARGS_CALL    self, objv
 
  // return object
  #define  OT_retObj_SET_BUS(nat)  retObj  =  MK(MkBufferStreamC_ObjNew) (MK_RT_CALL &MK(MkBufferStreamCR),nat)
 
  // new objec
  #define OT_TMP_BUS_OBJ(val)  MK(MkBufferStreamC_ObjNew)(MK_RT_CALL &MK(MkBufferStreamCR),val)
  MK_ARTIFICIAL
  mk_inline OT_OBJ_T MK(MkBufferStreamC_ObjNew)  ( MK_RT_ARGS OT_CLS_T type, MK_BUS hdl ) {
    return hdl ? MK(AtomObjNew)(MK_RT_CALL type,MkBufferStreamC_X2obj(hdl)) : Py_NewRef(MkBufferStreamC_MK_NULL);
  }
 
  // cast from LNG to MQ
  #define VAL2BUS(val) ((MkBufferStreamC_Obj*) (val))->hdl
 
// ----------------------------------------------------------------------
// class: MkErrorC
 
  // class struct
  typedef struct MkErrorC_Obj {
    PyObject_HEAD
      MK_ERR hdl;
  } MkErrorC_Obj;
 
  MK_PY_EXTERN_DATA OT_CLASS_TYPE_REF MK(MkErrorCR);
  #define MkErrorC_lngO         (&MK(MkErrorCR))
  #define MkErrorC_base         (&MK(MkObjectCR))
 
  // MK_NULL singelton
  #define MkErrorC_MK_NULL      MK(MkKernelThreadState).MkErrorC_MK_NULL
 
  // arguments
  #define MkErrorC_ARGS         MkErrorC_Obj *self, PyObject *objv
  #define MkErrorC_ARGS_CALL    self, objv
 
  // return object
  #define  OT_retObj_SET_ERR(nat)  retObj  =  MK(MkErrorC_ObjNew) (MK_RT_CALL &MK(MkErrorCR),nat)
 
  // new objec
  #define OT_TMP_ERR_OBJ(val)  MK(MkErrorC_ObjNew)(MK_RT_CALL &MK(MkErrorCR),val)
  MK_ARTIFICIAL
  mk_inline OT_OBJ_T MK(MkErrorC_ObjNew)  ( MK_RT_ARGS OT_CLS_T type, MK_ERR hdl ) {
    return hdl ? MK(AtomObjNew)(MK_RT_CALL type,MkErrorC_X2obj(hdl)) : Py_NewRef(MkErrorC_MK_NULL);
  }
 
  // cast from LNG to MQ
  #define VAL2ERR(val) ((MkErrorC_Obj*) (val))->hdl
 
// ----------------------------------------------------------------------
// class: MkLogFileC
 
  // class struct
  typedef struct MkLogFileC_Obj {
    PyObject_HEAD
      MK_LFL hdl;
  } MkLogFileC_Obj;
 
  MK_PY_EXTERN_DATA OT_CLASS_TYPE_REF MK(MkLogFileCR);
  #define MkLogFileC_lngO         (&MK(MkLogFileCR))
  #define MkLogFileC_base         (&MK(MkObjectCR))
 
  // MK_NULL singelton
  #define MkLogFileC_MK_NULL      MK(MkKernelThreadState).MkLogFileC_MK_NULL
 
  // arguments
  #define MkLogFileC_ARGS         MkLogFileC_Obj *self, PyObject *objv
  #define MkLogFileC_ARGS_CALL    self, objv
 
  // return object
  #define  OT_retObj_SET_LFL(nat)  retObj  =  MK(MkLogFileC_ObjNew) (MK_RT_CALL &MK(MkLogFileCR),nat)
 
  // new objec
  #define OT_TMP_LFL_OBJ(val)  MK(MkLogFileC_ObjNew)(MK_RT_CALL &MK(MkLogFileCR),val)
  MK_ARTIFICIAL
  mk_inline OT_OBJ_T MK(MkLogFileC_ObjNew)  ( MK_RT_ARGS OT_CLS_T type, MK_LFL hdl ) {
    return hdl ? MK(AtomObjNew)(MK_RT_CALL type,MkLogFileC_X2obj(hdl)) : Py_NewRef(MkLogFileC_MK_NULL);
  }
 
  // cast from LNG to MQ
  #define VAL2LFL(val) ((MkLogFileC_Obj*) (val))->hdl
 
// ----------------------------------------------------------------------
// class: MkObjectC
 
  // class struct
  typedef struct MkObjectC_Obj {
    PyObject_HEAD
      MK_OBJ hdl;
  } MkObjectC_Obj;
 
  MK_PY_EXTERN_DATA OT_CLASS_TYPE_REF MK(MkObjectCR);
  #define MkObjectC_lngO         (&MK(MkObjectCR))
  #define MkObjectC_base         NULL
 
  // MK_NULL singelton
  #define MkObjectC_MK_NULL      MK(MkKernelThreadState).MkObjectC_MK_NULL
 
  // arguments
  #define MkObjectC_ARGS         MkObjectC_Obj *self, PyObject *objv
  #define MkObjectC_ARGS_CALL    self, objv
 
  // return object
  #define  OT_retObj_SET_OBJ(nat)  retObj  =  MK(MkObjectC_ObjNew) (MK_RT_CALL &MK(MkObjectCR),nat)
 
  // new objec
  #define OT_TMP_OBJ_OBJ(val)  MK(MkObjectC_ObjNew)(MK_RT_CALL &MK(MkObjectCR),val)
  MK_ARTIFICIAL
  mk_inline OT_OBJ_T MK(MkObjectC_ObjNew)  ( MK_RT_ARGS OT_CLS_T type, MK_OBJ hdl ) {
    return hdl ? MK(AtomObjNew)(MK_RT_CALL type,MkObjectC_X2obj(hdl)) : Py_NewRef(MkObjectC_MK_NULL);
  }
 
  // cast from LNG to MQ
  #define VAL2OBJ(val) ((MkObjectC_Obj*) (val))->hdl
 
// ----------------------------------------------------------------------
// class: MkRuntimeC
 
  // class struct
  typedef struct MkRuntimeC_Obj {
    PyObject_HEAD
      MK_RT hdl;
  } MkRuntimeC_Obj;
 
  MK_PY_EXTERN_DATA OT_CLASS_TYPE_REF MK(MkRuntimeCR);
  #define MkRuntimeC_lngO         (&MK(MkRuntimeCR))
  #define MkRuntimeC_base         (&MK(MkObjectCR))
 
  // MK_NULL singelton
  #define MkRuntimeC_MK_NULL      MK(MkKernelThreadState).MkRuntimeC_MK_NULL
 
  // arguments
  #define MkRuntimeC_ARGS         MkRuntimeC_Obj *self, PyObject *objv
  #define MkRuntimeC_ARGS_CALL    self, objv
 
  // return object
  #define  OT_retObj_SET_RT(nat)  retObj  =  MK(MkRuntimeC_ObjNew) (MK_RT_CALL &MK(MkRuntimeCR),nat)
 
  // new objec
  #define OT_TMP_RT_OBJ(val)  MK(MkRuntimeC_ObjNew)(MK_RT_CALL &MK(MkRuntimeCR),val)
  MK_ARTIFICIAL
  mk_inline OT_OBJ_T MK(MkRuntimeC_ObjNew)  ( MK_RT_ARGS OT_CLS_T type, MK_RT hdl ) {
    return hdl ? MK(AtomObjNew)(MK_RT_CALL type,MkRuntimeC_X2obj(hdl)) : Py_NewRef(MkRuntimeC_MK_NULL);
  }
 
  // cast from LNG to MQ
  #define VAL2RT(val) ((MkRuntimeC_Obj*) (val))->hdl
 
// END-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
typedef MkObjectC_Obj*  OT_LNG_OBJ_T;
 
// setup ***********************************************************************************
 
#define OT_SETUP_ARGS_ALL(d)                 \
  PyObject *retObj=NULL;                     \
  Py_ssize_t __skip=0;                       \
  MK_UNUSED static const MK_STRN __doc=d;    \
  MK_UNUSED PyObject* frame=NULL;            \
 
#define OT_FRAME_CLEANUP if (frame != NULL) Py_CLEAR(frame)
 
#define OT_SETUP_VARARGS(min,max,d)          \
  OT_SETUP_ARGS_ALL(d)                       \
  Py_ssize_t objc=PyTuple_GET_SIZE(objv);    \
  OT_CHECK_NUM_ARGS(min,max);                \
 
#define OT_SETUP_CONSTRUCTOR_ARGS(...) OT_SETUP_VARARGS(__VA_ARGS__)
 
#define OT_SETUP_ONEARG(d)    \
  OT_SETUP_ARGS_ALL(d)        \
  Py_ssize_t objc=1;          \
  OT_CHECK_NUM_ARGS(1,1);     \
 
#define OT_SETUP_NOARG(d)    \
  OT_SETUP_ARGS_ALL(d)       \
  Py_ssize_t objc=0;         \
  OT_CHECK_NUM_ARGS(0,0);    \
 
#define OT_SETUP_OBJ(o,v)     PyObject* o=(PyObject*)v;
 
#define OT_SELF               ((PyObject*)self)
#define OT_SELF_X(x)          ((PyObject*)(MkOBJ_R(x).self))
#define OT_SELF_O(o)          ((PyObject*)((*o).self))
 
mk_inline PyObject* OT_PyObjectOrNone(MK_MNG mng) {
  return (MkObjCheck(mng) ? (PyObject*) (((MK_OBJ)mng)->self) : Py_None);
}
 
#define OT_SETUP_hdl_tmpl(cls)                                              \
  typeof(self->hdl) hdl = self->hdl;                                        \
  if (hdl == NULL) {                                                        \
    OT_ERROR_VAR_DEFAULT("'%s' hdl is NULL",OT_LNG_OBJ_CLASSNAME(self));    \
    goto error;                                                             \
  }                                                                         \
  SetupRtFromObj_XN(hdl);                                                   \
 
#define OT_SETUP_hdl_tmpl__null_allow(cls)    \
  typeof(self->hdl) hdl = self->hdl;          \
  SetupRtFromObj_X(hdl);                      \
 
#define OT_RET_SELF                 (Py_NewRef(OT_SELF))
 
#define OT_retObj_SET(val)          retObj = (val);
#define OT_retObj_SET_None          retObj = Py_NewRef(Py_None);
//#define OT_retObj_SET_Error         retObj = MK(ErrorAppend)(__doc);
#define OT_retObj_SET_Error         retObj = NULL;
#define OT_retObj_SET_List          retObj = PyList_New(0);
#define OT_retObj_APPEND(var)       PyList_Append(retObj,var);
#define OT_retObj_RETURN            return ((PyObject*)retObj);
 
#define OT_retObj_SET_BOL(nat)      retObj = BOL2VAL(nat);
#define OT_retObj_SET_I8(nat)       retObj = I82VAL(nat);
#define OT_retObj_SET_I16(nat)      retObj = I162VAL(nat);
#define OT_retObj_SET_I32(nat)      retObj = INT2VAL(nat);
#define OT_retObj_SET_I64(nat)      retObj = I642VAL(nat);
#define OT_retObj_SET_FLT(nat)      retObj = FLT2VAL(nat);
#define OT_retObj_SET_DBL(nat)      retObj = DBL2VAL(nat);
#define OT_retObj_SET_BIN(nat,len)  retObj = BIN2VAL(nat,len);
#define OT_retObj_SET_STR(nat)      retObj = STRN2VAL(nat);
#define OT_retObj_SET_STRN(nat)     retObj = STRN2VAL(nat);
#define OT_retObj_SET_LONG(nat)     retObj = LONG2VAL(nat);
#define OT_retObj_SET_HDL(nat)      retObj = HDL2VAL(nat);
 
#define OT_CONSTRUCTOR_POST(x)
 
// METHOD CALL **********************************************************************
 
#define OT_MK_CALL_0(obj,cls,meth,ret)   ret=MK(cls##_##meth)((cls##_Obj*)cls##_constr(obj),MK(MkKernelThreadState).emptyTuple);
//#define OT_MK_CALL_0(obj,cls,meth,ret)   ret=PyObject_CallMethod((PyObject*)cls##_constr(obj),#meth,NULL)
 
// error ******************************************************************************
 
#define OT_ERROR_LNG_RETURN   return NULL
 
#define OT_ERROR_BASE(err,str) { \
  if (MkErrorCheckE_0E()) { \
    PyErr_Format(err,"%s\nMqError: %s",str,MkErrorGetText_0E()); \
    MkErrorReset_0M(); \
  } else { \
    PyErr_SetString(err,str); \
  } \
}
 
#define OT_ERROR_SOFT_CONSTRUCTOR(class)  { \
  OT_ERROR_BASE(MK(MkKernelThreadState).InitSoftError, "'" #class "' soft constructor return 'NULL' pointer"); \
}
 
#define OT_ERROR_CONSTRUCTOR(class)   \
  OT_ERROR_BASE(MK(MkKernelThreadState).InitError, "'" #class "' constructor return 'NULL' pointer")
 
#define OT_ERROR_TYPE(str)            \
  PyErr_SetString(PyExc_TypeError, str);
 
#define MkErrorC_Check(mng,PROC) \
  if (unlikely(MkErrorCheckI(PROC))) { \
    OT_ERROR_META_2_LNG(mng); goto error; \
  }
 
#define MkErrorC_Check_1(PROC) \
  if (unlikely(MkErrorCheckI(PROC))) { \
    OT_ERROR_META_2_LNG(MK_ERROR_FORMAT); goto error; \
  }
 
#define MkErrorC_CheckD(PROC) \
  if (unlikely(MkErrorCheckI(PROC))) { \
    OT_ERROR_META_2_LNG(hdl); goto error; \
  }
 
#define OT_ERROR_META_2_LNG(m)        MK(MkExceptionC_Raise)  (OT_Prefix_CALL m,__doc,__FILE__,__LINE__)
#define OT_ERROR_LNG_2_META(m)        MK(MkExceptionC_Catch)  (OT_Prefix_CALL m, NULL, __func__)
 
#define check_LNG(PROC)             if ((PROC) < 0)
#define OtErrorCheckLng(PROC)         if ((PROC) < 0) goto error;
#define LngErrorCheckT(TAG,PROC)    if ((PROC) < 0) goto TAG;
#define LngErrorCheckN(PROC)        if ((PROC) == NULL) goto error;
#define LngErrorCheckNT(TAG,PROC)   if ((PROC) == NULL) goto TAG;
 
// !! attention → always jumps to error
#define OT_ERROR_NUMARGS(...) MkErrorC_CheckD(WrongNumArgs(__VA_ARGS__))
 
#if 1
# define OT_ERROR_VAR_DEFAULT(...)  PyErr_Format(PyExc_SystemError,__VA_ARGS__) 
#else
# define OT_ERROR_VAR_DEFAULT(...) do { \
    char buf[512]; \
    PyOS_snprintf(buf,512,__VA_ARGS__); \
    PyErr_SetString(PyExc_SystemError,buf); \
  } while (0)
#endif
 
// new object ******************************************************************************
 
#define OT_TMP_BOL_OBJ(val)       BOL2VAL(val)
#define OT_TMP_I8_OBJ(val)       I82VAL(val)
#define OT_TMP_I16_OBJ(val)       I162VAL(val)
#define OT_TMP_I32_OBJ(val)       INT2VAL(val)
#define OT_TMP_I64_OBJ(val)       I642VAL(val)
#define OT_TMP_FLT_OBJ(val)       FLT2VAL(val)
#define OT_TMP_DBL_OBJ(val)       DBL2VAL(val)
#define OT_TMP_BIN_OBJ(val,len)   BIN2VAL(val,len)
#define OT_TMP_STR_OBJ(val)       STRN2VAL(val)
 
// check *********************************************************************************
 
#define OT_Prefix_ARGS      MK_RT_ARGS
#define OT_Prefix_CALL      MK_RT_CALL
 
#define SETUP_ARGS          MK_RT_ARGS Py_ssize_t objc, PyObject *objv
#define SETUP_ARGS_CALL     MK_RT_CALL objc, objv
 
#define OT_Check_ARGS       SETUP_ARGS,       MK_MNG hdl, MK_STRN const arg, Py_ssize_t *skipP
#define OT_Check_CALL(arg)  SETUP_ARGS_CALL,         hdl,               arg, &__skip
 
#define OT_LNG_NULL_IS(obj)               (obj == Py_None)
#define OT_LNG_ARRAY_IS(obj)              PyObject_TypeCheck(obj,&PyList_Type)
#define OT_LNG_LONG_IS(obj)               (CHECK_LONG(obj) || CHECK_STRING(obj))   // from "high"
#define OT_LNG_I32_IS(obj)                (CHECK_LONG(obj) || CHECK_STRING(obj))    // from "high"
 
#define OT_LNG_SKIP_TYPE                  Py_ssize_t
 
#define OT_LNG_OBJ_ENUM_IS(obj,enm)       PyObject_TypeCheck((obj),(enm))
#define OT_LNG_ENUM_NAME(enm)             OT_LNG_NAME_FROM_CLASS(enm)
#define OT_ENUM_TO_I32(o,e)        
#define OT_ENUM_TO_I32_2(o,str)
 
#define OT_LNG_STRN_PRE(str,obj)          PyObject *__##str=PyObject_Str(obj); \
                                          LngErrorCheckN(__##str); \
                                          MK_STRN str=PyUnicode_AsUTF8(__##str)
 
#define OT_LNG_STRN_PRE_AND_LEN(str,_len,obj) \
    PyObject *__##str=PyObject_Str(obj);      \
    LngErrorCheckN(__##str);                  \
    MK_STRN str=PyUnicode_AsUTF8AndSize(__##str,&_len)
 
#define OT_LNG_STRN_POST(str,obj)         Py_CLEAR(__##str)
 
#include "tmpl/mk_misc_check_lng.h"
 
#define OT_TUPLE_GET_ITEM(_obj,_skip) ({typeof(_skip) _idx=(_skip);(PyTuple_Check(_obj)?PyTuple_GET_ITEM((_obj),(_idx)):(_obj));})
 
#define OT_CHECK_OPTIONAL(val)  if (__skip < objc) {val}
#define OT_CHECK_REQUIRED(val)  val
 
#define OT_CHECK_NUM_ARGS(min,max) \
  if (objc < min || objc > max) {\
    OT_ERROR_NUMARGS(hdl,__skip, objc, min, max, "");\
  }
 
#define OT_CHECK_NOARGS \
  if (__skip != objc) {\
    OT_ERROR_NUMARGS(hdl,__skip, objc, -999, +999, "");\
  }
 
#define OT_CHECK_BNP(val,len) \
  if (__skip >= objc) { \
    OT_ERROR_NUMARGS(hdl,__skip, objc, -999, +999, #val); \
  } else {\
    PyObject *t1 = OT_TUPLE_GET_ITEM(objv,__skip++);\
    if (PyByteArray_Check(t1)) { \
      val = (MK_BIN)PyByteArray_AS_STRING(t1); \
      len = (MK_SIZE)PyByteArray_GET_SIZE(t1); \
    } else { \
      PyErr_SetString(PyExc_TypeError, "parameter '" #val "' must be a 'byte-array'.");\
      goto error;\
    } \
  };
 
#define OT_CHECK_BCP(val) \
  if (__skip >= objc) { \
    OT_ERROR_NUMARGS(hdl,__skip, objc, -999, +999, #val); \
  } else {\
    PyObject *t1 = OT_TUPLE_GET_ITEM(objv,__skip++);\
    if (PyByteArray_Check(t1)) { \
      val = (MK_BINN)PyByteArray_AS_STRING(t1); \
    } else { \
      PyErr_SetString(PyExc_TypeError, "parameter '" #val "' must be a 'byte-array'.");\
      goto error;\
    } \
  };
 
#define OT_GET_CONSTR_NAME(ctor)      ((PyTypeObject*)ctor)->tp_name
 
#define check_NULL(E)                 if (unlikely((E) == NULL))
 
// enum ******************************************************************************
 
// #define MK_ENUM(enm)  py_mkkernel_MkKernelThreadState.enm
 
// BEGIN-EnumExtern - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
#define MkErrorE_lngO (MK(MkKernelThreadState).MkErrorE)
#define MkIdSE_lngO (MK(MkKernelThreadState).MkIdSE)
#define MkTimeoutE_lngO (MK(MkKernelThreadState).MkTimeoutE)
#define MkTypeE_lngO (MK(MkKernelThreadState).MkTypeE)
 
// END-EnumExtern - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
#define OT_NEW_Mk_enum_OBJ(typ,val)  PyObject_CallFunction((PyObject*)(Mk ## typ ##_lngO),"i",val)
 
// class ******************************************************************************
 
// object 2 native *************************************************************************
 
#define OT_CHECK_STRN(val)                                   \
  if (__skip >= objc) {                                      \
    OT_ERROR_NUMARGS(hdl,__skip, objc, -999, +999, #val);    \
  } else {                                                   \
    Py_ssize_t len;                                          \
    PyObject *obj=OT_TUPLE_GET_ITEM(objv,__skip++);          \
    if (obj == Py_None) {                                    \
      val="";                                                \
    } else {                                                 \
      if (PyUnicode_Check(obj)) {                            \
        val=PyUnicode_AsUTF8AndSize(obj,&len);               \
      } else {                                               \
        OT_LNG_STRN_PRE_AND_LEN(strC,len,obj);               \
        /* NO function because of strdupa */                 \
        val=strdupa(strC);                                   \
        OT_LNG_STRN_POST(strC,obj);                          \
      }                                                      \
      if (MK_NULL_STR_CHECK(val,len)) {                      \
        val = NULL;                                          \
      }                                                      \
    }                                                        \
  };
 
#define OT_CHECK_C_COPY(val,size)                            \
  if (__skip >= objc) {                                      \
    OT_ERROR_NUMARGS(hdl,__skip, objc, -999, +999, #val);    \
  } else {                                                   \
    PyObject *obj=OT_TUPLE_GET_ITEM(objv,__skip++);          \
    if (obj == Py_None) {                                    \
      val[0]='\0';                                           \
    } else {                                                 \
      if (PyUnicode_Check(obj)) {                            \
        strncpy(val,PyUnicode_AsUTF8(obj),size);             \
      } else {                                               \
        OT_LNG_STRN_PRE(strC,obj);                           \
        strncpy(val,strC,size);                              \
        OT_LNG_STRN_POST(strC,obj);                          \
      }                                                      \
    }                                                        \
  };
 
// object 2 native *************************************************************************
 
#include "tmpl/mk_misc_ObjAs_lng.h"
 
#define OT_CHECK_LNGTMPL(val,func) MkErrorC_CheckD(func(OT_Check_CALL(#val),&val));
 
#define OT_CHECK_bool(val)      OT_CHECK_LNGTMPL(val,MK(Obj_AsBOOL))
#define OT_CHECK_NB1(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsBOL))
#define OT_CHECK_NI1(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsI8))
#define OT_CHECK_NI2(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsI16))
#define OT_CHECK_NI4(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsI32))
#define OT_CHECK_NI8(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsI64))
#define OT_CHECK_NF4(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsFLT))
#define OT_CHECK_NF8(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsDBL))
#define OT_CHECK_NIL(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsLONG))
 
// isc nspection *************************************************************************
 
#define OT_GET_CALL_PROC    MK(Get_Call_Proc)(0,&frame)
#define OT_GET_CALL_FILE    MK(Get_Call_Script)(0,&frame)
#define OT_GET_CALL_LINE    MK(Get_Call_Line)(0,&frame)
 
MK_PY_EXTERN    MK_STRN  MK(Get_Call_Proc)    (Py_ssize_t,PyObject**);
MK_PY_EXTERN    MK_STRN  MK(Get_Call_Code)    (Py_ssize_t,PyObject**);
MK_PY_EXTERN    MK_STRN  MK(Get_Call_Script)  (Py_ssize_t,PyObject**);
MK_PY_EXTERN    MK_I32  MK(Get_Call_Line)     (Py_ssize_t,PyObject**);
                bool    MK(Get_Call_Stack)    (MK_RT_ARGS MK_ERR const,Py_ssize_t,PyObject**);
 
// call ******************************************************************************
 
typedef struct MkCallS {
  OT_OBJ_T  callable;
  MK_MNG    hdl;
  MK_RT     mkrt;
  bool      isAlloc;    // instance was alloced 
} MkCallS;
 
// cleanup MkCallS from above
mk_inline void NS(CallFreeOnce) (MK_CBP* callP) 
{
  if ( callP == NULL || *callP == NULL || _Py_IsFinalizing()) return;
 
  struct MkCallS *call = *callP;
 
  OT_REF_DECR_AND_NULL(call->callable);
 
  if (call->isAlloc)  MkSysFree(*callP); 
  else                *callP = NULL;
}
 
mk_inline void NS(CallFree) (MK_CBP* callP) 
{
  if ( callP == NULL || *callP == NULL || _Py_IsFinalizing()) return;
 
  OT_OBJ_T callable = *callP;
 
  OT_REF_DECR_AND_NULL(callable);
 
  *callP = NULL;
}
 
/*****************************************************************************/
/*                                                                           */
/*                              Object_API                                   */
/*                                                                           */
/*****************************************************************************/
 
#define OT_OBJECT_DISPOSE(self)           MK(AtomDispose)(MK_RT_CALL hdl);
#define OT_OBJECT_DELETE(self)            MK(AtomDelete)(MK_RT_CALL hdl);
#define OT_OBJECT_DELETE_HARD(self)       MK(AtomDeleteHard)(MK_RT_CALL self);
#define OT_MODULE_STATE(Ns)               ((NS(ModuleStateS)*)MK_RT_REF.mkThreadData)
 
/*****************************************************************************/
/*                                                                           */
/*                             MISC functions                                */
/*                                                                           */
/*****************************************************************************/
 
// from misc_py.c
 
//MK_PY_EXTERN      PyObject*       MK(ErrorAppend)(MK_STRN);
 
// MkExceptionC_py.c
MK_PY_EXTERN      MK_ERR          MK(MkExceptionC_Catch)  (OT_Prefix_ARGS MK_MNG const, MK_EXP const, MK_STRN const);
MK_PY_EXTERN      void            MK(MkExceptionC_Raise)  (OT_Prefix_ARGS MK_MNGN const,MK_STRN const,MK_STRN const,MK_I32);
 
// from MkBufferC_py.c
MK_PY_EXTERN      OT_ProcRet      MK(MkBufferC_ToObject)  (MkBufferC_ARGS);
MK_PY_EXTERN      OT_ProcRet      MK(MkBufferC_GetBFL)      (MkBufferC_ARGS);
 
// from MkBufferListC_py.c
MK_PY_EXTERN      OT_ProcRet      MK(MkBufferListC_ToList)   (MkBufferListC_ARGS);
 
// misc
mk_inline PyObject* PyC2O(MK_STRN v) {
  return (v?PyUnicode_FromString(v):Py_NewRef(Py_None));
}
 
/*****************************************************************************/
/*                                                                           */
/*                                 definition's                              */
/*                                                                           */
/*****************************************************************************/
 
//#define       PTR2VAL(nat)        _PTR2VAL(nat)
#define OBJ2VAL(nat)        ((OT_OBJ_T)((MK_OBJ)nat)->self)
#define I82VAL(nat)         PyLong_FromLong(nat) 
#define BOL2VAL(nat)        PyBool_FromLong(nat)
#define I162VAL(nat)        PyLong_FromLong(nat)
#define INT2VAL(nat)        PyLong_FromLong(nat)
#define I642VAL(nat)        PyLong_FromLongLong(nat)
#define FLT2VAL(nat)        PyFloat_FromDouble(nat)
#define DBL2VAL(nat)        PyFloat_FromDouble(nat)
#define STRN2VAL(nat)       MK(STRN2VAL)(nat)
#define STR2VAL(ptr,len)    MK(STR2VAL)(ptr,len)
#define BIN2VAL(ptr,len)    PyByteArray_FromStringAndSize((const char*)ptr,(Py_ssize_t)len)
#define LONG2VAL(nat)       PyLong_FromLong(nat)
#define HDL2VAL(nat)        PyLong_FromLong(nat)
 
#define VAL2MNG(val)        (MK_MNG)((MkObjectC_Obj*) val)->hdl
 
// *********************************************************************************************
 
mk_inline PyObject* MK(STRN2VAL)(MK_STRN str) {
  PyObject *uc=NULL;
  if (str == MK_NULL) {
    return PyUnicode_FromString(MK_NULL_STR);
  } else if ((uc = PyUnicode_FromString(str)) == NULL) {
    PyErr_Print();
    return PyUnicode_FromString("ERROR in STRN2VAL");
  } else {
    return uc;
  }
}
 
mk_inline PyObject* MK(STR2VAL)(MK_STRN str, MK_NUM len) {
  PyObject *uc=NULL;
  if (str == MK_NULL) {
    return PyUnicode_FromString(MK_NULL_STR);
  } else if ((uc = PyUnicode_FromStringAndSize(str,len)) == NULL) {
    PyErr_Print();
    return PyUnicode_FromString("ERROR in STR2VAL");
  } else {
    return uc;
  }
}
 
/*****************************************************************************/
/*                                                                           */
/*                          reference                                        */
/*                                                                           */
/*****************************************************************************/
 
#define ME_REF_MkBinaryR                MkBinaryR
#define OT_GET__ME_REF_MkBinaryR(b)     BIN2VAL(b.data,b.size)
#define VAL2MkBinaryR(_obj) ({                                                             \
  PyObject *obj=_obj;                                                                      \
  MK_BIN bin=NULL;                                                                         \
  MK_SIZE len=0;                                                                           \
  if (obj != Py_None) {                                                                    \
    if (PyByteArray_Check(obj)) {                                                          \
      bin = (MK_BIN)PyByteArray_AS_STRING(obj);                                            \
      len = (MK_SIZE)PyByteArray_GET_SIZE(obj);                                            \
    } else {                                                                               \
      PyErr_SetString(PyExc_TypeError, "parameter '" #_obj "' must be a 'byte-array'.");   \
      goto error;                                                                          \
    }                                                                                      \
  }                                                                                        \
  MkBinaryCreate(len,bin);                                                                 \
})
#define OT_CHECK__ME_REF_MkBinaryR(val)                      \
  if (__skip >= objc) {                                      \
    OT_ERROR_NUMARGS(hdl,__skip, objc, -999, +999, #val);    \
  } else {                                                   \
    val=VAL2MkBinaryR(OT_TUPLE_GET_ITEM(objv,__skip++));     \
  }
 
#define ME_REF_MkStringR                MkStringR
#define OT_GET__ME_REF_MkStringR(b)     STR2VAL(b.ptr,b.len)
#define VAL2MkStringR(_obj) ({                       \
  PyObject *obj=_obj;                                \
  const char *str=NULL;                              \
  Py_ssize_t len=0;                                  \
  if (obj != Py_None) {                              \
    if (PyUnicode_Check(obj)) {                      \
      str=PyUnicode_AsUTF8AndSize(obj,&len);         \
    } else {                                         \
      OT_LNG_STRN_PRE_AND_LEN(strC,len,obj);         \
      /* NO function because of strdupa */           \
      str=strdupa(strC);                             \
      OT_LNG_STRN_POST(strC,obj);                    \
    }                                                \
  }                                                  \
  MkStringCreate((MK_NUM)len,str);                   \
})
#define OT_CHECK__ME_REF_MkStringR(val)                      \
  if (__skip >= objc) {                                      \
    OT_ERROR_NUMARGS(hdl,__skip, objc, -999, +999, #val);    \
  } else {                                                   \
    val=VAL2MkStringR(OT_TUPLE_GET_ITEM(objv,__skip++));     \
  };
 
/*****************************************************************************/
/*                                                                           */
/*                              debugging                                    */
/*                                                                           */
/*****************************************************************************/
 
mk_inline void MK(printObjRaw)(PyObject* obj, MK_STRN str, MK_STRN caller) {
  if (obj == NULL) obj = Py_None;
  fprintf(stderr,"%-30s:%-25s[refCnt=%-3zi, type=%-10s, self=%-20p] -> ",
    caller,str,Py_REFCNT(obj),Py_TYPE(obj)->tp_name,obj);
  PyObject_Print(obj,stderr,Py_PRINT_RAW);
  fprintf(stderr,"\n");
  fflush(stderr);
}
 
  #define formatObj_fmt         "%-10s [ptr=%-16p, refCnt=%-3zi, type=%-16s, self=%-16p, mq=%p] -> %s"
  #define formatObj_args(s,o)   s, o, Py_REFCNT(o),Py_TYPE(o)->tp_name, o, MK(LngObjToMqPtr)(o), MK(LngObjToString)(o)
 
  #define formatObj(s,o)        formatObj_fmt,formatObj_args(s,o)
 
  #define printXSObj(ctx,s,o)   printXV(ctx, formatObj_fmt, formatObj_args(s,o));
  #define printXLngObj(x,o)     printXSObj(x,#o,(o!=NULL?(PyObject*)o:(PyObject*)Py_None))
  #define printLngObj(o)        printXLngObj(NULL,(o))
 
  #define formatObj2_fmt   "%-10s [ptr=%-16p, refCnt=%-3zi, type=%-16s, self=%-16p, mq=%p]"
  #define formatObj2_args(s,o)  s, o, Py_REFCNT(o),Py_TYPE(o)->tp_name, o, MK(LngObjToMqPtr)(o)
 
  #define printXSObj2(ctx,s,o)  printXV(ctx, formatObj2_fmt, formatObj2_args(s,o));
  #define printXLngObj2(x,o)    printXSObj2(x,#o,(o!=NULL?(PyObject*)o:(PyObject*)Py_None))
  #define printLngObj2(o)       printXLngObj2(NULL,o)
 
  #define printObj1(x,o)        printXLngObj(x,o)
  #define printRef(s,o)         printV(s ": " #o "<%p>, refCount<%li>\n", o, Py_REFCNT(o));
  #define printXRef(x,s,o) {\
    if (o == NULL) {\
      printXLV(x,s ": " #o "<%p>, refCount<%li>\n", NULL, 0L);\
    } else {\
      printXLV(x,s ": " #o "<%p>, refCount<%li>\n", o, Py_REFCNT(o));\
    } \
  } while (0);
 
#if META_DEBUG
  #define printError(ctx,str) if (PyErr_Occurred()) {\
    MLTxt2(ctx,str,MK(LngErrorToString)())\
  } else {\
    MLTxt2(ctx,str,"None")\
  }
#endif
 
char* MK(LngErrorToString)(void);
 
// required in "tmpl/misc_ObjAs_lng.h" error-message
MK_PY_EXTERN  const char*   MK(LngObjToString)(PyObject*);
MK_PY_EXTERN  MK_OBJ        MK(LngObjToMqPtr)(PyObject*);
              void          MK(LngUnicodeObjToBuffer)(PyObject*,MK_STR,MK_SIZE,MK_STRN);
 
// ***********************************************************************************
 
// CALLED from: "Dispose"
mk_inline void NS(AtomDispose) (MK_RT_ARGS MK_MNG mng)
{
  // check if hdl is valid
  MK_OBJ obj = MkObj(mng);
  // delete link between PYTHON and MQ
  check_NULL(obj) return;
 
  // delete link between MQ and PYTHON
  obj = MkRefDecrWithUnlinkSelf(obj);
}
 
// CALLED from: "Delete"
mk_inline void NS(AtomDelete) (MK_RT_ARGS MK_MNG mng)
{
  // check if hdl is valid
  MK_OBJ obj = MkObj(mng);
  // delete link between PYTHON and MQ
  check_NULL(obj) return;
  // delete link between META and PYTHON
  MkRefDecrWithUnlinkSelf(obj);
}
 
// CALLED to delete an EXISTING self
mk_inline void NS(AtomDeleteHard) (MK_RT_ARGS OT_OBJ_T selfO)
{
  if (selfO==NULL || _Py_IsFinalizing()) return;
  MkObjectC_Obj *self = (MkObjectC_Obj*) selfO;
 
#ifdef LOG_REF
  printLngObj(self)
#endif
 
  // check if hdl is valid
  MK_OBJ obj = MkObj(self->hdl);
    check_NULL(obj) return;
 
  // delete link between SELF and META
  self->hdl = NULL;
 
  // delete link between META and SELF
  MkRefDecrWithoutSelf(obj);
 
  // cleanup python object
  Py_CLEAR(selfO);
}
 
mk_inline PyObject* NS(AtomCreate) (
  MK_RT_ARGS
  PyTypeObject        *type,
  MK_OBJ              obj
) {
  MkObjectC_Obj *retObj = (MkObjectC_Obj*) (type)->tp_alloc(type, 0);
 
  if (obj) {
    retObj->hdl = obj;
      MkRefIncr(obj);
    MkSelfSet (obj, (void*) retObj, NULL);
  }
 
#if LOG_REF
  printLngObj(retObj);
#endif
 
//  mk_dbg_color_ln(MK_COLOR_PURPLE,"obj<%p>, retObj<%p>, retObj->hdl<%p>", obj, retObj, retObj->hdl);
 
  return (PyObject*)retObj;
}
 
mk_inline PyObject* NS(AtomObjNew) (
  MK_RT_ARGS
  PyTypeObject        *type,
  MK_OBJ              obj
) {
  if (obj == NULL) {
    if (PyErr_Occurred()) {
      return NULL;
    } else {
      Py_RETURN_NONE;
      //PyErr_Format(PyExc_ValueError, "'%s' constructor return a NULL pointer", type->tp_name);
    }
  }
 
  #define __doc  "AtomObjNew"
  MK_PTR selfO = NULL;
  MkErrorC_Check(obj, MkSelfNew(obj,&selfO,NULL))
  return Py_NewRef((OT_OBJ_T) selfO);
  #undef  __doc
error:
  return NULL;
}
 
#undef HEADER