LibMkKernel_atl.h

Go to the documentation of this file.

 
#pragma once
 
#include "libmyoox_mox.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
 
#if 0
  #define OT_DEBUG_NAMESPACE_DELETE(c,...) do { \
    mk_dbg_color_ln(c, "delete namespace %-3s : " __VA_ARGS__); \
    /* MkSysPrintStackTrace_RT(NULL,NULL,0,__func__,1,0,-1); */ \
  } while (0)
#else
  #define OT_DEBUG_NAMESPACE_DELETE(...)
#endif
 
/*****************************************************************************/
/*                                                                           */
/*                              Macro_API                                    */
/*                                                                           */
/*****************************************************************************/
 
// BEGIN-HEADER - created by 'atl_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_ATL_EXTERN
#if defined(META_IGNORE_EXTERN)
#   define MK_ATL_EXTERN
#elif defined(PIC)
   // does we build a DLL ?
#  if defined(DLL_EXPORT)
       // does we build the libmkkernel library ?
#      if defined(MK_ATL_BUILD_DLL)
#        define MK_ATL_EXTERN __declspec(dllexport)
#      else
#        define MK_ATL_EXTERN __declspec(dllimport)
#      endif
#  else
   // no DLL - architecture specific extern specifier
#    define MK_ATL_EXTERN __attribute__ ((visibility("default")))
#  endif
#else
#   define MK_ATL_EXTERN
#endif
 
// external data lookup
#undef MK_ATL_EXTERN_DATA
#if defined(META_PRIVATE)
#  define MK_ATL_EXTERN_DATA extern
#elif defined(META_IGNORE_EXTERN)
#  define MK_ATL_EXTERN_DATA extern
#elif defined(PIC)
   // does we build a DLL ?
#  if defined(DLL_EXPORT)
       // does we build the libmkkernel library ?
#      if defined(MK_ATL_BUILD_DLL)
#        define MK_ATL_EXTERN_DATA __declspec(dllexport)
#      else
#        define MK_ATL_EXTERN_DATA __declspec(dllimport)
#      endif
#  else
   // no DLL - architecture specific extern specifier
#    define MK_ATL_EXTERN_DATA __attribute__ ((visibility("default"))) extern
#  endif
#else
#  define MK_ATL_EXTERN_DATA extern
#endif
 
#undef MK
#define MK(n) atlmkkernel_ ## n
#undef NS
#define NS(n) atlmkkernel_ ## n
 
// END-HEADER - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
#define META_CONTEXT_S            hdl
 
#define OT_ProcRet                int
 
#define ATL_OBJV_ARGS             int objc, OT_OBJ_T const objv[]
#define ATL_OBJV_ARGS_CALL        objc, objv
 
#define ATL_ARGS                  OT_ENV_T interp, int objc, OT_OBJ_T const objv[]
#define ATL_ARGS_CALL             interp, objc, objv
 
#define OBJECT_ARGS               ClientData clientData, ATL_ARGS
#define OBJECT_ARGS_CALL          hdl, ATL_ARGS_CALL
 
#define OBJCMD_ARGS               ClientData clientData, ATL_ARGS
#define OBJCMD_ARGS_CALL          clientData, ATL_ARGS_CALL
 
#define CONSTR_ARGS               OBJECT_ARGS
 
#define SKIP_ARGS                 ATL_ARGS, int __skip
#define SKIP_ARGS_CALL            ATL_ARGS_CALL, __skip
 
#define OtClass_ARGS              OBJECT_ARGS
#define OtClass_ARGS_CALL         OBJECT_ARGS_CALL
 
// class args ******************************************************************************
 
// BEGIN-Class-def - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
#define MkBufferListC_ARGS        OBJECT_ARGS
#define MkBufferListC_ARGS_CALL   OBJECT_ARGS_CALL
#define MkBufferC_ARGS            OBJECT_ARGS
#define MkBufferC_ARGS_CALL       OBJECT_ARGS_CALL
#define MkBufferStreamC_ARGS      OBJECT_ARGS
#define MkBufferStreamC_ARGS_CALL OBJECT_ARGS_CALL
#define MkErrorC_ARGS             OBJECT_ARGS
#define MkErrorC_ARGS_CALL        OBJECT_ARGS_CALL
#define MkLogFileC_ARGS           OBJECT_ARGS
#define MkLogFileC_ARGS_CALL      OBJECT_ARGS_CALL
#define MkObjectC_ARGS            OBJECT_ARGS
#define MkObjectC_ARGS_CALL       OBJECT_ARGS_CALL
#define MkRuntimeC_ARGS           OBJECT_ARGS
#define MkRuntimeC_ARGS_CALL      OBJECT_ARGS_CALL
 
// END-Class-def - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// setup ***********************************************************************************
 
#define OT_SETUP_ARGS_ALL(d)                 \
  OT_OBJ_T retObj=NULL;                      \
  MK_UNUSED static const MK_STRN __doc=d;    \
  MK_UNUSED OT_OBJ_T frame=NULL;             \
 
#define OT_FRAME_CLEANUP  if (frame != NULL) { Tcl_DecrRefCount(frame); frame = NULL; }
 
#define OT_SETUP_VARARGS(min,max,d)    \
  OT_SETUP_ARGS_ALL(d)                 \
  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)        \
  OT_CHECK_NUM_ARGS(1,1)
 
#define OT_SETUP_NOARG(d)    \
  OT_SETUP_ARGS_ALL(d)       \
  OT_CHECK_NUM_ARGS(0,0)
 
#define OT_SETUP_obj              MK_OBJ obj = OBJ
#define OT_SETUP_doc              __attribute__((unused)) const MK_STRN __doc = __func__;
 
#define SETUP_ARGS                MK_RT_ARGS ATL_ARGS
#define SETUP_ARGS_CALL           MK_RT_CALL ATL_ARGS_CALL
 
//#define OT_retObj_CONSTR(x)       retObj = SELF2VAL(AtomCreateCONSTR(MkOBJ(x),OT_CLASS,nameO));
#define OT_CONSTRUCTOR_POST(x)
 
#define OT_retObj_SET(val)        retObj = (val)
#define OT_retObj_SET_isPtr       ((long)retObj) > 0x1
#define OT_retObj_SET_None        retObj = ((OT_OBJ_T)0x1)
#define OT_retObj_SET_isNone      ((long)retObj) == 0x1
#define OT_retObj_SET_Error       retObj = NULL
  /*Tcl_AppendResult(interp,"\n  ->  found in: ", doc, NULL);*/
#define OT_retObj_SET_List        retObj = Tcl_NewListObj(0,NULL)
#define OT_retObj_APPEND(var)     check_LNG(Tcl_ListObjAppendElement(interp,retObj,var)) goto error
#define OT_retObj_RETURN do {           \
  if (OT_retObj_SET_isPtr) {            \
    Tcl_SetObjResult(interp,retObj);    \
    return TCL_OK;                      \
  } else if (OT_retObj_SET_isNone) {    \
    Tcl_ResetResult(interp);            \
    return TCL_OK;                      \
  } else {                              \
    return TCL_ERROR;                   \
  }                                     \
} while (0)
 
#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_U16(nat)      retObj = U162VAL(nat);
#define OT_retObj_SET_I32(nat)      retObj = INT2VAL(nat);
#define OT_retObj_SET_I64(nat)      retObj = I642VAL(nat);
#define OT_retObj_SET_LLG(nat)      retObj = LLG2VAL(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);
 
// METHOD CALL **********************************************************************
 
#if 0
 
#define OT_MK_CALL_0_v1
 
// calling an object TROUGH the Tcl_Eval api
#define OT_MK_CALL_0(hdl,cls,meth,ret)                     \
{
  ret = MK(EvalObjvVR)(NULL,interp,0,MK(cls##_ObjNew)(interp,hdl),MK(cls##_##meth##_Obj),NULL);
}
 
#else
 
// call an method direct.
// !! ATTENTION !! the "selfO" is NULL -> do NOT use this call for any "internal" usage.
#define OT_MK_CALL_0(hdl,cls,meth,ret) {                            \
  OT_SELF_T selfO = cls##_ObjNew(hdl);                              \
    assert(selfO != NULL);                                          \
  RL_init(2,cls##_##meth,RL_NewS(0,MK_CPPXSTR(::cls::meth))) ; RL_O(1,SELF2VAL(selfO)) ; \
  check_LNG(RL_EvalEx(TCL_EVAL_GLOBAL)) goto error; \
  ret = Tcl_GetObjResult(interp); \
}
 
#endif
 
// MARK_R ---------------------------------------------------------------------------
// Runtime
 
typedef MOX_PTR     OT_PTR_T    ;
typedef MOX_ENV_T   OT_ENV_T    ;
typedef MOX_NS_T    OT_NS_T     ;
typedef MOX_CLS_T   OT_CLS_T    ;
typedef MOX_OBJ_T   OT_OBJ_T    ;
 
typedef MK_STRN     OT_ENUM_T   ;
typedef MOX_OBJ_T   OT_SELF_T   ;
 
typedef enum OT_MK_RT_StatusE {
  OT_MK_RT_STATUS_NEW     = 0,
  OT_MK_RT_STATUS_ONEXIT  = 1,
  OT_MK_RT_STATUS_DELETED = 2,
} OT_MK_RT_StatusE;
 
#define OT_MK_RT_SIG   0x62384526
 
struct AtlClassDefS;
 
typedef struct {
  MK_SIG            signature;
  //OT_MK_RT_StatusE  status;
  MK_RT             mkrt;
  OT_ENV_T          interp;
  MOX_RT_T          moxrt;
  #define           AtlClassName_buf_size   64
  char              AtlClassName_buf[AtlClassName_buf_size];
 
  #define regTclObj(t)      OT_OBJ_T t;
  #define regTclObj2(t,v)   OT_OBJ_T t;
  #define regTclCmd(t)      OT_OBJ_T t;
  #define regTclArray(m,t)  OT_OBJ_T t[m];
  #include "LibMkKernel_registry_atl.h"
  #undef regTclArray
  #undef regTclCmd
  #undef regTclObj
  #undef regTclObj2
 
  const Tcl_ObjType  *LONG;
  const Tcl_ObjType  *WIDE;
  const Tcl_ObjType  *DOUBLE;
  const Tcl_ObjType  *BOOLEAN;
  const Tcl_ObjType  *INDEX;
  const Tcl_ObjType  *NS;
 
  struct AtlClassDefS *atlClassDefL;
 
  // BEGIN-CLASS-rt - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  OT_CLS_T AtlMkObjectC               ;
  OT_NS_T  AtlMkObjectC_NS            ;
  OT_OBJ_T AtlMkObjectC_MK_NULL       ;
  MK_TYP   AtlMkObjectCTT             ;
  OT_CLS_T AtlMkBufferC               ;
  OT_NS_T  AtlMkBufferC_NS            ;
  OT_OBJ_T AtlMkBufferC_MK_NULL       ;
  MK_TYP   AtlMkBufferCTT             ;
  OT_CLS_T AtlMkBufferListC           ;
  OT_NS_T  AtlMkBufferListC_NS        ;
  OT_OBJ_T AtlMkBufferListC_MK_NULL   ;
  MK_TYP   AtlMkBufferListCTT         ;
  OT_CLS_T AtlMkLogFileC              ;
  OT_NS_T  AtlMkLogFileC_NS           ;
  OT_OBJ_T AtlMkLogFileC_MK_NULL      ;
  MK_TYP   AtlMkLogFileCTT            ;
  OT_CLS_T AtlMkErrorC                ;
  OT_NS_T  AtlMkErrorC_NS             ;
  OT_OBJ_T AtlMkErrorC_MK_NULL        ;
  MK_TYP   AtlMkErrorCTT              ;
  OT_CLS_T AtlMkRuntimeC              ;
  OT_NS_T  AtlMkRuntimeC_NS           ;
  OT_OBJ_T AtlMkRuntimeC_MK_NULL      ;
  MK_TYP   AtlMkRuntimeCTT            ;
  OT_CLS_T AtlMkBufferStreamC         ;
  OT_NS_T  AtlMkBufferStreamC_NS      ;
  OT_OBJ_T AtlMkBufferStreamC_MK_NULL ;
  MK_TYP   AtlMkBufferStreamCTT       ;
 
  // END-CLASS-rt - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
} OT_MK_RT_S;
typedef OT_MK_RT_S* OT_MK_RT_T;
 
MK_EXTERN_DATA MkThreadLocal OT_MK_RT_S amkrtR;
 
#define OT_MK_ARGS                   OT_MK_RT_T amkrt, OT_ENV_T interp, MK_RT_ARGS
#define OT_MK_CALL                              amkrt,          interp, MK_RT_CALL
 
#define OT_LNG_NULL                   NULL
#define OT_LNG_UNDEF                  NULL
#define OT_LNG_RETURN(ret,cmd)        \
  check_LNG(cmd) goto error;          \
  ret = Tcl_GetObjResult(interp);     \
 
#define OT_LNG_NAME_FROM_OBJECT(_obj)       VAL2STR(_obj)
#define OT_LNG_NAME_FROM_CLASS(_cls)        OT_LNG_NAME_FROM_OBJECT(_cls)
#define OT_LNG_NAME_FROM_OBJ(_obj)          OT_LNG_NAME_FROM_OBJECT(_obj)
// silent assume a "OT_LNG_OBJECT_IS" or "OT_LNG_CLASS_IS" befor set "retP"
#define OT_LNG_OBJ_CLASSNAME(val)           MK(ClassName)(OT_Prefix_CALL val, false)
#define OT_LNG_OBJ_CLASSNAME_SHORT(val)     MK(ClassName)(OT_Prefix_CALL val, true)
#define OT_OBJ_TYPE_STRING(val)             MK(ClassName)(OT_Prefix_CALL val, false)
 
// self adon
#define OT_LNG_SELF_2_LNG(selfT)        ((OT_OBJ_T)(selfT))
 
#define OT_LNG_OBJV(__skip)             objv[__skip]
 
#define OT_OBJ_TO_CLASS(obj)          obj
#define OT_OBJ_TO_ENUM(str)           #str
 
#define OT_LNG_SET_VAR(var,val)     \
  if (Tcl_ObjSetVar2(interp, var, NULL, val, TCL_LEAVE_ERR_MSG) == NULL) goto error
 
#define OT_LNG_EMBEDDED(type,call,...) ({ \
  type ret = (type) 0; \
  check_LNG(call (__VA_ARGS__,&ret)) { \
    OT_ERROR_APPEND_LNG_STACK(); \
    goto error; \
  } \
  ret; \
})
 
// ERROR ******************************************************************************
 
#define OT_ERROR_LNG_RETURN return TCL_ERROR
 
#define OT_ERROR_VAR_DEFAULT(...)   Tcl_SetObjResult(interp,Tcl_ObjPrintf(__VA_ARGS__))
#define OT_ERROR_STR_DEFAULT(...)   Tcl_SetObjResult(interp,Tcl_NewStringObj(__VA_ARGS__,-1))
 
#define OT_ERROR_TYPE(str)          Tcl_SetObjResult(interp, Tcl_ObjPrintf("TYPE ERROR: %s", str))
 
#define OT_ERROR_SOFT_CONSTRUCTOR(class)  do { \
  Tcl_SetResult(interp, "InitSoftError: '" #class "' soft constructor return 'NULL' pointer", TCL_STATIC); \
} while (0)
 
#define OT_ERROR_CONSTRUCTOR(class)       do { \
  Tcl_SetResult(interp, "InitError: '" #class "' constructor return 'NULL' pointer", TCL_STATIC); \
  if (MkErrorCheckE_0E()) { \
    Tcl_AppendResult(interp, "\nMqError: ", MkErrorGetText_0E(), NULL); \
    MkErrorReset_0M(); \
  } \
} while (0)
 
// !! attention → always jumps to error
#define OT_ERROR_NUMARGS(...)             \
  MkErrorC_CheckD(WrongNumArgs(__VA_ARGS__))
 
#define OT_ERROR_ABNORMAL(mng) do { \
  MkErrorSetV_4M(mng,__func__,999,"AbnormalError: %s", Tcl_GetStringResult(interp));\
  Tcl_ResetResult(interp); \
} while (0)
 
#define OT_ERROR_APPEND_LNG_STACK()  \
  Tcl_AppendResult(interp,"\nERROR-STACK: func=",__func__,", file=",__FILE__,", line=",MK_CPPXSTR(__LINE__),NULL)
 
// =============================================================================================================
// return
 
#define OT_ERROR_LNG_RETURN_VAR_ERROR(...) return ({ OT_ERROR_VAR_DEFAULT(__VA_ARGS__); TCL_ERROR; })
#define OT_ERROR_LNG_RETURN_STR_ERROR(...) return ({ OT_ERROR_STR_DEFAULT(__VA_ARGS__); TCL_ERROR; })
 
#define OT_ERROR_LNG_RETURN_HDL_NAT_NULL(_hdl) do {                         \
  OT_ERROR_VAR_DEFAULT("[HdlIsNullError] : %s", MkObjectToString(_hdl));    \
  return TCL_ERROR;                                                         \
} while (0)
 
#define OT_ERROR_LNG_RETURN_INVALID_CLASS(_clsHasS,_clsExpS) do {                                             \
  OT_ERROR_VAR_DEFAULT("[InvalidClassError] : Expect class '%s' but get class '%s'", _clsExpS, _clsHasS );    \
  return TCL_ERROR;                                                                                           \
} while (0)
 
#define OT_ERROR_LNG_RETURN_HDL_IS_NULL() return MK(OT_ERROR_LNG_RETURN_HDL_IS_NULL)(OT_MK_CALL OT_CLASS, OT_SELF)
MK_EXTERN int MK_DECL MK(OT_ERROR_LNG_RETURN_HDL_IS_NULL)(OT_MK_ARGS OT_CLS_T, OT_OBJ_T);
 
// check *********************************************************************************
 
#define OT_Prefix_ARGS                OT_MK_ARGS
#define OT_Prefix_CALL                OT_MK_CALL
#define OT_Check_ARGS                 OT_MK_ARGS MK_MNG hdl, MK_STRN const arg, ATL_OBJV_ARGS, int *skipP
#define OT_Check_CALL(arg)            OT_MK_CALL hdl, arg, ATL_OBJV_ARGS_CALL, &__skip
#define OT_Check_CALL2(arg)           OT_MK_CALL hdl, arg, ATL_OBJV_ARGS_CALL, skipP
 
#define OT_CHECK_OPTIONAL(val)  if (__skip < objc) {val}
#define OT_CHECK_REQUIRED(val)  val
 
#define OT_CHECK_NUM_ARGS(min,max)                  \
  if ((objc-__skip) < min || (objc-__skip) > max) {     \
    OT_ERROR_NUMARGS(hdl,__skip, objc, min, max, "");    \
  }
// printLV("objc<%i>, __skip<%i>, min<1>, max<999>\n",objc, __skip);
 
#define OT_CHECK_NOARGS                              \
  if (__skip != objc) {                                \
    OT_ERROR_NUMARGS(hdl,objc, __skip, -999, +999, "");    \
  }
 
#define OT_GET_CONSTR_NAME(ctor) VAL2STR(MoxCls__NAME__N(ctor))
 
#define OT_CHECK_BNP(val,len) \
  if (__skip >= objc) {\
    OT_ERROR_NUMARGS(hdl,__skip, objc, -999, +999, #val); \
  } else { \
    int i; \
    val = (MK_BINN) Tcl_GetByteArrayFromObj(objv[__skip++], &i); \
    len = (MK_SIZE)i; \
  }
 
#define OT_CHECK_BCP(val) \
  if (__skip >= objc) {\
    OT_ERROR_NUMARGS(hdl,__skip, objc, -999, +999, #val); \
  } else { \
    val = (MK_BIN) Tcl_GetByteArrayFromObj(objv[__skip++], NULL); \
  }
 
#define OT_CHECK_BCPN(val) \
  if (__skip >= objc) {\
    OT_ERROR_NUMARGS(hdl,__skip, objc, -999, +999, #val); \
  } else { \
    val = (MK_BINN) Tcl_GetByteArrayFromObj(objv[__skip++], NULL); \
  }
 
// ----------------------------------------------------------------------------
 
#define MkErrorC_Check(mng,PROC) \
  if (unlikely(MkErrorCheckI(PROC))) { \
    OT_ERROR_META_2_LNG(mng); 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(code)           if ((code) != TCL_OK)
#define check_NULL(code)          if ((code) == NULL)
#define check_META(code)          if (MkErrorCheckI(code))
 
// 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)
#define OT_TMP_CST_OBJ(val)       STRN2VAL(val)
 
// atom ******************************************************************************
 
mk_inline OT_OBJ_T              MK(AtomObjNew)      (OT_MK_ARGS MK_OBJ, MK_PTR);
mk_inline bool        MK_DECL   MK(AtomDeleteHard)  (OT_MK_ARGS OT_SELF_T);
mk_inline void        MK_DECL   MK(AtomDispose)     (OT_MK_ARGS OT_SELF_T);
 
// THIS is an soft-delete called from the "<destructor>", SOFT mean that SELF is already on-DELETE
#define OT_OBJECT_DELETE_SOFT(O)  error: done in Atom_ns_delete
 
// THIS is an hard-delete called from everywhere, HARD mean that SELF have to be deleted too
#define OT_OBJECT_DELETE_HARD(O)  MK(AtomDeleteHard)  (OT_MK_CALL O)
 
// THIS is an "dispose" delete the link between LNG an META
#define OT_OBJECT_DISPOSE(O)      MK(AtomDispose)     (OT_MK_CALL O)
// This is the delete via the destructor which is called via "DestroyN" which destroy the "namespace"
#define OT_OBJECT_DELETE(O)       MK(AtomDispose)     (OT_MK_CALL O)
 
#define OT_REF_INCR(_obj)             Tcl_IncrRefCount(_obj)
#define OT_REF_DECR(_obj)             Tcl_DecrRefCount(_obj)
#define OT_REF_INCR_AND_RETURN(_obj)  ({ Tcl_IncrRefCount(_obj); _obj;})
#define OT_REF_DECR_AND_NULL(_obj)    if (_obj) { Tcl_DecrRefCount (_obj) ; _obj = NULL; }
 
// call ******************************************************************************
 
#define MkCallS_SIG 0x30364351
typedef enum MkCallTypeE {
    MkCallS_init          = 0,
    MkCallS_null          = 1,
    MkCallS_proc          = 2,
    MkCallS_static        = 3,
    MkCallS_own_method    = 4,
    MkCallS_other_method  = 5,
    MkCallS_error         = 6,
} MkCallTypeE;
 
typedef struct MkCallS {
  MK_SIG          signature;
  MkCallTypeE     type;
  OT_OBJ_T        my;         // if "MkCallS_static"  -> this is the CLASS "my"
  OT_OBJ_T        mth;        // if 'proc' than NULL if 'method' than "method-name"
  OT_OBJ_T        args;       // additionals arguments passed to the calling proc at beginning of the argument list
  MK_MNG          hdl;        // always the 'hdl'
  OT_MK_RT_T      amkrt;      // always the 'atl-runtime'
  bool            isAlloc;    // instance was alloced
  OT_CLS_T        nsO;        // SLOW but secure: namespace of the check proc ATTENTION class NS have to be constant
  MK_RT           mkrt;       // used to setup local "mkrt" if "mkrt" is NOT part of the callback-args
  
} MkCallS;
 
MK_ATL_EXTERN void MK(CallLog) ( MK_RT_ARGS MkCallS *call, MK_STRN caller );
#define MkCallLog(c)  MK(CallLog) ( MK_RT_CALL_NULL (c), __func__ )
 
#define MkProcResolve_maxArgsLen 16
MK_ATL_EXTERN enum MkErrorE MK_DECL MK(ProcResolve)   ( OT_MK_ARGS MK_MNG, struct MkCallS* );
 
mk_inline void MK(ProcResolveAppendArgs) (
  struct MkCallS  *call,
  int             *objcP,
  OT_OBJ_T        objv[]
) {
  assert(call   != NULL);
  assert(objcP  != NULL);
  assert(objv   != NULL);
 
  if (call->args == NULL) return;
  int myobjc;
  OT_OBJ_T *myobjv;
  int objc = *objcP;
  // call->args already checked to be a valid TCL-LIST
  Tcl_ListObjGetElements(NULL,call->args,&myobjc,&myobjv);
  for (int i=0; i<myobjc; i++) {
//printLLngObj(objv[i])
    objv[objc++] = myobjv[i];
  }
  *objcP = objc;
}
 
mk_inline void MK(CallFree) ( MK_CBP *dataP )
{
  if (amkrtR.signature != OT_MK_RT_SIG) return;
 
  MkCallS * call = *dataP;
 
//MkCallLog(call);
 
  call->signature = 0x0;
 
  OT_REF_DECR_AND_NULL(call->mth);
  OT_REF_DECR_AND_NULL(call->my);
  OT_REF_DECR_AND_NULL(call->args);
  OT_REF_DECR_AND_NULL(call->nsO);
 
  if (call->isAlloc)  MkSysFree(*dataP); 
  else                *dataP = NULL;
}
 
mk_inline void MK(CallFreeOnce) ( MK_CBP *callP )
{
  MK(CallFree) (callP);
}
 
#ifdef META_HAS_THREAD
  #define OT_OBJ_COPY(o)  ({OT_OBJ_T t=(o); if (t) { t = Tcl_NewStringObj(Tcl_GetString(t),-1); OT_REF_INCR(t); }; t; })
#else
  #define OT_OBJ_COPY(o)  ({OT_OBJ_T t=(o); if (t) { OT_REF_INCR(t); }; t; })
#endif
 
mk_inline void MK(CallCopy) ( MK_RT_ARGS MK_OBJ obj, MK_CBP *dataP )
{
  assert (dataP != NULL && *dataP != NULL);
 
  MkCallS *call = MkSysMemDup(MK_ERROR_PANIC,*dataP,sizeof(*call));
  call->isAlloc = true;
 
  call->my   = OT_OBJ_COPY (call->my)     ;
  call->mth  = OT_OBJ_COPY (call->mth)    ;
  call->args = OT_OBJ_COPY (call->args)   ;
  call->nsO  = OT_OBJ_COPY (call->nsO)    ;
 
  *dataP = call;
}
 
/*
#define CallProlog(m)                                                       \
  OT_MK_RT_T const amkrt = call->amkrt;                                     \
    if (amkrt->signature != OT_MK_RT_SIG) {                                 \
      mk_warning("amkrt->signature <%p:%d>", amkrt, amkrt->signature);      \
      printSTACK_1(m);                                                      \
      return MK_OK;                                                         \
    }                                                                       \
  OT_ENV_T const interp = amkrt->interp;                                    \
    if (Tcl_InterpDeleted(interp) ) {                                       \
      mk_warning("interp deleted <%p>", interp);                            \
      printSTACK_1(m);                                                      \
      return MK_OK;                                                         \
    }                                                                       \
 
*/
 
#define CallProlog(m)                                                       \
  /* 1. setup runtime */                                                    \
  OT_MK_RT_T const amkrt = call->amkrt;                                     \
    assert (amkrt->signature == OT_MK_RT_SIG);                              \
  OT_ENV_T const interp = amkrt->interp;                                    \
    assert (!Tcl_InterpDeleted(interp));                                    \
                                                                            \
  /* 2. setup arguments */                                                  \
  Tcl_Obj *objv[5+MkProcResolve_maxArgsLen];                                \
                                                                            \
  rescan:                                                                   \
    int objc = 1;                                                           \
                                                                            \
    /* 1. setup methode */                                                  \
    objv[0] = call->mth;                                                    \
                                                                            \
    /* 2. setup my */                                                       \
    switch (call->type) {                                                   \
      case MkCallS_own_method:                                              \
        dbgMsg("%s","MkCallS_own_method");                                  \
        break;                                                              \
      case MkCallS_static:                                                  \
        dbgMsg("%s","MkCallS_static");                                      \
        break;                                                              \
      case MkCallS_proc:                                                    \
        dbgMsg("%s","MkCallS_proc");                                        \
        break;                                                              \
      case MkCallS_other_method:                                            \
        dbgMsg("%s","MkCallS_other_method");                                \
        objv[objc++] = call->my;                                            \
        break;                                                              \
      case MkCallS_init: {                                                  \
        dbgMsg("%s","MkCallS_init");                                        \
        check_META(MK(ProcResolve)(OT_MK_CALL (m), call)) goto error_mq;    \
        goto rescan;                                                        \
      }                                                                     \
      case MkCallS_null:                                                    \
        dbgMsg("%s","MkCallS_null");                                        \
        return MK_OK;                                                       \
      case MkCallS_error:                                                   \
        dbgMsg("%s","MkCallS_error");                                       \
        goto error;                                                         \
    }
 
// check *****************************************************************************
 
#define NO_OtCheckEnum
#define NO_OtCheckEnumFlag
#define NO_TestObject
#include "tmpl/mk_misc_check_lng.h"
 
#define OT_CHECK_ENUM(ename,val) \
  if (__skip >= objc) {\
    OT_ERROR_NUMARGS(hdl,__skip, objc, -999, +999, #val); \
  } else { \
    check_LNG(Get_ ## ename ## _FromObj_path (MK_RT_CALL interp,objv[__skip++],&val)) goto error; \
  }
 
#define OT_CHECK_ENUM_FLAG(ename,val) \
  if (__skip >= objc) {\
    OT_ERROR_NUMARGS(hdl,__skip, objc, -999, +999, #val); \
  } else { \
    check_LNG(Get_ ## ename ## _FromObj_path (MK_RT_CALL interp,objv[__skip++],&val)) goto error; \
  }
 
// 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_U2N(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsU16))
#define OT_CHECK_NI4(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsI32))
#define OT_CHECK_U4N(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsU32))
#define OT_CHECK_NI8(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsI64))
#define OT_CHECK_IXN(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsLLG))
#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_STRN(val)      OT_CHECK_LNGTMPL(val,MK(Obj_AsSTRN))
#define OT_CHECK_NIL(val)       OT_CHECK_LNGTMPL(val,MK(Obj_AsLONG))
#define OT_CHECK_NIH(val)       MK_HDL_REF_S3(OT_CHECK_) (val)
 
#define OT_CHECK_STRN_NULL(val)  OT_CHECK_LNGTMPL(val,MK(Obj_AsCSTNull))
 
MK_ATL_EXTERN enum MkErrorE   MK_DECL MK(Obj_AsSTR_COPY)    (OT_Check_ARGS,MK_STR,size_t);
#define OT_CHECK_C_COPY(val,size)  MkErrorC_CheckD (MK(Obj_AsSTR_COPY)(OT_Check_CALL(#val),val,size));
 
// inspection *************************************************************************
 
#define OT_GET_CALL_PROC        MK(Get_Call_Proc)(OT_MK_CALL &frame)
#define OT_GET_CALL_FILE        MK(Get_Call_File)(OT_MK_CALL &frame)
#define OT_GET_CALL_LINE        MK(Get_Call_Line)(OT_MK_CALL &frame)
 
#define FRAME_ARGS  OT_MK_ARGS OT_OBJ_T * frameP
#define FRAME_CALL  OT_MK_CALL &frame
 
MK_ATL_EXTERN MK_STRN MK_DECL MK(Get_Call_Proc)   ( FRAME_ARGS );
MK_ATL_EXTERN MK_STRN MK_DECL MK(Get_Call_File)   ( FRAME_ARGS );
MK_ATL_EXTERN MK_I32  MK_DECL MK(Get_Call_Line)   ( FRAME_ARGS );
MK_ATL_EXTERN bool    MK_DECL MK(Get_Call_Stack)  ( OT_MK_ARGS MK_ERR const, int );
 
// enum ******************************************************************************
 
struct LookupEnumE {
  const char  *key;
  int         val;
};
 
MK_ATL_EXTERN int     MK_DECL MK(EnumFlagWorker) (MK_RT_ARGS OT_ENV_T , const struct LookupEnumE*, OT_OBJ_T , int*);
 
// from MkBufferC_atl.c
MK_ATL_EXTERN int MK_DECL MK(MkBufferC_ToObject)        (MkBufferC_ARGS);
MK_ATL_EXTERN int MK_DECL MK(MkBufferC_GetBFL)          (MkBufferC_ARGS);
MK_ATL_EXTERN int MK_DECL MK(MkBufferC_Temp)            (MkBufferC_ARGS);
 
// from MkBufferListC_atl.c
MK_ATL_EXTERN int MK_DECL MK(MkBufferListC_ToList)         (MkBufferListC_ARGS);
 
MK_ATL_EXTERN bool      MK_DECL MK(TestObject)        (OT_Prefix_ARGS OT_OBJ_T, OT_CLS_T, MK_OBJ*, MkTestClassE*);
MK_ATL_EXTERN MK_STRN   MK_DECL MK(ClassName)         (OT_Prefix_ARGS OT_OBJ_T, bool);
MK_ATL_EXTERN MK_STRN   MK_DECL MK(GetTypeFromObj)    (OT_Prefix_ARGS OT_OBJ_T, bool*);
 
typedef int (*LookupClassF) (SKIP_ARGS);
 
struct LookupClassS {
  const char     *key;
  LookupClassF    keyF;
};
 
#define WNA(min,max,txt) { \
/* printObjV */ \
  if (objc<(__skip+min) || objc>(__skip+max)) { \
    Tcl_WrongNumArgs (interp, __skip, objv, txt); \
    return TCL_ERROR; \
  } \
}
 
#define AltClassDef(...) MK(ClassDef)(OT_MK_CALL __VA_ARGS__)
MK_ATL_EXTERN OT_CLS_T MK_DECL MK(ClassDef) (OT_MK_ARGS MK_TYP, OT_NS_T*);
 
typedef struct {
  const char *name;               /* Name of this type of method, mostly for
                                   * debugging purposes. */
  Tcl_ObjCmdProc *callProc;       /* How to invoke this method. */
} OtObjProcDefS;
 
#define AtlUnknownSetup(...)  MK(UnknownSetup) (interp, __VA_ARGS__)
MK_ATL_EXTERN int MK_DECL MK(UnknownSetup)  (
  OT_ENV_T, 
  const OtObjProcDefS[], 
  ClientData
);
 
//*****************************************************************************
//*
//*                         FRAME feature
//*
//*****************************************************************************
 
struct MkVarFrameS {
  MK_NUM max;
  MK_NUM num;
  OT_OBJ_T  *data;
  OT_OBJ_T  prealloc[50];
} ;
typedef struct MkVarFrameS * OT_VARFRAME;
 
#define OT_VARFRAME_CREATE   \
  struct MkVarFrameS otVarFrame = {50, 0}; otVarFrame.data = otVarFrame.prealloc; \
  OT_VARFRAME varframe = &otVarFrame;
 
#define OT_VARFRAME_DELETE { \
  for (int i=0; i<varframe->num; i++) Tcl_DecrRefCount(varframe->data[i]); \
  varframe = NULL; \
}
 
#define OT_VARFRAME_ARGS   MK_RT_ARGS OT_VARFRAME  varframe
#define OT_VARFRAME_CALL   MK_RT_CALL varframe
 
static inline OT_OBJ_T MK(OT_VARFRAME_ADD)(OT_VARFRAME_ARGS, OT_OBJ_T add) {
  if (varframe != NULL) {
    if (varframe->num >= varframe->max) {
      void *tmp;
      if (varframe->data == varframe->prealloc) {
        tmp = MkSysCalloc(MK_ERROR_PANIC,(size_t)varframe->max*2,sizeof(OT_OBJ_T));
        memcpy(tmp,varframe->data,(size_t)varframe->max*sizeof(OT_OBJ_T));
      } else {
        tmp = MkSysReCalloc(MK_ERROR_PANIC,varframe->data,varframe->max,varframe->max,sizeof(OT_OBJ_T));
      }
      varframe->data = tmp;
      varframe->max *= 2;
    }
    varframe->data[varframe->num++] = add;
    Tcl_IncrRefCount(add);
  }
  return add;
}
 
#define OT_VARFRAME_OBJ_RESULT(itp) MK(OT_VARFRAME_ADD)(OT_VARFRAME_CALL,Tcl_GetObjResult(itp))
 
 
/*****************************************************************************/
/* MARK_F                                                                    */
/*                                 functions                                 */
/*                                                                           */
/*****************************************************************************/
 
MK_ATL_EXTERN MK_STR    MK_DECL MK(PrintObj)    (OT_Prefix_ARGS MK_STRN, OT_OBJ_T );
MK_ATL_EXTERN void      MK_DECL MK(PrintObj2)   (OT_Prefix_ARGS MK_STRN, OT_OBJ_T, MK_STRN );
MK_ATL_EXTERN int       MK_DECL MK(EvalObjvVA)  (OT_ENV_T, int, ...);
 
MK_ATL_EXTERN MK_STRN       MK_DECL  MK(ObjvToString)        ( MK_RT_ARGS MK_STRN cls, ATL_ARGS );
MK_ATL_EXTERN enum MkErrorE MK_DECL  MK(LngListToMkBufferListS) ( OT_Prefix_ARGS OT_OBJ_T , MK_BFL* );
 
#define OT_EVAL_ARGS    OT_ENV_T interp, int objc, OT_OBJ_T const objv[], int flags
#define OT_EVAL_CALL                 interp,     objc,                objv  ,     flags
 
mk_inline OT_OBJ_T NS(EvalObjvRt) ( OT_EVAL_ARGS ) 
{
  check_LNG(Tcl_EvalObjv (interp, objc, objv, flags)) return NULL;
  return Tcl_GetObjResult(interp);
}
 
mk_inline OT_OBJ_T NS(EvalObjvFr) ( OT_VARFRAME_ARGS , OT_EVAL_ARGS )
{
//printAry2("objv",objc,objv)
  check_LNG(Tcl_EvalObjv (interp, objc, objv, flags)) return NULL;
  OT_OBJ_T result = OT_VARFRAME_OBJ_RESULT(interp);
//printLng(result)
  return result;
}
 
// The "MK(EvalObjv)" IS required to "cleanup" the "objv" after the "eval" to free TEMPORARY Tcl_Obj*
mk_inline int NS(EvalObjv) ( OT_EVAL_ARGS ) 
{
  int i,ret;
  for (i=0;i<objc;i++) Tcl_IncrRefCount(objv[i]);
  ret = Tcl_EvalObjv (interp, objc, objv, flags);
  for (i=0;i<objc;i++) Tcl_DecrRefCount(objv[i]);
  return ret;
}
 
MK_ATL_EXTERN int     MK_DECL MK(FillNamespace)       (OT_ENV_T, const OtObjProcDefS[], ClientData);
MK_ATL_EXTERN MK_ERR  MK_DECL MK(MkExceptionC_Catch)  (OT_Prefix_ARGS MK_MNG const, MK_EXP const, MK_STRN const);
MK_ATL_EXTERN void    MK_DECL MK(MkExceptionC_Raise)  (OT_Prefix_ARGS MK_MNGN const, MK_STRN const, MK_STRN const, MK_I32);
 
// from MkCall_atl.c
 
void          MK_DECL NS(ObjectDeleteFree)      ( MkObjectDeleteFreeF_ARGS );
enum MkErrorE MK_DECL NS(ObjectDeleteCall)      ( MkObjectDeleteCallF_ARGS );
 
// enum ******************************************************************************
 
// BEGIN-enum-tostring - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
#define OT_NEW_Mk_enum_OBJ(typ,val)  MK(Mk ## typ ## _ToString(val))
 
MK_ATL_EXTERN OT_OBJ_T MK_DECL MK(MkErrorE_ToString) (const enum MkErrorE);
 
MK_ATL_EXTERN OT_OBJ_T MK_DECL MK(MkIdSE_ToString) (const enum MkIdSE);
 
MK_ATL_EXTERN OT_OBJ_T MK_DECL MK(MkTimeoutE_ToString) (const enum MkTimeoutE);
 
MK_ATL_EXTERN OT_OBJ_T MK_DECL MK(MkTypeE_ToString) (const enum MkTypeE);
 
// END-enum-tostring - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// BEGIN-enum - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
MK_ATL_EXTERN int MK_DECL MK(Get_MkErrorE_FromObj)(MK_RT_ARGS OT_ENV_T interp, OT_OBJ_T enumE, enum MkErrorE *ret);
#define Get_MkErrorE_FromObj_path MK(Get_MkErrorE_FromObj)
 
MK_ATL_EXTERN int MK_DECL MK(Get_MkIdSE_FromObj)(MK_RT_ARGS OT_ENV_T interp, OT_OBJ_T enumE, enum MkIdSE *ret);
#define Get_MkIdSE_FromObj_path MK(Get_MkIdSE_FromObj)
 
MK_ATL_EXTERN int MK_DECL MK(Get_MkTimeoutE_FromObj)(MK_RT_ARGS OT_ENV_T interp, OT_OBJ_T enumE, enum MkTimeoutE *ret);
#define Get_MkTimeoutE_FromObj_path MK(Get_MkTimeoutE_FromObj)
 
MK_ATL_EXTERN int MK_DECL MK(Get_MkTypeE_FromObj)(MK_RT_ARGS OT_ENV_T interp, OT_OBJ_T enumE, enum MkTypeE *ret);
#define Get_MkTypeE_FromObj_path MK(Get_MkTypeE_FromObj)
 
// END-enum - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
//
// ==================================================================================
//
 
#define SETUP_interp      MK_UNUSED OT_ENV_T interp = amkrt->interp
#define SETUP_moxrt       MK_UNUSED MOX_RT_T moxrt = amkrt->moxrt; \
                            assert(moxrt && moxrt->signature == MOX_RT_SIG);
#define SETUP_amkrt(r)    MK_UNUSED OT_MK_RT_T const amkrt = (r) ? (r) : &amkrtR; \
                            assert(amkrt && amkrt->signature == OT_MK_RT_SIG); \
                          SETUP_interp; \
                          SETUP_moxrt  
 
#define OT_SELF_O(o)      ((OT_SELF_T)(*o).self)
#define OT_SELF_X(x)      OT_SELF_O(MkOBJ(x))
#define OT_SELF_M(m)      OT_SELF_O((MK_OBJ)(m))    /* unsafe */
#define OT_SELF           selfO
 
#define   SetupHdlFromMetaData_init_2(_SHORT)    \
  MK_RT_SETUP_METHOD;                            \
  int __skip; OT_SELF_T selfO; _SHORT hdl;
 
#define   SetupHdlFromMetaData_2(_SHORT)                                           \
  SetupHdlFromMetaData_init_2(_SHORT)                                              \
    if (objc < 2) OT_ERROR_LNG_RETURN_STR_ERROR("error: missing hdl argument");    \
  __skip = 2;                                                                      \
  selfO = objv[1];                                                                 \
  hdl = SELF2HDL(selfO);                                                           \
    if (hdl == NULL) OT_ERROR_LNG_RETURN_HDL_IS_NULL(); 
 
#define   SetupHdlFromMetaData__null_allow_2(_SHORT)         \
  SetupHdlFromMetaData_init_2(_SHORT)                        \
  if (objc < 2) {                                            \
    __skip = 1;                                              \
    selfO = OT_CLASS;                                        \
    hdl = NULL;                                              \
  } else {                                                   \
    __skip = 2;                                              \
    selfO = objv[1];                                         \
    hdl = SELF2HDL(selfO);                                   \
  }
 
#define   SetupHdlConstr(_ClassC)                                                          \
  MK_RT_SETUP_METHOD;                                                                      \
  int __skip=2;                                                                            \
  /* on ATL the self is already available if the CTOR is called */                         \
  MK_UNUSED OT_SELF_T selfO = objv[1];                                                     \
    if (!AtlClassIsN(selfO,_ClassC##_lngO))                                                \
      OT_ERROR_LNG_RETURN_INVALID_CLASS(VAL2STR(MoxMy__CLASS__N(selfO)),OT_CLASS_NAME);    \
  MK_UNUSED MK_TYP hdl = _ClassC##_TT;         \
 
#define   SetupHdlStatic(_ClassC)              \
  MK_RT_SETUP_METHOD;                          \
  int __skip=1;                                \
  MK_UNUSED OT_SELF_T selfO = OT_CLASS;        \
  MK_UNUSED MK_TYP hdl = _ClassC##_TT;         \
 
/*****************************************************************************/
/*                                                                           */
/*                                 definition's                              */
/*                                                                           */
/*****************************************************************************/
 
#define PTR2VAL(nat)        (OT_OBJ_T)(nat)
#define SELF2VAL(slf)       (slf)
#define CLS2VAL(cls)        (cls)
#define META2VAL_X(x)       SELF2VAL(OT_SELF_X(x))
#define META2VAL_O(o)       SELF2VAL(OT_SELF_O(o))
 
#define I82VAL(nat)         Tcl_NewIntObj(nat)
#define BOL2VAL(nat)        Tcl_NewBooleanObj(nat)
#define I162VAL(nat)        Tcl_NewIntObj(nat)
#define U162VAL(nat)        Tcl_NewIntObj((int)nat)
#define INT2VAL(nat)        Tcl_NewIntObj(nat)
#define I642VAL(nat)        Tcl_NewWideIntObj(nat)
#define HDL2VAL(nat)        Tcl_NewIntObj(nat)
#define LLG2VAL(nat)        Tcl_NewWideIntObj(nat)
#define FLT2VAL(nat)        Tcl_NewDoubleObj(nat)
#define DBL2VAL(nat)        Tcl_NewDoubleObj(nat)
#define STRN2VAL(nat)       MK(STRN2VAL)(nat)
#define BIN2VAL(ptr,len)    Tcl_NewByteArrayObj((const unsigned char*)ptr,(int)len)
#define STR2VAL(ptr)        Tcl_NewStringObj((const char*)ptr,-1)
#define STR2VAL_2(ptr,len)  Tcl_NewStringObj((const char*)ptr,(int)len)
#define LONG2VAL(nat)       Tcl_NewLongObj(nat)
 
#define VAL2STR(val)        Tcl_GetString(val)
#define VAL2STR_NULL(val)   (val?Tcl_GetString(val):"NULL")
#define VAL2SELF(val)       (val)
 
#define VAL2OBJ(val)        ((MK_OBJ)Self2PtrN(val))
#define VAL2BFL(val)        ((MK_BFL)Self2PtrN(val))
#define VAL2MNG(val)        ((MK_MNG)Self2PtrN(val))
 
// *********************************************************************************************
 
mk_inline OT_OBJ_T MK(STRN2VAL)(MK_STRN val) {
  static MkThreadLocal OT_OBJ_T T_MK_NULL = NULL;
  if (T_MK_NULL == NULL) {
    T_MK_NULL = Tcl_NewStringObj(MK_NULL_STR,-1);
    Tcl_IncrRefCount(T_MK_NULL);
  }
  // mark=MK_NULL
  if (val==MK_NULL) {
    return T_MK_NULL;
  } else {
    return Tcl_NewStringObj(val,-1);
  }
}
 
/*****************************************************************************/
/*                                                                           */
/*                          Tcl private Interface                            */
/*                                                                           */
/*****************************************************************************/
 
#define AtlInfoScript(s) MK(AtlInfoScript)(OT_MK_CALL s)
MK_ATL_EXTERN MK_STRN MK_DECL MK(AtlInfoScript)  ( OT_MK_ARGS MK_STRN );
 
#define AtlInfoExists(l) MK(AtlInfoExists)(OT_MK_CALL l)
MK_ATL_EXTERN int MK_DECL MK(AtlInfoExists)  ( OT_MK_ARGS OT_OBJ_T );
 
#define AtlArrayExists(l) MK(AtlArrayExists)(OT_MK_CALL l)
MK_ATL_EXTERN int MK_DECL MK(AtlArrayExists)  ( OT_MK_ARGS OT_OBJ_T );
 
#define AtlClassIsN(...) OT_LNG_EMBEDDED(bool,MK(AtlClassIsN),OT_MK_CALL __VA_ARGS__)
MK_ATL_EXTERN int MK_DECL MK(AtlClassIsN) ( OT_MK_ARGS OT_SELF_T myNsO, OT_CLS_T clsNsO, bool *boolP );
 
/*****************************************************************************/
/*                                                                           */
/*                          former TclMsgque.c                               */
/*                                                                           */
/*****************************************************************************/
 
// TODO → who set OT_SHARED_IS_DLL ?
#ifdef OT_SHARED_IS_DLL
#    define OT_ATL_EXTERN __declspec(dllexport)
#else
#    define OT_ATL_EXTERN __attribute__ ((visibility("default")))
#endif
 
/*****************************************************************************/
/* MARK_C                                                                    */
/*                               Class_API                                   */
/*                                                                           */
/*****************************************************************************/
 
typedef struct AtlClassDefS {
  MK_SIG signature;
  OT_CLS_T classO;
  OT_MK_RT_T amkrt;
  MK_TYP classTT;
  OT_NS_T classNS;
  struct AtlClassDefS *prev, *next;
} AtlClassDefS;
 
typedef AtlClassDefS* AtlClassDefT;
 
#define AtlClassDefGetNN(...) NS(AtlClassDefGetNN)(OT_MK_CALL __VA_ARGS__)
MK_EXTERN AtlClassDefT MK_CDECL MK(AtlClassDefGetNN) (OT_MK_ARGS OT_NS_T classP, OT_CLS_T classO, MK_TYP classTT, int flags) ;
 
#define AtlGetClassFrmNsPtr(nsP,flg)      MK(GetClassFrmNsPtr)(OT_MK_CALL nsP, flg)
mk_inline OT_CLS_T MK(GetClassFrmNsPtr) ( OT_MK_ARGS OT_NS_T nsP, int flags ) {
  AtlClassDefT clsDef = AtlClassDefGetNN(nsP,NULL,NULL,flags);
    if (clsDef != NULL) return clsDef->classO;
/*
  assert(nsP != NULL);
  SETUP_moxrt;
  return MoxCls__NS__NN(nsP,0);
*/
  return NULL;
}
 
// borrow reference
#define AtlGetClassFromProc(cmdT)  MK(GetClassFromProc)(OT_MK_CALL cmdT)
mk_inline OT_CLS_T MK(GetClassFromProc) ( OT_MK_ARGS Tcl_Command cmdT ) {
  Tcl_CmdInfo cmdInfo;
  Tcl_GetCommandInfoFromToken(cmdT,&cmdInfo);
  SETUP_moxrt;
  return MoxCls__NS__NN(cmdInfo.namespacePtr,0);
}
 
#define OT_TMP_BAC_OBJ(val) MK(MkBufferListC_ObjNew) (OT_MK_CALL val)
 
// BEGIN-CLASS - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// ----------------------------------------------------------------------
// class: MkBufferListC
 
  #define MkBufferListC_rt (*amkrt)
  #define MkBufferListC_lngO (MkBufferListC_rt.AtlMkBufferListC)
  #undef MkBufferListCTT
  #define MkBufferListCTT (MkBufferListC_rt.AtlMkBufferListCTT)
 
  int MK(pMkBufferListC_Init) (OT_MK_ARGS OT_NS_T);
 
  #define MkBufferListC_ObjNew(nat) MK(MkBufferListC_ObjNew) (OT_MK_CALL nat)
  #define OT_TMP_BFL_OBJ(nat) MkBufferListC_ObjNew (nat)
  #define OT_retObj_SET_BFL(nat) retObj = MkBufferListC_ObjNew (nat)
 
  MK_ARTIFICIAL
  mk_inline OT_OBJ_T MK(MkBufferListC_ObjNew) (OT_MK_ARGS MkBufferListC_type hdl) {
    return ( hdl ? MK(AtomObjNew) (OT_MK_CALL MkBufferListC_X2obj(hdl), amkrt) : MkBufferListC_rt.AtlMkBufferListC_MK_NULL );
  }
 
// ----------------------------------------------------------------------
// class: MkBufferC
 
  #define MkBufferC_rt (*amkrt)
  #define MkBufferC_lngO (MkBufferC_rt.AtlMkBufferC)
  #undef MkBufferCTT
  #define MkBufferCTT (MkBufferC_rt.AtlMkBufferCTT)
 
  int MK(pMkBufferC_Init) (OT_MK_ARGS OT_NS_T);
 
  #define MkBufferC_ObjNew(nat) MK(MkBufferC_ObjNew) (OT_MK_CALL nat)
  #define OT_TMP_BUF_OBJ(nat) MkBufferC_ObjNew (nat)
  #define OT_retObj_SET_BUF(nat) retObj = MkBufferC_ObjNew (nat)
 
  MK_ARTIFICIAL
  mk_inline OT_OBJ_T MK(MkBufferC_ObjNew) (OT_MK_ARGS MkBufferC_type hdl) {
    return ( hdl ? MK(AtomObjNew) (OT_MK_CALL MkBufferC_X2obj(hdl), amkrt) : MkBufferC_rt.AtlMkBufferC_MK_NULL );
  }
 
// ----------------------------------------------------------------------
// class: MkBufferStreamC
 
  #define MkBufferStreamC_rt (*amkrt)
  #define MkBufferStreamC_lngO (MkBufferStreamC_rt.AtlMkBufferStreamC)
  #undef MkBufferStreamCTT
  #define MkBufferStreamCTT (MkBufferStreamC_rt.AtlMkBufferStreamCTT)
 
  int MK(pMkBufferStreamC_Init) (OT_MK_ARGS OT_NS_T);
 
  #define MkBufferStreamC_ObjNew(nat) MK(MkBufferStreamC_ObjNew) (OT_MK_CALL nat)
  #define OT_TMP_BUS_OBJ(nat) MkBufferStreamC_ObjNew (nat)
  #define OT_retObj_SET_BUS(nat) retObj = MkBufferStreamC_ObjNew (nat)
 
  MK_ARTIFICIAL
  mk_inline OT_OBJ_T MK(MkBufferStreamC_ObjNew) (OT_MK_ARGS MkBufferStreamC_type hdl) {
    return ( hdl ? MK(AtomObjNew) (OT_MK_CALL MkBufferStreamC_X2obj(hdl), amkrt) : MkBufferStreamC_rt.AtlMkBufferStreamC_MK_NULL );
  }
 
// ----------------------------------------------------------------------
// class: MkErrorC
 
  #define MkErrorC_rt (*amkrt)
  #define MkErrorC_lngO (MkErrorC_rt.AtlMkErrorC)
  #undef MkErrorCTT
  #define MkErrorCTT (MkErrorC_rt.AtlMkErrorCTT)
 
  int MK(pMkErrorC_Init) (OT_MK_ARGS OT_NS_T);
 
  #define MkErrorC_ObjNew(nat) MK(MkErrorC_ObjNew) (OT_MK_CALL nat)
  #define OT_TMP_ERR_OBJ(nat) MkErrorC_ObjNew (nat)
  #define OT_retObj_SET_ERR(nat) retObj = MkErrorC_ObjNew (nat)
 
  MK_ARTIFICIAL
  mk_inline OT_OBJ_T MK(MkErrorC_ObjNew) (OT_MK_ARGS MkErrorC_type hdl) {
    return ( hdl ? MK(AtomObjNew) (OT_MK_CALL MkErrorC_X2obj(hdl), amkrt) : MkErrorC_rt.AtlMkErrorC_MK_NULL );
  }
 
// ----------------------------------------------------------------------
// class: MkLogFileC
 
  #define MkLogFileC_rt (*amkrt)
  #define MkLogFileC_lngO (MkLogFileC_rt.AtlMkLogFileC)
  #undef MkLogFileCTT
  #define MkLogFileCTT (MkLogFileC_rt.AtlMkLogFileCTT)
 
  int MK(pMkLogFileC_Init) (OT_MK_ARGS OT_NS_T);
 
  #define MkLogFileC_ObjNew(nat) MK(MkLogFileC_ObjNew) (OT_MK_CALL nat)
  #define OT_TMP_LFL_OBJ(nat) MkLogFileC_ObjNew (nat)
  #define OT_retObj_SET_LFL(nat) retObj = MkLogFileC_ObjNew (nat)
 
  MK_ARTIFICIAL
  mk_inline OT_OBJ_T MK(MkLogFileC_ObjNew) (OT_MK_ARGS MkLogFileC_type hdl) {
    return ( hdl ? MK(AtomObjNew) (OT_MK_CALL MkLogFileC_X2obj(hdl), amkrt) : MkLogFileC_rt.AtlMkLogFileC_MK_NULL );
  }
 
// ----------------------------------------------------------------------
// class: MkObjectC
 
  #define MkObjectC_rt (*amkrt)
  #define MkObjectC_lngO (MkObjectC_rt.AtlMkObjectC)
  #undef MkObjectCTT
  #define MkObjectCTT (MkObjectC_rt.AtlMkObjectCTT)
 
  int MK(pMkObjectC_Init) (OT_MK_ARGS OT_NS_T);
 
  #define MkObjectC_ObjNew(nat) MK(MkObjectC_ObjNew) (OT_MK_CALL nat)
  #define OT_TMP_OBJ_OBJ(nat) MkObjectC_ObjNew (nat)
  #define OT_retObj_SET_OBJ(nat) retObj = MkObjectC_ObjNew (nat)
 
  MK_ARTIFICIAL
  mk_inline OT_OBJ_T MK(MkObjectC_ObjNew) (OT_MK_ARGS MkObjectC_type hdl) {
    return ( hdl ? MK(AtomObjNew) (OT_MK_CALL MkObjectC_X2obj(hdl), amkrt) : MkObjectC_rt.AtlMkObjectC_MK_NULL );
  }
 
// ----------------------------------------------------------------------
// class: MkRuntimeC
 
  #define MkRuntimeC_rt (*amkrt)
  #define MkRuntimeC_lngO (MkRuntimeC_rt.AtlMkRuntimeC)
  #undef MkRuntimeCTT
  #define MkRuntimeCTT (MkRuntimeC_rt.AtlMkRuntimeCTT)
 
  int MK(pMkRuntimeC_Init) (OT_MK_ARGS OT_NS_T);
 
  #define MkRuntimeC_ObjNew(nat) MK(MkRuntimeC_ObjNew) (OT_MK_CALL nat)
  #define OT_TMP_RT_OBJ(nat) MkRuntimeC_ObjNew (nat)
  #define OT_retObj_SET_RT(nat) retObj = MkRuntimeC_ObjNew (nat)
 
  MK_ARTIFICIAL
  mk_inline OT_OBJ_T MK(MkRuntimeC_ObjNew) (OT_MK_ARGS MkRuntimeC_type hdl) {
    return ( hdl ? MK(AtomObjNew) (OT_MK_CALL MkRuntimeC_X2obj(hdl), amkrt) : MkRuntimeC_rt.AtlMkRuntimeC_MK_NULL );
  }
 
// END-CLASS - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
/*****************************************************************************/
/*                                                                           */
/*                          reference                                        */
/*                                                                           */
/*****************************************************************************/
 
#define ME_REF_MkBinaryR                MkBinaryR
#define OT_GET__ME_REF_MkBinaryR(b)     BIN2VAL(b.data,b.size)
#define VAL2MkBinaryR(obj)              \
  ({int size;unsigned char * bin =Tcl_GetByteArrayFromObj(obj,&size);MkBinaryCreate(size,bin);})
#define OT_CHECK__ME_REF_MkBinaryR(val)                      \
  if (__skip >= objc) {                                      \
    OT_ERROR_NUMARGS(hdl,__skip, objc, -999, +999, #val);    \
  } else {                                                   \
    val = VAL2MkBinaryR(objv[__skip++]);                     \
  }
 
#define ME_REF_MkStringR                MkStringR
#define OT_GET__ME_REF_MkStringR(s)     STR2VAL_2(s.ptr,s.len)
#define VAL2MkStringR(obj)              \
  ({int len;char * str =Tcl_GetStringFromObj(obj,&len);MkStringCreate(len,str);})
#define OT_CHECK__ME_REF_MkStringR(val)                      \
  if (__skip >= objc) {                                      \
    OT_ERROR_NUMARGS(hdl,__skip, objc, -999, +999, #val);    \
  } else {                                                   \
    val = VAL2MkStringR(objv[__skip++]);                     \
  }
 
mk_inline MkStringR Ot_GetStringFromObj ( OT_OBJ_T tclO ) {
  int len = 0;
  char* str = Tcl_GetStringFromObj(tclO,&len);
  return MkStringCreate(len,str);
}
 
mk_inline void Ot_DecrRefCount ( OT_OBJ_T tclO ) {
  if (tclO) Tcl_DecrRefCount(tclO);
}
 
#define Ot_GetBooleanFromObj(val) ({int bol; if (Tcl_GetBooleanFromObj(interp,val,&bol)==TCL_ERROR) goto error; bol;})
 
/*****************************************************************************/
/*                                                                           */
/*                          enum helpers                                     */
/*                                                                           */
/*****************************************************************************/
 
// helper for xxx_ToString, the ERROR returned from Tcl_ListObjAppendElement is NOT checked
#define ot_fixstr(_s,_l) Tcl_NewStringObj(_s,_l)
#define ot_fixstrobj(_s) ot_fixstr(_s,strlen(_s))
#define ot_enum_append(_o,_s) Tcl_ListObjAppendElement(NULL,_o,ot_fixstrobj(_s))
 
/*****************************************************************************/
/*                                                                           */
/*                          inline functions                                 */
/*                                                                           */
/*****************************************************************************/
 
// debugging ***********************************************************************************
 
#define printLng(var)       printV(#var" = '%s' [ref=%i]",(var?VAL2STR(var):"NULL"),(var)?(var)->refCount:-1)
#define printXLng(x,var)    printXV(x,#var" = '%s' [ref=%i]",(var?VAL2STR(var):"NULL"),(var)?(var)->refCount:-1)
#define printXLngObj(x,var) printXC2(x,MK(PrintObj)(OT_Prefix_CALL #var,var))
#define printLLngObj(var)   printLC2(  MK(PrintObj)(OT_Prefix_CALL #var,var))
#define printLngObj(var)    printTxt(MK(PrintObj)(OT_Prefix_CALL #var,var))
#define printLngObj2(var)   MK(PrintObj2)(OT_Prefix_CALL #var,var,__func__)
 
#define printLngErrorCode() do {                                                       \
  OT_OBJ_T errorCode = Tcl_GetVar2Ex (interp, "errorCode", NULL, TCL_GLOBAL_ONLY);    \
  printLngObj(errorCode);                                                              \
} while (0);                                                                           \
 
#define printLngErrorInfo() do {                                                       \
  OT_OBJ_T errorInfo = Tcl_GetVar2Ex (interp, "errorInfo", NULL, TCL_GLOBAL_ONLY);    \
  printLngObj(errorInfo);                                                              \
} while (0);                                                                           \
 
#define printObjv \
  printV("printObjv: __skip=%i, objc=%i",__skip,objc);\
  printAry(objc,objv)
 
#define printXObjv(x) \
  printXV(x,"__skip=%i, objc=%i",__skip,objc);\
  printXAry(x,objc,objv)
 
#define printAry(c,o) \
  printAry3(#o,c,o)
 
#define printAryDetail(c,o) \
  for(int i=0;i<c;i++) { printLngObj(o[i]) }
 
#define printXAry(x,c,o) \
  for(int i=0;i<c;i++) { printXV(x,"%2i= %s",i,o[i]?Tcl_GetString(o[i]):"NULL"); }
 
#define printXAryDetail(x,c,o) \
  for(int i=0;i<c;i++) { printXLngObj(x,o[i]) }
 
#define printAry3(txt, c,o) do { \
  mk_dbg_Z_start(512,MK_COLOR_BLUE "%s : ",txt); \
  for(int i=0;i<c;i++) { \
    mk_dbg_Z_next(MK_COLOR_YELLOW "[%d:%p]" MK_COLOR_RESET "='%s' ",i,o[i],o[i]?Tcl_GetString(o[i]):"NULL"); \
  } \
  mk_dbg_Z_end(); \
} while (0)
 
#define printAryX(x,t,c,o) \
  printXV(x, "%-15s = ",t); \
  for(int i=0;i<c;i++) { \
    fprintf(stderr, "'%s' ",o[i]?Tcl_GetString(o[i]):"NULL"); \
  } \
  fputc('\n', stderr);
 
#define printAryL(t,c,o) printAryX(META_CONTEXT_S,t,c,o) \
 
#define xstr(s) str(s)
#define str(s) #s
 
#define printLngClass(clsC)     printV(#clsC " name = %s", OT_LNG_NAME_FROM_CLASS(clsC))
#define printLngObject(objO)    printV(#objO " name = %s", OT_LNG_NAME_FROM_OBJECT(objO))
 
// ---------------------------------------------------------------------------
// SELF
 
#define Self2PtrNN(myP)      MK(Self2PtrNN)(myP)
#define Self2PtrN(myO)       MK(Self2PtrN)(interp,myO)
 
mk_inline MK_MNG MK(Self2PtrNN) ( OT_NS_T nsP ) {
  return nsP->clientData;
}
 
mk_inline MK_MNG MK(Self2PtrN) ( OT_ENV_T interp, OT_SELF_T myO ) {
  OT_NS_T myP = MoxResolveN(myO);
    if (myP == NULL) return NULL;
  return Self2PtrNN(myP);
}
 
/*
#define PTR2SELF(s,p)       MK(PTR2SELF)(interp,s,p)
mk_inline OT_SELF_T MK(PTR2SELF) ( OT_ENV_T interp, OT_SELF_T selfO, MK_MNG ptr ) {
  OT_NS_T ns = MoxResolveN(selfO);
    if (ns == NULL) return NULL;
  ns->clientData = ptr;
  return selfO;
}
*/
 
 
mk_inline OT_OBJ_T MK(AtomObjNew) (
  OT_MK_ARGS
  MK_OBJ        obj,
  MK_PTR        env
) {
  #define __doc  "AtomObjNew"
  MK_PTR selfO = NULL;
  // force "class-NULL object → test done BEFORE "AtomObjNew" is called
  assert(obj != NULL);
  MkErrorC_Check(obj, MkSelfNew(obj,&selfO,env))
  OT_OBJ_T ret = OT_LNG_SELF_2_LNG(selfO);
  return ret;
  #undef  __doc
error:
  return NULL;
}
 
// update SELF if OBJECT is already available
// CALLED from: "<contructor>", MkAtomCreate
MK_EXTERN OT_SELF_T MK_DECL MK(AtomInit) (
  OT_MK_ARGS
  OT_SELF_T     selfO,
  MK_OBJ        obj,
  MK_PTR const  env
);
 
#define AtomInit(...) MK(AtomInit)(OT_MK_CALL __VA_ARGS__)
 
// create OBJECT and update SELF
// CALLED from: "*_SelfCreate"
MK_EXTERN OT_SELF_T MK_DECL MK(AtomCreate) (
  OT_MK_ARGS
  MK_OBJ              obj,
  OT_CLS_T            cls,
  OT_OBJ_T            nameO,
  OT_OBJ_T            nsO,
  int                 objc,
  OT_OBJ_T const      objv[],
  MK_PTR const        env
);
 
#define AtomCreate(...) MK(AtomCreate)(OT_MK_CALL __VA_ARGS__)
 
MK_EXTERN OT_SELF_T MK_DECL MK(AtomMake) (
  OT_MK_ARGS
  MK_OBJ              obj,
  OT_CLS_T            cls,
  OT_OBJ_T            nameO,
  OT_OBJ_T            nsO,
  MK_PTR const        env
);
 
#define AtomMake(...) MK(AtomMake)(OT_MK_CALL __VA_ARGS__)
 
mk_inline OT_SELF_T MK(AtomCreateNULL) (
  OT_MK_ARGS
  OT_CLS_T            cls,
  MK_STRN             name,
  MK_PTR const        env
) {
  return AtomMake(NULL, cls, STR2VAL(name), NULL, env);
}
 
#define AtomCreateNULL(...) MK(AtomCreateNULL)(OT_MK_CALL __VA_ARGS__)
 
MK_EXTERN OT_SELF_T MK_DECL MK(AtomCreateCONSTR) (
  OT_MK_ARGS
  MK_OBJ              obj,
  OT_CLS_T            cls,
  OT_OBJ_T            nameO,
  MK_PTR const        env
);
 
#define AtomCreateCONSTR(...) MK(AtomCreateCONSTR)(OT_MK_CALL __VA_ARGS__)
 
// ATL object is still alive
// called by: "Delete" and "Dispose" as pseudo-DTOR
mk_inline bool MK(AtomDeleteHard)(
  OT_MK_ARGS
  OT_SELF_T selfO
) {
  assert(selfO != NULL);
  // if (Tcl_InterpDeleted(interp)) return false;
  OT_NS_T ns = MoxResolveN(selfO);
    check_NULL(ns) return false;
  Tcl_DeleteNamespace(ns);
  // refer: AtomInit
  OT_REF_DECR(selfO);
  return true;
}
 
// SOFT: delete META if ATL is still active
// CALLED from: "Dispose"
mk_inline void MK(AtomDispose) (
  OT_MK_ARGS
  OT_SELF_T selfO
) { 
  assert(selfO != NULL);
  MK_MNG mng = VAL2MNG(selfO);
  check_NULL(mng) return;
  MK_OBJ obj = MkObj(mng);
  check_NULL(obj) return;
  // unlink ATL from META
  MkRefDecrWithUnlinkSelf(obj);
}
 
// SOFT: delete META if ATL is still active
// CALLED from: "Dispose"
mk_inline void MK(AtomUnlink) (
  OT_MK_ARGS
  OT_SELF_T selfO
) { 
#if 0
  // I need a HATRD-DELETE here because the namespace should also be deleted.
  //
  // Every instance has a namespace, and the @e instance-ns has a dependency on the @e instance-type-ns. 
  // The @RMqExit uses `Tcl_Exit` to delete, among other things, all namespaces, including the @e instance-ns. 
  // However, the @e instance-ns in turn has a dependency on the @e type-ns, which is also deleted. 
  // A simple @e unlink removes the dependency, which then results in the @e type-ns being deleted, perhaps @b BEFORE 
  // the @e instance-ns, which in turn has consequences for memory management.
  MK(AtomDeleteHard) ( OT_MK_CALL selfO );
#else
  assert(selfO != NULL);
  OT_OBJ_T  myO = SELF2VAL(selfO);
    check_NULL(myO) return;
 
  OT_NS_T myNs = MoxResolveN(myO);
  myNs->clientData = NULL;
  myNs->deleteProc = NULL;
  //PTR2SELF(selfO,0);
#endif
}
 
// ==============================================================================================
// extension
 
#if 1
  #define Atl_EvalObjv(...)   Tcl_EvalObjv(__VA_ARGS__)
#else
  MK_ATL_EXTERN int Atl_EvalObjv( Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], int flags );
#endif
 
#undef HEADER