LibLcConfig_py.c

Go to the documentation of this file.

 
/* LABEL-NO */
 
#include "LibLcConfig_py.h"
 
#define OT_SETUP_hdl            MkRtSetup_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 LcSetupTmpl()
#define LcCleanupTmpl()
 
// MARK_D ################################################################
// -----------------------------------------------------------------------
// documentation order
// --------------------------------------------------------------------------------
 
// BEGIN-EnumDef - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// UNDEF
 
// END-EnumDef - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
 
// BEGIN-DOC - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// doc-key: LcConfig,EnumFunc,sco,func
#define ConfigFormatE_FromInt_doc "LcConfigFormatE ConfigFormatE_FromInt(value:int32)"
#define ConfigOptionsEF_FromInt_doc "LcConfigOptionsEF ConfigOptionsEF_FromInt(value:int32)"
#define ConfigTypeE_FromInt_doc "LcConfigTypeE ConfigTypeE_FromInt(value:int32)"
#define ErrorE_FromInt_doc "LcErrorE ErrorE_FromInt(value:int32)"
#define ErrorTypeE_FromInt_doc "LcErrorTypeE ErrorTypeE_FromInt(value:int32)"
 
// doc-key: LcConfig,EnumFunc,sm_,func
#define ConfigFormatE_ToInt_doc "int32 ConfigFormatE_ToInt(value:LcConfigFormatE)"
#define ConfigFormatE_ToString_doc "string ConfigFormatE_ToString(value:LcConfigFormatE)"
#define ConfigOptionsEF_ToInt_doc "int32 ConfigOptionsEF_ToInt(value:LcConfigOptionsEF)"
#define ConfigOptionsEF_ToString_doc "string ConfigOptionsEF_ToString(value:LcConfigOptionsEF)"
#define ConfigTypeE_ToInt_doc "int32 ConfigTypeE_ToInt(value:LcConfigTypeE)"
#define ConfigTypeE_ToString_doc "string ConfigTypeE_ToString(value:LcConfigTypeE)"
#define ErrorE_ToInt_doc "int32 ErrorE_ToInt(value:LcErrorE)"
#define ErrorE_ToString_doc "string ErrorE_ToString(value:LcErrorE)"
#define ErrorTypeE_ToInt_doc "int32 ErrorTypeE_ToInt(value:LcErrorTypeE)"
#define ErrorTypeE_ToString_doc "string ErrorTypeE_ToString(value:LcErrorTypeE)"
 
// doc-key: LcConfig,Setup,sm_,func
#define Cleanup_doc "Cleanup()"
#define Setup_doc "Setup()"
 
// END-DOC - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
#define Debug_doc "Debug(prefix:str, ?obj:object?"
 
/*****************************************************************************/
/*                                                                           */
/*                                 Check                                     */
/*                                                                           */
/*****************************************************************************/
 
#include "tmpl/lc_misc_check_lng.h"
 
 
// BEGIN-LcConfig - created by 'py_MqC.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
 
// doc-key: LcConfig,LcConfig-Enum,sco
 
static OT_ProcRet NS(LcConfig_ConfigFormatE_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ConfigFormatE_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum LcConfigFormatE value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,LcConfigFormatE_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Lc_enum_OBJ(ConfigFormatE,value_out));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ConfigOptionsEF_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ConfigOptionsEF_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum LcConfigOptionsEF value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,LcConfigOptionsEF_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Lc_enum_OBJ(ConfigOptionsEF,value_out));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ConfigTypeE_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ConfigTypeE_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum LcConfigTypeE value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,LcConfigTypeE_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Lc_enum_OBJ(ConfigTypeE,value_out));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_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 LcErrorE value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,LcErrorE_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Lc_enum_OBJ(ErrorE,value_out));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ErrorTypeE_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ErrorTypeE_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum LcErrorTypeE value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,LcErrorTypeE_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Lc_enum_OBJ(ErrorTypeE,value_out));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: LcConfig,LcConfig-Enum,sm_
 
static OT_ProcRet NS(LcConfig_ConfigFormatE_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ConfigFormatE_ToInt_doc);
  enum LcConfigFormatE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcConfigFormatE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(LcConfigFormatE_ToInt (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ConfigFormatE_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ConfigFormatE_ToString_doc);
  enum LcConfigFormatE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcConfigFormatE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(LcConfigFormatE_ToString (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ConfigOptionsEF_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ConfigOptionsEF_ToInt_doc);
  enum LcConfigOptionsEF value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcConfigOptionsEF,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(LcConfigOptionsEF_ToInt (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ConfigOptionsEF_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ConfigOptionsEF_ToString_doc);
  enum LcConfigOptionsEF value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcConfigOptionsEF,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(LcConfigOptionsEF_ToString (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ConfigTypeE_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ConfigTypeE_ToInt_doc);
  enum LcConfigTypeE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcConfigTypeE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(LcConfigTypeE_ToInt (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ConfigTypeE_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ConfigTypeE_ToString_doc);
  enum LcConfigTypeE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcConfigTypeE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(LcConfigTypeE_ToString (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ErrorE_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ErrorE_ToInt_doc);
  enum LcErrorE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcErrorE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(LcErrorE_ToInt (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ErrorE_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ErrorE_ToString_doc);
  enum LcErrorE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcErrorE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(LcErrorE_ToString (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ErrorTypeE_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ErrorTypeE_ToInt_doc);
  enum LcErrorTypeE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcErrorTypeE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(LcErrorTypeE_ToInt (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ErrorTypeE_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ErrorTypeE_ToString_doc);
  enum LcErrorTypeE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcErrorTypeE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(LcErrorTypeE_ToString (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// LcConfig_Enum_PY_API
 
 
// doc-key: LcConfig,LcConfig-Setup,sm_
 
static OT_ProcRet NS(LcConfig_Cleanup) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Cleanup_doc);
  OT_CHECK_NOARGS;
  LcCleanupTmpl ();
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_Setup) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Setup_doc);
  OT_CHECK_NOARGS;
  LcSetupTmpl ();
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// LcConfig_Setup_PY_API
 
// END-LcConfig - created by 'py_MqC.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// vim: Marker(t)
 
static PyMethodDef NS(sLcConfigMethods)[] = {
 
  // BEGIN-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  // doc-key: LcConfig,EnumFunc,sco
  { "ConfigFormatE_FromInt"    , (PyCFunction) NS(LcConfig_ConfigFormatE_FromInt)    , METH_O      , ConfigFormatE_FromInt_doc },
  { "ConfigOptionsEF_FromInt"  , (PyCFunction) NS(LcConfig_ConfigOptionsEF_FromInt)  , METH_O      , ConfigOptionsEF_FromInt_doc },
  { "ConfigTypeE_FromInt"      , (PyCFunction) NS(LcConfig_ConfigTypeE_FromInt)      , METH_O      , ConfigTypeE_FromInt_doc },
  { "ErrorE_FromInt"           , (PyCFunction) NS(LcConfig_ErrorE_FromInt)           , METH_O      , ErrorE_FromInt_doc },
  { "ErrorTypeE_FromInt"       , (PyCFunction) NS(LcConfig_ErrorTypeE_FromInt)       , METH_O      , ErrorTypeE_FromInt_doc },
 
  // doc-key: LcConfig,EnumFunc,sm_
  { "ConfigFormatE_ToInt"      , (PyCFunction) NS(LcConfig_ConfigFormatE_ToInt)      , METH_O      , ConfigFormatE_ToInt_doc },
  { "ConfigFormatE_ToString"   , (PyCFunction) NS(LcConfig_ConfigFormatE_ToString)   , METH_O      , ConfigFormatE_ToString_doc },
  { "ConfigOptionsEF_ToInt"    , (PyCFunction) NS(LcConfig_ConfigOptionsEF_ToInt)    , METH_O      , ConfigOptionsEF_ToInt_doc },
  { "ConfigOptionsEF_ToString" , (PyCFunction) NS(LcConfig_ConfigOptionsEF_ToString) , METH_O      , ConfigOptionsEF_ToString_doc },
  { "ConfigTypeE_ToInt"        , (PyCFunction) NS(LcConfig_ConfigTypeE_ToInt)        , METH_O      , ConfigTypeE_ToInt_doc },
  { "ConfigTypeE_ToString"     , (PyCFunction) NS(LcConfig_ConfigTypeE_ToString)     , METH_O      , ConfigTypeE_ToString_doc },
  { "ErrorE_ToInt"             , (PyCFunction) NS(LcConfig_ErrorE_ToInt)             , METH_O      , ErrorE_ToInt_doc },
  { "ErrorE_ToString"          , (PyCFunction) NS(LcConfig_ErrorE_ToString)          , METH_O      , ErrorE_ToString_doc },
  { "ErrorTypeE_ToInt"         , (PyCFunction) NS(LcConfig_ErrorTypeE_ToInt)         , METH_O      , ErrorTypeE_ToInt_doc },
  { "ErrorTypeE_ToString"      , (PyCFunction) NS(LcConfig_ErrorTypeE_ToString)      , METH_O      , ErrorTypeE_ToString_doc },
 
  // doc-key: LcConfig,Setup,sm_
  { "Cleanup"                  , (PyCFunction) NS(LcConfig_Cleanup)                  , METH_NOARGS , Cleanup_doc },
  { "Setup"                    , (PyCFunction) NS(LcConfig_Setup)                    , METH_NOARGS , Setup_doc },
 
  // END-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  // BEGIN-OBJ - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  // → no data
 
  // END-OBJ - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
    {NULL, NULL, 0, NULL}        /* Sentinel */
};
 
// MARK_P
 
// MODULE
 
MkThreadLocal LcConfigThreadStateS LC(LcConfigThreadState) = {0} ;
 
typedef struct {
  MK_RT mkrt;
} NS(sLcConfigStateS);
 
MK_UNUSED static inline NS(sLcConfigStateS)*
NS(sLcConfigGetState)(PyObject *module)
{
  void *state = PyModule_GetState(module);
  assert(state != NULL);
  return (NS(sLcConfigStateS)*)state;
}
 
static int
NS(sLcConfigTraverse)(PyObject *module, visitproc visit, void *arg)
{
  // BEGIN-EnumTraverse - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  Py_VISIT(LcConfigFormatE_lngO);
  Py_VISIT(LcConfigOptionsEF_lngO);
  Py_VISIT(LcConfigTypeE_lngO);
  Py_VISIT(LcErrorE_lngO);
  Py_VISIT(LcErrorTypeE_lngO);
 
  // END-EnumTraverse - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
  // BEGIN-ClassTraverse - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  Py_VISIT(LcConfigC_MK_NULL);
  Py_VISIT(LcSettingC_MK_NULL);
 
  // END-ClassTraverse - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
  return 0;
}
 
static int
NS(sLcConfigClear)(PyObject *module)
{
  // BEGIN-EnumClear - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  Py_CLEAR(LcConfigFormatE_lngO);
  Py_CLEAR(LcConfigOptionsEF_lngO);
  Py_CLEAR(LcConfigTypeE_lngO);
  Py_CLEAR(LcErrorE_lngO);
  Py_CLEAR(LcErrorTypeE_lngO);
 
  // END-EnumClear - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
  // BEGIN-ClassClear - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  Py_CLEAR(LcConfigC_MK_NULL);
  Py_CLEAR(LcSettingC_MK_NULL);
 
  // END-ClassClear - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
  return 0;
}
 
static void
NS(sLcConfigFree)(void *module)
{
  NS(sLcConfigClear)((PyObject *)module);
}
 
static int
NS(sLcConfigExec)(PyObject *module)
{
  int ret;
  LcSetup();
  MkRtSetup_NULL;
 
  NS(sLcConfigStateS) *state = NS(sLcConfigGetState)(module);
  state->mkrt = MK_RT_PTR;
 
  PyObject *mainM = PyImport_AddModule("__main__");
 
  PyObject *mkM = PyImport_ImportModule("pymkkernel");
  LngErrorCheckN(mkM);
  ret = PyObject_SetAttrString(mainM,"pymkkernel",mkM);
  OtErrorCheckLng(ret);
  Py_CLEAR(mkM);
 
  // BEGIN-CLASS-DEF - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  OtErrorCheckLng( NS(pLcConfigC_Init)  (MK_RT_CALL module) ) ;
  OtErrorCheckLng( NS(pLcSettingC_Init) (MK_RT_CALL module) ) ;
 
  // END-CLASS-DEF - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  // init NULL object… on EVERY thread
  //NS(inMain) = false;
 
  // init ENUM
  MK_STR enumCode =
    "from enum import IntEnum, IntFlag\n"
 
  // BEGIN-EnumCode - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  "class LcConfigFormatE(IntEnum):\n"
  "  DEFAULT = 0\n"
  "  HEX     = 1\n"
 
  "class LcConfigOptionsEF(IntFlag):\n"
  "  NONE                            = 0\n"
  "  AUTOCONVERT                     = 1\n"
  "  SEMICOLON_SEPARATORS            = 2\n"
  "  COLON_ASSIGNMENT_FOR_GROUPS     = 4\n"
  "  COLON_ASSIGNMENT_FOR_NON_GROUPS = 8\n"
  "  OPEN_BRACE_ON_SEPARATE_LINE     = 16\n"
  "  ALLOW_SCIENTIFIC_NOTATION       = 32\n"
  "  FSYNC                           = 64\n"
  "  ALLOW_OVERRIDES                 = 128\n"
 
  "class LcConfigTypeE(IntEnum):\n"
  "  NONE   = 0\n"
  "  GROUP  = 1\n"
  "  INT    = 2\n"
  "  INT64  = 3\n"
  "  FLOAT  = 4\n"
  "  STRING = 5\n"
  "  BOOL   = 6\n"
  "  ARRAY  = 7\n"
  "  LIST   = 8\n"
 
  "class LcErrorE(IntEnum):\n"
  "  FALSE = 0\n"
  "  TRUE  = 1\n"
 
  "class LcErrorTypeE(IntEnum):\n"
  "  NONE    = 0\n"
  "  FILE_IO = 1\n"
  "  PARSE   = 2\n"
 
  // END-EnumCode - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.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/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  LcConfigFormatE_lngO = (PyTypeObject*) Py_NewRef(PyDict_GetItemString(myD,"LcConfigFormatE"));
  LcConfigOptionsEF_lngO = (PyTypeObject*) Py_NewRef(PyDict_GetItemString(myD,"LcConfigOptionsEF"));
  LcConfigTypeE_lngO = (PyTypeObject*) Py_NewRef(PyDict_GetItemString(myD,"LcConfigTypeE"));
  LcErrorE_lngO = (PyTypeObject*) Py_NewRef(PyDict_GetItemString(myD,"LcErrorE"));
  LcErrorTypeE_lngO = (PyTypeObject*) Py_NewRef(PyDict_GetItemString(myD,"LcErrorTypeE"));
 
  // END-EnumSet - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  return 0;
error:
  return -1;
}
 
MK_UNUSED static PyModuleDef_Slot NS(sLcConfigDefSlots)[] = {
  {Py_mod_exec, NS(sLcConfigExec)},
  {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
  {0, NULL}
};
 
static PyModuleDef NS(sLcConfigDef) = {
  PyModuleDef_HEAD_INIT,
  .m_name     = "pylcconfig",
  .m_doc      = "python language binding for 'theConfig'",
  .m_size     = sizeof(NS(sLcConfigStateS)),
  .m_methods  = NS(sLcConfigMethods),
  .m_slots    = NS(sLcConfigDefSlots),
  .m_traverse = NS(sLcConfigTraverse),    // garbage collection
  .m_clear    = NS(sLcConfigClear),
  .m_free     = NS(sLcConfigFree),
};
 
// MARK_P
 
PyMODINIT_FUNC
LibLcConfig(void)
{
  // Multi-phase initialization
  return PyModuleDef_Init(&NS(sLcConfigDef));
}
 
// vim: nowrap