LcConfigC_py.c

Go to the documentation of this file.

 
/* LABEL-START */
 
#define META_FILE_NAME              "LcConfigC_py.c"
 
#include "LibLcConfig_private_py.h"
 
// PY class
#define OT_CLASS                    (&NS(LcConfigCR))
#define OT_CLASS_NAME               "LcConfigC"
 
#define OT_LNG2META(O)              LcCfg(VAL2MNG(O))
 
#define OT_retObj_CONSTR(mng)       OT_retObj_SET(NS(LcConfigC_CTOR)(MK_RT_CALL (PyTypeObject*)class,mng))
 
#define OT_SETUP_hdl                OT_SETUP_hdl_tmpl(LcConfigC)
#define OT_SETUP_hdl__null_allow    OT_SETUP_hdl_tmpl__null_allow(LcConfigC)
#define OT_SETUP_hdl_constr         MK_RT_UNUSED AllRtSetup_NULL; \
                                    LC_CFG hdl = (LC_CFG) OT_CLASS;
#define OT_SETUP_hdl_destr          OT_SETUP_hdl_tmpl__null_allow(LcConfigC)
#define OT_SETUP_hdl_static         MK_RT_UNUSED AllRtSetup_NULL; \
                                    __attribute__((unused)) MK_TYP hdl = LcConfigC##_TT;
 
#define OT_SETUP_hdl_static_constr  OT_SETUP_hdl_static
 
#if !defined(SetupRtFromObj_X)
  #define SetupRtFromObj_X(hdl)     AllRtSetup_X(hdl)
  #define SetupRtFromObj_XN(hdl)    AllRtSetup_XN(hdl)
#endif
 
// MO class
#undef LcConfigCTT
#define LcConfigCTT LC(LcConfigThreadState).LcConfigCTT
/* LcConfigC_MK_NULL defined in LibLcConfig_py.h */
 
__attribute__((unused)) mk_inline
OT_OBJ_T NS(LcConfigC_CTOR) (MK_RT_ARGS OT_CLS_T type, LC_CFG hdl) {
  return MK(AtomCreate)(MK_RT_CALL type,LcConfigC_X2obj(hdl));
}
 
// helper: mk_dbg_color_ln(MK_COLOR_YELLOW,"hdl<%p>, self<%p>", obj, self);
 
// META: ObjNew feature: selfCreate will be called from "ObjNew->MkSelfNew" if MkObj need a SELF pointer
static MK_PTR NS(LcConfigC_selfCreate) (MK_RT_ARGS MK_OBJ const obj, MK_PTR const env) {
  return MK(AtomCreate) (MK_RT_CALL OT_CLASS,obj);
}
// META: called if MkObj must be destroyed and if the SELF is still alive → goal: destroy the SELF
static void NS(LcConfigC_selfDelete) (MK_RT_ARGS MK_PTR self, MK_PTR const env) {
  MK(AtomDeleteHard) (MK_RT_CALL OT_SELF);
}
// META: called to destroy link from SELF to META
static void NS(LcConfigC_selfUnlink) (MK_RT_ARGS MK_PTR self, MK_PTR const env) {
  MkObjectC_Obj *selfO = (MkObjectC_Obj*) self;
  selfO->hdl = NULL;
}
 
// initialize the PY and MO class specific object
#define   ClassInit \
  /* if not already done, initialize NEW META type */ \
  if (LcConfigCTT == NULL) LcConfigCTT = LcConfigSTT; \
  \
  /* protect against double call */ \
  if (LcConfigCTT->selfCreate == NS(LcConfigC_selfCreate)) return MK_OK; \
  \
  /* add "selfCreate" and "selfDelete" feature to the META-Class */ \
  LcConfigCTT->selfCreate    = NS(LcConfigC_selfCreate); \
  LcConfigCTT->selfDelete    = NS(LcConfigC_selfDelete); \
  LcConfigCTT->selfUnlink    = NS(LcConfigC_selfUnlink); \
  \
  if (!PyType_HasFeature(OT_CLASS,Py_TPFLAGS_READY)) { \
    NS(LcConfigCR).tp_base = LcConfigC_base; \
    OtErrorCheckLng (PyType_Ready(OT_CLASS)); \
  } \
  OtErrorCheckLng(PyModule_AddObjectRef(m, "LcConfigC", (PyObject *)OT_CLASS)); \
  \
  /* define the "NULL" object */ \
  LcConfigC_MK_NULL = Py_NewRef(MK(AtomCreate) (MK_RT_CALL OT_CLASS, NULL /*obj*/));
 
/* LABEL-END */
 
#define META_CONTEXT_S        MK_ERROR_DEFAULT
 
 
// BEGIN-DOC - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// doc-key: LcConfigC,LcConfig,sCc,func
#define Create_doc "LcConfigC LcConfigC.Create()"
#define new_doc "LcConfigC LcConfigC.new()"
 
// doc-key: LcConfigC,LcConfig,sc_,func
#define GetNull_doc "LcConfigC LcConfigC.GetNull()"
#define HandleResolve_doc "LcConfigC LcConfigC.HandleResolve(netHdl:MK_HDL)"
#define Instances_doc "LcConfigC LcConfigC.Instances()"
 
// doc-key: LcConfigC,LcConfig,oc_,func
#define Lookup_doc "LcSettingC config.Lookup(path:string) (const)"
#define Next_doc "LcConfigC cfg.Next()"
#define Prev_doc "LcConfigC cfg.Prev()"
#define RootSetting_doc "LcSettingC config.RootSetting() (const)"
 
// doc-key: LcConfigC,LcConfig,om_,func
#define Clear_doc "config.Clear()"
#define ErrorType_doc "LcErrorTypeE config.ErrorType() (const)"
#define GetDefaultFormat_doc "LcConfigFormatE config.GetDefaultFormat() (const)"
#define GetFloatPrecision_doc "int16 config.GetFloatPrecision() (const)"
#define GetIncludeDir_doc "string config.GetIncludeDir() (const)"
#define GetOption_doc "bool config.GetOption(option:LcConfigOptionsEF) (const)"
#define GetOptions_doc "LcConfigOptionsEF config.GetOptions() (const)"
#define GetTabWidth_doc "int16 config.GetTabWidth() (const)"
// skip class-overload: HandleGet → MkObjectHandleGet
#define Log_doc "cfg.Log(?fmtobj:MkObjectC=None?, ?debug:int32=0?, ?callfunc:string=\"MK_NULL\"?, ?lvl:int32=0?) (const)"
#define ReadFile_doc "config.ReadFile(filename:string)"
#define ReadString_doc "config.ReadString(str:string)"
#define SetDefaultFormat_doc "config.SetDefaultFormat(format:LcConfigFormatE)"
#define SetFloatPrecision_doc "config.SetFloatPrecision(digits:int16)"
#define SetIncludeDir_doc "config.SetIncludeDir(include_dir:string)"
#define SetIncludeFunc_doc "cfg.SetIncludeFunc(?fConfigIncludeData:LC_CBP=None?)"
#define SetOption_doc "config.SetOption(option:LcConfigOptionsEF, flag:bool)"
#define SetOptions_doc "config.SetOptions(options:LcConfigOptionsEF)"
#define SetSettingDeleteFunc_doc "cfg.SetSettingDeleteFunc(?fSettingDeleteData:LC_CBP=None?)"
#define SetTabWidth_doc "config.SetTabWidth(width:int16)"
#define WriteFile_doc "config.WriteFile(filename:string)"
 
// doc-key: LcConfigC,LcConfig,omo,func
#define LookupBool_doc "bool config.LookupBool(path:string) (const)"
#define LookupFloat_doc "double config.LookupFloat(path:string) (const)"
#define LookupInt_doc "int32 config.LookupInt(path:string) (const)"
#define LookupInt64_doc "int64 config.LookupInt64(path:string) (const)"
#define LookupString_doc "string config.LookupString(path:string) (const)"
#define WriteString_doc "string cfg.WriteString() (const)"
 
// END-DOC - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// ---------------------------------------------------------------------------------------
 
 
// ---------------------------------------------------------------------------------------
 
// BEGIN-LcConfigC - created by 'py_MqC.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
 
// doc-key: LcConfigC,LcConfigC-Class-Export,sc_
 
static OT_ProcRet NS(LcConfigC_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;
  LC_CFG retVal = LcConfigHandleResolve (netHdl);
  OT_retObj_SET_CFG(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: LcConfigC,LcConfigC-Class-Export,om_
 
// skip on class-overload: LcConfigHandleGet → MkObjectHandleGet
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(LcConfigC_HandleGet) (LcConfigC_ARGS) {OT_ERROR_LNG_RETURN;}
 
// LcConfigC_Class_PY_API
 
 
// doc-key: LcConfigC,LcConfigC-Class-Introspection,oc_
 
static OT_ProcRet NS(LcConfigC_Next) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Next_doc);
  OT_CHECK_NOARGS;
  LC_CFG retVal = LcConfigNext (hdl);
  OT_retObj_SET_CFG(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_Prev) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Prev_doc);
  OT_CHECK_NOARGS;
  LC_CFG retVal = LcConfigPrev (hdl);
  OT_retObj_SET_CFG(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: LcConfigC,LcConfigC-Class-Introspection,sc_
 
static OT_ProcRet NS(LcConfigC_Instances) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Instances_doc);
  OT_CHECK_NOARGS;
  LC_CFG retVal = LcConfigInstances ();
  OT_retObj_SET_CFG(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// LcConfigC_Class_PY_API
 
 
// doc-key: LcConfigC,LcConfigC-Class-Misc,sc_
 
static OT_ProcRet NS(LcConfigC_GetNull) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(GetNull_doc);
  OT_CHECK_NOARGS;
  LC_CFG retVal = LcConfigGetNull ();
  OT_retObj_SET_CFG(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// LcConfigC_Class_PY_API
 
 
// doc-key: LcConfigC,LcConfigC-Error,om_
 
static OT_ProcRet NS(LcConfigC_ErrorType) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ErrorType_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET(OT_NEW_Lc_enum_OBJ(ErrorTypeE,LcConfigErrorType (hdl)));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// LcConfigC_Error_PY_API
 
 
// doc-key: LcConfigC,LcConfigC-Get,om_
 
static OT_ProcRet NS(LcConfigC_GetDefaultFormat) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetDefaultFormat_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET(OT_NEW_Lc_enum_OBJ(ConfigFormatE,LcConfigGetDefaultFormat (hdl)));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_GetFloatPrecision) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetFloatPrecision_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_I16(LcConfigGetFloatPrecision (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_GetIncludeDir) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetIncludeDir_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(LcConfigGetIncludeDir (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_GetOption) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(GetOption_doc);
  enum LcConfigOptionsEF option = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcConfigOptionsEF,option))
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(LcConfigGetOption (hdl, option));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_GetOptions) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetOptions_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET(OT_NEW_Lc_enum_OBJ(ConfigOptionsEF,LcConfigGetOptions (hdl)));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_GetTabWidth) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetTabWidth_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_I16(LcConfigGetTabWidth (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// LcConfigC_Get_PY_API
 
 
// doc-key: LcConfigC,LcConfigC-Lookup,oc_
 
static OT_ProcRet NS(LcConfigC_Lookup) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(Lookup_doc);
  MK_STRN path = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (path))
  OT_CHECK_NOARGS;
  LC_CFS retVal = LcConfigLookup (hdl, path);
  OT_retObj_SET_CFS(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: LcConfigC,LcConfigC-Lookup,omo
 
static OT_ProcRet NS(LcConfigC_LookupBool) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(LookupBool_doc);
  MK_STRN path = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (path))
  OT_CHECK_NOARGS;
  MK_BOOL value_out;
  MkErrorC_Check(hdl,LcConfigLookupBool (hdl, path, &value_out));
  OT_retObj_SET_BOL(value_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_LookupFloat) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(LookupFloat_doc);
  MK_STRN path = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (path))
  OT_CHECK_NOARGS;
  MK_DBL value_out;
  MkErrorC_Check(hdl,LcConfigLookupFloat (hdl, path, &value_out));
  OT_retObj_SET_DBL(value_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_LookupInt) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(LookupInt_doc);
  MK_STRN path = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (path))
  OT_CHECK_NOARGS;
  MK_I32 value_out;
  MkErrorC_Check(hdl,LcConfigLookupInt (hdl, path, &value_out));
  OT_retObj_SET_I32(value_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_LookupInt64) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(LookupInt64_doc);
  MK_STRN path = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (path))
  OT_CHECK_NOARGS;
  MK_I64 value_out;
  MkErrorC_Check(hdl,LcConfigLookupInt64 (hdl, path, &value_out));
  OT_retObj_SET_I64(value_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_LookupString) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(LookupString_doc);
  MK_STRN path = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (path))
  OT_CHECK_NOARGS;
  MK_STRN value_out;
  MkErrorC_Check(hdl,LcConfigLookupString (hdl, path, &value_out));
  OT_retObj_SET_STR(value_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// LcConfigC_Lookup_PY_API
 
 
// doc-key: LcConfigC,LcConfigC-Misc,oc_
 
static OT_ProcRet NS(LcConfigC_RootSetting) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(RootSetting_doc);
  OT_CHECK_NOARGS;
  LC_CFS retVal = LcConfigRootSetting (hdl);
  OT_retObj_SET_CFS(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: LcConfigC,LcConfigC-Misc,om_
 
static OT_ProcRet NS(LcConfigC_Clear) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Clear_doc);
  OT_CHECK_NOARGS;
  LcConfigClear (hdl);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_Log) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,4,Log_doc);
  MK_OBJN fmtobj = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_OBJN (fmtobj,MK_NULL_YES))
  MK_DBG debug = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (debug))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_I32 lvl = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (lvl))
  OT_CHECK_NOARGS;
  if (debug > MkRuntimeDebugGet()) {
    OT_retObj_SET_None;
    goto end;
  }
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  LcConfigLog (hdl, fmtobj, debug, callfunc, lvl);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_ReadFile) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ReadFile_doc);
  MK_STRN filename = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (filename))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,LcConfigReadFile (hdl, filename));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_ReadString) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ReadString_doc);
  MK_STRN str = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (str))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,LcConfigReadString (hdl, str));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_WriteFile) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(WriteFile_doc);
  MK_STRN filename = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (filename))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,LcConfigWriteFile (hdl, filename));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: LcConfigC,LcConfigC-Misc,omo
 
static OT_ProcRet NS(LcConfigC_WriteString) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(WriteString_doc);
  OT_CHECK_NOARGS;
  MK_STRN val_out;
  MkErrorC_Check(hdl,LcConfigWriteString (hdl, &val_out));
  OT_retObj_SET_STR(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// LcConfigC_Misc_PY_API
 
 
// doc-key: LcConfigC,LcConfigC-Set,om_
 
static OT_ProcRet NS(LcConfigC_SetDefaultFormat) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetDefaultFormat_doc);
  enum LcConfigFormatE format = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcConfigFormatE,format))
  OT_CHECK_NOARGS;
  LcConfigSetDefaultFormat (hdl, format);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_SetFloatPrecision) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetFloatPrecision_doc);
  MK_I16 digits = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI2 (digits))
  OT_CHECK_NOARGS;
  LcConfigSetFloatPrecision (hdl, digits);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_SetIncludeDir) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetIncludeDir_doc);
  MK_STRN include_dir = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (include_dir))
  OT_CHECK_NOARGS;
  LcConfigSetIncludeDir (hdl, include_dir);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_SetIncludeFunc) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,1,SetIncludeFunc_doc);
  OT_SETUP_CALLABLE(fConfigIncludeData)
  OT_CHECK_OPTIONAL(OT_CHECK_CALLABLE(fConfigIncludeData))
  OT_CHECK_NOARGS;
  LcConfigIncludeCallF fConfigIncludeCall = (fConfigIncludeData == NULL ? NULL : NS(ConfigIncludeCall));
  MkErrorC_Check(hdl,LcConfigSetIncludeFunc (hdl, fConfigIncludeCall, fConfigIncludeData, NS(ConfigIncludeFree)));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_CLEANUP_CALLABLE(fConfigIncludeData)
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_SetOption) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,2,SetOption_doc);
  enum LcConfigOptionsEF option = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcConfigOptionsEF,option))
  MK_BOOL flag = 0;
  OT_CHECK_REQUIRED(OT_CHECK_bool (flag))
  OT_CHECK_NOARGS;
  LcConfigSetOption (hdl, option, flag);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_SetOptions) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetOptions_doc);
  enum LcConfigOptionsEF options = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcConfigOptionsEF,options))
  OT_CHECK_NOARGS;
  LcConfigSetOptions (hdl, options);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_SetSettingDeleteFunc) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,1,SetSettingDeleteFunc_doc);
  OT_SETUP_CALLABLE(fSettingDeleteData)
  OT_CHECK_OPTIONAL(OT_CHECK_CALLABLE(fSettingDeleteData))
  OT_CHECK_NOARGS;
  LcSettingDeleteCallF fSettingDeleteCall = (fSettingDeleteData == NULL ? NULL : NS(SettingDeleteCall));
  MkErrorC_Check(hdl,LcConfigSetSettingDeleteFunc (hdl, fSettingDeleteCall, fSettingDeleteData, NS(SettingDeleteFree)));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_CLEANUP_CALLABLE(fSettingDeleteData)
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_SetTabWidth) (LcConfigC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetTabWidth_doc);
  MK_I16 width = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI2 (width))
  OT_CHECK_NOARGS;
  LcConfigSetTabWidth (hdl, width);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// LcConfigC_Set_PY_API
 
 
// doc-key: LcConfigC,LcConfigC-TOR,sCc
 
static OT_ProcRet NS(LcConfigC_Create) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_NOARG(Create_doc);
  OT_CHECK_NOARGS;
  LC_CFG retVal = LcConfigCreate (NULL, NULL);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(LcConfigC);
    goto error;
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_SET_CFG(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfigC_new) (CONSTR_ARGS) {
  OT_SETUP_hdl_constr;
  OT_SETUP_CONSTRUCTOR_ARGS(0,0,new_doc);
  LC_CFG retVal = LcConfigCreate (NULL, NULL);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(LcConfigC);
    goto error;
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_CONSTR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// LcConfigC_TOR_PY_API
 
// END-LcConfigC - created by 'py_MqC.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// vim: Marker(t)
 
static PyMethodDef LcConfigC_Methods[] = {
 
  // BEGIN-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  // doc-key: LcConfigC,LcConfig,sCc
  { "Create"               , (PyCFunction) NS(LcConfigC_Create)               , METH_NOARGS|METH_CLASS , Create_doc },
 
  // doc-key: LcConfigC,LcConfig,sc_
  { "GetNull"              , (PyCFunction) NS(LcConfigC_GetNull)              , METH_NOARGS|METH_CLASS , GetNull_doc },
  { "HandleResolve"        , (PyCFunction) NS(LcConfigC_HandleResolve)        , METH_O|METH_CLASS      , HandleResolve_doc },
  { "Instances"            , (PyCFunction) NS(LcConfigC_Instances)            , METH_NOARGS|METH_CLASS , Instances_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
 
  // doc-key: LcConfigC,LcConfig,oc_
  { "Lookup"               , (PyCFunction) NS(LcConfigC_Lookup)               , METH_O                 , Lookup_doc },
  { "Next"                 , (PyCFunction) NS(LcConfigC_Next)                 , METH_NOARGS            , Next_doc },
  { "Prev"                 , (PyCFunction) NS(LcConfigC_Prev)                 , METH_NOARGS            , Prev_doc },
  { "RootSetting"          , (PyCFunction) NS(LcConfigC_RootSetting)          , METH_NOARGS            , RootSetting_doc },
 
  // doc-key: LcConfigC,LcConfig,om_
  { "Clear"                , (PyCFunction) NS(LcConfigC_Clear)                , METH_NOARGS            , Clear_doc },
  { "ErrorType"            , (PyCFunction) NS(LcConfigC_ErrorType)            , METH_NOARGS            , ErrorType_doc },
  { "GetDefaultFormat"     , (PyCFunction) NS(LcConfigC_GetDefaultFormat)     , METH_NOARGS            , GetDefaultFormat_doc },
  { "GetFloatPrecision"    , (PyCFunction) NS(LcConfigC_GetFloatPrecision)    , METH_NOARGS            , GetFloatPrecision_doc },
  { "GetIncludeDir"        , (PyCFunction) NS(LcConfigC_GetIncludeDir)        , METH_NOARGS            , GetIncludeDir_doc },
  { "GetOption"            , (PyCFunction) NS(LcConfigC_GetOption)            , METH_O                 , GetOption_doc },
  { "GetOptions"           , (PyCFunction) NS(LcConfigC_GetOptions)           , METH_NOARGS            , GetOptions_doc },
  { "GetTabWidth"          , (PyCFunction) NS(LcConfigC_GetTabWidth)          , METH_NOARGS            , GetTabWidth_doc },
  // skip class-overload: LcConfigHandleGet → HandleGet, NS(LcConfigC_HandleGet)
  { "Log"                  , (PyCFunction) NS(LcConfigC_Log)                  , METH_VARARGS           , Log_doc },
  { "ReadFile"             , (PyCFunction) NS(LcConfigC_ReadFile)             , METH_O                 , ReadFile_doc },
  { "ReadString"           , (PyCFunction) NS(LcConfigC_ReadString)           , METH_O                 , ReadString_doc },
  { "SetDefaultFormat"     , (PyCFunction) NS(LcConfigC_SetDefaultFormat)     , METH_O                 , SetDefaultFormat_doc },
  { "SetFloatPrecision"    , (PyCFunction) NS(LcConfigC_SetFloatPrecision)    , METH_O                 , SetFloatPrecision_doc },
  { "SetIncludeDir"        , (PyCFunction) NS(LcConfigC_SetIncludeDir)        , METH_O                 , SetIncludeDir_doc },
  { "SetIncludeFunc"       , (PyCFunction) NS(LcConfigC_SetIncludeFunc)       , METH_VARARGS           , SetIncludeFunc_doc },
  { "SetOption"            , (PyCFunction) NS(LcConfigC_SetOption)            , METH_VARARGS           , SetOption_doc },
  { "SetOptions"           , (PyCFunction) NS(LcConfigC_SetOptions)           , METH_O                 , SetOptions_doc },
  { "SetSettingDeleteFunc" , (PyCFunction) NS(LcConfigC_SetSettingDeleteFunc) , METH_VARARGS           , SetSettingDeleteFunc_doc },
  { "SetTabWidth"          , (PyCFunction) NS(LcConfigC_SetTabWidth)          , METH_O                 , SetTabWidth_doc },
  { "WriteFile"            , (PyCFunction) NS(LcConfigC_WriteFile)            , METH_O                 , WriteFile_doc },
 
  // doc-key: LcConfigC,LcConfig,omo
  { "LookupBool"           , (PyCFunction) NS(LcConfigC_LookupBool)           , METH_O                 , LookupBool_doc },
  { "LookupFloat"          , (PyCFunction) NS(LcConfigC_LookupFloat)          , METH_O                 , LookupFloat_doc },
  { "LookupInt"            , (PyCFunction) NS(LcConfigC_LookupInt)            , METH_O                 , LookupInt_doc },
  { "LookupInt64"          , (PyCFunction) NS(LcConfigC_LookupInt64)          , METH_O                 , LookupInt64_doc },
  { "LookupString"         , (PyCFunction) NS(LcConfigC_LookupString)         , METH_O                 , LookupString_doc },
  { "WriteString"          , (PyCFunction) NS(LcConfigC_WriteString)          , METH_NOARGS            , WriteString_doc },
 
  // END-OBJ - created by 'py_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
    {NULL, NULL, 0, NULL}        /* Sentinel */
};
 
 
OT_CLASS_TYPE_REF NS(LcConfigCR) = {
  PyVarObject_HEAD_INIT(NULL, 0)
  .tp_name        = "pymsgque.LcConfigC",
  .tp_doc         = "PyMsgque LcConfigC Type",
  .tp_basicsize   = sizeof(LcConfigC_Obj),
  .tp_itemsize    = 0,
  .tp_new         = (newfunc)     NS(LcConfigC_new),
  .tp_flags       = Py_TPFLAGS_DEFAULT,
  .tp_methods     = LcConfigC_Methods,
  .tp_base        = NULL
};
 
int NS(pLcConfigC_Init) ( MK_RT_ARGS PyObject* m)
{
  ClassInit
 
  return 0;
error:
  return -1;
}
 
// vim: nowrap