LcConfigC_rb.c

Go to the documentation of this file.

 
/* LABEL-START */
#define META_FILE_NAME "LcConfigC_rb.c"
 
#include  "LibLcConfig_private_rb.h"
 
#define OT_CLASS            NS(LcConfigC)
#define OT_CLASS_NAME       "LcConfigC"
 
#define OT_LNG2META(O)      LcCfg(VAL2MNG(O))
 
OT_CLS_T OT_CLASS;
 
// new Class type object
static MK_TYP LcConfigCTT = NULL;
OT_OBJ_T LC(LcConfigC_MK_NULL) = 0;
 
// GS marker in "Data_Wrap_Struct"
static void  NS(sMark)    (MK_PTR);
 
// ruby datatype of the wrapped struct
static rb_data_type_t NS(LcConfigC_T) = {
  "LcConfigC",
  {
    NS(sMark),
    MK(AtomDeleteSoft),
    0, /* dsize */
    0, /* reserved[1] */
  },
  NULL, /* parent */
  NULL, /* data */
  RUBY_TYPED_FREE_IMMEDIATELY
};
 
// >>THIS<< is a Phase-1-CONSTRUCTOR: a constructor which create the SELF object
// A Phase-2-CONSTRUCTOR is a constructor which configure an already existing object
// DO: create a new SELF and link this SELF with the MQ-Object "mng"
// clazz is the toplevel "subclass" or "LcConfigC"
mk_inline OT_OBJ_T NS(LNG_CONSTR) (OT_CLS_T clazz, MK_MNG mng, int objc, VALUE* objv) {
  return MK(AtomObjCrt)(clazz,&NS(LcConfigC_T),mng,objc,objv);
}
// MQ: ObjNew feature: called to return a new or an already existing RUBY-SELF-Object
// -> moved to: msgque_rb.h
// OT_OBJ_T NS(LcConfigC_ObjNew) (MK_CFG hdl) {
//   return MK(AtomObjNew) (LcConfigC_X2obj(hdl));
// }
// MQ: 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 obj, MK_PTR envP) {
  OT_OBJ_T self = NS(LNG_CONSTR) (OT_CLASS, obj, 0, NULL);
  return VAL2PTR(self);
}
// MQ: called on instance-destruction for a "selfCreate" instance → goal: destroy the SELF
static void NS(LcConfigC_selfDelete) (MK_RT_ARGS MK_PTR ptr, MK_PTR envP) {
  OT_OBJECT_DELETE_HARD(PTR2VAL(ptr));
}
// MQ: called to destroy link from SELF to META
static void NS(LcConfigC_selfUnlink) (MK_RT_ARGS MK_PTR ptr, MK_PTR envP) {
  OT_OBJ_T self =  PTR2VAL(ptr);
  RDATA(self)->data = NULL;
}
// initialize the RUBY and MO class specific object
#define S_INIT NS(sInit)(MK_RT_CALL_ONLY)
static void NS(sInit)(MK_RT_ARGS_ONLY) {
 
  // add "selfCreate" and "selfDelete" feature to the MQ-LcConfigC-Type
  LcConfigCTT->selfCreate    = NS(LcConfigC_selfCreate);
  LcConfigCTT->selfDelete    = NS(LcConfigC_selfDelete);
  LcConfigCTT->selfUnlink    = NS(LcConfigC_selfUnlink);
 
  // create the RUBY class
  OT_CLASS = rb_define_class_under(OT_PKG, "LcConfigC", MK_BASE_CLASS);
  rb_undef_alloc_func(OT_CLASS);
 
  /* define the "NULL" object */
  VALUE nullO = TypedData_Wrap_Struct (OT_CLASS, &NS(LcConfigC_T), MK_NULL);
  NS(LcConfigC_MK_NULL) = nullO;
  INCR_REF(&NS(LcConfigC_MK_NULL));
}
 
#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         AllRtSetup_NULL; \
                                    OT_OBJ_T clazz = self; \
                                    LcConfigC_type hdl = (LcConfigC_type) &MkERROR;
#define OT_SETUP_hdl_destr          OT_SETUP_hdl_tmpl__null_allow(LcConfigC);
#define OT_SETUP_hdl_static         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
 
/* LABEL-END */
 
// BEGIN-DOC - created by 'rb_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=nil?, ?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=nil?)"
#define SetOption_doc "config.SetOption(option:LcConfigOptionsEF, flag:bool)"
#define SetOptions_doc "config.SetOptions(options:LcConfigOptionsEF)"
#define SetSettingDeleteFunc_doc "cfg.SetSettingDeleteFunc(?fSettingDeleteData:LC_CBP=nil?)"
#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 'rb_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
/*****************************************************************************/
/*                                                                           */
/*                              O B J E C T                                  */
/*                                                                           */
/*****************************************************************************/
 
// BEGIN-LcConfigC - created by 'rb_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);
  end: MK_UNUSED  /* LONG JUMP on error */
  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_RB_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);
  end: MK_UNUSED  /* LONG JUMP on error */
  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);
  end: MK_UNUSED  /* LONG JUMP on error */
  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);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// LcConfigC_Class_RB_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);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// LcConfigC_Class_RB_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)));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// LcConfigC_Error_RB_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)));
  end: MK_UNUSED  /* LONG JUMP on error */
  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));
  end: MK_UNUSED  /* LONG JUMP on error */
  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));
  end: MK_UNUSED  /* LONG JUMP on error */
  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));
  end: MK_UNUSED  /* LONG JUMP on error */
  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)));
  end: MK_UNUSED  /* LONG JUMP on error */
  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));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// LcConfigC_Get_RB_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);
  end: MK_UNUSED  /* LONG JUMP on error */
  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);
  end: MK_UNUSED  /* LONG JUMP on error */
  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);
  end: MK_UNUSED  /* LONG JUMP on error */
  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);
  end: MK_UNUSED  /* LONG JUMP on error */
  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);
  end: MK_UNUSED  /* LONG JUMP on error */
  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);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// LcConfigC_Lookup_RB_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);
  end: MK_UNUSED  /* LONG JUMP on error */
  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;
  end: MK_UNUSED  /* LONG JUMP on error */
  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;
  end: MK_UNUSED  /* LONG JUMP on error */
  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;
  end: MK_UNUSED  /* LONG JUMP on error */
  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;
  end: MK_UNUSED  /* LONG JUMP on error */
  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;
  end: MK_UNUSED  /* LONG JUMP on error */
  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);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// LcConfigC_Misc_RB_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;
  end: MK_UNUSED  /* LONG JUMP on error */
  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;
  end: MK_UNUSED  /* LONG JUMP on error */
  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;
  end: MK_UNUSED  /* LONG JUMP on error */
  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;
  end: MK_UNUSED  /* LONG JUMP on error */
  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;
  end: MK_UNUSED  /* LONG JUMP on error */
  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;
  end: MK_UNUSED  /* LONG JUMP on error */
  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;
  end: MK_UNUSED  /* LONG JUMP on error */
  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;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// LcConfigC_Set_RB_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);
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_SET_CFG(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  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);
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_CONSTR(retVal);
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// LcConfigC_TOR_RB_API
 
// END-LcConfigC - created by 'rb_MqC.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
/*****************************************************************************/
/*                                                                           */
/*                                public                                     */
/*                                                                           */
/*****************************************************************************/
 
void NS(sMark) (MK_PTR ptr) {
}
 
void LC(LcConfigC_Init) (MK_RT_ARGS_ONLY) {
 
  // init type
  LcConfigCTT = LcConfigC_TT;
  S_INIT;
 
// BEGIN-CLASS - created by 'rb_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// doc-key: LcConfigC,LcConfig,sCc
OT_METH_S ( LcConfigC, Create,                    LcConfigC_Create                    )
OT_METH_C ( LcConfigC, new,                       LcConfigC_new                       )
 
// doc-key: LcConfigC,LcConfig,sc_
OT_METH_O ( LcConfigC, GetNull,                   LcConfigC_GetNull                   )
OT_METH_S ( LcConfigC, GetNull,                   LcConfigC_GetNull                   )
OT_METH_O ( LcConfigC, HandleResolve,             LcConfigC_HandleResolve             )
OT_METH_S ( LcConfigC, HandleResolve,             LcConfigC_HandleResolve             )
OT_METH_O ( LcConfigC, Instances,                 LcConfigC_Instances                 )
OT_METH_S ( LcConfigC, Instances,                 LcConfigC_Instances                 )
 
// END-CLASS - created by 'rb_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// BEGIN-OBJ - created by 'rb_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// doc-key: LcConfigC,LcConfig,oc_
OT_METH_O ( LcConfigC, Lookup,                    LcConfigC_Lookup                    )
OT_METH_O ( LcConfigC, Next,                      LcConfigC_Next                      )
OT_METH_O ( LcConfigC, Prev,                      LcConfigC_Prev                      )
OT_METH_O ( LcConfigC, RootSetting,               LcConfigC_RootSetting               )
 
// doc-key: LcConfigC,LcConfig,om_
OT_METH_O ( LcConfigC, Clear,                     LcConfigC_Clear                     )
OT_METH_O ( LcConfigC, ErrorType,                 LcConfigC_ErrorType                 )
OT_METH_O ( LcConfigC, GetDefaultFormat,          LcConfigC_GetDefaultFormat          )
OT_METH_O ( LcConfigC, GetFloatPrecision,         LcConfigC_GetFloatPrecision         )
OT_METH_O ( LcConfigC, GetIncludeDir,             LcConfigC_GetIncludeDir             )
OT_METH_O ( LcConfigC, GetOption,                 LcConfigC_GetOption                 )
OT_METH_O ( LcConfigC, GetOptions,                LcConfigC_GetOptions                )
OT_METH_O ( LcConfigC, GetTabWidth,               LcConfigC_GetTabWidth               )
// skip class-overload: LcConfigHandleGet → HandleGet, LcConfigC_HandleGet
OT_METH_O ( LcConfigC, Log,                       LcConfigC_Log                       )
OT_METH_O ( LcConfigC, ReadFile,                  LcConfigC_ReadFile                  )
OT_METH_O ( LcConfigC, ReadString,                LcConfigC_ReadString                )
OT_METH_O ( LcConfigC, SetDefaultFormat,          LcConfigC_SetDefaultFormat          )
OT_METH_O ( LcConfigC, SetFloatPrecision,         LcConfigC_SetFloatPrecision         )
OT_METH_O ( LcConfigC, SetIncludeDir,             LcConfigC_SetIncludeDir             )
OT_METH_O ( LcConfigC, SetIncludeFunc,            LcConfigC_SetIncludeFunc            )
OT_METH_O ( LcConfigC, SetOption,                 LcConfigC_SetOption                 )
OT_METH_O ( LcConfigC, SetOptions,                LcConfigC_SetOptions                )
OT_METH_O ( LcConfigC, SetSettingDeleteFunc,      LcConfigC_SetSettingDeleteFunc      )
OT_METH_O ( LcConfigC, SetTabWidth,               LcConfigC_SetTabWidth               )
OT_METH_O ( LcConfigC, WriteFile,                 LcConfigC_WriteFile                 )
 
// doc-key: LcConfigC,LcConfig,omo
OT_METH_O ( LcConfigC, LookupBool,                LcConfigC_LookupBool                )
OT_METH_O ( LcConfigC, LookupFloat,               LcConfigC_LookupFloat               )
OT_METH_O ( LcConfigC, LookupInt,                 LcConfigC_LookupInt                 )
OT_METH_O ( LcConfigC, LookupInt64,               LcConfigC_LookupInt64               )
OT_METH_O ( LcConfigC, LookupString,              LcConfigC_LookupString              )
OT_METH_O ( LcConfigC, WriteString,               LcConfigC_WriteString               )
 
// END-OBJ - created by 'rb_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
}