MqFactoryC_tcl.c

Go to the documentation of this file.

 
/* LABEL-INIT */
 
/* LABEL-START */
 
#define   META_FILE_NAME      "MqFactoryC_tcl.c"
 
#include  "LibMqMsgque_private_tcl.h"
 
#define   OT_CLASS            NS(MqFactoryC)
#define   OT_CLASS_NAME       "MqFactoryC"
 
#define   OBJECT2FCT(O)   MkAssertCastM(MqFactoryC,(Tcl_ObjectGetMetadata(O, &MK(AtomMeta))))
 
// TCL class
MkThreadLocal OT_CLS_T OT_CLASS = NULL;
 
// META class
static MkThreadLocal MK_TYP MqFactoryCTT = NULL;
MkThreadLocal OT_OBJ_T MQ(MqFactoryC_MK_NULL) = NULL;
 
// META: ObjNew feature: selfCreate will be called from "ObjNew->MkSelfNew" if MkObj need a SELF pointer
static MK_PTR NS(MqFactoryC_selfCreate) (MK_RT_ARGS MK_OBJ const obj, MK_PTR const env) {
  OT_ENV_T interp = env;
  return MK(AtomCreate) (MK_RT_CALL interp,obj,OT_CLASS,NULL,NULL);
}
// META: is called when the META object is destroyed and SELF does NOT belongs to the META.
static void NS(MqFactoryC_selfDelete) (MK_RT_ARGS MK_PTR selfP, MK_PTR const env) {
  OT_SELF_T selfO = selfP;
  OT_ENV_T  interp = env;
  MK(AtomDeleteHard) (MK_RT_CALL interp, selfO);
}
// META: is called when the META object is destroyed and SELF does NOT belong to the META.
static void NS(MqFactoryC_selfUnlink) (MK_RT_ARGS MK_PTR selfP, MK_PTR const env) {
  OT_SELF_T selfO = selfP;
  OT_ENV_T  interp = env;
  MK(AtomUnlink) (MK_RT_CALL interp, selfO);
}
 
// ATTENTION: TCL has no "Unlink" because the "Tcl_ObjectSetMetadata(selfO,&MK(AtomMeta),NULL);" call
// also the destructor
 
#define   OT_SETUP_hdl_static_constr_pre
#define   OT_SETUP_hdl_static_constr \
  OT_SETUP_hdl_static_constr_pre; \
  OT_SETUP_hdl_static
 
#define   OT_SETUP_hdl_static     \
  int __skip=Tcl_ObjectContextSkippedArgs(objCtx); \
  AllRtSetup_NULL; \
  __attribute__((unused)) OT_SELF_T selfO = Tcl_ObjectContextObject(objCtx); \
  __attribute__((unused)) MK_TYP hdl = MqFactoryC##_TT;
 
#define   OT_SETUP_hdl              SetupHdlFromMetaData_2(FCT,MQ_FCT);
#define   OT_SETUP_hdl__null_allow  SetupHdlFromMetaData__null_allow_2(FCT,MQ_FCT);
#define   OT_SETUP_hdl_destr        SetupHdlFromMetaData__null_allow_2(FCT,MQ_FCT);
 
#define   OT_SETUP_hdl_constr_pre
#define   OT_SETUP_hdl_constr \
  OT_SETUP_hdl_constr_pre; \
  int __skip=Tcl_ObjectContextSkippedArgs(objCtx); \
  AllRtSetup_NULL; \
  MK_RT_UNUSED OT_SELF_T selfO = Tcl_ObjectContextObject(objCtx); \
  MQ_FCT hdl = (MQ_FCT) &MkERROR;
 
#if !defined(SetupRtFromHdl_XN)
  #define SetupRtFromHdl_XN(hdl)  AllRtSetup_XN(hdl)
  #define SetupRtFromHdl_X(hdl)   AllRtSetup_X(hdl)
#endif
 
// initialize the TCL and MO class specific object
#define   ClassInit \
  /* if not already done, initialize NEW MQ type */ \
  if (MqFactoryCTT == NULL) MqFactoryCTT = MqFactorySTT; \
 \
  /* protect against double call */ \
  if (MqFactoryCTT->selfCreate == NS(MqFactoryC_selfCreate)) return MK_OK; \
 \
  /* add "selfCreate" and "selfDelete" feature to the MQ-Class */ \
  MqFactoryCTT->selfCreate    = NS(MqFactoryC_selfCreate); \
  MqFactoryCTT->selfDelete    = NS(MqFactoryC_selfDelete); \
  MqFactoryCTT->selfUnlink    = NS(MqFactoryC_selfUnlink); \
 \
  /* create the TCL-class */ \
  OT_SELF_T classO = MK(ClassDef)(interp,ns,MqFactoryCTT); \
  check_NULL(classO) goto error; \
  OT_CLASS = Tcl_GetObjectAsClass(classO); \
 \
  /* create the TCL static Methods */ \
  static MkThreadLocal OtUnknownS NS(sClassUnknown) = {OT_UNKNOWN_CLASS}; \
  check_LNG(MK(UnknownSetup) (interp,classO,NS(sOtClassDef),&NS(sClassUnknown))) goto error; \
 \
  /* create the TCL instance Methods */ \
  static MkThreadLocal OtUnknownS NS(sInstanceUnknown) = {OT_UNKNOWN_INSTANCE}; \
  check_LNG(MK(UnknownSetup) (interp,classO,NS(sInstanceDef),&NS(sInstanceUnknown))) goto error; \
 \
  /* define the "NULL" object */ \
  MQ(MqFactoryC_MK_NULL) = Tcl_GetObjectName(interp, \
    MK(AtomCreate) (MK_RT_CALL interp,  NULL /*obj*/, OT_CLASS, "MK_NULL" /*name*/, "::tclmqmsgque::MqFactoryC" /*ns*/) \
  ); \
  Tcl_IncrRefCount(MQ(MqFactoryC_MK_NULL));
 
#define VER TCL_OO_METHOD_VERSION_CURRENT
 
/* LABEL-END */
 
#undef META_CONTEXT_S
#define META_CONTEXT_S          mqctx
 
 
extern MkThreadLocal bool NS(inMain);
 
static char msg[] = "ERROR: a 'MqFactoryC' command was called OUTSIDE"                               \
" of the 'tclmqmsgque::Main'-proc.\n"                                                                \
"\n"                                                                                                 \
"Description: a 'tclmqmsgque SERVER' listen on a port and start for every incoming connetion\n"      \
"a sub-server. If a thread sub-server was choosen... with the '--thread' commandline-option...\n"    \
"a new thread is created. To setup a new thread the INITIAL tcl-file is RE-READ again and\n"         \
"PROCS and VARIABLES are initialized. The NEW thread has it's own 'Main'-proc and so... the\n"       \
"original 'Main'-proc is skipped. If a 'factory' command is used OUTSIDE of the 'Main'-proc...\n"    \
"the initial 'Factory' will be created TWICE. The creation of multiple 'Factory' objects...\n"       \
"with the SAME name... is an ERROR.";                                                                \
 
#undef OT_SETUP_hdl_constr_pre
#define OT_SETUP_hdl_constr_pre \
  if (NS(inMain) == false) {                                                           \
    Tcl_SetResult(interp,msg,TCL_STATIC);                                              \
    return TCL_ERROR;                                                                  \
  }
 
#undef OT_SETUP_hdl_static_constr_pre
#define OT_SETUP_hdl_static_constr_pre OT_SETUP_hdl_constr_pre
 
static void NS(sFactoryDataFree) ( MK_RT_ARGS MK_PTR *dataP)
{
  assert (dataP != NULL && *dataP != NULL);
  SETUP_interp;
  if (Tcl_InterpDeleted(interp)) return;
  OT_REF_DECR_AND_NULL(*dataP);   // OT_REF_INCR in: CheckConstructor 
}
 
static void NS(sFactoryDataCopy) ( MK_RT_ARGS MK_PTR *dataP)
{
  assert (dataP != NULL && *dataP != NULL);
  *dataP = OT_OBJ_COPY(*dataP);
}
 
 
// BEGIN-DOC - created by 'tcl_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
// doc-key: MqFactoryC,MqFactory,sCc,func
#define Add_doc "MqFactoryC [MqFactoryC Add constructor:class ?ident:string=\"MK_NULL\"?]"
#define CTOR_doc "MqFactoryC [MqFactoryC CTOR constructor:class ?ident:string=\"MK_NULL\"?]"
 
// doc-key: MqFactoryC,MqFactory,sc_,func
#define Get_doc "MqFactoryC [MqFactoryC Get ?ident:string=\"\"?]"
#define GetCalled_doc "MqFactoryC [MqFactoryC GetCalled ?ident:string=\"\"?]"
#define GetCalledL_doc "MqFactoryC [MqFactoryC GetCalledL largs:MkBufferListC]"
#define GetNull_doc "MqFactoryC [MqFactoryC GetNull]"
#define HandleResolve_doc "MqFactoryC [MqFactoryC HandleResolve netHdl:MK_HDL]"
#define Instances_doc "MqFactoryC [MqFactoryC Instances]"
 
// doc-key: MqFactoryC,MqFactory,sm_,func
#define DefaultIdent_doc "string [MqFactoryC DefaultIdent]"
#define InitialIdent_doc "string [MqFactoryC InitialIdent]"
#define LogAll_doc "MqFactoryC LogAll ?callfunc:string=\"MK_NULL\"?"
 
// doc-key: MqFactoryC,MqFactory,oCx,func
#define Dup2_doc "MqFactoryC [$fct Dup2 ident:string] (const)"
 
// doc-key: MqFactoryC,MqFactory,oc_,func
#define Default_doc "MqFactoryC [$fct Default]"
#define Initial_doc "MqFactoryC [$fct Initial]"
#define Next_doc "MqFactoryC [$fct Next]"
#define Prev_doc "MqFactoryC [$fct Prev]"
 
// doc-key: MqFactoryC,MqFactory,oco,func
#define New_doc "MqContextC [$fct New]"
 
// doc-key: MqFactoryC,MqFactory,om_,func
#define GetOriginalIdent_doc "string [$fct GetOriginalIdent] (const)"
// skip class-overload: HandleGet → MkObjectHandleGet
// skip class-overload: Log → MkObjectLog
 
// END-DOC - created by 'tcl_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
 
/*
-> NOT required because Tcl_CreateThread does NOT more than the MQ SysServerThread..
 
static Tcl_ThreadCreateType
SysServerThreadMain( ClientData clientData)
{   
  MqSysServerThreadMain((struct MqSysServerThreadMainS *)clientData);
  TCL_THREAD_CREATE_RETURN;
}
 
static enum MkErrorE SysServerThread (
  MK_RT_ARGS
  MQ_CTX const context,
  struct MqSysServerThreadMainS * const argP,
  MK_STRN  name,
  int thread_status,
  struct MkIdS * idP
)
{
  Tcl_ThreadId tid;
 
  // after a "thread" no "fork" is possible
  MqContextC_T_X(context)->ignoreFork = true;
 
  // start thread as "tcl" thread
  if (Tcl_CreateThread(&tid,SysServerThreadMain, argP, TCL_THREAD_STACK_DEFAULT, TCL_THREAD_NOFLAGS) != TCL_OK)
  {
    return MkErrorSetV_2M(context, "can not start server '%s'", name);
  }
 
  // save tid
  (*idP).val = (MK_IDNT)tid;
  (*idP).type = MK_ID_THREAD;
 
  return MK_OK;
}
*/
 
#include "valgrind/callgrind.h"
 
static enum MkErrorE NS(sFactoryCTor) ( MQ_CALLBACK_FACTORY_CTOR_ARGS )
{
  OT_ENV_T interp = (OT_ENV_T) MK_RT_REF.mkThreadData.ptr;
 
//printSTACK0()
//MkObjLog(fct);
 
  MQ_CTX      mqctx = NULL;
  OT_SELF_T   retObject = NULL;
  OT_CLS_T    createC = NULL;
  OT_OBJ_T tmplObj = tmpl ? META2VAL_X(tmpl) : NULL;
 
//#define CALLGRIND_DEBUG
 
  if (create == MQ_FACTORY_NEW_THREAD) {
#ifdef CALLGRIND_DEBUG
printTxt("start CALLGRIND_ZERO_STATS")
printSTACK_0()
CALLGRIND_ZERO_STATS;
#endif
    interp = Tcl_CreateInterp();
    // tmpl→MK_ERROR_DEFAULT 25.11.2019 aotto
    check_LNG(Tcl_Init(interp)) {
      OT_ERROR_LNG_2_META(MK_ERROR_DEFAULT);
      return MK_ERROR;
    }
    // mark new interpreter as "MQ_STARTUP_IS_THREAD"
    Tcl_SetVar (interp, "MQ_STARTUP_IS_THREAD", "yes", TCL_GLOBAL_ONLY);
    // source initial script
    check_LNG(Tcl_EvalFile(interp, MqInitGetArg0()->data[1]->storage.first.C)) {
      OT_ERROR_LNG_2_META(MK_ERROR_DEFAULT);
      return MK_ERROR;
    }
    // set script
    check_NULL(MK(InfoScript)(MK_RT_CALL interp, MqInitGetArg0()->data[1]->storage.first.C)) {
      OT_ERROR_LNG_2_META(MK_ERROR_DEFAULT);
      return MK_ERROR;
    }
#ifdef CALLGRIND_DEBUG
CALLGRIND_DUMP_STATS_AT("tcl_thread_startup");
printTxt("end CALLGRIND_ZERO_STATS")
#endif
  }
 
  // reflection -> "child" use the same "OT_CLS_T" as tmpl=parent
  if (tmplObj && create & (MQ_FACTORY_NEW_CHILD|MQ_FACTORY_NEW_SLAVE|MQ_FACTORY_NEW_FILTER)) {
    OT_SELF_T clsO = MK(GetClassObjectFromObj)(MK_RT_CALL interp, tmplObj);
    if (clsO) createC = Tcl_GetObjectAsClass(clsO);
  } else {
 
    // BUG FIX (13.Nov.2020) using a OT_OBJ_T as fct_ctor.data create mustic bugs with single
    // "createO" return from Tcl_GetObjectFromObj on DIFFERENT threads… This bug only happen
    // if NO debugging tool is invilved
 
    if (fct->fct_ctor.data) {
      OT_OBJ_T createObj = fct->fct_ctor.data;
      OT_SELF_T createO = Tcl_GetObjectFromObj(interp, createObj);
 
      if (createO == NULL) {
        MkErrorSetC_1E(Tcl_GetStringResult(interp));
        goto error;
      }
      createC = Tcl_GetObjectAsClass(createO);
    } else {
      createC = NS(MqContextC);
    }
//printV("interp=%p, tmplObj=%p, createO=%p, createC=%p\n", interp, tmplObj, createO, createC)
  }
 
  // security check of the OT_CLS_T pointer
  if (createC == NULL) {
    MkErrorSetC_1E("internal error: Factory as 'NULL' OT_CLS_T");
    goto error;
  }
 
  // Call Factory -> Contructor
  OT_OBJ_T lobjv[1];
 
  // 2. add "self"
  // MQ_FACTORY_NEW_THREAD get a NEW "interp" and "tmpl->obj.self" is only defined
  // on the original interp -> no "tmpl" possible -> missing "MqConfigDup"
  if (create & (MQ_FACTORY_NEW_INIT|MQ_FACTORY_NEW_THREAD)) {
    lobjv[0] = RG(nullObj);
  } else {
    lobjv[0] = tmplObj;
  }
 
  // 3. evaluate the script
  retObject = Tcl_NewObjectInstance(interp, createC, NULL, NULL, 1, lobjv, 0);
  check_NULL(retObject) {
    OT_ERROR_LNG_2_META(MK_ERROR_DEFAULT);
    goto error;
  }
 
  // 4. get context
  mqctx = MqCtx(Tcl_ObjectGetMetadata(retObject, &MK(AtomMeta)));
  if (mqctx == NULL) {
    MkErrorSetC_1E("Factory return no MqContextC type");
    goto error;
  }
 
//printLV("222 → <%p>\n", mqctx->setup.Event.data)
 
  // 5. check for MQ error
  MkErrorCheck(MkErrorGetCode_0E());
 
  // 6. do the missing "MqConfigDup" from "2"
  // BUGFIX: without MQ_FACTORY_NEW_CHILD the OT_CONSTRUCTOR_POST prefix will NOT cleanup
  if (tmpl && create & (MQ_FACTORY_NEW_THREAD|MQ_FACTORY_NEW_CHILD|MQ_FACTORY_NEW_FILTER)) {
    MqConfigDup(mqctx, tmpl);
  }
 
  // 7. copy and initialize "setup" data
  // "MQ_FACTORY_NEW_THREAD|MQ_FACTORY_NEW_FORK" is only used to support NON factory startup
  if (tmpl && create & (MQ_FACTORY_NEW_CHILD|MQ_FACTORY_NEW_THREAD|MQ_FACTORY_NEW_FORK)) {
//MkObjLog(tmpl);
    MqSetupDup(mqctx, tmpl);
  }
 
  // tcl-special: default event handler has !no! data and calling just the
  // tcl-event-update function. CHILD does not need to call it too
  if (create & MQ_FACTORY_NEW_CHILD && mqctx->setup.Event.data == NULL) {
    mqctx->setup.Event.fCall = NULL;
  }
  
//printLV("333 → <%p>\n", mqctx->setup.Event.data)
//printXV(mqctx,"333 → MqLinkGetTargetIdent = %s\n", MqLinkGetTargetIdent(mqctx))
  *contextP = mqctx;
  return MK_OK;
 
error:
  *contextP = NULL;
  if (retObject) {
    Tcl_DeleteCommandFromToken(interp, Tcl_GetObjectCommand(retObject));
  }
  return MkErrorStack_0E();
}
 
/*
static void NS(sFactoryDTor) (
  MK_RT_ARGS
  MQ_CTX hdl,
  bool doFactoryCleanup,
  MQ_FCT fct
) {
  if (doFactoryCleanup) {
    SETUP_interp;
//colorRED("hdl<%p>",hdl);
    OT_SELF_T selfO = OT_SELF_X(hdl);
    if (selfO && OT_OBJECT_DELETE_HARD(selfO)) return;
  }
  MqContextDelete(hdl);
}
*/
 
 
// BEGIN-MqFactoryC - created by 'tcl_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
 
// doc-key: MqFactoryC,MqFactoryC-Class-Export,sc_
 
static OT_ProcRet NS(MqFactoryC_HandleResolve) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(HandleResolve_doc);
  MK_HDL netHdl = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NIH (netHdl))
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryHandleResolve (netHdl);
  OT_retObj_SET_FCT(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqFactoryC,MqFactoryC-Class-Export,om_
 
// skip on class-overload: MqFactoryHandleGet → MkObjectHandleGet
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MqFactoryC_HandleGet) (MqFactoryC_ARGS) {OT_ERROR_LNG_RETURN;}
 
// MqFactoryC_Class_TCL_API
 
 
// doc-key: MqFactoryC,MqFactoryC-Class-Introspection,oc_
 
static OT_ProcRet NS(MqFactoryC_Next) (MqFactoryC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Next_doc);
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryNext (hdl);
  OT_retObj_SET_FCT(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqFactoryC_Prev) (MqFactoryC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Prev_doc);
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryPrev (hdl);
  OT_retObj_SET_FCT(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqFactoryC,MqFactoryC-Class-Introspection,sc_
 
static OT_ProcRet NS(MqFactoryC_Instances) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Instances_doc);
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryInstances ();
  OT_retObj_SET_FCT(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqFactoryC_Class_TCL_API
 
 
// doc-key: MqFactoryC,MqFactoryC-Class-Misc,sc_
 
static OT_ProcRet NS(MqFactoryC_GetNull) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(GetNull_doc);
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryGetNull ();
  OT_retObj_SET_FCT(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqFactoryC_Class_TCL_API
 
 
// doc-key: MqFactoryC,MqFactoryC-Get,sc_
 
static OT_ProcRet NS(MqFactoryC_Get) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_VARARGS(0,1,Get_doc);
  MK_STRN ident = "";
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (ident))
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryGet (ident);
  OT_retObj_SET_FCT(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqFactoryC_GetCalled) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_VARARGS(0,1,GetCalled_doc);
  MK_STRN ident = "";
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (ident))
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryGetCalled (ident);
  OT_retObj_SET_FCT(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqFactoryC_GetCalledL) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(GetCalledL_doc);
  MkBufferListCreateTLS_T(largs,10);
  OT_CHECK_REQUIRED(OT_CHECK_BFLN (largs,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryGetCalledL (largs);
  OT_retObj_SET_FCT(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqFactoryC,MqFactoryC-Get,om_
 
static OT_ProcRet NS(MqFactoryC_GetOriginalIdent) (MqFactoryC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetOriginalIdent_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqFactoryGetOriginalIdent (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqFactoryC_Get_TCL_API
 
 
// doc-key: MqFactoryC,MqFactoryC-Misc,oc_
 
static OT_ProcRet NS(MqFactoryC_Default) (MqFactoryC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Default_doc);
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryDefault (hdl);
  OT_retObj_SET_FCT(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqFactoryC_Initial) (MqFactoryC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Initial_doc);
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryInitial (hdl);
  OT_retObj_SET_FCT(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqFactoryC,MqFactoryC-Misc,oco
 
static OT_ProcRet NS(MqFactoryC_New) (MqFactoryC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(New_doc);
  OT_CHECK_NOARGS;
  MQ_CTX val_out;
  MkErrorC_Check(hdl,MqFactoryNew (hdl, NULL, &val_out));
  OT_retObj_SET_CTX(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqFactoryC,MqFactoryC-Misc,om_
 
// skip on class-overload: MqFactoryLog → MkObjectLog
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MqFactoryC_Log) (MqFactoryC_ARGS) {OT_ERROR_LNG_RETURN;}
 
// doc-key: MqFactoryC,MqFactoryC-Misc,sm_
 
static OT_ProcRet NS(MqFactoryC_DefaultIdent) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(DefaultIdent_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqFactoryDefaultIdent ());
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqFactoryC_InitialIdent) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(InitialIdent_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqFactoryInitialIdent ());
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqFactoryC_LogAll) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_VARARGS(0,1,LogAll_doc);
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MqFactoryLogAll (callfunc);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
// MqFactoryC_Misc_TCL_API
 
 
// doc-key: MqFactoryC,MqFactoryC-TOR,oCx
 
static OT_ProcRet NS(MqFactoryC_Dup2) (MqFactoryC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(Dup2_doc);
  MK_STRN ident = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (ident))
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqFactoryDup2 (hdl, ident);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MqFactoryC);
    goto error;
  }
  OT_retObj_SET_FCT(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqFactoryC,MqFactoryC-TOR,sCc
 
static OT_ProcRet NS(MqFactoryC_Add) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_VARARGS(1,2,Add_doc);
  MK_CCP constructor = 0;
  OT_CHECK_REQUIRED(OT_CHECK_CONSTRUCTOR(constructor))
  MK_STRN ident = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (ident))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(ident)) {ident = OT_GET_CONSTR_NAME(constructor);}
  MQ_FCT retVal = MqFactoryAdd (NULL, NS(sFactoryCTor), constructor, NS(sFactoryDataFree), NS(sFactoryDataCopy), NULL, NULL, NULL, NULL, ident);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MqFactoryC);
    goto error;
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_SET_FCT(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqFactoryC_CTOR) (CONSTR_ARGS) {
  OT_SETUP_hdl_constr;
  OT_SETUP_CONSTRUCTOR_ARGS(1,2,CTOR_doc);
  MK_CCP constructor = 0;
  OT_CHECK_REQUIRED(OT_CHECK_CONSTRUCTOR(constructor))
  MK_STRN ident = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (ident))
  if (MkSysStringIsNULL(ident)) {ident = OT_GET_CONSTR_NAME(constructor);}
  MQ_FCT retVal = MqFactoryAdd (NULL, NS(sFactoryCTor), constructor, NS(sFactoryDataFree), NS(sFactoryDataCopy), NULL, NULL, NULL, NULL, ident);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MqFactoryC);
    goto error;
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_CONSTR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqFactoryC_TOR_TCL_API
 
// END-MqFactoryC - created by 'tcl_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
// ---------------------------------------------------------------------------------------
 
static Tcl_MethodType NS(sOtClassDef)[] = {
// BEGIN-CLASS - created by 'tcl_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
// doc-key: MqFactoryC,MqFactory,sCc
  {VER, "Add"                 , NS(MqFactoryC_Add)                      , NULL, NULL},
 
// doc-key: MqFactoryC,MqFactory,sc_
  {VER, "Get"                 , NS(MqFactoryC_Get)                      , NULL, NULL},
  {VER, "GetCalled"           , NS(MqFactoryC_GetCalled)                , NULL, NULL},
  {VER, "GetCalledL"          , NS(MqFactoryC_GetCalledL)               , NULL, NULL},
  {VER, "GetNull"             , NS(MqFactoryC_GetNull)                  , NULL, NULL},
  {VER, "HandleResolve"       , NS(MqFactoryC_HandleResolve)            , NULL, NULL},
  {VER, "Instances"           , NS(MqFactoryC_Instances)                , NULL, NULL},
 
// doc-key: MqFactoryC,MqFactory,sm_
  {VER, "DefaultIdent"        , NS(MqFactoryC_DefaultIdent)             , NULL, NULL},
  {VER, "InitialIdent"        , NS(MqFactoryC_InitialIdent)             , NULL, NULL},
  {VER, "LogAll"              , NS(MqFactoryC_LogAll)                   , NULL, NULL},
 
// END-CLASS - created by 'tcl_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
  {0, NULL, NULL, NULL}
};
 
// ---------------------------------------------------------------------------------------
 
static Tcl_MethodType NS(sInstanceDef)[] = {
// BEGIN-OBJ - created by 'tcl_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
// doc-key: MqFactoryC,MqFactory,oC_
  {VER, "<constructor>"       , NS(MqFactoryC_CTOR)                     , NULL, NULL},
 
// doc-key: MqFactoryC,MqFactory,oCx
  {VER, "Dup2"                , NS(MqFactoryC_Dup2)                     , NULL, NULL},
 
// doc-key: MqFactoryC,MqFactory,oc_
  {VER, "Default"             , NS(MqFactoryC_Default)                  , NULL, NULL},
  {VER, "Initial"             , NS(MqFactoryC_Initial)                  , NULL, NULL},
  {VER, "Next"                , NS(MqFactoryC_Next)                     , NULL, NULL},
  {VER, "Prev"                , NS(MqFactoryC_Prev)                     , NULL, NULL},
 
// doc-key: MqFactoryC,MqFactory,oco
  {VER, "New"                 , NS(MqFactoryC_New)                      , NULL, NULL},
 
// doc-key: MqFactoryC,MqFactory,om_
  {VER, "GetOriginalIdent"    , NS(MqFactoryC_GetOriginalIdent)         , NULL, NULL},
  // skip class-overload: MqFactoryHandleGet → HandleGet, NS(MqFactoryC_HandleGet)
  // skip class-overload: MqFactoryLog → Log, NS(MqFactoryC_Log)
 
// END-OBJ - created by 'tcl_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
  {0, NULL, NULL, NULL, NULL}
};
 
 
int
NS(MqFactoryC_Setup) (MK_RT_ARGS OT_ENV_T interp)
{
  if (!strcmp(MqFactoryDefaultIdent(), "libmqmsgque")) {
    if  ( MqFactoryDefault(
            MqFactoryInitial(
              MqFactoryAdd (MK_ERROR_FORMAT,
                NS(sFactoryCTor), NULL, NULL, NULL, NULL, NULL, NULL, NULL, "tclmqmsgque"
              )
            )
          ) == NULL
        )
    { 
      Tcl_SetResult(interp,"MqFactoryS exception",TCL_STATIC);
      return TCL_ERROR;
    }
  }
  return TCL_OK;
}
 
int NS(pMqFactoryC_Init) ( MK_RT_ARGS OT_ENV_T interp, OT_NS_T ns)
{
  MQ_STATIC_RT;
  ClassInit
  
  return TCL_OK;
error:
  return TCL_ERROR;
}