LcConfigC_atl.c

Go to the documentation of this file.

 
/* LABEL-START */
 
#define   META_FILE_NAME      "LcConfigC_atl.c"
 
#include  "LibLcConfig_private_atl.h"
 
#define   OT_CLASS            alcrt->AtlLcConfigC
#define   OT_NULL             alcrt->AtlLcConfigC_MK_NULL
#define   OT_CLASS_NAME       "LcConfigC"
 
#define   SELF2HDL(O)         LcCfg(VAL2MNG(O))
 
// LNG: class
// -> moved to LibLcConfig_atl.h → OT_LC_RT_S → AtlLcConfigCTT;
 
// META: ObjNew feature: called to return a new or an already existing ATL-SELF-Object
// -> moved to LibLcConfig_atl.h → LcConfigC_ObjNew
 
// 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) {
  SETUP_alcrt(env);
  return AtomMake(obj,OT_CLASS,NULL,NULL,env);
}
 
// 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 selfP, MK_PTR const env) {
  OT_SELF_T selfO = selfP;
  SETUP_alcrt(env);
  MK(AtomDeleteHard) (OT_MK_CALL selfO);
}
 
// META: called to destroy link from SELF to META
static void NS(LcConfigC_selfUnlink) (MK_RT_ARGS MK_PTR selfP, MK_PTR const env) {
  OT_SELF_T selfO = selfP;
  SETUP_alcrt(env);
  return MK(AtomUnlink) (OT_MK_CALL selfO);
}
 
#define OT_SETUP_hdl                  SetupHdlFromMetaData_2(LC_CFG)
#define OT_SETUP_hdl__null_allow      SetupHdlFromMetaData__null_allow_2(LC_CFG)
#define OT_SETUP_hdl_destr            SetupHdlFromMetaData__null_allow_2(LC_CFG)
#define OT_SETUP_hdl_constr           SetupHdlConstr(LcConfigC)
#define OT_SETUP_hdl_static_constr    OT_SETUP_hdl_static
#define OT_SETUP_hdl_static           SetupHdlStatic(LcConfigC)
 
#define OT_retObj_CONSTR(x)           OT_retObj_SET(AtomInit(OT_SELF,LcConfigC_X2obj(x),alcrt))
 
// initialize the ATL and META 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); \
 \
  /* create the ATL-class */ \
  OT_CLASS = AltClassDef(LcConfigCTT,&alcrt->AtlLcConfigC_NS); \
    if (OT_CLASS == NULL) goto error; \
    OT_REF_INCR(OT_CLASS); \
 \
  /* create the ATL static Methods */ \
  check_LNG(AtlUnknownSetup (NS(sOtClassDef),alcrt)) goto error; \
 \
  /* create the ATL instance Methods */ \
  check_LNG(AtlUnknownSetup (NS(sInstanceDef),alcrt)) goto error; \
 \
  /* after class was modified, recompile the class */ \
  RL_init(2, recompile, RL_T(0,RecompileN)); RL_O(1,OT_CLASS) ; \
    int retI = RL_EvalEx(0); \
      if (retI != TCL_OK) return retI; \
 \
  /* define the "NULL" object */ \
  OT_NULL = AtomCreateNULL(OT_CLASS, "::LcConfigC::MK_NULL", (MK_PTR)alcrt); \
    if (OT_NULL == NULL) goto error; \
    OT_REF_INCR(OT_NULL);
/* LABEL-END */
 
// BEGIN-DOC - created by 'atl_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 [LcConfigC::Lookup $config path:string] (const)"
#define Next_doc "LcConfigC [LcConfigC::Next $cfg]"
#define Prev_doc "LcConfigC [LcConfigC::Prev $cfg]"
#define RootSetting_doc "LcSettingC [LcConfigC::RootSetting $config] (const)"
 
// doc-key: LcConfigC,LcConfig,om_,func
#define Clear_doc "LcConfigC::Clear $config"
#define ErrorType_doc "LcErrorTypeE [LcConfigC::ErrorType $config] (const)"
#define GetDefaultFormat_doc "LcConfigFormatE [LcConfigC::GetDefaultFormat $config] (const)"
#define GetFloatPrecision_doc "int16 [LcConfigC::GetFloatPrecision $config] (const)"
#define GetIncludeDir_doc "string [LcConfigC::GetIncludeDir $config] (const)"
#define GetOption_doc "bool [LcConfigC::GetOption $config option:LcConfigOptionsEF] (const)"
#define GetOptions_doc "LcConfigOptionsEF [LcConfigC::GetOptions $config] (const)"
#define GetTabWidth_doc "int16 [LcConfigC::GetTabWidth $config] (const)"
// skip class-overload: HandleGet → MkObjectHandleGet
#define Log_doc "LcConfigC::Log $cfg ?fmtobj:MkObjectC=NULL? ?debug:int32=0? ?callfunc:string=\"MK_NULL\"? ?lvl:int32=0? (const)"
#define ReadFile_doc "LcConfigC::ReadFile $config filename:string"
#define ReadString_doc "LcConfigC::ReadString $config str:string"
#define SetDefaultFormat_doc "LcConfigC::SetDefaultFormat $config format:LcConfigFormatE"
#define SetFloatPrecision_doc "LcConfigC::SetFloatPrecision $config digits:int16"
#define SetIncludeDir_doc "LcConfigC::SetIncludeDir $config include_dir:string"
#define SetIncludeFunc_doc "LcConfigC::SetIncludeFunc $cfg ?fConfigIncludeData:LC_CBP=NULL?"
#define SetOption_doc "LcConfigC::SetOption $config option:LcConfigOptionsEF flag:bool"
#define SetOptions_doc "LcConfigC::SetOptions $config options:LcConfigOptionsEF"
#define SetSettingDeleteFunc_doc "LcConfigC::SetSettingDeleteFunc $cfg ?fSettingDeleteData:LC_CBP=NULL?"
#define SetTabWidth_doc "LcConfigC::SetTabWidth $config width:int16"
#define WriteFile_doc "LcConfigC::WriteFile $config filename:string"
 
// doc-key: LcConfigC,LcConfig,omo,func
#define LookupBool_doc "bool [LcConfigC::LookupBool $config path:string] (const)"
#define LookupFloat_doc "double [LcConfigC::LookupFloat $config path:string] (const)"
#define LookupInt_doc "int32 [LcConfigC::LookupInt $config path:string] (const)"
#define LookupInt64_doc "int64 [LcConfigC::LookupInt64 $config path:string] (const)"
#define LookupString_doc "string [LcConfigC::LookupString $config path:string] (const)"
#define WriteString_doc "string [LcConfigC::WriteString $cfg] (const)"
 
// END-DOC - created by 'atl_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 'atl_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_ATL_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_ATL_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_ATL_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_ATL_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_ATL_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_ATL_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_ATL_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_ATL_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_ATL_API
 
// END-LcConfigC - created by 'atl_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 const OtObjProcDefS NS(sOtClassDef)[] = {
  // BEGIN-CLASS - created by 'atl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  // doc-key: LcConfigC,LcConfig,sCc
  { "::LcConfigC::Create"               , NS(LcConfigC_Create)               },
 
  // doc-key: LcConfigC,LcConfig,sc_
  { "::LcConfigC::GetNull"              , NS(LcConfigC_GetNull)              },
  { "::LcConfigC::HandleResolve"        , NS(LcConfigC_HandleResolve)        },
  { "::LcConfigC::Instances"            , NS(LcConfigC_Instances)            },
 
  // END-CLASS - created by 'atl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
  { NULL }
};
 
// ---------------------------------------------------------------------------------------
 
static const OtObjProcDefS NS(sInstanceDef)[] = {
//  {VER, "test"              , NS(LcConfigC_test)                    , NULL, NULL},
  // BEGIN-OBJ - created by 'atl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  // doc-key: LcConfigC,LcConfig,oC_
  { "::LcConfigC::LcConfigC"            , NS(LcConfigC_CTOR)                 },
 
  // doc-key: LcConfigC,LcConfig,oc_
  { "::LcConfigC::Lookup"               , NS(LcConfigC_Lookup)               },
  { "::LcConfigC::Next"                 , NS(LcConfigC_Next)                 },
  { "::LcConfigC::Prev"                 , NS(LcConfigC_Prev)                 },
  { "::LcConfigC::RootSetting"          , NS(LcConfigC_RootSetting)          },
 
  // doc-key: LcConfigC,LcConfig,om_
  { "::LcConfigC::Clear"                , NS(LcConfigC_Clear)                },
  { "::LcConfigC::ErrorType"            , NS(LcConfigC_ErrorType)            },
  { "::LcConfigC::GetDefaultFormat"     , NS(LcConfigC_GetDefaultFormat)     },
  { "::LcConfigC::GetFloatPrecision"    , NS(LcConfigC_GetFloatPrecision)    },
  { "::LcConfigC::GetIncludeDir"        , NS(LcConfigC_GetIncludeDir)        },
  { "::LcConfigC::GetOption"            , NS(LcConfigC_GetOption)            },
  { "::LcConfigC::GetOptions"           , NS(LcConfigC_GetOptions)           },
  { "::LcConfigC::GetTabWidth"          , NS(LcConfigC_GetTabWidth)          },
  // skip class-overload: HandleGet → MkObjectHandleGet
  { "::LcConfigC::Log"                  , NS(LcConfigC_Log)                  },
  { "::LcConfigC::ReadFile"             , NS(LcConfigC_ReadFile)             },
  { "::LcConfigC::ReadString"           , NS(LcConfigC_ReadString)           },
  { "::LcConfigC::SetDefaultFormat"     , NS(LcConfigC_SetDefaultFormat)     },
  { "::LcConfigC::SetFloatPrecision"    , NS(LcConfigC_SetFloatPrecision)    },
  { "::LcConfigC::SetIncludeDir"        , NS(LcConfigC_SetIncludeDir)        },
  { "::LcConfigC::SetIncludeFunc"       , NS(LcConfigC_SetIncludeFunc)       },
  { "::LcConfigC::SetOption"            , NS(LcConfigC_SetOption)            },
  { "::LcConfigC::SetOptions"           , NS(LcConfigC_SetOptions)           },
  { "::LcConfigC::SetSettingDeleteFunc" , NS(LcConfigC_SetSettingDeleteFunc) },
  { "::LcConfigC::SetTabWidth"          , NS(LcConfigC_SetTabWidth)          },
  { "::LcConfigC::WriteFile"            , NS(LcConfigC_WriteFile)            },
 
  // doc-key: LcConfigC,LcConfig,omo
  { "::LcConfigC::LookupBool"           , NS(LcConfigC_LookupBool)           },
  { "::LcConfigC::LookupFloat"          , NS(LcConfigC_LookupFloat)          },
  { "::LcConfigC::LookupInt"            , NS(LcConfigC_LookupInt)            },
  { "::LcConfigC::LookupInt64"          , NS(LcConfigC_LookupInt64)          },
  { "::LcConfigC::LookupString"         , NS(LcConfigC_LookupString)         },
  { "::LcConfigC::WriteString"          , NS(LcConfigC_WriteString)          },
 
  // END-OBJ - created by 'atl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
  { NULL }
};
 
 
int NS(pLcConfigC_Init) ( OT_LC_ARGS OT_NS_T ns )
{
  ClassInit
  
  return TCL_OK;
error:
  return TCL_ERROR;
}