LcConfigC_tcl.c

Go to the documentation of this file.

 
/* LABEL-START */
 
#define   META_FILE_NAME      "LcConfigC_tcl.c"
 
#include  "LibLcConfig_private_tcl.h"
 
#define   OT_CLASS            NS(LcConfigC)
#define   OT_CLASS_NAME       "LcConfigC"
 
#define   OBJECT2CFG(O)   MkAssertCastM(LcConfigC,(Tcl_ObjectGetMetadata(O, &MK(AtomMeta))))
 
// TCL class
MkThreadLocal OT_CLS_T OT_CLASS = NULL;
 
// META class
static MkThreadLocal MK_TYP LcConfigCTT = NULL;
MkThreadLocal OT_OBJ_T LC(LcConfigC_MK_NULL) = NULL;
 
// 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) {
  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(LcConfigC_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(LcConfigC_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 = LcConfigC##_TT;
 
#define   OT_SETUP_hdl              SetupHdlFromMetaData_2(CFG,LC_CFG);
#define   OT_SETUP_hdl__null_allow  SetupHdlFromMetaData__null_allow_2(CFG,LC_CFG);
#define   OT_SETUP_hdl_destr        SetupHdlFromMetaData__null_allow_2(CFG,LC_CFG);
 
#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); \
  LC_CFG hdl = (LC_CFG) &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 (LcConfigCTT == NULL) LcConfigCTT = LcConfigSTT; \
 \
  /* protect against double call */ \
  if (LcConfigCTT->selfCreate == NS(LcConfigC_selfCreate)) return MK_OK; \
 \
  /* add "selfCreate" and "selfDelete" feature to the MQ-Class */ \
  LcConfigCTT->selfCreate    = NS(LcConfigC_selfCreate); \
  LcConfigCTT->selfDelete    = NS(LcConfigC_selfDelete); \
  LcConfigCTT->selfUnlink    = NS(LcConfigC_selfUnlink); \
 \
  /* create the TCL-class */ \
  OT_SELF_T classO = MK(ClassDef)(interp,ns,LcConfigCTT); \
  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 */ \
  LC(LcConfigC_MK_NULL) = Tcl_GetObjectName(interp, \
    MK(AtomCreate) (MK_RT_CALL interp,  NULL /*obj*/, OT_CLASS, "MK_NULL" /*name*/, "::tcllcconfig::LcConfigC" /*ns*/) \
  ); \
  Tcl_IncrRefCount(LC(LcConfigC_MK_NULL));
 
#define VER TCL_OO_METHOD_VERSION_CURRENT
 
/* LABEL-END */
 
// BEGIN-DOC - created by 'tcl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// doc-key: LcConfigC,LcConfig,sCc,func
#define CTOR_doc "LcConfigC [LcConfigC CTOR]"
#define Create_doc "LcConfigC [LcConfigC Create]"
 
// 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=\"MK_NULL\"? ?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=\"MK_NULL\"?"
#define SetOption_doc "$config SetOption option:LcConfigOptionsEF flag:bool"
#define SetOptions_doc "$config SetOptions options:LcConfigOptionsEF"
#define SetSettingDeleteFunc_doc "$cfg SetSettingDeleteFunc ?fSettingDeleteData:LC_CBP=\"MK_NULL\"?"
#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 'tcl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
/*****************************************************************************/
/*                                                                           */
/*                       C O N / D E - S T R U C T O R                       */
/*                                                                           */
/*****************************************************************************/
 
 
/*****************************************************************************/
/*                                                                           */
/*                        O B J E C T                                        */
/*                                                                           */
/*****************************************************************************/
 
// BEGIN-LcConfigC - created by 'tcl_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_TCL_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_TCL_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_TCL_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_TCL_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_TCL_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_TCL_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_TCL_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_TCL_API
 
 
// doc-key: LcConfigC,LcConfigC-TOR,sCc
 
static OT_ProcRet NS(LcConfigC_CTOR) (CONSTR_ARGS) {
  OT_SETUP_hdl_constr;
  OT_SETUP_CONSTRUCTOR_ARGS(0,0,CTOR_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;
}
 
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;
}
 
// LcConfigC_TOR_TCL_API
 
// END-LcConfigC - created by 'tcl_MqC.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
 
#if 0
// Assumes little endian
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=num; \
  printf("%-40s → %s\n", #num, printBits(4,&tmp)); \
})
 
static OT_ProcRet NS(LcConfigC_test) (LcConfigC_ARGS) {
  MK_UNUSED int __skip; Tcl_Object selfO; LC_CFG hdl; \
  if (objCtx) { \
    /* call method via TCL */ \
    __skip = Tcl_ObjectContextSkippedArgs(objCtx); \
    selfO = Tcl_ObjectContextObject(objCtx); \
    hdl = OBJECT2CFG(selfO); \
    if (hdl == NULL) { \
      Tcl_SetResult(interp, "PointerError: 'LcConfigC' hdl is NULL", TCL_STATIC); \
      return TCL_ERROR; \
    } \
 
printP(hdl)
myprint(MkOBJ_R(hdl).signature);
myprint(MkOBJ_R(hdl).type->objmask);
myprint(LcConfigS_SIGNATURE);
myprint(LcConfigS_MASK);
myprint(MkObjectS_SIGNATURE);
myprint(MkObjectS_MASK);
 
    //if (!__MkCheckX(LcConfig,hdl)) { MkPanicV_1E("broken hdl=%p\n",hdl); } 
  } else { \
    /* call method DIRECT */ \
    __skip = 0; \
    selfO = NULL; \
    hdl = (LC_CFG) clientData; \
  } \
  SetupRtFromHdl(hdl);
 
  return TCL_OK;
/*
  OT_SETUP_hdl
  OT_SETUP_ONEARG(Lookup_doc)
  MK_STRN path = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (path))
  OT_CHECK_NOARGS
  if (hdl->nat == NULL) OT_ERROR_LNG_RETURN_HDL_NAT_NULL(hdl);
  config_setting_t* nat = config_lookup (hdl->nat, path);
  LC_CFS retVal = OT_get_CFS_from_NAT(nat);
  OT_retObj_SET_CFS(retVal)
  goto end;
  error:
  OT_retObj_SET_Error
  end:
  OT_retObj_RETURN
*/
}
#endif
 
// ---------------------------------------------------------------------------------------
 
static Tcl_MethodType NS(sOtClassDef)[] = {
// BEGIN-CLASS - created by 'tcl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// doc-key: LcConfigC,LcConfig,sCc
  {VER, "Create"              , NS(LcConfigC_Create)                    , NULL, NULL},
 
// doc-key: LcConfigC,LcConfig,sc_
  {VER, "GetNull"             , NS(LcConfigC_GetNull)                   , NULL, NULL},
  {VER, "HandleResolve"       , NS(LcConfigC_HandleResolve)             , NULL, NULL},
  {VER, "Instances"           , NS(LcConfigC_Instances)                 , NULL, NULL},
 
// END-CLASS - created by 'tcl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
  {0, NULL, NULL, NULL}
};
 
// ---------------------------------------------------------------------------------------
 
static Tcl_MethodType NS(sInstanceDef)[] = {
//  {VER, "test"              , NS(LcConfigC_test)                    , NULL, NULL},
// BEGIN-OBJ - created by 'tcl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// doc-key: LcConfigC,LcConfig,oC_
  {VER, "<constructor>"       , NS(LcConfigC_CTOR)                      , NULL, NULL},
 
// doc-key: LcConfigC,LcConfig,oc_
  {VER, "Lookup"              , NS(LcConfigC_Lookup)                    , NULL, NULL},
  {VER, "Next"                , NS(LcConfigC_Next)                      , NULL, NULL},
  {VER, "Prev"                , NS(LcConfigC_Prev)                      , NULL, NULL},
  {VER, "RootSetting"         , NS(LcConfigC_RootSetting)               , NULL, NULL},
 
// doc-key: LcConfigC,LcConfig,om_
  {VER, "Clear"               , NS(LcConfigC_Clear)                     , NULL, NULL},
  {VER, "ErrorType"           , NS(LcConfigC_ErrorType)                 , NULL, NULL},
  {VER, "GetDefaultFormat"    , NS(LcConfigC_GetDefaultFormat)          , NULL, NULL},
  {VER, "GetFloatPrecision"   , NS(LcConfigC_GetFloatPrecision)         , NULL, NULL},
  {VER, "GetIncludeDir"       , NS(LcConfigC_GetIncludeDir)             , NULL, NULL},
  {VER, "GetOption"           , NS(LcConfigC_GetOption)                 , NULL, NULL},
  {VER, "GetOptions"          , NS(LcConfigC_GetOptions)                , NULL, NULL},
  {VER, "GetTabWidth"         , NS(LcConfigC_GetTabWidth)               , NULL, NULL},
  // skip class-overload: LcConfigHandleGet → HandleGet, NS(LcConfigC_HandleGet)
  {VER, "Log"                 , NS(LcConfigC_Log)                       , NULL, NULL},
  {VER, "ReadFile"            , NS(LcConfigC_ReadFile)                  , NULL, NULL},
  {VER, "ReadString"          , NS(LcConfigC_ReadString)                , NULL, NULL},
  {VER, "SetDefaultFormat"    , NS(LcConfigC_SetDefaultFormat)          , NULL, NULL},
  {VER, "SetFloatPrecision"   , NS(LcConfigC_SetFloatPrecision)         , NULL, NULL},
  {VER, "SetIncludeDir"       , NS(LcConfigC_SetIncludeDir)             , NULL, NULL},
  {VER, "SetIncludeFunc"      , NS(LcConfigC_SetIncludeFunc)            , NULL, NULL},
  {VER, "SetOption"           , NS(LcConfigC_SetOption)                 , NULL, NULL},
  {VER, "SetOptions"          , NS(LcConfigC_SetOptions)                , NULL, NULL},
  {VER, "SetSettingDeleteFunc", NS(LcConfigC_SetSettingDeleteFunc)      , NULL, NULL},
  {VER, "SetTabWidth"         , NS(LcConfigC_SetTabWidth)               , NULL, NULL},
  {VER, "WriteFile"           , NS(LcConfigC_WriteFile)                 , NULL, NULL},
 
// doc-key: LcConfigC,LcConfig,omo
  {VER, "LookupBool"          , NS(LcConfigC_LookupBool)                , NULL, NULL},
  {VER, "LookupFloat"         , NS(LcConfigC_LookupFloat)               , NULL, NULL},
  {VER, "LookupInt"           , NS(LcConfigC_LookupInt)                 , NULL, NULL},
  {VER, "LookupInt64"         , NS(LcConfigC_LookupInt64)               , NULL, NULL},
  {VER, "LookupString"        , NS(LcConfigC_LookupString)              , NULL, NULL},
  {VER, "WriteString"         , NS(LcConfigC_WriteString)               , NULL, NULL},
 
// END-OBJ - created by 'tcl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
  {0, NULL, NULL, NULL, NULL}
};
 
 
int NS(pLcConfigC_Init) ( MK_RT_ARGS Tcl_Interp *interp, Tcl_Namespace *ns)
{
  ClassInit
  
  return TCL_OK;
error:
  return TCL_ERROR;
}