LibMkKernel_atl.c

Go to the documentation of this file.

 
/* LABEL-NO */
 
#define  META_FILE_NAME          "MkKernel_atl.c"
#define  VER                     TCL_OO_METHOD_VERSION_CURRENT
 
#include "LibMkKernel_private_atl.h"
#include <stdlib.h>
#include <errno.h>
 
#undef OtClass_ARGS
#define OtClass_ARGS  OBJCMD_ARGS
 
#define OT_CLASS  NULL
#undef OT_SELF
#define OT_SELF   NULL
 
#define OT_SETUP_hdl_static \
  MK_UNUSED int __skip=1; \
  MK_UNUSED OT_MK_RT_T amkrt = clientData; \
  MK_UNUSED MK_RT mkrt = amkrt->mkrt; \
  MK_UNUSED MK_ERR hdl = &MkERROR; \
 
  /* printAry2("cmd",objc,objv); */
 
/* LABEL-END */
 
#include <limits.h>
#include <float.h>
#include <math.h>
#include <ctype.h>
 
#include "tmpl/mk_type_S_lng.h"
#include "mk_check_atl.h"
#include "utlist_mk.h"
 
#define MkSetupTmpl()
#define MkCleanupTmpl()
 
// #######################################################################
// -----------------------------------------------------------------------
// documentation order
 
 
 
 
 
 
 
 
 
// --------------------------------------------------------------------------------
 
// BEGIN-DOC - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// doc-key: MkKernel,EnumFunc,sco,func
#define ErrorE_FromInt_doc "MkErrorE [MkKernel::ErrorE_FromInt value:int32]"
#define IdSE_FromInt_doc "MkIdSE [MkKernel::IdSE_FromInt value:int32]"
#define TimeoutE_FromInt_doc "MkTimeoutE [MkKernel::TimeoutE_FromInt value:int32]"
#define TypeE_FromInt_doc "MkTypeE [MkKernel::TypeE_FromInt value:int32]"
 
// doc-key: MkKernel,EnumFunc,sm_,func
#define ErrorE_ToInt_doc "int32 [MkKernel::ErrorE_ToInt value:MkErrorE]"
#define ErrorE_ToString_doc "string [MkKernel::ErrorE_ToString value:MkErrorE]"
#define IdSE_ToInt_doc "int32 [MkKernel::IdSE_ToInt value:MkIdSE]"
#define IdSE_ToString_doc "string [MkKernel::IdSE_ToString value:MkIdSE]"
#define TimeoutE_ToInt_doc "int32 [MkKernel::TimeoutE_ToInt value:MkTimeoutE]"
#define TimeoutE_ToString_doc "string [MkKernel::TimeoutE_ToString value:MkTimeoutE]"
#define TypeE_ToInt_doc "int32 [MkKernel::TypeE_ToInt value:MkTypeE]"
#define TypeE_ToString_doc "string [MkKernel::TypeE_ToString value:MkTypeE]"
 
// doc-key: MkKernel,Setup,sm_,func
#define Cleanup_doc "MkKernel::Cleanup"
#define Setup_doc "MkKernel::Setup"
 
// END-DOC - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
#define AtlClassDefS_SIG         0x88342873
 
void MK(ClassDef_ns_delete) (ClientData clientData) {
  AtlClassDefT classDef = clientData;
    assert (classDef->signature == AtlClassDefS_SIG);
  OT_OBJ_T classO = classDef->classO;
    if (classO == NULL) return;
OT_DEBUG_NAMESPACE_DELETE(MK_COLOR_RED,"%s<%p> in clientData<%p>","CLS",VAL2STR(classO),classO,clientData);
  OT_MK_RT_T amkrt = classDef->amkrt;
    if (amkrt==NULL || amkrt->signature != OT_MK_RT_SIG) return;
  MK_TYP classTT = classDef->classTT;
  MkRtSetup_RT(amkrt->mkrt);
  OT_ENV_T interp = amkrt->interp;
 
  MK_OBJ obj,tmp;
  MkTypeForeachInstancesSave(classTT) {
    if (obj->self == NULL) { obj = MkObjectNext(obj); continue; }
    OT_OBJ_T selfO = obj->self;
    OT_NS_T ns = Tcl_FindNamespace(interp,VAL2STR(selfO),NULL,TCL_GLOBAL_ONLY);
      if (ns == NULL) { obj = MkObjectNext(obj); continue; }
      Tcl_DeleteNamespace(ns);
  }
 
  DL_DELETE(amkrt->atlClassDefL,classDef);
  classDef->next = NULL;
 
  classDef->signature = 0x0;
  OT_REF_DECR_AND_NULL(classDef->classO);
  MkSysFree(classDef);
}
 
#define ClassDefCreateNN(...) NS(ClassDefCreateNN)(OT_MK_CALL __VA_ARGS__)
mk_inline AtlClassDefT MK(ClassDefCreateNN) (OT_MK_ARGS OT_NS_T clsNS, OT_CLS_T classO, MK_TYP classTT)
{
  AtlClassDefT classDef = MkSysMalloc(MK_ERROR_PANIC,sizeof(*classDef));
//mk_dbg_color_ln(MK_COLOR_GREEN,"classDef<%p>",classDef);
  (*classDef) = (AtlClassDefS) {AtlClassDefS_SIG,classO,amkrt,classTT,clsNS,NULL,NULL};
    Tcl_IncrRefCount(classO);
  clsNS->clientData = classDef;
  clsNS->deleteProc = MK(ClassDef_ns_delete);
 
  DL_APPEND(amkrt->atlClassDefL,classDef);
  
  return classDef;
}
 
#define AtlClassDefGetTypN(...) NS(AtlClassDefGetTypN)(OT_MK_CALL __VA_ARGS__)
mk_inline MK_TYP NS(AtlClassDefGetTypN)(OT_MK_ARGS OT_CLS_T clsOi, int flags) ;
 
#define AtlClassDefGetTypNN(...) NS(AtlClassDefGetTypNN)(OT_MK_CALL __VA_ARGS__)
mk_inline MK_TYP NS(AtlClassDefGetTypNN)(OT_MK_ARGS OT_NS_T clsP, OT_CLS_T clsO, int flags) ;
 
#define AtlClassDefGetTypNNN(...) NS(AtlClassDefGetTypNNN)(OT_MK_CALL __VA_ARGS__)
mk_inline MK_TYP NS(AtlClassDefGetTypNNN)(OT_MK_ARGS OT_NS_T clsP, OT_CLS_T clsO, int flags) ;
 
AtlClassDefT MK(AtlClassDefGetNN) (OT_MK_ARGS OT_NS_T classP, OT_CLS_T classO, MK_TYP classTT, int flags)
{
//colorBLUE("classP->fullName<%s>, classO<%s>, classTT<%s>", classP->fullName, VAL2STR_NULL(classO), MK_TYP2STR(classTT));
  assert(classP != NULL);
  if (classP->clientData) {
    AtlClassDefT clsDef = classP->clientData;
      assert(clsDef->signature == AtlClassDefS_SIG);
    return clsDef;
  }
  if (classO == NULL) 
    classO = STR2VAL(classP->fullName);
  #ifndef NDEBUG
    OT_NS_T classNsP = MoxResolveN(classO);
      assert(classNsP == classP);
  #endif
  if (classTT == NULL) {
    SETUP_moxrt;
    int retI;
 
    // is this a ATL Class ?
    OT_OBJ_T superO = MoxCls__SUPER__NN(classP,flags);
      if (superO == NULL) {
        if (flags & TCL_LEAVE_ERR_MSG) {
          OT_ERROR_VAR_DEFAULT("[ClassDefError] unable to retrieve '__SUPER__' from '%s'\n  -> %s",
            classP->fullName, Tcl_GetStringResult(interp));
          Tcl_SetErrorCode(interp,"ATLMK","CLASS","TYP","INVALID",NULL);
        }
        return NULL;
      }
    int objc;
    Tcl_Obj **objv;
    retI = Tcl_ListObjGetElements(interp,superO,&objc,&objv);
      if (retI == TCL_OK) {
        for (int i=0; i<objc; i++) {
          classTT = AtlClassDefGetTypN(objv[i],0);
          if (classTT) break;
        }
      }
 
      if (classTT == NULL) {
        if (flags & TCL_LEAVE_ERR_MSG) {
          OT_ERROR_VAR_DEFAULT("[ClassDefError] unable to retrieve 'MK_TYP' from '%s'",classP->fullName);
          Tcl_SetErrorCode(interp,"ATLMK","CLASS","TYP","INVALID",NULL);
        }
        return NULL;
      }
  }
  return ClassDefCreateNN(classP,classO,classTT);
}
 
mk_inline MK_TYP NS(AtlClassDefGetTypNNN)(OT_MK_ARGS OT_NS_T clsP, OT_CLS_T clsO, int flags) 
{
  AtlClassDefT clsDef = AtlClassDefGetNN(clsP,clsO,NULL,flags);
    if (clsDef == NULL) return NULL;
  return clsDef->classTT;
}
mk_inline MK_TYP NS(AtlClassDefGetTypNN)(OT_MK_ARGS OT_NS_T clsP, OT_CLS_T clsO, int flags) 
{
  MK_TYP retTT=NULL ;
  SETUP_moxrt;
  MoxPushN(clsP);
    retTT = AtlClassDefGetTypNNN(clsP,clsO,flags);
  MoxPopN();
  return retTT;
}
mk_inline MK_TYP NS(AtlClassDefGetTypN)(OT_MK_ARGS OT_CLS_T clsO, int flags) 
{
  OT_NS_T ns = MoxResolveN(clsO);
    if (ns == NULL) return NULL;
  return AtlClassDefGetTypNN(ns,clsO,flags);
}
 
// return classO WITH Tcl_IncrRefCount
OT_CLS_T MK(ClassDef)(
  OT_MK_ARGS
  MK_TYP    typeTT,
  OT_NS_T   *clsNsP
) {
  int retI;
  Tcl_ResetResult(interp);
  assert(typeTT != NULL);
  MK_TYP  classTT = typeTT->type_class;
 
  // 1. ClassName = ::TypeName
  OT_OBJ_T classNs = Tcl_ObjPrintf("::%s", classTT->type_class->type_name);
    if (classNs == NULL) return NULL;
 
  OT_OBJ_T classO = NULL;
  OT_OBJ_T codeO = NULL;
 
  // If 'classTT->self' is defined - import it
  // > require that "interp" and "MkOBJ_R(classTT).env" are in the SAME thread.
  // > silent assume that class dependency is ORDERED with "MkObjectC" first !!
  if (classTT != MkObjectC_TT)  {
    if (MkOBJ_R(classTT->type_base).env != amkrt) {
      char buf[256] = {0};
      snprintf(buf,256,"\nCLASS-SETUP-ERROR: the '%s-env=%p' and the 'class-def-interp=%p' are not equal",
          MkOBJ_R(classTT->type_base).type->type_name, MkOBJ_R(classTT->type_base).env, interp
      );
      Tcl_AppendResult(interp, buf,NULL);
      Tcl_SetErrorCode(interp,"ATLMK","CLASS","ENV",NULL);
      goto error;
    } else if (MkOBJ_R(classTT->type_base).self == NULL) {
      Tcl_AppendResult(interp,
        "\nCLASS-SETUP-ERROR: class '", classTT->type_name, "' has a base class '", classTT->type_base->type_name, 
          "' with EMPTY SELF pointer", NULL);
      Tcl_SetErrorCode(interp,"ATLMK","CLASS","SELF",NULL);
      goto error;
    } else {
      codeO = MkOBJ_R(classTT->type_base).self;
    }
  }
  // 2. call class-CTOR
  retI = MOX(ClassN_direct)(amkrt->moxrt,interp,classNs,codeO);
    if (retI != TCL_OK) goto error;
 
  // 3. "final" class-Name (should by ClassName but open for future change)
  classO = Tcl_GetObjResult(interp);
    OT_REF_INCR(classO);
 
  OT_OBJ_T superO = Tcl_ObjPrintf("SuperI %s", Tcl_GetString(classO));
    MkSelfSet_3X(classTT, (MK_PTR) superO, amkrt);    // save reference of OT_CLS_T and OT_ENV_T
      Tcl_IncrRefCount(superO);
 
  // save my namespace
  OT_NS_T classNS = (*clsNsP) = MoxResolveN(classO);
    if (classNS == NULL) goto error;
 
  // attach Class-O to Class-NS
  ClassDefCreateNN(classNS,classO,classTT);
 
  // export public commands
  retI = Tcl_Export(interp, classNS, "[A-Za-z]*", 0);
    if (retI != TCL_OK) goto error;
 
end:
  if (classO) {
    Tcl_SetObjResult(interp,classO);
      OT_REF_DECR(classO);
  }
  return classO;
error:
  OT_ERROR_APPEND_LNG_STACK();
  goto end;
}
 
//
// *********************************************************************************
//
 
#define FRAME_UPDATE                                            \
  if (*frameP == NULL) {                                        \
    RL_init( 2, info_frame_2, RL_NewS(0,"::tcl::info::frame") ) ; RL_T(1,null0) ; \
    OT_OBJ_T ret = RL_EvalRtEx(TCL_EVAL_GLOBAL);                \
      if (ret==NULL) OT_ERROR_ABNORMAL(MK_ERROR_PANIC);         \
    Tcl_IncrRefCount(ret);                                      \
    *frameP = ret;                                              \
  } \
 
#define FRAME_GET(key)                                \
  OT_OBJ_T key = NULL;                                \
  Tcl_DictObjGet(interp,*frameP,amkrt->key,&key);
 
MK_STRN MK(Get_Call_Proc) (FRAME_ARGS) {
  OT_OBJ_T retObj = NULL;
  FRAME_UPDATE
  FRAME_GET(method)
  if (method != NULL) {retObj = method; goto end;}
  FRAME_GET(proc)
  if (proc != NULL)   {retObj = proc; goto end;}
  return "main";
end:
  return Tcl_GetStringFromObj(retObj,NULL);;
}
 
MK_STRN MK(Get_Call_Cmd) (FRAME_ARGS) {
#define Get_Call_Cmd__SIZE 100
  static MkThreadLocal char buffer[Get_Call_Cmd__SIZE+10];
  FRAME_UPDATE
  FRAME_GET(cmd)
  if (cmd == NULL) goto error;
  int len;
  char* str = Tcl_GetStringFromObj(cmd, &len);
  if (len > Get_Call_Cmd__SIZE) {
    strncpy(buffer,str,Get_Call_Cmd__SIZE);
    char* nl=strchr(buffer,'\n');
    if (nl)
      *nl='\0';
    else
      buffer[Get_Call_Cmd__SIZE] = '\0';
    strcat(buffer," ...");
    return buffer;
  } else {
    return str;
  }
error:
  Tcl_ResetResult(interp);
  FRAME_GET(type)
  return Tcl_GetStringFromObj(type,NULL);
#undef Get_Call_Cmd__SIZE
}
 
MK_STRN MK(Get_Call_File) (FRAME_ARGS) {
  FRAME_UPDATE
  FRAME_GET(file)
  if (file == NULL) goto error;
  return Tcl_GetStringFromObj(file,NULL);
error: {
    MK_STRN script = AtlInfoScript(NULL);
    check_NULL(script) goto error1;
    return script;
  }
error1:
  Tcl_ResetResult(interp);
  FRAME_GET(type)
  return Tcl_GetStringFromObj(type,NULL);
}
 
MK_I32 MK(Get_Call_Line) (FRAME_ARGS) {
  FRAME_UPDATE
  FRAME_GET(line)
  if (line == NULL) goto error;
  MK_I32 lineI = -1;
  if (Tcl_GetIntFromObj(NULL,line,&lineI)==TCL_ERROR) goto error;
  return lineI;
error:
  Tcl_ResetResult(interp);
  return -1;
}
 
// attention: "level" only used ONCE at startup  !!
bool MK(Get_Call_Stack) (OT_MK_ARGS MK_ERR const err, int level) {
  RL_init( 2, info_frame_2, RL_NewS(0,"::tcl::info::frame") ) ; RL_NewI(1,level) ;
  OT_OBJ_T frame = RL_EvalRt(TCL_EVAL_GLOBAL);
  Tcl_IncrRefCount(frame);
//printLng(frame);
  MkErrorStackFormat(err,
    MK(Get_Call_Cmd)(FRAME_CALL),
      MK(Get_Call_File)(FRAME_CALL),
        MK(Get_Call_Line)(FRAME_CALL)
  );
  Tcl_DecrRefCount(frame);
  return true;
error:
  Tcl_ResetResult(interp);
  return false;
}
 
//
// *********************************************************************************
//
 
#if 0
// Assumes little endian
static char* printBits(size_t const size, void const * const ptr)
{
    static char buf[100];
    char * bufP = &buf[0];
    unsigned char *b = (unsigned char*) ptr;
    unsigned char byte;
    int i, j;
    int num;
    
    for (i = (int)size-1; i >= 0; i--) {
        for (j = 7; j >= 0; j--) {
            byte = (b[i] >> j) & 1;
            num = sprintf(bufP,"%u", byte);
            bufP+=num;
        }
    }
    *bufP = '\0';
    return buf;
}
 
#define myprint(num)  ({ \
  unsigned int tmp=(unsigned int)num; \
  printV("%-40s → %s\n", #num, printBits(4,&tmp)); \
})
#endif
 
int MK(EnumFlagWorker) (MK_RT_ARGS OT_ENV_T interp, const struct LookupEnumE *keys, OT_OBJ_T enumE, int *ret)
{
  // read flag enum
  int     valI    = 0;
  int     index   = 0;
  int     objc    = 0;
  OT_OBJ_T *objv  = NULL;
  check_LNG(Tcl_ListObjGetElements(interp,enumE,&objc,&objv)) return TCL_ERROR;
  for (int i=0; i<objc; i++) {
    check_LNG (Tcl_GetIndexFromObjStruct (interp, objv[i], keys,
        sizeof(struct LookupClassS), "enum", TCL_EXACT, &index)) return TCL_ERROR;
    valI |= keys[index].val;
  }
//myprint(valI);
  *ret = valI;
  return TCL_OK;
}
 
//
// *********************************************************************************
//
 
bool MK(TestObject) (
  OT_Prefix_ARGS
  OT_OBJ_T          myO,
  OT_CLS_T          clsO,
  MK_OBJ          * objP,
  MkTestClassE    * flagP
) {
  assert(myO != NULL); 
  assert(clsO!= NULL); 
  Tcl_ResetResult(interp); 
  MkTestClassE flag = MkTestClassE_OK; 
  MOX_RT_T moxrt = amkrt->moxrt;
  MK_OBJ myOBJ = NULL;
 
  OT_NS_T myNs = MoxResolveN(myO);
    if (myNs == NULL) {  
      // first check for "", "MK_NULL", ...
      int len=0; 
      MK_STRN str = Tcl_GetStringFromObj(myO,&len); 
      if (len == 0 || MkStringIsNULL(MkStringCreate(len,str))) { 
        flag=MkTestClassE_NULL;
      } else {
        flag=MkTestClassE_NONE_OBJECT;
      }
      goto end;
    }
 
  myOBJ = Self2PtrNN(myNs);
    if (myOBJ == NULL) {
      if (MoxMyIsNN(myNs)) {
        flag=MkTestClassE_NULL; goto end;
      } else {
        flag=MkTestClassE_NONE_OBJECT; goto end;
      }
    }
 
  if (!MkObjCheck(myOBJ)) {
    flag=MkTestClassE_INVALID_SIGNATURE; goto end;
  }
 
  MK_TYP clsTT = AtlClassDefGetTypN(clsO,0);
    if (clsTT == NULL) {
      flag=MkTestClassE_INTERNAL; goto end;
    }
 
  if (!__MkCheckTO(clsTT,myOBJ)) {
    flag = MkTestClassE_WRONG_CLASS; goto end;
  }
 
  flag = MkTestClassE_OK; 
  if (objP)   *objP = myOBJ;
 
end: 
  if (flagP)  *flagP = flag; 
  switch(flag) { 
    case MkTestClassE_NONE_OBJECT : return false; 
    default                       : return true; 
  }
}
 
MK_STRN MK(GetTypeFromObj) (
  OT_Prefix_ARGS
  OT_OBJ_T myO,
  bool *isObject
) {
  SETUP_moxrt;
  const Tcl_ObjType *typePtr=myO->typePtr;
  MK_STRN name=NULL;
  bool isObjectB=false;
 
  if (MoxMyIsN(myO)) {
    // myoo instance NS
    isObjectB=true;
    name = OT_LNG_NAME_FROM_CLASS(MoxMy__CLASS__N(myO));
  } else if (MoxClsIsN(myO)) {
    // myoo class NS
    isObjectB=true;
    name = "Class";
  } else {
    // Tcl_Obj
    name = typePtr ? typePtr->name : "unknown";
    isObjectB=false;
  }
  if (isObject) *isObject=isObjectB;
  return name;
}
 
static MK_STRN NS(NamespaceTailCmd)(MK_STRN name) {
  // from: NamespaceTailCmd --------------------------
  const char *p;
  for (p = name;  *p != '\0';  p++) {
      /* empty body */
  }
  while (--p > name) {
      if ((*p == ':') && (*(p-1) == ':')) {
          p++;                        /* Just after the last "::" */
          break;
      }
  }
 
  if (p >= name) {
      name = p;
  }
  // ------------------------------------------------
  return name;
}
 
MK_STRN MK(ClassName) (
  OT_Prefix_ARGS
  OT_OBJ_T  myO,
  bool      doShort
) {
  const Tcl_ObjType *typePtr=myO->typePtr;
  MK_STRN name = NULL;
  MOX_RT_T const moxrt = amkrt->moxrt;
 
  if (MoxMyIsN(myO)) {
    // myoo instance
    name = OT_LNG_NAME_FROM_CLASS(MoxMy__CLASS__N(myO));
  } else if (MoxClsIsN(myO)) {
    // myoo class
    name = OT_LNG_NAME_FROM_CLASS(myO);
  } else {
    snprintf(amkrt->AtlClassName_buf,AtlClassName_buf_size,"Tcl_ObjType<%s>",typePtr ? typePtr->name : "unknown");
    name = amkrt->AtlClassName_buf;
    doShort = false;
  }
  if (doShort) name = NS(NamespaceTailCmd)(name);
  return name;
}
 
static void MK(LngTupleToMkBufferListS) (
  SETUP_ARGS,
  int      * skipP,
  MK_BFL   * retP
) {
  MK_BFL retVal = *retP;
  int __skip = *skipP;
 
  if (retVal == NULL) retVal = MkBufferListCreate (objc-__skip);
  else                MkBufferListReserve(retVal,objc-__skip);
  for (int i=__skip; i<objc; i++) {
    MkBufferListIndexSetSTR(retVal, i-__skip, VAL2STR(objv[i]));
  }
 
  *skipP = objc;
  *retP = retVal;
}
 
enum MkErrorE MK(LngListToMkBufferListS) (
  OT_Prefix_ARGS
  OT_OBJ_T argsO,
  MK_BFL      * retP
) {
  if (argsO == NULL) {
    return MK_OK;
  } else {
    int         __skip=0;
    int         listObjc;
    OT_OBJ_T *  listObjv;
    check_LNG (Tcl_ListObjGetElements(interp,argsO,&listObjc,&listObjv)) goto error;
    MK(LngTupleToMkBufferListS)( MK_RT_CALL interp,listObjc,listObjv,&__skip,retP);
  }
  return MK_OK;
error:
  return MK_ERROR;
}
 
int NS(OT_ERROR_LNG_RETURN_HDL_IS_NULL) (OT_MK_ARGS OT_CLS_T clsO, OT_OBJ_T objO)
{
  MOX_RT_T const moxrt = amkrt->moxrt;
  OT_CLS_T  objClsO = MoxMy__CLASS__N(objO);
 
  if (objClsO == NULL) {
    OT_ERROR_VAR_DEFAULT("HdlIsNullError: '%s' hdl is NULL (not a myoox)",VAL2STR(clsO));
    Tcl_SetErrorCode(interp,"ATLMK","HDL","NULL",NULL);
    goto error;
  }
 
  MK_STRN   objClsC = VAL2STR(objClsO);
  MK_MNG mng = VAL2MNG(objO);
 
  if (mng == NULL) {
    OT_ERROR_VAR_DEFAULT("HdlIsNullError: '%s' hdl is NULL (not an instance)",objClsC);
    Tcl_SetErrorCode(interp,"ATLMK","HDL","NULL",NULL);
    goto error;
  }
 
  MK_OBJ obj = MkObj(mng);
  if (obj == NULL) {
    OT_ERROR_VAR_DEFAULT("HdlIsNullError: '%s' hdl is NULL (not an object)",objClsC);
    Tcl_SetErrorCode(interp,"ATLMK","HDL","NULL",NULL);
    goto error;
  }
 
  MK_TYP    objTT = AtlClassDefGetTypN(objClsO,TCL_LEAVE_ERR_MSG);
              if (objTT == NULL) goto error_and_stack;
  MK_TYP    clsTT = AtlClassDefGetTypN(clsO,TCL_LEAVE_ERR_MSG);
              if (clsTT == NULL) goto error_and_stack;
 
/*
  RL_init(3,hdl_is_null_3, RL_T(0,ClassIsN) ) ; RL_O(1,objO) ; RL_O(2,clsO) ;
  OT_OBJ_T retO = RL_EvalRt(TCL_EVAL_GLOBAL);
  int boolI;
  if (retO == NULL || Tcl_GetBooleanFromObj(interp,retO,&boolI) != TCL_OK) {
    OT_ERROR_VAR_DEFAULT("[HdlInternalError] '%s'",Tcl_GetStringResult(interp));
    Tcl_SetErrorCode(interp,"ATLMK","HDL","INTERNAL",NULL);
    goto error;
  }
*/
 
  MK_STRN   clsC = VAL2STR(clsO);
  if (objTT == clsTT) {
    OT_ERROR_VAR_DEFAULT("HdlClassInvalidError: Expected 'hdl' in class '%s' not found", objClsC);
    Tcl_SetErrorCode(interp,"ATLMK","HDL","INVALID",NULL);
  } else {
    OT_ERROR_VAR_DEFAULT("HdlClassInvalidError: Expecting 'hdl' class '%s', but getting class '%s'", clsC, objClsC);
    Tcl_SetErrorCode(interp,"ATLMK","HDL","WRONG","CLASS",NULL);
  }
error_and_stack:
  OT_ERROR_APPEND_LNG_STACK(); 
error:
  return TCL_ERROR;
}
 
 
int MK(UnknownSetup) (
  OT_ENV_T          interp,
  const OtObjProcDefS   methodsDefs[],
  const ClientData      clientData
) {
 
  for (int i=0; methodsDefs[i].name != 0; i++) {
    check_NULL(Tcl_CreateObjCommand(interp, methodsDefs[i].name, methodsDefs[i].callProc, clientData, NULL)) 
      goto error;
  }
 
  return TCL_OK;
error:
  OT_ERROR_APPEND_LNG_STACK();
  return TCL_ERROR;
}
 
/*****************************************************************************/
/*                                                                           */
/*                               Obj_As                                      */
/*                                                                           */
/*****************************************************************************/
 
#define OT_LNG_STRING(o)              Tcl_GetString(o)
 
#define OT_LNG_STRING_BYTES(o)        o->bytes
#define OT_LNG_STRING_LENGTH(o)       o->length
#define OT_LNG_SKIP_TYPE              int
 
// -------------------------------------------------------------------------------
 
 
#include "tmpl/mk_misc_ObjAs_lng.h"
 
enum MkErrorE MK(Obj_AsSTRN) (OT_Check_ARGS, MK_STRN *retP) {
  if ((*skipP) >= objc) {
    return WrongNumArgs(hdl, (*skipP), objc, -999, +999, arg);
  }
  int len=0;
  MK_STRN ret = Tcl_GetStringFromObj(objv[(*skipP)++], &len);
  // mark=MK_NULL
  if (MK_NULL_STR_CHECK(ret,len)) {
    ret = NULL;
  }
  *retP = ret;
  return MK_OK;
}
 
/*
enum MkErrorE MK(Obj_AsCSTNULL) (OT_Check_ARGS, MK_STRN *retP) {
  if ((*skipP) >= objc) {
    return WrongNumArgs(hdl, (*skipP), objc, -999, +999, arg);
  }
  MK_STRN ret = Tcl_GetString(objv[(*skipP)++]);
  if (strcmp(ret,"NULL") == 0) ret=NULL;
  *retP = Tcl_GetString(objv[(*skipP)++]);
  return MK_OK;
}
*/
 
enum MkErrorE MK(Obj_AsSTR_COPY) (OT_Check_ARGS, MK_STR ret, size_t size) {
  if ((*skipP) >= objc) {
    return WrongNumArgs(hdl, (*skipP), objc, -999, +999, arg);
  }
  strncpy(ret,Tcl_GetString(objv[(*skipP)++]),size);
  return MK_OK;
}
 
/*****************************************************************************/
/*                                                                           */
/*                                 Check                                     */
/*                                                                           */
/*****************************************************************************/
 
#include "tmpl/mk_misc_check_lng.h"
 
//
// *********************************************************************************
//
 
int MK(EvalObjvVA) (
  OT_ENV_T interp,
  int          flags,
  ...
) {
  #define SIZE  20
  int objc;
  OT_OBJ_T objv[SIZE];
  va_list ap;
  va_start(ap, flags);
  for (objc=0; (objv[objc]=(OT_OBJ_T )va_arg(ap,OT_OBJ_T )) != NULL; objc++) {
    //Tcl_IncrRefCount(objv[objc]);
    if (objc >= (SIZE-1)) {
      Tcl_SetResult(interp, "EVAL-ERROR: size in MkEvalObjvVA is limited to " xstr(SIZE), TCL_STATIC);
      return TCL_ERROR;
    }
  }
  va_end(ap);
//printAry2(__func__,objc,objv)
  int 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;
  #undef SIZE
}
 
int MK(FillNamespace) (
  OT_ENV_T            interp,
  const OtObjProcDefS type[],
  ClientData          env
) {
  // 2. create commands
  for (int i=0; type[i].name != NULL; i++) {
    check_NULL  ( 
      Tcl_CreateObjCommand(interp, type[i].name, type[i].callProc, env,NULL)
    ) return TCL_ERROR;
  }
  return TCL_OK;
}
 
MK_STRN MK(ObjvToString) (MK_RT_ARGS MK_STRN cls, ATL_ARGS) {
  MkBufferCreateTLS_T(MkBuffer64C,ret,50);
  MkBufferAppendV(ret,"&%s ", cls);
  for(int i=1;i<objc;i++) { 
    MkBufferAppendV(ret,"%s ", VAL2STR(objv[i]));
  }
  return MkBUF_R(&retR).storage.first.C;
}
 
#define __printV(_color,_caller,_fmt,...) \
  fprintf(MK_OUT, MK_DEBUG_FMT _color _fmt MK_COLOR_RESET "\n", MK_DEBUG_ARG_1(_caller), __VA_ARGS__)
#define _printV(fmt,...) \
  __printV(MK_COLOR_CYAN,caller,fmt, __VA_ARGS__)
 
void MK(PrintObj2) (
  OT_Prefix_ARGS
  MK_STRN   header,
  OT_OBJ_T  obj,
  MK_STRN   caller
) {
  if (obj == NULL) {
    _printV("%s=NULL", header);
  }
  const Tcl_ObjType *typePtr = obj->typePtr;
  _printV("STRING # %s<%s>", header, VAL2STR(obj));
  if (typePtr) {
    const char * typeName = typePtr->name;
    _printV("  | OBJECT # typePtr<%s>, refCount<%d>", typeName, obj->refCount);
    if (strcmp(typeName,"parsedVarName")==0) {
      _printV("    | %-10p # pointer to the array name Tcl_Obj, or NULL if it is ascalar variable",
                              obj->internalRep.twoPtrValue.ptr1);
      _printV("    | %-10p # pointer to the element name string (owned by this Tcl_Obj), or NULL if it is a scalar variable",
                              obj->internalRep.twoPtrValue.ptr2);
    } else if (strcmp(typeName,"nsName")==0) {
      // ===========================================================================
      // generic/tclNamesp.c
      /*
       * This structure contains a cached pointer to a namespace that is the result
       * of resolving the namespace's name in some other namespace. It is the
       * internal representation for a nsName object. It contains the pointer along
       * with some information that is used to check the cached pointer's validity.
       */
 
      typedef struct ResolvedNsName {
          Namespace *nsPtr;             /* A cached pointer to the Namespace that the
                                       * name resolved to. */
          Namespace *refNsPtr;  /* Points to the namespace context in which
                                       * the name was resolved. NULL if the name is
                                       * fully qualified and thus the resolution
                                       * does not depend on the context. */
          int refCount;         /* Reference count: 1 for each nsName object
                                       * that has a pointer to this ResolvedNsName
                                       * structure as its internal rep. This
                                       * structure can be freed when refCount
                                       * becomes zero. */
      } ResolvedNsName;
      // ===========================================================================
      ResolvedNsName *resNamePtr = obj->internalRep.twoPtrValue.ptr1;
        if (resNamePtr==NULL) return;
      Namespace* nsPtr = resNamePtr->nsPtr ;
        char *nsPtrS = nsPtr ? nsPtr->fullName : "null";
        ClientData nsPtrCD = nsPtr ? nsPtr->clientData : NULL;
      Namespace* refNsPtr = resNamePtr->refNsPtr;
        char *refNsPtrS = refNsPtr ? refNsPtr->fullName : "null";
        _printV("    | NAMESPACE # namespace<%s>, ClientData<%p>, refNsPtr<%s>", nsPtrS, nsPtrCD, refNsPtrS);
    }
  } else {
    _printV("  | OBJECT # refCount : %d", obj->refCount);
  }
}
#undef _printV
#undef __printV
 
MK_STR MK(PrintObj) (
  OT_Prefix_ARGS
  MK_STRN   header,
  OT_OBJ_T  valO
) {
  if (valO == NULL) {
    MkBufferSetV(MkBUF(&MK_RT_REF.tbuf), "%s=NULL", header);
  } else {
  //printP(valO)
    MK_OBJ retObj = NULL;
    bool isObject;
    MK_STRN type = MK(GetTypeFromObj) (OT_Prefix_CALL valO, &isObject);
    if (isObject) OT_LNG_OBJECT_IS_3(valO, &retObj, NULL);
 
    #define objF  "[type<%s>, refCount<MQ=%i,TCL=%i,SHARED=%i>, ptr<MQ=%p,TCL=%p>]"
    #define objA  type, (retObj?retObj->refCount:-1),valO->refCount, Tcl_IsShared(valO), retObj, (retObj?retObj->self:NULL)
 
    // fill the buf and get the len back
    if (header) {
      MkBufferSetV(MkBUF(&MK_RT_REF.tbuf), "%-20s: %s " objF, header,  Tcl_GetString (valO), objA);
    } else if (retObj) {
      MkBufferSetV(MkBUF(&MK_RT_REF.tbuf),        "%s " objF,          Tcl_GetString (valO), objA);
    } else {
      MkBufferSetV(MkBUF(&MK_RT_REF.tbuf),        "%s " objF,          Tcl_GetString (valO), objA);
    }
 
    #undef objF
    #undef objA
  }
 
  return MkBUF_R(&MK_RT_REF.tbuf).storage.first.S;
}
 
// MARK_P ////////////////////////////////////////////////////////////////////////
 
int MK(AtlInfoExists) ( OT_MK_ARGS OT_OBJ_T var ) 
{
  RL_init( 2, info_exists, RL_NewS(0,"::tcl::info::exists") ); RL_O(1,var) ;
  return Ot_GetBooleanFromObj(RL_EvalRt(TCL_EVAL_GLOBAL));
error:
  return 0;
}
 
int MK(AtlArrayExists) ( OT_MK_ARGS OT_OBJ_T var ) 
{
  RL_init( 2, array_exists, RL_NewS(0,"::tcl::array::exists") ); RL_O(1,var) ;
  return Ot_GetBooleanFromObj(RL_EvalRt(TCL_EVAL_GLOBAL));
error:
  return 0;
}
 
MK_STRN MK(AtlInfoScript) ( OT_MK_ARGS MK_STRN script )
{
  OT_OBJ_T ret;
  if (script) {
    RL_init( 2, info_script_2, RL_NewS(0,"::tcl::info::script") ) ; RL_NewS(1,script) ;
    ret = RL_EvalRt(TCL_EVAL_GLOBAL);
  } else {
    RL_init( 1, info_script_1, RL_NewS(0,"::tcl::info::script") ) ; 
    ret = RL_EvalRt(TCL_EVAL_GLOBAL);
  }
  return Tcl_GetStringFromObj(ret,NULL);
error:
  return NULL;
}
 
int MK(AtlClassIsN) ( OT_MK_ARGS OT_SELF_T myNsO, OT_CLS_T clsNsO, bool *boolP ) 
{ 
  SETUP_moxrt;
  int retI;
  RL_init(3,MyIsClsN,RL_NewS(0,"::myooX::ClassIsN")) ; RL_O(1,myNsO) ; RL_O(2,clsNsO) ;
  retI = RL_EvalEx(TCL_EVAL_GLOBAL);
    if (retI != TCL_OK) goto error;
  OT_OBJ_T retO = Tcl_GetObjResult(interp);
  int intB;
  retI = Tcl_GetBooleanFromObj(interp,retO,&intB);
    if (retI != TCL_OK) goto error;
  (*boolP) = intB;
error:
  OT_ERROR_APPEND_LNG_STACK();
  return retI;
}
 
// MARK_E ////////////////////////////////////////////////////////////////////////
 
// BEGIN-enum - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
int MK(Get_MkErrorE_FromObj) (MK_RT_ARGS OT_ENV_T interp, OT_OBJ_T enumE, enum MkErrorE *ret) {
  const static struct LookupEnumE keys[] = {
    { "OK"          , MK_OK       },
    { "MK_OK"       , MK_OK       },
    { "ERROR"       , MK_ERROR    },
    { "CONTINUE"    , MK_CONTINUE },
    { "MK_ERROR"    , MK_ERROR    },
    { "MK_CONTINUE" , MK_CONTINUE },
    { NULL          , 0           },
  };
 
  int index;
  check_LNG(Tcl_GetIndexFromObjStruct (interp, enumE, &keys,
      sizeof(struct LookupClassS), "enum", TCL_EXACT, &index)) return TCL_ERROR;
  *ret = keys[index].val;
  return TCL_OK;
}
 
int MK(Get_MkIdSE_FromObj) (MK_RT_ARGS OT_ENV_T interp, OT_OBJ_T enumE, enum MkIdSE *ret) {
  const static struct LookupEnumE keys[] = {
    { "UNUSED"        , MK_ID_UNUSED  },
    { "THREAD"        , MK_ID_THREAD  },
    { "PROCESS"       , MK_ID_PROCESS },
    { "ID_UNUSED"     , MK_ID_UNUSED  },
    { "ID_THREAD"     , MK_ID_THREAD  },
    { "ID_PROCESS"    , MK_ID_PROCESS },
    { "MK_ID_THREAD"  , MK_ID_THREAD  },
    { "MK_ID_UNUSED"  , MK_ID_UNUSED  },
    { "MK_ID_PROCESS" , MK_ID_PROCESS },
    { NULL            , 0             },
  };
 
  int index;
  check_LNG(Tcl_GetIndexFromObjStruct (interp, enumE, &keys,
      sizeof(struct LookupClassS), "enum", TCL_EXACT, &index)) return TCL_ERROR;
  *ret = keys[index].val;
  return TCL_OK;
}
 
int MK(Get_MkTimeoutE_FromObj) (MK_RT_ARGS OT_ENV_T interp, OT_OBJ_T enumE, enum MkTimeoutE *ret) {
  const static struct LookupEnumE keys[] = {
    { "MAX"                  , MK_TIMEOUT_MAX       },
    { "LONG"                 , MK_TIMEOUT_LONG      },
    { "INIT"                 , MK_TIMEOUT_INIT      },
    { "USER"                 , MK_TIMEOUT_USER      },
    { "SHORT"                , MK_TIMEOUT_SHORT     },
    { "NORMAL"               , MK_TIMEOUT_NORMAL    },
    { "SOCKET"               , MK_TIMEOUT_SOCKET    },
    { "DEFAULT"              , MK_TIMEOUT_DEFAULT   },
    { "VERYSHORT"            , MK_TIMEOUT_VERYSHORT },
    { "TIMEOUT_MAX"          , MK_TIMEOUT_MAX       },
    { "TIMEOUT_USER"         , MK_TIMEOUT_USER      },
    { "TIMEOUT_LONG"         , MK_TIMEOUT_LONG      },
    { "TIMEOUT_INIT"         , MK_TIMEOUT_INIT      },
    { "TIMEOUT_SHORT"        , MK_TIMEOUT_SHORT     },
    { "TIMEOUT_NORMAL"       , MK_TIMEOUT_NORMAL    },
    { "TIMEOUT_SOCKET"       , MK_TIMEOUT_SOCKET    },
    { "MK_TIMEOUT_MAX"       , MK_TIMEOUT_MAX       },
    { "MK_TIMEOUT_USER"      , MK_TIMEOUT_USER      },
    { "MK_TIMEOUT_LONG"      , MK_TIMEOUT_LONG      },
    { "MK_TIMEOUT_INIT"      , MK_TIMEOUT_INIT      },
    { "TIMEOUT_DEFAULT"      , MK_TIMEOUT_DEFAULT   },
    { "MK_TIMEOUT_SHORT"     , MK_TIMEOUT_SHORT     },
    { "MK_TIMEOUT_NORMAL"    , MK_TIMEOUT_NORMAL    },
    { "MK_TIMEOUT_SOCKET"    , MK_TIMEOUT_SOCKET    },
    { "TIMEOUT_VERYSHORT"    , MK_TIMEOUT_VERYSHORT },
    { "MK_TIMEOUT_DEFAULT"   , MK_TIMEOUT_DEFAULT   },
    { "MK_TIMEOUT_VERYSHORT" , MK_TIMEOUT_VERYSHORT },
    { NULL                   , 0                    },
  };
 
  int index;
  check_LNG(Tcl_GetIndexFromObjStruct (interp, enumE, &keys,
      sizeof(struct LookupClassS), "enum", TCL_EXACT, &index)) return TCL_ERROR;
  *ret = keys[index].val;
  return TCL_OK;
}
 
int MK(Get_MkTypeE_FromObj) (MK_RT_ARGS OT_ENV_T interp, OT_OBJ_T enumE, enum MkTypeE *ret) {
  const static struct LookupEnumE keys[] = {
    { "I8T"     , MK_I8T  },
    { "BOLT"    , MK_BOLT },
    { "STRT"    , MK_STRT },
    { "DBLT"    , MK_DBLT },
    { "LSTT"    , MK_LSTT },
    { "I32T"    , MK_I32T },
    { "FLTT"    , MK_FLTT },
    { "I16T"    , MK_I16T },
    { "BINT"    , MK_BINT },
    { "I64T"    , MK_I64T },
    { "MK_I8T"  , MK_I8T  },
    { "MK_BOLT" , MK_BOLT },
    { "MK_STRT" , MK_STRT },
    { "MK_DBLT" , MK_DBLT },
    { "MK_LSTT" , MK_LSTT },
    { "MK_I32T" , MK_I32T },
    { "MK_FLTT" , MK_FLTT },
    { "MK_I16T" , MK_I16T },
    { "MK_BINT" , MK_BINT },
    { "MK_I64T" , MK_I64T },
    { NULL      , 0       },
  };
 
  int index;
  check_LNG(Tcl_GetIndexFromObjStruct (interp, enumE, &keys,
      sizeof(struct LookupClassS), "enum", TCL_EXACT, &index)) return TCL_ERROR;
  *ret = keys[index].val;
  return TCL_OK;
}
 
// END-enum - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// CALLED from: "<destructor>", "META-DATA-Destructor"
static void MK(Atom_ns_delete) (MK_MNG mng)
{ 
  assert(mng != NULL);
  MK_OBJ obj = MkObj(mng);
  check_NULL(obj) return;
  MkRtSetup_ON(obj);
  #ifdef OT_DEBUG_NAMESPACE_DELETE
    OT_SELF_T selfO = META2VAL_O(obj);
    if (selfO) {
      OT_DEBUG_NAMESPACE_DELETE(MK_COLOR_ORANGE,"%s<%p>"          , "INS", VAL2STR(selfO), selfO);
    } else {
      OT_DEBUG_NAMESPACE_DELETE(MK_COLOR_ORANGE,"(selfO=NULL) %s" , "INS", MkObjectToName(obj));
    }
  #endif
 
//MkObjectLogShort_2Lvl(obj,1);
//MkSysPrintStackTrace_4(obj,0,__func__,1);
//MkDLogV_O(obj,8,"%s [%s]\n",MkObjectToName(obj),__func__);
 
  // SELF is already "dead"
  MkRefDecrWithoutSelf(obj);
}
 
// update SELF if OBJECT is already available
// CALLED from: "<contructor>", MkAtomCreate
OT_SELF_T MK(AtomInit) (
  OT_MK_ARGS
  OT_SELF_T     selfO,
  MK_OBJ        obj,
  MK_PTR const  env
) {
  if (obj) {
    MkSelfSet (obj, (void*) selfO, env);
    //attention "OT_REF_DECR" in "AtomDeleteHard"
    OT_REF_INCR(selfO);
    MkRefIncr(obj);
 
    OT_NS_T myNsP = MoxResolveN(selfO);
      if (myNsP == NULL) goto error;
 
    myNsP->clientData = obj;
    myNsP->deleteProc = MK(Atom_ns_delete);
  }
 
  return selfO;
error:
  // HINT: refCnt-leak in "selfO" and "obj"
  OT_ERROR_LNG_2_META(obj);
  MkErrorStackFormat_0E();
  return NULL;
}
 
// create OBJECT and update SELF
// CALLED from: "*_SelfCreate"
OT_SELF_T MK(AtomCreate) (
  OT_MK_ARGS
  MK_OBJ              obj,
  OT_CLS_T            clsC,
  OT_OBJ_T            nameO,
  OT_OBJ_T            nsO,
  int                 objc,
  OT_OBJ_T const      objv[],
  MK_PTR const        env
) {
  SETUP_moxrt;
  int retI;
  OT_SELF_T selfO = NULL;
 
  retI = MoxCreate3N(clsC, nameO, nsO, objc, objv);
    if (retI != TCL_OK) goto error;
 
  selfO = Tcl_GetObjResult(interp);
    if (selfO == NULL) goto error;
 
  selfO = AtomInit(selfO,obj,env);
    if (selfO == NULL) goto error;
 
  return selfO;
error:
  OT_ERROR_LNG_2_META(obj);
  MkErrorStackFormat_0E();
  return NULL;
}
 
OT_SELF_T MK(AtomMake) (
  OT_MK_ARGS
  MK_OBJ        obj,
  OT_CLS_T      clsC,
  OT_OBJ_T      nameO,
  OT_OBJ_T      nsO,
  MK_PTR const  env
) {
  SETUP_moxrt;
  OT_SELF_T selfO = NULL;
 
  selfO = MoxMakeN(clsC, nameO, nsO);
    if (selfO == NULL) goto error;
 
  selfO = AtomInit(selfO,obj,env);
    if (selfO == NULL) goto error;
 
  return selfO;
error:
  OT_ERROR_LNG_2_META(obj);
  MkErrorStackFormat_0E();
  return NULL;
}
 
// create instance "nameO" with "namespace" (default current) and install namespace delete callback
OT_SELF_T MK(AtomCreateCONSTR) (
  OT_MK_ARGS
  MK_OBJ        obj,
  OT_CLS_T      clsC,
  OT_OBJ_T      nameO,
  MK_PTR const  env
) {
  assert(nameO != NULL);
 
  OT_SELF_T selfO = NULL;
  OT_OBJ_T nsO = NULL;
 
  // check if "nameO" has Namespace
  if (strncmp("::",Tcl_GetString(nameO),2) != 0) {
    nsO = STR2VAL(Tcl_GetCurrentNamespace(interp)->fullName);
    Tcl_IncrRefCount(nsO);
  }
  selfO = AtomCreate(obj, clsC, nameO, nsO, 0, NULL, env);
    if (selfO == NULL) goto error;
 
  Ot_DecrRefCount(nsO);
  return selfO;
error:
  Ot_DecrRefCount(nsO);
  OT_ERROR_APPEND_LNG_STACK();
  return NULL;
}
 
 
static int NS(Print_Class_Cmd) (OtClass_ARGS)
{
  int ret = TCL_OK;
  OT_SETUP_hdl_static
  int index;
 
  static const char *option[] = {
    "object", "type", "var", NULL
  };
  enum options {
    OBJECT, TYPE, VARIABLE
  };
 
  // get the Index
  check_LNG (Tcl_GetIndexFromObj (interp, objv[__skip++], option, "subcommand", 0, &index))
    return TCL_ERROR;
 
  // do the work
  switch ((enum options) index) {
    case OBJECT:
      WNA(1,1,"tclObj");
      Tcl_SetResult (interp, MK(PrintObj) (OT_Prefix_CALL "print", objv[__skip]), TCL_VOLATILE);
      break;
    case TYPE:
      WNA(1,1,"tclObj");
      Tcl_SetResult (interp, (char*) MK(GetTypeFromObj) (OT_Prefix_CALL objv[__skip], NULL), TCL_VOLATILE);
      break;
    case VARIABLE: {
      // same as tcl "Print ..."
      WNA(1,99,"tclObj...");
      OT_VARFRAME_CREATE
      RL_init( 1, info_level_1, RL_NewS(0,"::tcl::info::level") )
      OT_OBJ_T lvlObj = RL_EvalFr(varframe,0);
      int lvl;
      check_LNG(Tcl_GetIntFromObj(interp,lvlObj,&lvl)) goto error;
      char *STR;
      fputs("print var ",stderr);
      if (lvl > 0) {
        RL_init( 2, info_level_2, RL_NewS(0,"::tcl::info::level") ; RL_NewI(1,0) ) ;
        lvlObj = RL_EvalFr(varframe,0);
        OT_OBJ_T nameObj;
        check_LNG(Tcl_ListObjIndex(interp,lvlObj,0,&nameObj)) goto error;
        STR = Tcl_GetString(nameObj);
      } else {
        STR = "GLOBAL -> ";
      }
      fputs(STR,stderr);
      
      for (int i=2; i<objc; i++) {
        char * nameS = Tcl_GetString(objv[i]);
        OT_OBJ_T var = Tcl_ObjGetVar2(interp,objv[i],NULL,0);
        if (var) {
          fprintf(stderr,"%s<%s>, ", nameS, Tcl_GetString(var));
        } else {
          fprintf(stderr,"%s<not set>, ", nameS);
        }
      }
      fputs("\n",stderr);
      OT_VARFRAME_DELETE
      break;
error:
      ret = TCL_ERROR;
      OT_VARFRAME_DELETE
      break;
    }
  }
 
  return ret;
}
 
static int NS(Const_Class_Cmd) (OtClass_ARGS)
{
  OT_SETUP_hdl_static
  int index;
 
  OT_OBJ_T Obj = NULL;
 
  static const char *constant[] = {
    "maxY", "minY", "maxS", "minS", "maxI", "minI", "maxF", "minF", "maxW", "minW", "maxD", "minD", NULL
  };
  enum constants {
    MAXY, MINY, MAXS, MINS, MAXI, MINI, MAXF, MINF, MAXW, MINW, MAXD, MIND, 
  };
 
  WNA(1,1,"(maxY|minY|maxS|minS|maxI|minI|maxF|minF|maxW|minW|maxD|minD)");
 
  // get the Index
  check_LNG (Tcl_GetIndexFromObj (interp, objv[__skip], constant, "constant", 0, &index))
    return TCL_ERROR;
 
  // do the work
  switch ((enum constants) index) {
    case  MAXY:  Obj  =  Tcl_NewIntObj      (SCHAR_MAX);  break;
    case  MINY:  Obj  =  Tcl_NewIntObj      (SCHAR_MIN);  break;
    case  MAXS:  Obj  =  Tcl_NewIntObj      (SHRT_MAX);   break;
    case  MINS:  Obj  =  Tcl_NewIntObj      (SHRT_MIN);   break;
    case  MAXI:  Obj  =  Tcl_NewLongObj     (INT_MAX);    break;
    case  MINI:  Obj  =  Tcl_NewLongObj     (INT_MIN);    break;
    case  MAXF:  Obj  =  Tcl_NewDoubleObj   (FLT_MAX);    break;
    case  MINF:  Obj  =  Tcl_NewDoubleObj   (FLT_MIN);    break;
    case  MAXW:  Obj  =  Tcl_NewWideIntObj  (LLONG_MAX);  break;
    case  MINW:  Obj  =  Tcl_NewWideIntObj  (LLONG_MIN);  break;
    case  MAXD:  Obj  =  Tcl_NewDoubleObj   (DBL_MAX);    break;
    case  MIND:  Obj  =  Tcl_NewDoubleObj   (DBL_MIN);    break;
  }
 
  Tcl_SetObjResult (interp, Obj);
  return TCL_OK;
}
 
static int NS(Support_Class_Cmd) (OtClass_ARGS)
{
  OT_SETUP_hdl_static
  int index;
 
  Tcl_Obj *Obj = NULL;
 
  static const char *constant[] = {
    "thread", "fork", NULL
  };
  enum constants {
    THREAD, FORK, 
  };
 
  WNA(1,1,"(thread|fork)")
 
  // get the Index
  check_LNG (Tcl_GetIndexFromObj (interp, objv[__skip], constant, "configuration", 0, &index)) return TCL_ERROR;
 
  // do the work
  switch ((enum constants) index) {
    case THREAD:
#if META_HAS_THREAD
      Obj = Tcl_NewBooleanObj (1);
#else
      Obj = Tcl_NewBooleanObj (0);
#endif
      break;
    case FORK:
#if defined(HAVE_FORK)
      Obj = Tcl_NewBooleanObj (1);
#else
      Obj = Tcl_NewBooleanObj (0);
#endif
      break;
  }
 
  Tcl_SetObjResult (interp, Obj);
  return TCL_OK;
}
 
/*****************************************************************************/
/*                                                                           */
/*                               enum                                        */
/*                                                                           */
/*****************************************************************************/
 
// BEGIN-Enum-ToString - created by 'atl_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
OT_OBJ_T MK(MkBoolE_ToString) ( const enum MkBoolE type ) 
{
  switch (type) {
    case MK_NO  : return ot_fixstrobj("NO" ) ;
    case MK_YES : return ot_fixstrobj("YES") ;
  }
  return ot_fixstrobj("NOTHING");
}
 
OT_OBJ_T MK(MkErrorE_ToString) ( const enum MkErrorE type ) 
{
  switch (type) {
    case MK_OK       : return ot_fixstrobj("OK"      ) ;
    case MK_CONTINUE : return ot_fixstrobj("CONTINUE") ;
    case MK_ERROR    : return ot_fixstrobj("ERROR"   ) ;
  }
  return ot_fixstrobj("NOTHING");
}
 
OT_OBJ_T MK(MkIdSE_ToString) ( const enum MkIdSE type ) 
{
  switch (type) {
    case MK_ID_UNUSED  : return ot_fixstrobj("UNUSED" ) ;
    case MK_ID_PROCESS : return ot_fixstrobj("PROCESS") ;
    case MK_ID_THREAD  : return ot_fixstrobj("THREAD" ) ;
  }
  return ot_fixstrobj("NOTHING");
}
 
OT_OBJ_T MK(MkNativeIsE_ToString) ( const enum MkNativeIsE type ) 
{
  switch (type) {
    case MK_NATIVE_IS_INITIAL : return ot_fixstrobj("INITIAL") ;
    case MK_NATIVE_IS_STRING  : return ot_fixstrobj("STRING" ) ;
    case MK_NATIVE_IS_LITTLE  : return ot_fixstrobj("LITTLE" ) ;
    case MK_NATIVE_IS_BIG     : return ot_fixstrobj("BIG"    ) ;
  }
  return ot_fixstrobj("NOTHING");
}
 
OT_OBJ_T MK(MkTimeoutE_ToString) ( const enum MkTimeoutE type ) 
{
  switch (type) {
    case MK_TIMEOUT_INIT      : return ot_fixstrobj("INIT"     ) ;
    case MK_TIMEOUT_LONG      : return ot_fixstrobj("LONG"     ) ;
    case MK_TIMEOUT_NORMAL    : return ot_fixstrobj("NORMAL"   ) ;
    case MK_TIMEOUT_SHORT     : return ot_fixstrobj("SHORT"    ) ;
    case MK_TIMEOUT_SOCKET    : return ot_fixstrobj("SOCKET"   ) ;
    case MK_TIMEOUT_VERYSHORT : return ot_fixstrobj("VERYSHORT") ;
    case MK_TIMEOUT_DEFAULT   : return ot_fixstrobj("DEFAULT"  ) ;
    case MK_TIMEOUT_USER      : return ot_fixstrobj("USER"     ) ;
    case MK_TIMEOUT_MAX       : return ot_fixstrobj("MAX"      ) ;
  }
  return ot_fixstrobj("NOTHING");
}
 
OT_OBJ_T MK(MkTypeE_ToString) ( const enum MkTypeE type ) 
{
  switch (type) {
    case MK_I8T  : return ot_fixstrobj("I8T" ) ;
    case MK_BOLT : return ot_fixstrobj("BOLT") ;
    case MK_I16T : return ot_fixstrobj("I16T") ;
    case MK_I32T : return ot_fixstrobj("I32T") ;
    case MK_FLTT : return ot_fixstrobj("FLTT") ;
    case MK_I64T : return ot_fixstrobj("I64T") ;
    case MK_DBLT : return ot_fixstrobj("DBLT") ;
    case MK_BINT : return ot_fixstrobj("BINT") ;
    case MK_STRT : return ot_fixstrobj("STRT") ;
    case MK_LSTT : return ot_fixstrobj("LSTT") ;
  }
  return ot_fixstrobj("NOTHING");
}
 
// END-Enum-ToString - created by 'atl_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// BEGIN-MkKernel - created by 'atl_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// doc-key: MkKernel,MkKernel-Enum,sco
 
static OT_ProcRet NS(MkKernel_ErrorE_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ErrorE_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum MkErrorE value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,MkErrorE_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Mk_enum_OBJ(ErrorE,value_out));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_IdSE_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(IdSE_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum MkIdSE value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,MkIdSE_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Mk_enum_OBJ(IdSE,value_out));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_TimeoutE_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(TimeoutE_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum MkTimeoutE value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,MkTimeoutE_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Mk_enum_OBJ(TimeoutE,value_out));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_TypeE_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(TypeE_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum MkTypeE value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,MkTypeE_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Mk_enum_OBJ(TypeE,value_out));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkKernel,MkKernel-Enum,sm_
 
static OT_ProcRet NS(MkKernel_ErrorE_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ErrorE_ToInt_doc);
  enum MkErrorE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MkErrorE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkErrorE_ToInt (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_ErrorE_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ErrorE_ToString_doc);
  enum MkErrorE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MkErrorE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MkErrorE_ToString (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_IdSE_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(IdSE_ToInt_doc);
  enum MkIdSE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MkIdSE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkIdSE_ToInt (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_IdSE_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(IdSE_ToString_doc);
  enum MkIdSE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MkIdSE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MkIdSE_ToString (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_TimeoutE_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(TimeoutE_ToInt_doc);
  enum MkTimeoutE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MkTimeoutE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkTimeoutE_ToInt (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_TimeoutE_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(TimeoutE_ToString_doc);
  enum MkTimeoutE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MkTimeoutE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MkTimeoutE_ToString (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_TypeE_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(TypeE_ToInt_doc);
  enum MkTypeE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MkTypeE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkTypeE_ToInt (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_TypeE_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(TypeE_ToString_doc);
  enum MkTypeE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MkTypeE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MkTypeE_ToString (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkKernel_Enum_ATL_API
 
 
// doc-key: MkKernel,MkKernel-Setup-libmkkernel,sm_
 
static OT_ProcRet NS(MkKernel_Cleanup) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Cleanup_doc);
  OT_CHECK_NOARGS;
  MkCleanupTmpl ();
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_Setup) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Setup_doc);
  OT_CHECK_NOARGS;
  MkSetupTmpl ();
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkKernel_Setup_libmkkernel_ATL_API
 
// END-MkKernel - created by 'atl_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// ---------------------------------------------------------------------------------------
 
MK_UNUSED 
static const OtObjProcDefS MK(sOtClassDef)[] = {
  { "::MkKernel::print"             , NS(Print_Class_Cmd)            },
  { "::MkKernel::const"             , NS(Const_Class_Cmd)            },
  { "::MkKernel::support"           , NS(Support_Class_Cmd)          },
  // BEGIN-CLASS - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // doc-key: MkKernel,EnumFunc,sco
  { "::MkKernel::ErrorE_FromInt"    , NS(MkKernel_ErrorE_FromInt)    },
  { "::MkKernel::IdSE_FromInt"      , NS(MkKernel_IdSE_FromInt)      },
  { "::MkKernel::TimeoutE_FromInt"  , NS(MkKernel_TimeoutE_FromInt)  },
  { "::MkKernel::TypeE_FromInt"     , NS(MkKernel_TypeE_FromInt)     },
 
  // doc-key: MkKernel,EnumFunc,sm_
  { "::MkKernel::ErrorE_ToInt"      , NS(MkKernel_ErrorE_ToInt)      },
  { "::MkKernel::ErrorE_ToString"   , NS(MkKernel_ErrorE_ToString)   },
  { "::MkKernel::IdSE_ToInt"        , NS(MkKernel_IdSE_ToInt)        },
  { "::MkKernel::IdSE_ToString"     , NS(MkKernel_IdSE_ToString)     },
  { "::MkKernel::TimeoutE_ToInt"    , NS(MkKernel_TimeoutE_ToInt)    },
  { "::MkKernel::TimeoutE_ToString" , NS(MkKernel_TimeoutE_ToString) },
  { "::MkKernel::TypeE_ToInt"       , NS(MkKernel_TypeE_ToInt)       },
  { "::MkKernel::TypeE_ToString"    , NS(MkKernel_TypeE_ToString)    },
 
  // doc-key: MkKernel,Setup,sm_
  { "::MkKernel::Cleanup"           , NS(MkKernel_Cleanup)           },
  { "::MkKernel::Setup"             , NS(MkKernel_Setup)             },
 
  // END-CLASS - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
  { NULL }
};
 
// ---------------------------------------------------------------------------------------
// not used.
 
__attribute__((unused))  
static const OtObjProcDefS MK(sInstanceDef)[] = {
  // BEGIN-OBJ - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // → no data
 
  // END-OBJ - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
  { NULL }
};
 
 
void NS(MkKernel_ns_delete)(ClientData clientData) 
{
  OT_MK_RT_T amkrt = clientData;
#ifdef OT_DEBUG_NAMESPACE_DELETE
  OT_DEBUG_NAMESPACE_DELETE(MK_COLOR_YELLOW,"::MkKernel with amkrt<%p>","MK",amkrt);
#endif
  OT_ENV_T interp = amkrt->interp;
  //amkrt->status = OT_MK_RT_STATUS_ONEXIT;
 
  // BEGIN-CLASS-delete-2 - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  OT_NS_T ns;
    ns = Tcl_FindNamespace(interp,"::MkBufferStreamC",NULL,TCL_GLOBAL_ONLY);
      if (ns) Tcl_DeleteNamespace(ns);
    ns = Tcl_FindNamespace(interp,"::MkRuntimeC",NULL,TCL_GLOBAL_ONLY);
      if (ns) Tcl_DeleteNamespace(ns);
    ns = Tcl_FindNamespace(interp,"::MkErrorC",NULL,TCL_GLOBAL_ONLY);
      if (ns) Tcl_DeleteNamespace(ns);
    ns = Tcl_FindNamespace(interp,"::MkLogFileC",NULL,TCL_GLOBAL_ONLY);
      if (ns) Tcl_DeleteNamespace(ns);
    ns = Tcl_FindNamespace(interp,"::MkBufferListC",NULL,TCL_GLOBAL_ONLY);
      if (ns) Tcl_DeleteNamespace(ns);
    ns = Tcl_FindNamespace(interp,"::MkBufferC",NULL,TCL_GLOBAL_ONLY);
      if (ns) Tcl_DeleteNamespace(ns);
    ns = Tcl_FindNamespace(interp,"::MkObjectC",NULL,TCL_GLOBAL_ONLY);
      if (ns) Tcl_DeleteNamespace(ns);
 
  // END-CLASS-delete-2 - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // delete all TYPES registert in amkrt
  // test: Nhi1Exec --prefix=vgs MyServer.atl → should be empty
  AtlClassDefT item,tmp;
  DL_FOREACH_SAFE(amkrt->atlClassDefL,item,tmp) {
    Tcl_DeleteNamespace(item->classNS);
  }
 
    #define AtlRtFree(tok) if (amkrt->tok) OT_REF_DECR_AND_NULL(amkrt->tok);
      #define regTclObj2(t,v)   AtlRtFree(t)
      #define regTclObj(t)      AtlRtFree(t)
      #define regTclCmd(t)      AtlRtFree(t)
      #include "LibMkKernel_registry_atl.h"
      #undef regTclCmd
      #undef regTclObj
      #undef regTclObj2
 
  // BEGIN-CLASS-delete - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  if (amkrt->AtlMkBufferStreamC)         Tcl_DecrRefCount(amkrt->AtlMkBufferStreamC)         ;
  if (amkrt->AtlMkBufferStreamC_MK_NULL) Tcl_DecrRefCount(amkrt->AtlMkBufferStreamC_MK_NULL) ;
  if (amkrt->AtlMkRuntimeC)              Tcl_DecrRefCount(amkrt->AtlMkRuntimeC)              ;
  if (amkrt->AtlMkRuntimeC_MK_NULL)      Tcl_DecrRefCount(amkrt->AtlMkRuntimeC_MK_NULL)      ;
  if (amkrt->AtlMkErrorC)                Tcl_DecrRefCount(amkrt->AtlMkErrorC)                ;
  if (amkrt->AtlMkErrorC_MK_NULL)        Tcl_DecrRefCount(amkrt->AtlMkErrorC_MK_NULL)        ;
  if (amkrt->AtlMkLogFileC)              Tcl_DecrRefCount(amkrt->AtlMkLogFileC)              ;
  if (amkrt->AtlMkLogFileC_MK_NULL)      Tcl_DecrRefCount(amkrt->AtlMkLogFileC_MK_NULL)      ;
  if (amkrt->AtlMkBufferListC)           Tcl_DecrRefCount(amkrt->AtlMkBufferListC)           ;
  if (amkrt->AtlMkBufferListC_MK_NULL)   Tcl_DecrRefCount(amkrt->AtlMkBufferListC_MK_NULL)   ;
  if (amkrt->AtlMkBufferC)               Tcl_DecrRefCount(amkrt->AtlMkBufferC)               ;
  if (amkrt->AtlMkBufferC_MK_NULL)       Tcl_DecrRefCount(amkrt->AtlMkBufferC_MK_NULL)       ;
  if (amkrt->AtlMkObjectC)               Tcl_DecrRefCount(amkrt->AtlMkObjectC)               ;
  if (amkrt->AtlMkObjectC_MK_NULL)       Tcl_DecrRefCount(amkrt->AtlMkObjectC_MK_NULL)       ;
 
  // END-CLASS-delete - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  //amkrt->status = OT_MK_RT_STATUS_DELETED;
  amkrt->signature = 0x0;
}
 
MkThreadLocal OT_MK_RT_S amkrtR = {0};
 
// called on every NEW thread
OT_ATL_EXTERN int Atlmkkernel_Init ( OT_ENV_T interp ) 
{
  // check for the right tcl version
  if (Tcl_InitStubs (interp, "8.5", false) == NULL) {
    return TCL_ERROR;
  }
 
  // setup libmkkernel
  MkSetup();
  MkRtSetup_NULL;
 
  // announce my package
  check_LNG (Tcl_PkgProvideEx (interp, "atlmkkernel", META_VERSION, &amkrtR )) return TCL_ERROR;
 
  // pkg_mkIndex hack → only "Tcl_PkgProvide" is required
  if (Tcl_GetVar(interp,"::tcl::newPkgs", TCL_GLOBAL_ONLY) != NULL) return TCL_OK;
 
  // dependency.
  MK_STRN ver = Tcl_PkgRequire(interp, "libmyoox", "1.0", 0);
    check_NULL(ver) return TCL_ERROR;
 
  // create local runtime
  //   -> cleanup in: MkKernel_ns_delete
  OT_MK_RT_T amkrt = &amkrtR;
    if (amkrt->signature && amkrt->signature != OT_MK_RT_SIG) {
      Tcl_SetErrorCode(interp, "ATLMK", "INIT", "SIGNATURE", "INVALID", NULL);
      Tcl_SetResult(interp,"error: ATLMK setup failed with INVALID signature", TCL_STATIC);
      return TCL_ERROR;
    } else {
      amkrt->signature = OT_MK_RT_SIG;
    }
    if (amkrt->interp && amkrt->interp != interp) {
      Tcl_SetErrorCode(interp, "ATLMK", "INIT", "INTERPRETER", "INVALID", NULL);
      Tcl_SetResult(interp,"error: ATLMK setup failed with INVALID interpreter", TCL_STATIC);
      return TCL_ERROR;
    } else {
      amkrt->interp = interp;
    }
    if (amkrt->mkrt && amkrt->mkrt != MK_RT_PTR) {
      Tcl_SetErrorCode(interp, "ATLMK", "INIT", "MK_RT", "INVALID", NULL);
      Tcl_SetResult(interp,"error: ATLMK setup failed with INVALID MkRuntimeS", TCL_STATIC);
      return TCL_ERROR;
    } else {
      amkrt->mkrt = MK_RT_PTR;
    }
 
  // get "moxrt" from "::myooX"
  MOX_NS_T ns = Tcl_FindNamespace(interp,"::myooX",NULL,TCL_GLOBAL_ONLY|TCL_LEAVE_ERR_MSG);
    if (ns == NULL) return TCL_ERROR;
    amkrt->moxrt = ns->clientData;
      if (amkrt->moxrt == NULL) {
        Tcl_SetResult(interp,"error: libmyoox is broken, 'clientData=moxrt' is missing", TCL_STATIC);
        Tcl_SetErrorCode(interp, "ATLMK", "INIT", "LOOKUP", NULL);
        return TCL_ERROR;
      }
 
  // cleanup "access" objects
  #define regTclObj2(t,v)   if (amkrt->t) OT_REF_DECR(amkrt->t)
  #define regTclObj(t)      regTclObj2(t,#t)
  #define regTclCmd(t)      regTclObj2(t,#t)
  #include "LibMkKernel_registry_atl.h"
  #undef regTclCmd
  #undef regTclObj
  #undef regTclObj2
 
  // register "access" objects
  #define regTclObj2(t,v)   amkrt->t = STR2VAL(v); Tcl_IncrRefCount(amkrt->t);
  #define regTclObj(t)      regTclObj2(t,#t)
  #define regTclCmd(t)      regTclObj2(t,#t)
  #include "LibMkKernel_registry_atl.h"
  #undef regTclCmd
  #undef regTclObj
  #undef regTclObj2
 
  // create ::MkKernel
  ns = Tcl_FindNamespace(interp,"::MkKernel",NULL,TCL_GLOBAL_ONLY);
    if (ns == NULL) {
      ns = Tcl_CreateNamespace(interp,"::MkKernel",amkrt,NS(MkKernel_ns_delete));
        if (ns == NULL) return TCL_ERROR;
    }
 
  // add PACKAGE commands
  check_LNG( MK(FillNamespace) (interp,MK(sOtClassDef),amkrt) ) return TCL_ERROR;
 
  // ATTENTION: MK(ClassDef) "class-resolution" require that "MkObjectC" is always first
  // BEGIN-CLASS-call-init - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  check_LNG( NS(pMkObjectC_Init)       (OT_MK_CALL ns) ) return TCL_ERROR;
  check_LNG( NS(pMkBufferC_Init)       (OT_MK_CALL ns) ) return TCL_ERROR;
  check_LNG( NS(pMkBufferListC_Init)   (OT_MK_CALL ns) ) return TCL_ERROR;
  check_LNG( NS(pMkLogFileC_Init)      (OT_MK_CALL ns) ) return TCL_ERROR;
  check_LNG( NS(pMkErrorC_Init)        (OT_MK_CALL ns) ) return TCL_ERROR;
  check_LNG( NS(pMkRuntimeC_Init)      (OT_MK_CALL ns) ) return TCL_ERROR;
  check_LNG( NS(pMkBufferStreamC_Init) (OT_MK_CALL ns) ) return TCL_ERROR;
 
  // END-CLASS-call-init - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // get TCL internal data types
  amkrt->LONG     =  Tcl_GetObjType("int") ;
  amkrt->WIDE     =  Tcl_GetObjType("wideInt") ;
  amkrt->DOUBLE   =  Tcl_GetObjType("double") ;
  amkrt->BOOLEAN  =  Tcl_GetObjType("booleanString") ;
  amkrt->INDEX    =  Tcl_GetObjType("index") ;
 
  amkrt->NS       =  Tcl_GetObjType("nsName") ;
  
  return TCL_OK;
}
 
OT_ATL_EXTERN int Atlmkkernel_Unload ( OT_ENV_T interp, int flags) 
{
  OT_NS_T ns = Tcl_FindNamespace(interp,"::MkKernel",NULL,TCL_GLOBAL_ONLY);
    if (ns) Tcl_DeleteNamespace(ns);
 
  MkCleanup();
 
  return TCL_OK;
}