LibMqMsgque_py.c

Go to the documentation of this file.

 
/* LABEL-NO */
 
#include "LibMqMsgque_py.h"
#include "misc_check_py.h"
 
#define OT_SETUP_hdl            AllRtSetup_NULL; \
                                MK_OBJ hdl = MK_ERROR_PRINT;
#define OT_SETUP_hdl_static     __attribute__((unused)) MK_RT mkrt = MkRT; \
                                __attribute__((unused)) MK_ERR hdl = &MkERROR;
 
#define MqSetupTmpl()
#define MqCleanupTmpl()
 
// MARK_D ################################################################
// -----------------------------------------------------------------------
// documentation order
 
 
 
 
 
 
 
 
 
// --------------------------------------------------------------------------------
 
// BEGIN-EnumDef - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
// UNDEF
 
// END-EnumDef - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
int NS(pMqFactoryC_Setup) (MK_RT_ARGS OT_OBJ_T) ;
 
 
// BEGIN-DOC - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
// doc-key: MqMsgque,EnumFunc,sco,func
#define IdentE_FromInt_doc "MqIdentE IdentE_FromInt(value:int32)"
#define SlaveE_FromInt_doc "MqSlaveE SlaveE_FromInt(value:int32)"
#define StartE_FromInt_doc "MqStartE StartE_FromInt(value:int32)"
#define StatusIsEF_FromInt_doc "MqStatusIsEF StatusIsEF_FromInt(value:int32)"
#define WaitOnEventE_FromInt_doc "MqWaitOnEventE WaitOnEventE_FromInt(value:int32)"
 
// doc-key: MqMsgque,EnumFunc,sm_,func
#define IdentE_ToInt_doc "int32 IdentE_ToInt(value:MqIdentE)"
#define IdentE_ToString_doc "string IdentE_ToString(value:MqIdentE)"
#define SlaveE_ToInt_doc "int32 SlaveE_ToInt(value:MqSlaveE)"
#define SlaveE_ToString_doc "string SlaveE_ToString(value:MqSlaveE)"
#define StartE_ToInt_doc "int32 StartE_ToInt(value:MqStartE)"
#define StartE_ToString_doc "string StartE_ToString(value:MqStartE)"
#define StatusIsEF_ToInt_doc "int32 StatusIsEF_ToInt(value:MqStatusIsEF)"
#define StatusIsEF_ToString_doc "string StatusIsEF_ToString(value:MqStatusIsEF)"
#define WaitOnEventE_ToInt_doc "int32 WaitOnEventE_ToInt(value:MqWaitOnEventE)"
#define WaitOnEventE_ToString_doc "string WaitOnEventE_ToString(value:MqWaitOnEventE)"
 
// doc-key: MqMsgque,MqHelp,sm_,func
#define Help_doc "string Help(tool:string)"
#define HelpMsgque_doc "string HelpMsgque()"
 
// doc-key: MqMsgque,MqInit,sm_,func
#define InitGetArg0_doc "MkBufferListC InitGetArg0()"
#define InitResetArg0_doc "MkBufferListC InitResetArg0()"
#define InitSetArg0_doc "InitSetArg0(?bfl:MkBufferListC...=None?)"
 
// doc-key: MqMsgque,Setup,sm_,func
#define Cleanup_doc "Cleanup()"
#define Setup_doc "Setup()"
 
// END-DOC - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
#define Debug_doc "Debug(prefix:str, ?obj:object?"
 
/*****************************************************************************/
/*                                                                           */
/*                                 Check                                     */
/*                                                                           */
/*****************************************************************************/
 
#include "tmpl/mq_misc_check_lng.h"
 
enum MkErrorE NS(CheckConstructor) (
  OT_Check_ARGS,
  MK_CCP      *retP
) {
  if ((*skipP) >= objc) {
    WrongNumArgs(hdl,(*skipP), objc, -999, +999, arg);
    goto error;
  }
  PyObject  *objV = OT_LNG_OBJV((*skipP)++);
  if (PyObject_IsSubclass(objV,(OT_OBJ_T)&NS(MqContextCR)) == 1) {
    Py_INCREF(objV);
    *retP = (MK_CCP)objV;
  } else if (PyObject_IsSubclass(objV,(OT_OBJ_T)&MK(MkObjectCR)) == 1) {
    WrongTypeOfArgError(OT_LNG_NAME_FROM_CLASS(&NS(MqContextCR)), OT_LNG_NAME_FROM_CLASS((OT_CLS_T)objV));
  } else {
    WrongTypeOfArgError(OT_LNG_NAME_FROM_CLASS(&NS(MqContextCR)), OT_OBJ_TYPE_STRING(objV));
  }
  return MK_OK;
error:
  return OT_ERROR_STACK;
}
 
 
// BEGIN-MqMsgque - created by 'py_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
 
// doc-key: MqMsgque,MqMsgque-Enum,sco
 
static OT_ProcRet NS(MqMsgque_IdentE_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(IdentE_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum MqIdentE value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,MqIdentE_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Mq_enum_OBJ(IdentE,value_out));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqMsgque_SlaveE_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(SlaveE_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum MqSlaveE value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,MqSlaveE_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Mq_enum_OBJ(SlaveE,value_out));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqMsgque_StartE_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(StartE_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum MqStartE value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,MqStartE_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Mq_enum_OBJ(StartE,value_out));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqMsgque_StatusIsEF_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(StatusIsEF_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum MqStatusIsEF value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,MqStatusIsEF_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Mq_enum_OBJ(StatusIsEF,value_out));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqMsgque_WaitOnEventE_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(WaitOnEventE_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum MqWaitOnEventE value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,MqWaitOnEventE_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Mq_enum_OBJ(WaitOnEventE,value_out));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqMsgque,MqMsgque-Enum,sm_
 
static OT_ProcRet NS(MqMsgque_IdentE_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(IdentE_ToInt_doc);
  enum MqIdentE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MqIdentE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MqIdentE_ToInt (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqMsgque_IdentE_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(IdentE_ToString_doc);
  enum MqIdentE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MqIdentE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqIdentE_ToString (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqMsgque_SlaveE_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(SlaveE_ToInt_doc);
  enum MqSlaveE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MqSlaveE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MqSlaveE_ToInt (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqMsgque_SlaveE_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(SlaveE_ToString_doc);
  enum MqSlaveE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MqSlaveE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqSlaveE_ToString (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqMsgque_StartE_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(StartE_ToInt_doc);
  enum MqStartE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MqStartE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MqStartE_ToInt (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqMsgque_StartE_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(StartE_ToString_doc);
  enum MqStartE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MqStartE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqStartE_ToString (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqMsgque_StatusIsEF_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(StatusIsEF_ToInt_doc);
  enum MqStatusIsEF value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MqStatusIsEF,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MqStatusIsEF_ToInt (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqMsgque_StatusIsEF_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(StatusIsEF_ToString_doc);
  enum MqStatusIsEF value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MqStatusIsEF,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqStatusIsEF_ToString (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqMsgque_WaitOnEventE_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(WaitOnEventE_ToInt_doc);
  enum MqWaitOnEventE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MqWaitOnEventE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MqWaitOnEventE_ToInt (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqMsgque_WaitOnEventE_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(WaitOnEventE_ToString_doc);
  enum MqWaitOnEventE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MqWaitOnEventE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqWaitOnEventE_ToString (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqMsgque_Enum_PY_API
 
 
// doc-key: MqMsgque,MqMsgque-Help,sm_
 
static OT_ProcRet NS(MqMsgque_Help) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(Help_doc);
  MK_STRN tool = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (tool))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqHelp (tool));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqMsgque_HelpMsgque) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(HelpMsgque_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqHelpMsgque ());
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqMsgque_Help_PY_API
 
 
// doc-key: MqMsgque,MqMsgque-Init,sm_
 
static OT_ProcRet NS(MqMsgque_InitGetArg0) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(InitGetArg0_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BFL(MqInitGetArg0 ());
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqMsgque_InitResetArg0) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(InitResetArg0_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BFL(MqInitResetArg0 ());
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqMsgque_InitSetArg0) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_VARARGS(0,99,InitSetArg0_doc);
  MkBufferListCreateTLS_T(bfl,10);
  OT_CHECK_OPTIONAL(OT_CHECK_BAC (bfl))
  OT_CHECK_NOARGS;
  MqInitSetArg0 (bfl);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqMsgque_Init_PY_API
 
 
// doc-key: MqMsgque,MqMsgque-Setup,sm_
 
static OT_ProcRet NS(MqMsgque_Cleanup) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Cleanup_doc);
  OT_CHECK_NOARGS;
  MqCleanupTmpl ();
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqMsgque_Setup) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Setup_doc);
  OT_CHECK_NOARGS;
  MqSetupTmpl ();
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqMsgque_Setup_PY_API
 
// END-MqMsgque - created by 'py_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
// vim: Marker(t)
 
static PyMethodDef NS(sMqMsgqueMethods)[] = {
 
  // BEGIN-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  // doc-key: MqMsgque,EnumFunc,sco
  { "IdentE_FromInt"        , (PyCFunction) NS(MqMsgque_IdentE_FromInt)        , METH_O       , IdentE_FromInt_doc },
  { "SlaveE_FromInt"        , (PyCFunction) NS(MqMsgque_SlaveE_FromInt)        , METH_O       , SlaveE_FromInt_doc },
  { "StartE_FromInt"        , (PyCFunction) NS(MqMsgque_StartE_FromInt)        , METH_O       , StartE_FromInt_doc },
  { "StatusIsEF_FromInt"    , (PyCFunction) NS(MqMsgque_StatusIsEF_FromInt)    , METH_O       , StatusIsEF_FromInt_doc },
  { "WaitOnEventE_FromInt"  , (PyCFunction) NS(MqMsgque_WaitOnEventE_FromInt)  , METH_O       , WaitOnEventE_FromInt_doc },
 
  // doc-key: MqMsgque,EnumFunc,sm_
  { "IdentE_ToInt"          , (PyCFunction) NS(MqMsgque_IdentE_ToInt)          , METH_O       , IdentE_ToInt_doc },
  { "IdentE_ToString"       , (PyCFunction) NS(MqMsgque_IdentE_ToString)       , METH_O       , IdentE_ToString_doc },
  { "SlaveE_ToInt"          , (PyCFunction) NS(MqMsgque_SlaveE_ToInt)          , METH_O       , SlaveE_ToInt_doc },
  { "SlaveE_ToString"       , (PyCFunction) NS(MqMsgque_SlaveE_ToString)       , METH_O       , SlaveE_ToString_doc },
  { "StartE_ToInt"          , (PyCFunction) NS(MqMsgque_StartE_ToInt)          , METH_O       , StartE_ToInt_doc },
  { "StartE_ToString"       , (PyCFunction) NS(MqMsgque_StartE_ToString)       , METH_O       , StartE_ToString_doc },
  { "StatusIsEF_ToInt"      , (PyCFunction) NS(MqMsgque_StatusIsEF_ToInt)      , METH_O       , StatusIsEF_ToInt_doc },
  { "StatusIsEF_ToString"   , (PyCFunction) NS(MqMsgque_StatusIsEF_ToString)   , METH_O       , StatusIsEF_ToString_doc },
  { "WaitOnEventE_ToInt"    , (PyCFunction) NS(MqMsgque_WaitOnEventE_ToInt)    , METH_O       , WaitOnEventE_ToInt_doc },
  { "WaitOnEventE_ToString" , (PyCFunction) NS(MqMsgque_WaitOnEventE_ToString) , METH_O       , WaitOnEventE_ToString_doc },
 
  // doc-key: MqMsgque,MqHelp,sm_
  { "Help"                  , (PyCFunction) NS(MqMsgque_Help)                  , METH_O       , Help_doc },
  { "HelpMsgque"            , (PyCFunction) NS(MqMsgque_HelpMsgque)            , METH_NOARGS  , HelpMsgque_doc },
 
  // doc-key: MqMsgque,MqInit,sm_
  { "InitGetArg0"           , (PyCFunction) NS(MqMsgque_InitGetArg0)           , METH_NOARGS  , InitGetArg0_doc },
  { "InitResetArg0"         , (PyCFunction) NS(MqMsgque_InitResetArg0)         , METH_NOARGS  , InitResetArg0_doc },
  { "InitSetArg0"           , (PyCFunction) NS(MqMsgque_InitSetArg0)           , METH_VARARGS , InitSetArg0_doc },
 
  // doc-key: MqMsgque,Setup,sm_
  { "Cleanup"               , (PyCFunction) NS(MqMsgque_Cleanup)               , METH_NOARGS  , Cleanup_doc },
  { "Setup"                 , (PyCFunction) NS(MqMsgque_Setup)                 , METH_NOARGS  , Setup_doc },
 
  // END-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  // BEGIN-OBJ - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  // → no data
 
  // END-OBJ - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
    {NULL, NULL, 0, NULL}        /* Sentinel */
};
 
// MODULE
 
static typeof(MqLal.MqSysServerThreadCB) save_MqSysServerThreadF = NULL;
MK_UNUSED static int num = 0;
 
MK_UNUSED static enum MkErrorE NS(PyServerThread) (
  MK_RT_ARGS
  MQ_CTX const context,
  struct MqSysServerThreadMainS * const argP,
  MK_STRN  name,    
  int thread_status,    
  struct MkIdS * idP  
) {
  enum MkErrorE ret;
  PyGILState_STATE gilstate;
 
  gilstate = PyGILState_Ensure();
  Py_BEGIN_ALLOW_THREADS
 
//num++;
//printV("START num<%d>, ts<%p>, gil<%o>",num,_save,gilstate);
  ret = (*save_MqSysServerThreadF)(MK_RT_CALL context, argP, name, thread_status, idP);
//printV("END   num<%d>, ts<%p>, gil<%o>",num,_save,gilstate);
 
  Py_END_ALLOW_THREADS
  PyGILState_Release(gilstate);
 
  return ret;
}
 
/*
MK_UNUSED MK_NO_RETURN
static void NS(PyExit) (
  int isThread, 
  int num
) {
  if (isThread) {
    pthread_exit(NULL);
    //printTxt("skip: pthread_exit")
  } else {
    exit(num);
  }
}
*/
 
// ----------------------------------------------------------------------------------------------
 
MkThreadLocal MqMsgqueThreadStateS MQ(MqMsgqueThreadState) = {0};
 
typedef struct {
  MK_RT mkrt;
} NS(sMqMsgqueStateS);
 
MK_UNUSED static inline NS(sMqMsgqueStateS)*
NS(sMqMsgqueGetState)(PyObject *module)
{
  void *state = PyModule_GetState(module);
  assert(state != NULL);
  return (NS(sMqMsgqueStateS)*)state;
}
 
#if 0
#define myTrace2(col,str) mk_dbg_color_ln(col,"%s module<%p> refCnty<%zd>",str,module,Py_REFCNT(module));
#define myTrace(str) myTrace2(MK_COLOR_ORANGE,str)
#else
#define myTrace2(col,str) 
#define myTrace(str) 
#endif
 
MK_UNUSED static int
NS(sMqMsgqueTraverse)(PyObject *module, visitproc visit, void *arg)
{
myTrace("TRAVERSE")
 
  // BEGIN-EnumTraverse - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  Py_VISIT(MqIdentE_lngO);
  Py_VISIT(MqSlaveE_lngO);
  Py_VISIT(MqStartE_lngO);
  Py_VISIT(MqStatusIsEF_lngO);
  Py_VISIT(MqWaitOnEventE_lngO);
 
  // END-EnumTraverse - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
  // BEGIN-ClassTraverse - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  Py_VISIT(MqFactoryC_MK_NULL);
  Py_VISIT(MqDumpC_MK_NULL);
  Py_VISIT(MqContextC_MK_NULL);
 
  // END-ClassTraverse - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  return 0;
}
 
MK_UNUSED static int
NS(sMqMsgqueClear)(PyObject *module)
{
myTrace("CLEAR")
 
  // BEGIN-EnumClear - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  Py_CLEAR(MqIdentE_lngO);
  Py_CLEAR(MqSlaveE_lngO);
  Py_CLEAR(MqStartE_lngO);
  Py_CLEAR(MqStatusIsEF_lngO);
  Py_CLEAR(MqWaitOnEventE_lngO);
 
  // END-EnumClear - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
  // BEGIN-ClassClear - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  Py_CLEAR(MqFactoryC_MK_NULL);
  Py_CLEAR(MqDumpC_MK_NULL);
  Py_CLEAR(MqContextC_MK_NULL);
 
  // END-ClassClear - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  return 0;
}
 
static void
NS(sMqMsgqueFree)(void *module)
{
myTrace("FREE")
  NS(sMqMsgqueStateS) *state = NS(sMqMsgqueGetState)(module);
  NS(sMqMsgqueClear)((PyObject *)module);
  if (state && state->mkrt) {
    state->mkrt->mkThreadData.ptr = NULL;
    state->mkrt=NULL;
  }
}
 
static int
NS(sMqMsgqueExec)(PyObject *module)
{
myTrace2(MK_COLOR_BLUE,"START")
//printV("#1 PyThreadState_Get<%p>", PyThreadState_Get())
 
  MqSetup();
  MkRtSetup_NULL;
 
  NS(sMqMsgqueStateS) *state = NS(sMqMsgqueGetState)(module);
  state->mkrt = MK_RT_PTR;
 
  PyObject *mainM = PyImport_AddModule("__main__");
 
  PyObject *mkM;
  LngErrorCheckN(mkM = PyImport_ImportModule("pymkkernel"));
  OtErrorCheckLng(PyObject_SetAttrString(mainM,"pymkkernel",mkM));
  Py_CLEAR(mkM);
 
  // BEGIN-CLASS-DEF - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  OtErrorCheckLng( NS(pMqFactoryC_Init) (MK_RT_CALL module) ) ;
  OtErrorCheckLng( NS(pMqDumpC_Init)    (MK_RT_CALL module) ) ;
  OtErrorCheckLng( NS(pMqContextC_Init) (MK_RT_CALL module) ) ;
 
  // END-CLASS-DEF - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  // init ENUM
  MK_STR enumCode =
    "from enum import IntEnum, IntFlag\n"
 
  // BEGIN-EnumCode - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  "class MqIdentE(IntEnum):\n"
  "  PREFIX  = 0\n"
  "  FACTORY = 1\n"
 
  "class MqSlaveE(IntEnum):\n"
  "  LOOPBACK = 0\n"
  "  FILTER   = 1\n"
  "  MASTER   = 1\n"
  "  OTHER    = 1\n"
  "  USER     = 10\n"
  "  MAX      = 1024\n"
 
  "class MqStartE(IntEnum):\n"
  "  DEFAULT = 0\n"
  "  FORK    = 1\n"
  "  THREAD  = 2\n"
  "  SPAWN   = 3\n"
 
  "class MqStatusIsEF(IntFlag):\n"
  "  INITIAL = 0\n"
  "  DUP     = 1\n"
  "  THREAD  = 2\n"
  "  FORK    = 4\n"
  "  SPAWN   = 8\n"
 
  "class MqWaitOnEventE(IntEnum):\n"
  "  NO      = 0\n"
  "  ONCE    = 1\n"
  "  OWN     = 2\n"
  "  FOREVER = 3\n"
 
  // END-EnumCode - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
  ;
 
  PyObject *myD, *mainD, *tmpO;
  mainD = PyModule_GetDict(mainM);
  myD   = PyModule_GetDict(module);
  tmpO  = PyRun_String(enumCode, Py_file_input, mainD, myD);
  LngErrorCheckN(tmpO);
  Py_CLEAR(tmpO);
 
  // BEGIN-EnumSet - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  MqIdentE_lngO = (PyTypeObject*) Py_NewRef(PyDict_GetItemString(myD,"MqIdentE"));
  MqSlaveE_lngO = (PyTypeObject*) Py_NewRef(PyDict_GetItemString(myD,"MqSlaveE"));
  MqStartE_lngO = (PyTypeObject*) Py_NewRef(PyDict_GetItemString(myD,"MqStartE"));
  MqStatusIsEF_lngO = (PyTypeObject*) Py_NewRef(PyDict_GetItemString(myD,"MqStatusIsEF"));
  MqWaitOnEventE_lngO = (PyTypeObject*) Py_NewRef(PyDict_GetItemString(myD,"MqWaitOnEventE"));
 
  // END-EnumSet - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  // every new thread source the script
  // "from pymqmsgque import" is calling "PyInit_pymqmsgque"
  // → check if we on "thread" : __name__=__main__
 
  // only ONCE on INITIAL setup
  if (strcmp(PyModule_GetName(mainM),"__main__") == 0) {
 
    // set the thread startup 
    //save_MqSysServerThreadF = MqLal.SysServerThread;
    //MqLal.SysServerThread = NS(PyServerThread);
    //MkLal.SysExit = NS(PyExit);
 
    // init libmqmsgque global data
    if (MqInitGetArg0() == NULL && Py_GetProgramName() != NULL) {
      char *py = Py_EncodeLocale(Py_GetProgramName(),NULL);
 
      PyObject *sysO = PyImport_ImportModule("sys");
      LngErrorCheckN(sysO);
      PyObject *argvO = PyObject_GetAttrString(sysO, "argv");
      LngErrorCheckN(argvO);
      PyObject *itmO = PyList_GetItem(argvO, 0);
      LngErrorCheckN(itmO);
 
      MqInitSetArg0VA(py, PyUnicode_AsUTF8(itmO), NULL);
 
      Py_CLEAR(argvO);
      Py_CLEAR(sysO);
      PyMem_Free(py);
    }
 
    // create the default-factory
    OtErrorCheckLng (NS(pMqFactoryC_Setup) (MK_RT_CALL module));
  }
 
  //PyErr_SetString(PyExc_RuntimeError,"this is a test");
 
//mk_dbg_color_ln(MK_COLOR_BLUE,"END module<%p>",module);
  return 0;
error:
  return -1;
}
 
MK_UNUSED static PyModuleDef_Slot NS(sMqMsgqueDefSlots)[] = {
  {Py_mod_exec, NS(sMqMsgqueExec)},
  {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
  {0, NULL}
};
 
static PyModuleDef NS(sMqMsgqueDef) = {
  PyModuleDef_HEAD_INIT,
  .m_name     = "pymqmsgque",
  .m_doc      = "python language binding for 'theLink'",
  .m_size     = sizeof(NS(sMqMsgqueStateS)),
  .m_methods  = NS(sMqMsgqueMethods),
  .m_slots    = NS(sMqMsgqueDefSlots),
  .m_traverse = NS(sMqMsgqueTraverse),    // garbage collection
  .m_clear    = NS(sMqMsgqueClear),
  .m_free     = NS(sMqMsgqueFree),
};
 
// MARK_P
 
PyMODINIT_FUNC
LibMqMsgque(void)
{
  // Multi-phase initialization
  return PyModuleDef_Init(&NS(sMqMsgqueDef));
}
 
// vim: nowrap