LibMkKernel_tcl.c

Go to the documentation of this file.

 
/* LABEL-NO */
 
#define   META_FILE_NAME          "MkKernel_tcl.c"
#define   VER                     TCL_OO_METHOD_VERSION_CURRENT
 
#include  "LibMkKernel_private_tcl.h"
 
#undef OtClass_ARGS
#define OtClass_ARGS  OBJCMD_ARGS
 
#define OT_SETUP_hdl_static \
  int __skip=1;\
  /* printAry2("cmd",objc,objv); */ \
  __attribute__((unused)) MK_RT mkrt = MkRT; \
  __attribute__((unused)) MK_ERR hdl = &MkERROR;
 
/* LABEL-END */
 
#include <limits.h>
#include <float.h>
#include <math.h>
#include <ctype.h>
 
#include "mk_check_tcl.h"
 
#define MkSetupTmpl()
#define MkCleanupTmpl()
 
// #######################################################################
// -----------------------------------------------------------------------
// documentation order
 
 
 
 
 
 
 
 
 
const Tcl_ObjType  *MK(tcl_LONG)     = NULL;
const Tcl_ObjType  *MK(tcl_WIDE)     = NULL;
const Tcl_ObjType  *MK(tcl_DOUBLE)   = NULL;
const Tcl_ObjType  *MK(tcl_BOOLEAN)  = NULL;
const Tcl_ObjType  *MK(tcl_INDEX)    = NULL;
 
#ifdef OT_REGISTRY_AS_TLS
  MkThreadLocal   OT_OBJ_T MK(reggv)[100] = {0};
#else
                  OT_OBJ_T MK(reggv)[100] = {0};
#endif
#define regTclObj(str)        int MK(str);
#define regTclObj2(def,str)   int MK(def);
#include "MkRegistry_tcl.h"
#undef regTclObj
#undef regTclObj2
 
// --------------------------------------------------------------------------------
 
// BEGIN-DOC - created by 'tcl_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 'tcl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
struct MkAtlClassDefS {
  OT_CLS_T  ooclassC;
  OT_OBJ_T  ooRefC[100];
  long      count;
};
 
OT_SELF_T MK(ClassDef)(
  OT_ENV_T  interp,
  OT_NS_T   ns,
  MK_TYP    classM
) {
 
  // save base-class  "::oo::class" for later use
  static MkThreadLocal struct MkAtlClassDefS def = {0};
 
  Tcl_ResetResult(interp);
 
  while (def.ooclassC == NULL) {
    OT_OBJ_T objPtr   = Tcl_NewStringObj("::oo::class", -1);
    OT_SELF_T  ooclassO  = Tcl_GetObjectFromObj(interp, objPtr);
    Tcl_DecrRefCount(objPtr);
    check_NULL(ooclassO)                        goto error_ooclassC;
    def.ooclassC = Tcl_GetObjectAsClass(ooclassO);
    break;
error_ooclassC:
    Tcl_AppendResult(interp, "\nCLASS-SETUP-ERROR: unable to setup '::oo::class'", NULL);
    return NULL;
  }
 
  OT_OBJ_T cmdO = Tcl_ObjPrintf("%s::%s", ns->fullName, classM->type_class->type_name);
    OT_REF_INCR(cmdO);
  const char* cmdbuf = Tcl_GetString(cmdO);
 
//printC(cmdbuf)
  OT_SELF_T classO = Tcl_NewObjectInstance(interp,def.ooclassC,cmdbuf,cmdbuf,0, NULL, 0);
  check_NULL(classO)                            goto error;
 
  OT_OBJ_T classObj = Tcl_GetObjectName(interp,classO);
  Tcl_IncrRefCount(classObj);
  def.ooRefC[def.count] = classObj;
  MkSelfSet_3X(classM, (MK_PTR) def.count, interp);    // save reference on Tcl-Class in MQ-Type-Self
 
//printV("class=%-40s, pos=%ld", classM->type_name, def.count);
 
  def.count++;
 
//printV("name=%s, base=%p\n", classM->type_name, classM->type_base);
 
  // If base was defined - create a "tcl superclass" from MQ-Type-Self
  // > silent assume that "MkObjectC" is always FIRST !!
  if (def.count != 1 && classM->type_base != NULL /* && classM->type_base != MkTypeDefSTT && classM->type_base != MqTypeCtxSTT */ )  {
    OT_OBJ_T super = def.ooRefC[(long) (MkOBJ_R(classM->type_base).self ? MkOBJ_R(classM->type_base).self : 0)];
//printV("cmdbuf=%s, type_name=%s, base=%s\n", cmdbuf, classM->type_name, Tcl_GetStringFromObj(super,NULL));
/*
    // PROBLEM: MK(pMkObjectC_Init) not called -< code down create an EMPTY class
    check_NULL(super)
      super = Tcl_GetObjectName(interp, MK(ClassDef)(interp, ns, classM->type_base));
*/
    check_NULL(super) {
      Tcl_AppendResult(interp, "\nCLASS-SETUP-ERROR: class '", classM->type_base->type_name, 
                                    "' has EMPTY base SELF pointer", NULL);
      goto error;
    }
//printV("class=%-40s, super=%s", VAL2STR(cmdO), VAL2STR(super))
    RL_init( RL_NewS(0,"::oo::define") RL_NewC(2,superclass) ) ; RL_O(1,cmdO) ; RL_O(3,super)
    check_LNG(Tcl_EvalObjv(interp, 4, RL_data, TCL_EVAL_GLOBAL)) goto error;
  }
  
  OT_REF_DECR(cmdO);
  return classO;
error:
  Tcl_AppendResult(interp, "\nCLASS-SETUP-ERROR: found at '", __func__, "'", NULL);
  OT_REF_DECR(cmdO);
  return NULL;
}
 
//
// *********************************************************************************
//
 
OT_OBJ_T MK(GetMyFromObject) (OT_ENV_T interp, OT_SELF_T object) {
  OT_NS_T ns = Tcl_GetObjectNamespace(object);
  Tcl_Command   myCmdC = Tcl_FindCommand(interp, "my", ns, TCL_NAMESPACE_ONLY|TCL_LEAVE_ERR_MSG);
  check_NULL(myCmdC) goto error;
 
  OT_OBJ_T myCmdO = Tcl_NewObj();
  Tcl_GetCommandFullName(interp,myCmdC,myCmdO);
 
  return myCmdO;
error:
  return NULL;
}
 
//
// *********************************************************************************
//
 
#define FRAME_UPDATE                                            \
  if (*frameP == NULL) {                                        \
    RL_init( RL_O(0,RG(infoFrameCmd)) RL_NewC(1,0) )               \
    OT_OBJ_T ret = MK(EvalObjvAR)(MK_RT_CALL NULL,interp,0,RL_objv(2));    \
    /* check_NULL(ret) OT_ERROR_ABNORMAL(MK_ERROR_PANIC); */    \
    Tcl_IncrRefCount(ret);                                      \
    *frameP = ret;                                              \
  }
 
#define FRAME_GET(key)                            \
  OT_OBJ_T key = NULL;                            \
  Tcl_DictObjGet(interp,*frameP,RG(key),&key);    \
 
MK_STRN MK(Get_Call_Proc) (MK_RT_ARGS OT_ENV_T interp, OT_OBJ_T * frameP) {
  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) (MK_RT_ARGS OT_ENV_T interp, OT_OBJ_T * frameP) {
#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(InfoScript) (MK_RT_ARGS OT_ENV_T interp, MK_STRN script)
{
  RL_init( RL_O(0,RG(infoScriptCmd)) )
  if (script) RL_NewS(1,script)
  OT_OBJ_T ret = MK(EvalObjvAR)(MK_RT_CALL NULL, interp, 0, RL_objv(script?2:1));
  if (script) Tcl_DecrRefCount(RL_data[1]);
  check_NULL(ret) return NULL;
  return Tcl_GetStringFromObj(ret,NULL);
}
 
MK_STRN MK(Get_Call_File) (MK_RT_ARGS OT_ENV_T interp, OT_OBJ_T * frameP) {
  FRAME_UPDATE
  FRAME_GET(file)
  if (file == NULL) goto error;
  return Tcl_GetStringFromObj(file,NULL);
error: {
    MK_STRN script = MK(InfoScript)(MK_RT_CALL interp,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) (MK_RT_ARGS OT_ENV_T interp, OT_OBJ_T * frameP) {
  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) (MK_RT_ARGS OT_ENV_T interp, MK_ERR const err, int level) {
  //Tcl_ResetResult(interp);
  RL_init( RL_O(0,RG(infoFrameCmd)) ) ; RL_NewI(1,level)
//printAryX(err,"Get_Call_Stack",3,RL_data)
  OT_OBJ_T frame = MK(EvalObjvAR)(MK_RT_CALL NULL,interp, TCL_EVAL_NOERR, RL_objv(2));
    check_NULL(frame) goto error;
  Tcl_IncrRefCount(frame);
  //MkErrorStackFormat(err,"mark","mark",-1);
  MkErrorStackFormat(err,
    MK(Get_Call_Cmd)(MK_RT_CALL interp,&frame),
      MK(Get_Call_File)(MK_RT_CALL interp,&frame),
        MK(Get_Call_Line)(MK_RT_CALL interp,&frame)
  );
  Tcl_DecrRefCount(frame);
  RL_Free(1)
  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;
  OtErrorCheckLng(Tcl_ListObjGetElements(interp,enumE,&objc,&objv));
  for (int i=0; i<objc; i++) {
    OtErrorCheckLng (Tcl_GetIndexFromObjStruct (interp, objv[i], keys,
        sizeof(struct LookupClassS), "enum", TCL_EXACT, &index));
    valI |= keys[index].val;
  }
//myprint(valI);
  *ret = valI;
  return TCL_OK;
}
 
//
// *********************************************************************************
//
 
// return TCL error
OT_SELF_T MK(GetClassObjectFromObj) (MK_RT_ARGS OT_ENV_T interp, OT_OBJ_T selfO) {
  //MkRtSetup_NULL;
  //printLngObj(selfO);
  RL_init( RL_O(0,RG(infoObjectClassCmd)) ) ; RL_O(1,selfO)
  OT_OBJ_T clsObj = MK(EvalObjvAR)(MK_RT_CALL NULL,interp,TCL_EVAL_GLOBAL,  RL_objv(2));
  check_NULL(clsObj) goto error;
  return Tcl_GetObjectFromObj(interp, clsObj);
error:
  return NULL;
}
 
mk_inline MK_MNG MK(GetMNG) (
  OT_ENV_T interp,
  OT_OBJ_T tclO
)
{
  OT_SELF_T  objO = Tcl_GetObjectFromObj (interp, tclO);
  if (objO == NULL)   return NULL;
  return Tcl_ObjectGetMetadata(objO, &MK(AtomMeta));
}
 
mk_inline MkTestClassE NS(sCheckClass) (
  OT_ENV_T interp,
  OT_SELF_T       tclObj,
  OT_CLS_T        clazz,
  MkTestClassE    def
) {
  // check if object belong to class
  OT_OBJ_T objNameO = Tcl_GetObjectName(interp,tclObj);
  OT_OBJ_T clsNameO = Tcl_GetObjectName(interp,Tcl_GetClassAsObject(clazz));
  RL_init( RL_O(0,RG(infoObjectClassCmd)) ) ; RL_O(1,objNameO) ; RL_O(2,clsNameO)
  check_LNG(Tcl_EvalObjv(interp, RL_objv(3), TCL_EVAL_GLOBAL)) {
    return MkTestClassE_INTERNAL;
  }
  int isClass = 0;
  check_LNG(Tcl_GetBooleanFromObj(interp,Tcl_GetObjResult(interp),&isClass)) {
    return MkTestClassE_INTERNAL;
  }
  if (!isClass) { 
    return MkTestClassE_WRONG_CLASS;
  }
  return def;
}
 
bool MK(TestObject) (
  OT_Prefix_ARGS
  OT_OBJ_T          lngO,
  OT_CLS_T    clazz,
  MK_OBJ          * objP,
  MkTestClassE    * flagP
) {
  assert(lngO != NULL); 
  MkTestClassE flag = MkTestClassE_NONE_OBJECT; 
  MK_OBJ objM = NULL;
 
  // BUG FIX → need name WITH namespace from "Tcl_GetObjectName"
  OT_SELF_T tclObj = Tcl_GetObjectFromObj (interp, lngO); 
  if (tclObj == NULL)   {  
    Tcl_ResetResult(interp); 
    // first check for "", "MK_NULL", ...
    if (OT_LNG_NULL_IS(lngO)) { 
      flag=MkTestClassE_NULL; goto end; 
    } else {
      flag=MkTestClassE_NONE_OBJECT; goto end;  
    }
  };
 
  objM = Tcl_ObjectGetMetadata(tclObj, &MK(AtomMeta)); 
  /* NULL or wrong class */ 
  if (objM == NULL)   { 
    switch (flag = NS(sCheckClass)(interp,tclObj,clazz,flag)) {
      case MkTestClassE_INTERNAL:
      case MkTestClassE_WRONG_CLASS: break;
      default: flag=MkTestClassE_NULL;
    }
    goto end; 
  }
 
  if (clazz != MK(MkObjectC)) {
    // check if object belong to class
    switch (flag = NS(sCheckClass)(interp,tclObj,clazz,flag)) {
      case MkTestClassE_INTERNAL:
      case MkTestClassE_WRONG_CLASS: goto end;
      default: break;
    }
  } 
  
  objM = MkObj(objM); 
  if (objM == NULL)   { flag=MkTestClassE_INVALID_SIGNATURE  ; goto end; }; 
  
  flag = MkTestClassE_OK; 
  if (objP)   *objP = objM;
 
end: 
  if (flagP)  *flagP = flag; 
  switch(flag) { 
    case MkTestClassE_NONE_OBJECT : return false; 
    default                       : return true; 
  }
}
 
MK_STRN MK(GetClassNameFromObject) (
  OT_Prefix_ARGS
  OT_SELF_T object
) {
  OT_CLS_T cls = Tcl_GetObjectAsClass(object);
  // the "type" of a "Class" is "Class"
  //return OT_LNG_NAME_FROM_OBJECT(object);
  if (cls != NULL) return "Class";
/*
  if (cls != NULL) {
    // delete namespace
    char * run = Tcl_GetString(Tcl_GetObjectName(interp,object));
    char * last = run;
    while (*run != '\0') {
      if (*run == ':') last = run+1;
      run++;
    }
    return last;
  }
*/
 
  // only a real object
  RL_init( RL_O(0,RG(infoObjectClassCmd)) ) ; RL_O(1,Tcl_GetObjectName(interp,object))
  OT_OBJ_T classO = MK(EvalObjvAR)(MK_RT_CALL NULL,interp,0,RL_objv(2));
  check_NULL(classO) return Tcl_GetStringResult(interp);
  return OT_LNG_NAME_FROM_OBJ(classO);
}
 
MK_STRN MK(GetTypeFromObj) (
  OT_Prefix_ARGS
  OT_OBJ_T Obj,
  bool *isObject
)
{
  static MkThreadLocal char buf[50];
  strncpy(buf, Obj->typePtr ? Obj->typePtr->name : "unknown", 50);
  buf[50-1] = '\0';
 
  if (strcmp(buf,"unknown")!=0 && strcmp(buf,"string")!=0 && strcmp(buf,"cmdName")!=0)
    goto end;
  
  OT_SELF_T object = Tcl_GetObjectFromObj(interp,Obj);
  if (object) {
    if (isObject) *isObject=true;
    return MK(GetClassNameFromObject)(OT_Prefix_CALL object);
  }
end:
  if (isObject) *isObject=false;
  return buf;
}
 
MK_STRN MK(ClassName) (
  OT_Prefix_ARGS
  OT_OBJ_T lngO,
  bool        doShort
)
{
  static MkThreadLocal char buffer[50] = {0};
  strncpy(buffer,lngO->typePtr ? lngO->typePtr->name : "unknown", 50);
  buffer[50-1] = '\0';
  OT_OBJ_T classO = NULL;
 
  OT_SELF_T  objO = Tcl_GetObjectFromObj (interp, lngO);
  if (objO == NULL)   goto type;
 
  OT_CLS_T cls = Tcl_GetObjectAsClass(objO);
  if (cls)  {
    classO = Tcl_GetObjectName(interp, objO);
    goto end;
  }
 
  RL_init( RL_O(0,RG(infoObjectClassCmd)) ) ; RL_O(1,lngO)
  classO = MK(EvalObjvAR)(MK_RT_CALL NULL,interp,0,RL_objv(2));
 
end:
  if (classO != NULL) {
    MK_STRN name = Tcl_GetString(classO);
    if (doShort) {
      // 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;
  } else {
    return "unknown";
  }
type:
  if (strcmp(buffer,"cmdName")==0) {
    return Tcl_GetString(lngO);
  } else {
    return buffer;
  }
}
 
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;
    OtErrorCheckLngGoto (Tcl_ListObjGetElements(interp,argsO,&listObjc,&listObjv));
    MK(LngTupleToMkBufferListS)( MK_RT_CALL interp,listObjc,listObjv,&__skip,retP);
  }
  return MK_OK;
error:
  return MK_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"
 
//
// *********************************************************************************
//
 
/* moved to mk_inline
int MK(EvalObjv) (
  OT_ENV_T interp,
  int               objc,
  OT_OBJ_T const    objv[],
  int               flags
) {
  int i,ret;
//printAry(objc,objv)
  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;
}
*/
 
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
}
 
/*
OT_OBJ_T MK(EvalObjvVR) (
  OT_VARFRAME_ARGS     ,
  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++) {
    if (objc >= (SIZE-1)) {
      Tcl_SetResult(interp, "EVAL-ERROR: size in MkEvalObjvVA is limited to " xstr(SIZE), TCL_STATIC);
      return NULL;
    }
  }
  va_end(ap);
//printAry2("objv",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]);
  check_LNG(ret) return NULL;
  #undef SIZE
  OT_OBJ_T result = OT_VARFRAME_OBJ_RESULT(interp);
//printLng(result)
  return result;
}
*/
 
OT_OBJ_T MK(EvalObjvAR) (
  OT_VARFRAME_ARGS  ,
  OT_ENV_T interp,
  int               flags,
  int               objc,
  OT_OBJ_T          *objv
)
{
//printAry2("objv",objc,objv)
  int ret = Tcl_EvalObjv (interp, objc, objv, flags);
  //int ret = MK(EvalObjv) (interp, objc, objv, flags);
  check_LNG(ret) return NULL;
  OT_OBJ_T result = OT_VARFRAME_OBJ_RESULT(interp);
//printLng(result)
  return result;
}
 
/*
void MK(PrintLngObjAsObject)(MK_RT_ARGS OT_ENV_T interp, MK_STRN name, OT_OBJ_T in, MK_STRN proc) {
  OT_SELF_T inO = Tcl_GetObjectFromObj(interp,in);
  if (inO == NULL) {
    MkLogV_2(MK_ERROR_PRINT,proc,0,"%s object = %s\n", name, Tcl_GetStringResult(interp));
  } else {
    OT_SELF_T classO = MK(GetClassObjectFromObj)(MK_RT_CALL interp,in);
    MkLogV_2(MK_ERROR_PRINT,proc,0,"%s object = %s, class = %s\n", name, 
      OT_LNG_NAME_FROM_OBJECT(inO), OT_LNG_NAME_FROM_OBJECT(classO));
  }
}
*/
 
/*
int MK(NewEnsemble) (
  OT_ENV_T interp,
  const char *          name,
  OT_NS_T               ns,
  const OtObjProcDefS   type[],
  ClientData            clientData
) {
  Tcl_DString buffer;
  // 1. create ensemble
  Tcl_Command  ensembleCmd = Tcl_CreateEnsemble(interp, name, ns, 0);
  // 2. create commands
  OT_OBJ_T subcommandsL = Tcl_NewListObj(0,NULL);
  for (int i=0; type[i].version != 0; i++) {
    Tcl_DStringInit(&buffer);
    Tcl_DStringAppend(&buffer,ns->fullName,-1);
    Tcl_DStringAppend(&buffer,"::",-1);
    Tcl_DStringAppend(&buffer,type[i].name,-1);
    check_NULL  ( Tcl_CreateObjCommand(interp, Tcl_DStringValue(&buffer), 
                    type[i].callProc,clientData,type[i].deleteProc))
      goto error;
    check_LNG   (Tcl_ListObjAppendElement(interp,subcommandsL,Tcl_NewStringObj(type[i].name,-1)))
      goto error;
  }
  // 3. add "subcommands"
  check_LNG (Tcl_SetEnsembleSubcommandList(interp,ensembleCmd,subcommandsL)) goto error;
  // 4. add "ensemble" to exportList
  check_LNG (Tcl_Export(interp, ns, name, false)) goto error;
  // 5. import "ensemble" into parent (::tclXYZ)
  Tcl_DStringFree(&buffer); 
  Tcl_DStringAppend(&buffer,ns->fullName,-1); 
  Tcl_DStringAppend(&buffer,"::",-1); 
  Tcl_DStringAppend(&buffer,name,-1);
  check_LNG (Tcl_Import(interp, ns->parentPtr, Tcl_DStringValue(&buffer), true )) goto error;
  
  return TCL_OK;
error:
  return TCL_ERROR;
}
*/
 
int MK(FillNamespace) (
  OT_ENV_T            interp,
  OT_NS_T             ns,
  const OtObjProcDefS type[],
  ClientData          clientData
) {
  Tcl_DString buffer;
  // 2. create commands
  for (int i=0; type[i].version != 0; i++) {
    Tcl_DStringInit(&buffer);
    Tcl_DStringAppend(&buffer,ns->fullName,-1);
    Tcl_DStringAppend(&buffer,"::",-1);
    Tcl_DStringAppend(&buffer,type[i].name,-1);
    check_NULL  ( Tcl_CreateObjCommand(interp, Tcl_DStringValue(&buffer), 
                    type[i].callProc,clientData,type[i].deleteProc))
      goto error;
  }
  return TCL_OK;
error:
  return TCL_ERROR;
}
 
MK_STRN MK(ObjvToString) (MK_RT_ARGS MK_STRN cls, TCL_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;
}
 
MK_STR MK(PrintLngObj) (
  OT_Prefix_ARGS
  MK_STRN   header,
  OT_OBJ_T  Obj
) {
//printP(Obj)
  MK_OBJ retObj = NULL;
  bool isObject;
  MK_STRN type = MK(GetTypeFromObj) (OT_Prefix_CALL Obj, &isObject);
  if (isObject) OT_LNG_OBJECT_IS_3(Obj, &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),Obj->refCount, Tcl_IsShared(Obj), retObj, (retObj?retObj->self:NULL)
 
/*
  printV("ObjName <%20s>, ObjPtr, <%p>, ObjRef  <%i>\n", Tcl_GetString(Obj), Obj, Obj->refCount)
if (retObj) {
  OT_OBJ_T nameO = OT_SELF_NAME_O(retObj);
  printV("NameStr <%20s>, NamePtr <%p>, NameRef <%i>\n", Tcl_GetString(nameO), nameO, nameO->refCount)
 
  OT_OBJ_T cmdO = Tcl_NewObj();
  Tcl_GetCommandFullName(interp,OT_SELF_CMD_O(retObj),cmdO);
  printV("CmdStr  <%20s>, CmdPtr  <%p>, CmdRef  <%i>\n", Tcl_GetString(cmdO), cmdO, cmdO->refCount)
}
*/
 
  // fill the buf and get the len back
  if (header) {
    MkBufferSetV(MkBUF(&MK_RT_REF.tbuf), "%-20s: %s " objF, header, Tcl_GetString (Obj), objA);
  } else if (retObj) {
/*
    MQ_CTX ctx = MqCtx(retObj);
    if (ctx) {
      MkBufferSetV(MkBUF(&MK_RT_REF.tbuf), "%s(%s) " objF, Tcl_GetString (Obj), MqConfigGetName(ctx), objA);
    } else {
      MkBufferSetV(MkBUF(&MK_RT_REF.tbuf), "%s " objF, Tcl_GetString (Obj), objA);
    }
*/
    MkBufferSetV(MkBUF(&MK_RT_REF.tbuf), "%s " objF, Tcl_GetString (Obj), objA);
        
  } else {
    MkBufferSetV(MkBUF(&MK_RT_REF.tbuf), "%s " objF, Tcl_GetString (Obj), objA);
 
  }
 
  #undef objF
  #undef objA
 
  return MkBUF_R(&MK_RT_REF.tbuf).storage.first.S;
}
 
 
// BEGIN-enum - created by 'tcl_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;
  OtErrorCheckLng (Tcl_GetIndexFromObjStruct (interp, enumE, &keys,
      sizeof(struct LookupClassS), "enum", TCL_EXACT, &index));
  *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;
  OtErrorCheckLng (Tcl_GetIndexFromObjStruct (interp, enumE, &keys,
      sizeof(struct LookupClassS), "enum", TCL_EXACT, &index));
  *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;
  OtErrorCheckLng (Tcl_GetIndexFromObjStruct (interp, enumE, &keys,
      sizeof(struct LookupClassS), "enum", TCL_EXACT, &index));
  *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;
  OtErrorCheckLng (Tcl_GetIndexFromObjStruct (interp, enumE, &keys,
      sizeof(struct LookupClassS), "enum", TCL_EXACT, &index));
  *ret = keys[index].val;
  return TCL_OK;
}
 
// END-enum - created by 'tcl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// SOFT: delete META if TCL is already "on delete" 
// CALLED from: "<destructor>", "META-DATA-Destructor"
static void MK(AtomMetaDelete) (MK_MNG mng)
{ 
  check_NULL(mng) return;
  MK_OBJ obj = MkObj(mng);
  check_NULL(obj) return;
  MkRtSetup_ON(obj);
//printObjO(obj);
  // SELF is alredy "dead"
  MkRefDecrWithoutSelf(obj);
}
 
static int MK(AtomMetaClone) ( OT_ENV_T interp,  ClientData clientData, ClientData *out)
{
  *out = clientData;
  return TCL_OK;
}
 
const Tcl_ObjectMetadataType MK(AtomMeta) = {
  TCL_OO_METADATA_VERSION_CURRENT,
  "MK_OBJ",
  MK(AtomMetaDelete),
  MK(AtomMetaClone)
};
 
 
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
  OtErrorCheckLng (Tcl_GetIndexFromObj (interp, objv[__skip++], option, "subcommand", 0, &index));
 
  // do the work
  switch ((enum options) index) {
    case OBJECT:
      WNA(1,1,"tclObj");
      Tcl_SetResult (interp, MK(PrintLngObj) (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( RL_O(0,RG(infoLevelCmd)) )
      OT_OBJ_T lvlObj = MK(EvalObjvAR)(MK_RT_CALL varframe,interp,0,RL_objv(1));
      check_NULL(lvlObj) goto varerror;
      int lvl;
      check_LNG(Tcl_GetIntFromObj(interp,lvlObj,&lvl)) goto varerror;
      char *STR;
      fputs("print var ",stderr);
      if (lvl > 0) {
        RL_init( RL_O(0,RG(infoLevelCmd)) RL_NewI(1,0) )
        lvlObj = MK(EvalObjvAR)(MK_RT_CALL varframe,interp,0,RL_objv(2));
        check_NULL(lvlObj) goto varerror;
        OT_OBJ_T nameObj;
        check_LNG(Tcl_ListObjIndex(interp,lvlObj,0,&nameObj)) goto varerror;
        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;
varerror:
      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 lngO = 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
  OtErrorCheckLng (Tcl_GetIndexFromObj (interp, objv[__skip], constant, "constant", 0, &index));
 
  // do the work
  switch ((enum constants) index) {
    case  MAXY:  lngO  =  Tcl_NewIntObj      (SCHAR_MAX);  break;
    case  MINY:  lngO  =  Tcl_NewIntObj      (SCHAR_MIN);  break;
    case  MAXS:  lngO  =  Tcl_NewIntObj      (SHRT_MAX);   break;
    case  MINS:  lngO  =  Tcl_NewIntObj      (SHRT_MIN);   break;
    case  MAXI:  lngO  =  Tcl_NewLongObj     (INT_MAX);    break;
    case  MINI:  lngO  =  Tcl_NewLongObj     (INT_MIN);    break;
    case  MAXF:  lngO  =  Tcl_NewDoubleObj   (FLT_MAX);    break;
    case  MINF:  lngO  =  Tcl_NewDoubleObj   (FLT_MIN);    break;
    case  MAXW:  lngO  =  Tcl_NewWideIntObj  (LLONG_MAX);  break;
    case  MINW:  lngO  =  Tcl_NewWideIntObj  (LLONG_MIN);  break;
    case  MAXD:  lngO  =  Tcl_NewDoubleObj   (DBL_MAX);    break;
    case  MIND:  lngO  =  Tcl_NewDoubleObj   (DBL_MIN);    break;
  }
 
  Tcl_SetObjResult (interp, lngO);
  return TCL_OK;
}
 
/*****************************************************************************/
/*                                                                           */
/*                               enum                                        */
/*                                                                           */
/*****************************************************************************/
 
// BEGIN-Enum-ToString - created by 'tcl_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 'tcl_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// BEGIN-MkKernel - created by 'tcl_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_TCL_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_TCL_API
 
// END-MkKernel - created by 'tcl_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// ---------------------------------------------------------------------------------------
 
__attribute__((unused)) const static OtObjProcDefS MK(sOtClassDef)[] = {
  {VER, "print"               , NS(Print_Class_Cmd)                     , NULL, NULL},
  {VER, "const"               , NS(Const_Class_Cmd)                     , NULL, NULL},
// BEGIN-CLASS - created by 'tcl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// doc-key: MkKernel,EnumFunc,sco
  {VER, "ErrorE_FromInt"      , NS(MkKernel_ErrorE_FromInt)             , NULL, NULL},
  {VER, "IdSE_FromInt"        , NS(MkKernel_IdSE_FromInt)               , NULL, NULL},
  {VER, "TimeoutE_FromInt"    , NS(MkKernel_TimeoutE_FromInt)           , NULL, NULL},
  {VER, "TypeE_FromInt"       , NS(MkKernel_TypeE_FromInt)              , NULL, NULL},
 
// doc-key: MkKernel,EnumFunc,sm_
  {VER, "ErrorE_ToInt"        , NS(MkKernel_ErrorE_ToInt)               , NULL, NULL},
  {VER, "ErrorE_ToString"     , NS(MkKernel_ErrorE_ToString)            , NULL, NULL},
  {VER, "IdSE_ToInt"          , NS(MkKernel_IdSE_ToInt)                 , NULL, NULL},
  {VER, "IdSE_ToString"       , NS(MkKernel_IdSE_ToString)              , NULL, NULL},
  {VER, "TimeoutE_ToInt"      , NS(MkKernel_TimeoutE_ToInt)             , NULL, NULL},
  {VER, "TimeoutE_ToString"   , NS(MkKernel_TimeoutE_ToString)          , NULL, NULL},
  {VER, "TypeE_ToInt"         , NS(MkKernel_TypeE_ToInt)                , NULL, NULL},
  {VER, "TypeE_ToString"      , NS(MkKernel_TypeE_ToString)             , NULL, NULL},
 
// doc-key: MkKernel,Setup,sm_
  {VER, "Cleanup"             , NS(MkKernel_Cleanup)                    , NULL, NULL},
  {VER, "Setup"               , NS(MkKernel_Setup)                      , NULL, NULL},
 
// END-CLASS - created by 'tcl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
  {0, NULL, NULL, NULL, NULL}
};
 
// ---------------------------------------------------------------------------------------
// not used.
 
__attribute__((unused))  const static OtObjProcDefS MK(sInstanceDef)[] = {
// BEGIN-OBJ - created by 'tcl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// → no data
 
// END-OBJ - created by 'tcl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
  {0, NULL, NULL, NULL, NULL}
};
 
 
// called on every NEW thread
OT_TCL_EXTERN int Tclmkkernel_Init ( OT_ENV_T interp ) 
{
  // check for the right tcl version
  if (Tcl_InitStubs (interp, "8.6", true) == NULL) {
    return TCL_ERROR;
  }
  if (Tcl_OOInitStubs (interp) == NULL) {
    return TCL_ERROR;
  }
 
  // setup libmkkernel
  MkSetup();
  MkRtSetup_NULL;
 
  // announce my package
  OtErrorCheckLng (Tcl_PkgProvide (interp, "tclmkkernel", META_VERSION ));
 
  // pkg_mkIndex hack → only "Tcl_PkgProvide" is required
  if (Tcl_GetVar(interp,"::tcl::newPkgs", TCL_GLOBAL_ONLY) != NULL) return TCL_OK;
 
  // toplevel namespace
  OT_NS_T ns = Tcl_CreateNamespace   (interp, "tclmkkernel", NULL, NULL);
  check_NULL(ns) return TCL_ERROR;
 
  // add PACKAGE commands
  OtErrorCheckLng( MK(FillNamespace)          (interp,ns,MK(sOtClassDef),NULL));
 
  // ATTENTION: MK(ClassDef) "class-resolution" require that "MkObjectC" is always first
  // BEGIN-CLASS-call-init - created by 'tcl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  OtErrorCheckLng( NS(pMkObjectC_Init)       (MK_RT_CALL interp, ns)) ;
  OtErrorCheckLng( NS(pMkBufferC_Init)       (MK_RT_CALL interp, ns)) ;
  OtErrorCheckLng( NS(pMkBufferListC_Init)   (MK_RT_CALL interp, ns)) ;
  OtErrorCheckLng( NS(pMkLogFileC_Init)      (MK_RT_CALL interp, ns)) ;
  OtErrorCheckLng( NS(pMkErrorC_Init)        (MK_RT_CALL interp, ns)) ;
  OtErrorCheckLng( NS(pMkRuntimeC_Init)      (MK_RT_CALL interp, ns)) ;
  OtErrorCheckLng( NS(pMkBufferStreamC_Init) (MK_RT_CALL interp, ns)) ;
 
  // END-CLASS-call-init - created by 'tcl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // init libmkkernel global data
    if (MK_RT_REF.mkThreadData.ptr == NULL) {
      MK_RT_REF.mkThreadData = (MkThreadDataS) { "tclmkkernel", interp } ;
    } else if (strcmp(MK_RT_REF.mkThreadData.name,"tclmkkernel") == 0) {
      Tcl_SetErrorCode(interp, "TCLMK", "INIT", "NON-NULL", NULL);
      Tcl_SetResult(interp,"error: 'MK_RT_REF.mkThreadData' not NULL as expected",TCL_STATIC);
      return TCL_ERROR;
    } else {
      Tcl_SetErrorCode(interp, "TCLMK", "INIT", "WRONG-NAME", NULL);
      Tcl_SetResult(interp,"error: 'MK_RT_REF.mkThreadData' already in use with extension: ",TCL_STATIC);
      Tcl_AppendResult(interp, MK_RT_REF.mkThreadData.name, NULL);
      return TCL_ERROR;
    }
 
  // already done?
  if (MK(reggv)[0] == NULL) {
 
    int key=0;
#define regTclObj(str)        MK(reggv)[MK(str)=key++] = Tcl_NewStringObj(#str,-1);Tcl_IncrRefCount(MK(reggv)[MK(str)]);
#define regTclObj2(def,str)   MK(reggv)[MK(def)=key++] = Tcl_NewStringObj(str,-1);Tcl_IncrRefCount(MK(reggv)[MK(def)]);
#include "MkRegistry_tcl.h"
#undef regTclObj
#undef regTclObj2
  }
 
  // get TCL internal data types
  MK(tcl_LONG)     =  Tcl_GetObjType("int") ;
  MK(tcl_WIDE)     =  Tcl_GetObjType("wideInt") ;
  MK(tcl_DOUBLE)   =  Tcl_GetObjType("double") ;
  MK(tcl_BOOLEAN)  =  Tcl_GetObjType("booleanString") ;
  MK(tcl_INDEX)    =  Tcl_GetObjType("index") ;
 
  // export namespace
  OtErrorCheckLng( Tcl_Export(interp, ns, "Mk*C", false ) ) ;
 
  return TCL_OK;
}
 
OT_TCL_EXTERN int Tclmkkernel_Unload ( OT_ENV_T interp, int flags) 
{
  MkCleanup();
 
  return TCL_OK;
}