LibLcConfig_tcl.c

Go to the documentation of this file.

 
/* LABEL-NO */
 
#define   META_FILE_NAME          "LibLcConfig_tcl.c"
#define   VER                     TCL_OO_METHOD_VERSION_CURRENT
 
#include  "LibLcConfig_private_tcl.h"
 
#undef OtClass_ARGS
#define OtClass_ARGS  OBJCMD_ARGS
 
#define OT_SETUP_hdl_static \
  int __skip=1;\
  /* printAry2("cmd",objc,objv); */ \
  __attribute__((unused)) MK_RT mkrt = MkRT; \
  __attribute__((unused)) MK_ERR hdl = &MkERROR;
 
/* LABEL-END */
 
//#include <limits.h>
//#include <float.h>
 
#define LcSetupTmpl()
#define LcCleanupTmpl()
 
// MARK_D ################################################################
// -----------------------------------------------------------------------
// documentation order
// --------------------------------------------------------------------------------
 
// BEGIN-DOC - created by 'tcl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// doc-key: LcConfig,EnumFunc,sco,func
#define ConfigFormatE_FromInt_doc "LcConfigFormatE [LcConfig ConfigFormatE_FromInt value:int32]"
#define ConfigOptionsEF_FromInt_doc "LcConfigOptionsEF [LcConfig ConfigOptionsEF_FromInt value:int32]"
#define ConfigTypeE_FromInt_doc "LcConfigTypeE [LcConfig ConfigTypeE_FromInt value:int32]"
#define ErrorE_FromInt_doc "LcErrorE [LcConfig ErrorE_FromInt value:int32]"
#define ErrorTypeE_FromInt_doc "LcErrorTypeE [LcConfig ErrorTypeE_FromInt value:int32]"
 
// doc-key: LcConfig,EnumFunc,sm_,func
#define ConfigFormatE_ToInt_doc "int32 [LcConfig ConfigFormatE_ToInt value:LcConfigFormatE]"
#define ConfigFormatE_ToString_doc "string [LcConfig ConfigFormatE_ToString value:LcConfigFormatE]"
#define ConfigOptionsEF_ToInt_doc "int32 [LcConfig ConfigOptionsEF_ToInt value:LcConfigOptionsEF]"
#define ConfigOptionsEF_ToString_doc "string [LcConfig ConfigOptionsEF_ToString value:LcConfigOptionsEF]"
#define ConfigTypeE_ToInt_doc "int32 [LcConfig ConfigTypeE_ToInt value:LcConfigTypeE]"
#define ConfigTypeE_ToString_doc "string [LcConfig ConfigTypeE_ToString value:LcConfigTypeE]"
#define ErrorE_ToInt_doc "int32 [LcConfig ErrorE_ToInt value:LcErrorE]"
#define ErrorE_ToString_doc "string [LcConfig ErrorE_ToString value:LcErrorE]"
#define ErrorTypeE_ToInt_doc "int32 [LcConfig ErrorTypeE_ToInt value:LcErrorTypeE]"
#define ErrorTypeE_ToString_doc "string [LcConfig ErrorTypeE_ToString value:LcErrorTypeE]"
 
// doc-key: LcConfig,Setup,sm_,func
#define Cleanup_doc "LcConfig Cleanup"
#define Setup_doc "LcConfig Setup"
 
// END-DOC - created by 'tcl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
 
/*****************************************************************************/
/*                                                                           */
/*                                helper                                     */
/*                                                                           */
/*****************************************************************************/
 
// BEGIN-Enum-ToString - created by 'tcl_MqC.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
 
OT_OBJ_T LC(LcConfigFormatE_ToString) ( const enum LcConfigFormatE type ) 
{
  switch (type) {
    case CONFIG_FORMAT_DEFAULT : return ot_fixstrobj("DEFAULT") ;
    case CONFIG_FORMAT_HEX     : return ot_fixstrobj("HEX"    ) ;
  }
  return ot_fixstrobj("NOTHING");
}
 
OT_OBJ_T LC(LcConfigOptionsEF_ToString) ( const  enum LcConfigOptionsEF type ) 
{
  if (type == CONFIG_OPTION_NONE) {
    return ot_fixstrobj("NONE");
  } else {
    OT_OBJ_T tmpO = Tcl_NewObj();
    if (mk_bit_compare(type,CONFIG_OPTION_AUTOCONVERT                    )) ot_enum_append(tmpO,"AUTOCONVERT"                    ) ;
    if (mk_bit_compare(type,CONFIG_OPTION_SEMICOLON_SEPARATORS           )) ot_enum_append(tmpO,"SEMICOLON_SEPARATORS"           ) ;
    if (mk_bit_compare(type,CONFIG_OPTION_COLON_ASSIGNMENT_FOR_GROUPS    )) ot_enum_append(tmpO,"COLON_ASSIGNMENT_FOR_GROUPS"    ) ;
    if (mk_bit_compare(type,CONFIG_OPTION_COLON_ASSIGNMENT_FOR_NON_GROUPS)) ot_enum_append(tmpO,"COLON_ASSIGNMENT_FOR_NON_GROUPS") ;
    if (mk_bit_compare(type,CONFIG_OPTION_OPEN_BRACE_ON_SEPARATE_LINE    )) ot_enum_append(tmpO,"OPEN_BRACE_ON_SEPARATE_LINE"    ) ;
    if (mk_bit_compare(type,CONFIG_OPTION_ALLOW_SCIENTIFIC_NOTATION      )) ot_enum_append(tmpO,"ALLOW_SCIENTIFIC_NOTATION"      ) ;
    if (mk_bit_compare(type,CONFIG_OPTION_FSYNC                          )) ot_enum_append(tmpO,"FSYNC"                          ) ;
    if (mk_bit_compare(type,CONFIG_OPTION_ALLOW_OVERRIDES                )) ot_enum_append(tmpO,"ALLOW_OVERRIDES"                ) ;
    return tmpO;
  }
}
 
OT_OBJ_T LC(LcConfigTypeE_ToString) ( const enum LcConfigTypeE type ) 
{
  switch (type) {
    case CONFIG_TYPE_NONE   : return ot_fixstrobj("NONE"  ) ;
    case CONFIG_TYPE_GROUP  : return ot_fixstrobj("GROUP" ) ;
    case CONFIG_TYPE_INT    : return ot_fixstrobj("INT"   ) ;
    case CONFIG_TYPE_INT64  : return ot_fixstrobj("INT64" ) ;
    case CONFIG_TYPE_FLOAT  : return ot_fixstrobj("FLOAT" ) ;
    case CONFIG_TYPE_STRING : return ot_fixstrobj("STRING") ;
    case CONFIG_TYPE_BOOL   : return ot_fixstrobj("BOOL"  ) ;
    case CONFIG_TYPE_ARRAY  : return ot_fixstrobj("ARRAY" ) ;
    case CONFIG_TYPE_LIST   : return ot_fixstrobj("LIST"  ) ;
  }
  return ot_fixstrobj("NOTHING");
}
 
OT_OBJ_T LC(LcErrorE_ToString) ( const enum LcErrorE type ) 
{
  switch (type) {
    case CONFIG_FALSE : return ot_fixstrobj("FALSE") ;
    case CONFIG_TRUE  : return ot_fixstrobj("TRUE" ) ;
  }
  return ot_fixstrobj("NOTHING");
}
 
OT_OBJ_T LC(LcErrorTypeE_ToString) ( const enum LcErrorTypeE type ) 
{
  switch (type) {
    case CONFIG_ERRROR_NONE    : return ot_fixstrobj("NONE"   ) ;
    case CONFIG_ERRROR_FILE_IO : return ot_fixstrobj("FILE_IO") ;
    case CONFIG_ERRROR_PARSE   : return ot_fixstrobj("PARSE"  ) ;
  }
  return ot_fixstrobj("NOTHING");
}
 
// END-Enum-ToString - created by 'tcl_MqC.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// BEGIN-enum - created by 'tcl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
 
int LC(Get_LcConfigFormatE_FromObj) (MK_RT_ARGS OT_ENV_T interp, OT_OBJ_T enumE, enum LcConfigFormatE *ret) {
  const static struct LookupEnumE keys[] = {
    { "HEX"                   , CONFIG_FORMAT_HEX     },
    { "DEFAULT"               , CONFIG_FORMAT_DEFAULT },
    { "FORMAT_HEX"            , CONFIG_FORMAT_HEX     },
    { "FORMAT_DEFAULT"        , CONFIG_FORMAT_DEFAULT },
    { "CONFIG_FORMAT_HEX"     , CONFIG_FORMAT_HEX     },
    { "CONFIG_FORMAT_DEFAULT" , CONFIG_FORMAT_DEFAULT },
    { NULL                    , 0                     },
  };
 
  int index;
  OtErrorCheckLng (Tcl_GetIndexFromObjStruct (interp, enumE, &keys,
      sizeof(struct LookupClassS), "enum", TCL_EXACT, &index));
  *ret = keys[index].val;
  return TCL_OK;
}
 
int LC(Get_LcConfigOptionsEF_FromObj) (MK_RT_ARGS OT_ENV_T interp, OT_OBJ_T enumE, enum LcConfigOptionsEF *ret) {
  const static struct LookupEnumE keys[] = {
    { "NONE"                                          , CONFIG_OPTION_NONE                            },
    { "FSYNC"                                         , CONFIG_OPTION_FSYNC                           },
    { "OPTION_NONE"                                   , CONFIG_OPTION_NONE                            },
    { "AUTOCONVERT"                                   , CONFIG_OPTION_AUTOCONVERT                     },
    { "OPTION_FSYNC"                                  , CONFIG_OPTION_FSYNC                           },
    { "ALLOW_OVERRIDES"                               , CONFIG_OPTION_ALLOW_OVERRIDES                 },
    { "OPTION_AUTOCONVERT"                            , CONFIG_OPTION_AUTOCONVERT                     },
    { "CONFIG_OPTION_NONE"                            , CONFIG_OPTION_NONE                            },
    { "CONFIG_OPTION_FSYNC"                           , CONFIG_OPTION_FSYNC                           },
    { "SEMICOLON_SEPARATORS"                          , CONFIG_OPTION_SEMICOLON_SEPARATORS            },
    { "OPTION_ALLOW_OVERRIDES"                        , CONFIG_OPTION_ALLOW_OVERRIDES                 },
    { "CONFIG_OPTION_AUTOCONVERT"                     , CONFIG_OPTION_AUTOCONVERT                     },
    { "ALLOW_SCIENTIFIC_NOTATION"                     , CONFIG_OPTION_ALLOW_SCIENTIFIC_NOTATION       },
    { "OPEN_BRACE_ON_SEPARATE_LINE"                   , CONFIG_OPTION_OPEN_BRACE_ON_SEPARATE_LINE     },
    { "COLON_ASSIGNMENT_FOR_GROUPS"                   , CONFIG_OPTION_COLON_ASSIGNMENT_FOR_GROUPS     },
    { "OPTION_SEMICOLON_SEPARATORS"                   , CONFIG_OPTION_SEMICOLON_SEPARATORS            },
    { "CONFIG_OPTION_ALLOW_OVERRIDES"                 , CONFIG_OPTION_ALLOW_OVERRIDES                 },
    { "COLON_ASSIGNMENT_FOR_NON_GROUPS"               , CONFIG_OPTION_COLON_ASSIGNMENT_FOR_NON_GROUPS },
    { "OPTION_ALLOW_SCIENTIFIC_NOTATION"              , CONFIG_OPTION_ALLOW_SCIENTIFIC_NOTATION       },
    { "OPTION_OPEN_BRACE_ON_SEPARATE_LINE"            , CONFIG_OPTION_OPEN_BRACE_ON_SEPARATE_LINE     },
    { "OPTION_COLON_ASSIGNMENT_FOR_GROUPS"            , CONFIG_OPTION_COLON_ASSIGNMENT_FOR_GROUPS     },
    { "CONFIG_OPTION_SEMICOLON_SEPARATORS"            , CONFIG_OPTION_SEMICOLON_SEPARATORS            },
    { "OPTION_COLON_ASSIGNMENT_FOR_NON_GROUPS"        , CONFIG_OPTION_COLON_ASSIGNMENT_FOR_NON_GROUPS },
    { "CONFIG_OPTION_ALLOW_SCIENTIFIC_NOTATION"       , CONFIG_OPTION_ALLOW_SCIENTIFIC_NOTATION       },
    { "CONFIG_OPTION_OPEN_BRACE_ON_SEPARATE_LINE"     , CONFIG_OPTION_OPEN_BRACE_ON_SEPARATE_LINE     },
    { "CONFIG_OPTION_COLON_ASSIGNMENT_FOR_GROUPS"     , CONFIG_OPTION_COLON_ASSIGNMENT_FOR_GROUPS     },
    { "CONFIG_OPTION_COLON_ASSIGNMENT_FOR_NON_GROUPS" , CONFIG_OPTION_COLON_ASSIGNMENT_FOR_NON_GROUPS },
    { NULL                                            , 0                                             },
  };
 
  int index;
  OtErrorCheckLng(MK(EnumFlagWorker)(MK_RT_CALL interp,keys,enumE,&index));
  *ret = (enum LcConfigOptionsEF) index;
  return TCL_OK;
}
 
int LC(Get_LcConfigTypeE_FromObj) (MK_RT_ARGS OT_ENV_T interp, OT_OBJ_T enumE, enum LcConfigTypeE *ret) {
  const static struct LookupEnumE keys[] = {
    { "INT"                , CONFIG_TYPE_INT    },
    { "NONE"               , CONFIG_TYPE_NONE   },
    { "BOOL"               , CONFIG_TYPE_BOOL   },
    { "LIST"               , CONFIG_TYPE_LIST   },
    { "GROUP"              , CONFIG_TYPE_GROUP  },
    { "INT64"              , CONFIG_TYPE_INT64  },
    { "ARRAY"              , CONFIG_TYPE_ARRAY  },
    { "FLOAT"              , CONFIG_TYPE_FLOAT  },
    { "STRING"             , CONFIG_TYPE_STRING },
    { "TYPE_INT"           , CONFIG_TYPE_INT    },
    { "TYPE_NONE"          , CONFIG_TYPE_NONE   },
    { "TYPE_BOOL"          , CONFIG_TYPE_BOOL   },
    { "TYPE_LIST"          , CONFIG_TYPE_LIST   },
    { "TYPE_ARRAY"         , CONFIG_TYPE_ARRAY  },
    { "TYPE_FLOAT"         , CONFIG_TYPE_FLOAT  },
    { "TYPE_GROUP"         , CONFIG_TYPE_GROUP  },
    { "TYPE_INT64"         , CONFIG_TYPE_INT64  },
    { "TYPE_STRING"        , CONFIG_TYPE_STRING },
    { "CONFIG_TYPE_INT"    , CONFIG_TYPE_INT    },
    { "CONFIG_TYPE_BOOL"   , CONFIG_TYPE_BOOL   },
    { "CONFIG_TYPE_LIST"   , CONFIG_TYPE_LIST   },
    { "CONFIG_TYPE_NONE"   , CONFIG_TYPE_NONE   },
    { "CONFIG_TYPE_GROUP"  , CONFIG_TYPE_GROUP  },
    { "CONFIG_TYPE_INT64"  , CONFIG_TYPE_INT64  },
    { "CONFIG_TYPE_ARRAY"  , CONFIG_TYPE_ARRAY  },
    { "CONFIG_TYPE_FLOAT"  , CONFIG_TYPE_FLOAT  },
    { "CONFIG_TYPE_STRING" , CONFIG_TYPE_STRING },
    { NULL                 , 0                  },
  };
 
  int index;
  OtErrorCheckLng (Tcl_GetIndexFromObjStruct (interp, enumE, &keys,
      sizeof(struct LookupClassS), "enum", TCL_EXACT, &index));
  *ret = keys[index].val;
  return TCL_OK;
}
 
int LC(Get_LcErrorE_FromObj) (MK_RT_ARGS OT_ENV_T interp, OT_OBJ_T enumE, enum LcErrorE *ret) {
  const static struct LookupEnumE keys[] = {
    { "TRUE"         , CONFIG_TRUE  },
    { "FALSE"        , CONFIG_FALSE },
    { "CONFIG_TRUE"  , CONFIG_TRUE  },
    { "CONFIG_FALSE" , CONFIG_FALSE },
    { NULL           , 0            },
  };
 
  int index;
  OtErrorCheckLng (Tcl_GetIndexFromObjStruct (interp, enumE, &keys,
      sizeof(struct LookupClassS), "enum", TCL_EXACT, &index));
  *ret = keys[index].val;
  return TCL_OK;
}
 
int LC(Get_LcErrorTypeE_FromObj) (MK_RT_ARGS OT_ENV_T interp, OT_OBJ_T enumE, enum LcErrorTypeE *ret) {
  const static struct LookupEnumE keys[] = {
    { "NONE"                  , CONFIG_ERRROR_NONE    },
    { "PARSE"                 , CONFIG_ERRROR_PARSE   },
    { "FILE_IO"               , CONFIG_ERRROR_FILE_IO },
    { "ERRROR_NONE"           , CONFIG_ERRROR_NONE    },
    { "ERRROR_PARSE"          , CONFIG_ERRROR_PARSE   },
    { "ERRROR_FILE_IO"        , CONFIG_ERRROR_FILE_IO },
    { "CONFIG_ERRROR_NONE"    , CONFIG_ERRROR_NONE    },
    { "CONFIG_ERRROR_PARSE"   , CONFIG_ERRROR_PARSE   },
    { "CONFIG_ERRROR_FILE_IO" , CONFIG_ERRROR_FILE_IO },
    { NULL                    , 0                     },
  };
 
  int index;
  OtErrorCheckLng (Tcl_GetIndexFromObjStruct (interp, enumE, &keys,
      sizeof(struct LookupClassS), "enum", TCL_EXACT, &index));
  *ret = keys[index].val;
  return TCL_OK;
}
 
// END-enum - created by 'tcl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
/*****************************************************************************/
/*                                                                           */
/*                                 Check                                     */
/*                                                                           */
/*****************************************************************************/
 
#include "tmpl/lc_misc_check_lng.h"
 
/*****************************************************************************/
/*                                                                           */
/*                               enum                                        */
/*                                                                           */
/*****************************************************************************/
 
/*****************************************************************************/
/*                                                                           */
/*                               subcommands                                 */
/*                                                                           */
/*****************************************************************************/
 
// BEGIN-LcConfig - created by 'tcl_MqC.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
 
// doc-key: LcConfig,LcConfig-Enum,sco
 
static OT_ProcRet NS(LcConfig_ConfigFormatE_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ConfigFormatE_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum LcConfigFormatE value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,LcConfigFormatE_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Lc_enum_OBJ(ConfigFormatE,value_out));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ConfigOptionsEF_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ConfigOptionsEF_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum LcConfigOptionsEF value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,LcConfigOptionsEF_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Lc_enum_OBJ(ConfigOptionsEF,value_out));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ConfigTypeE_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ConfigTypeE_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum LcConfigTypeE value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,LcConfigTypeE_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Lc_enum_OBJ(ConfigTypeE,value_out));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ErrorE_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ErrorE_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum LcErrorE value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,LcErrorE_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Lc_enum_OBJ(ErrorE,value_out));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ErrorTypeE_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ErrorTypeE_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum LcErrorTypeE value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,LcErrorTypeE_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Lc_enum_OBJ(ErrorTypeE,value_out));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: LcConfig,LcConfig-Enum,sm_
 
static OT_ProcRet NS(LcConfig_ConfigFormatE_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ConfigFormatE_ToInt_doc);
  enum LcConfigFormatE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcConfigFormatE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(LcConfigFormatE_ToInt (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ConfigFormatE_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ConfigFormatE_ToString_doc);
  enum LcConfigFormatE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcConfigFormatE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(LcConfigFormatE_ToString (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ConfigOptionsEF_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ConfigOptionsEF_ToInt_doc);
  enum LcConfigOptionsEF value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcConfigOptionsEF,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(LcConfigOptionsEF_ToInt (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ConfigOptionsEF_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ConfigOptionsEF_ToString_doc);
  enum LcConfigOptionsEF value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcConfigOptionsEF,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(LcConfigOptionsEF_ToString (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ConfigTypeE_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ConfigTypeE_ToInt_doc);
  enum LcConfigTypeE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcConfigTypeE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(LcConfigTypeE_ToInt (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ConfigTypeE_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ConfigTypeE_ToString_doc);
  enum LcConfigTypeE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcConfigTypeE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(LcConfigTypeE_ToString (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ErrorE_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ErrorE_ToInt_doc);
  enum LcErrorE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcErrorE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(LcErrorE_ToInt (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ErrorE_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ErrorE_ToString_doc);
  enum LcErrorE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcErrorE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(LcErrorE_ToString (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ErrorTypeE_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ErrorTypeE_ToInt_doc);
  enum LcErrorTypeE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcErrorTypeE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(LcErrorTypeE_ToInt (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_ErrorTypeE_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ErrorTypeE_ToString_doc);
  enum LcErrorTypeE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcErrorTypeE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(LcErrorTypeE_ToString (value));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// LcConfig_Enum_TCL_API
 
 
// doc-key: LcConfig,LcConfig-Setup,sm_
 
static OT_ProcRet NS(LcConfig_Cleanup) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Cleanup_doc);
  OT_CHECK_NOARGS;
  LcCleanupTmpl ();
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(LcConfig_Setup) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Setup_doc);
  OT_CHECK_NOARGS;
  LcSetupTmpl ();
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// LcConfig_Setup_TCL_API
 
// END-LcConfig - created by 'tcl_MqC.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
 
// ---------------------------------------------------------------------------------------
 
__attribute__((unused)) const static OtObjProcDefS NS(sOtClassDef)[] = {
// BEGIN-CLASS - created by 'tcl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// doc-key: LcConfig,EnumFunc,sco
  {VER, "ConfigFormatE_FromInt", NS(LcConfig_ConfigFormatE_FromInt)      , NULL, NULL},
  {VER, "ConfigOptionsEF_FromInt", NS(LcConfig_ConfigOptionsEF_FromInt)    , NULL, NULL},
  {VER, "ConfigTypeE_FromInt" , NS(LcConfig_ConfigTypeE_FromInt)        , NULL, NULL},
  {VER, "ErrorE_FromInt"      , NS(LcConfig_ErrorE_FromInt)             , NULL, NULL},
  {VER, "ErrorTypeE_FromInt"  , NS(LcConfig_ErrorTypeE_FromInt)         , NULL, NULL},
 
// doc-key: LcConfig,EnumFunc,sm_
  {VER, "ConfigFormatE_ToInt" , NS(LcConfig_ConfigFormatE_ToInt)        , NULL, NULL},
  {VER, "ConfigFormatE_ToString", NS(LcConfig_ConfigFormatE_ToString)     , NULL, NULL},
  {VER, "ConfigOptionsEF_ToInt", NS(LcConfig_ConfigOptionsEF_ToInt)      , NULL, NULL},
  {VER, "ConfigOptionsEF_ToString", NS(LcConfig_ConfigOptionsEF_ToString)   , NULL, NULL},
  {VER, "ConfigTypeE_ToInt"   , NS(LcConfig_ConfigTypeE_ToInt)          , NULL, NULL},
  {VER, "ConfigTypeE_ToString", NS(LcConfig_ConfigTypeE_ToString)       , NULL, NULL},
  {VER, "ErrorE_ToInt"        , NS(LcConfig_ErrorE_ToInt)               , NULL, NULL},
  {VER, "ErrorE_ToString"     , NS(LcConfig_ErrorE_ToString)            , NULL, NULL},
  {VER, "ErrorTypeE_ToInt"    , NS(LcConfig_ErrorTypeE_ToInt)           , NULL, NULL},
  {VER, "ErrorTypeE_ToString" , NS(LcConfig_ErrorTypeE_ToString)        , NULL, NULL},
 
// doc-key: LcConfig,Setup,sm_
  {VER, "Cleanup"             , NS(LcConfig_Cleanup)                    , NULL, NULL},
  {VER, "Setup"               , NS(LcConfig_Setup)                      , 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, NULL}
};
 
// ---------------------------------------------------------------------------------------
// not used.
 
__attribute__((unused))  const static OtObjProcDefS NS(sInstanceDef)[] = {
// BEGIN-OBJ - created by 'tcl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// → no data
 
// END-OBJ - created by 'tcl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
  {0, NULL, NULL, NULL, NULL}
};
 
// ---------------------------------------------------------------------------------------
 
OT_TCL_EXTERN int
Tcllcconfig_Init (
  Tcl_Interp * interp
)
{
  // check for the right tcl version
  if (Tcl_InitStubs (interp, "8.6", true) == NULL) {
    return TCL_ERROR;
  }
  if (Tcl_OOInitStubs (interp) == NULL) {
    return TCL_ERROR;
  }
 
  // setup liblcconfig
  LcSetup();
  MkRtSetup_NULL;
 
  // announce my package
  OtErrorCheckLng (Tcl_PkgProvide (interp, "tcllcconfig", META_VERSION    ));
 
  // pkg_mkIndex hack → only "Tcl_PkgProvide" is required
  if (Tcl_GetVar(interp,"::tcl::newPkgs", TCL_GLOBAL_ONLY) != NULL) return TCL_OK;
 
  // dependency.
  MK_STRN ver = Tcl_PkgRequire(interp, "tclmkkernel", META_VERSION, 1);
  check_NULL(ver) return TCL_ERROR;
 
  // toplevel namespace
  Tcl_Namespace *ns = Tcl_CreateNamespace (interp, "tcllcconfig", NULL, NULL);
  check_NULL(ns) return TCL_ERROR;
 
  // add PACKAGE commands
  OtErrorCheckLng( MK(FillNamespace)          (interp,ns,LC(sOtClassDef),NULL));
 
  // BEGIN-CLASS-call-init - created by 'tcl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  OtErrorCheckLng( NS(pLcConfigC_Init)  (MK_RT_CALL interp, ns)) ;
  OtErrorCheckLng( NS(pLcSettingC_Init) (MK_RT_CALL interp, ns)) ;
 
  // END-CLASS-call-init - created by 'tcl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  // export namespace
  OtErrorCheckLng( Tcl_Export(interp, ns, "Lc*C", false ) ) ;
 
  return TCL_OK;
}
 
OT_TCL_EXTERN int
Tcllcconfig_Unload (
  Tcl_Interp * interp,
  int flags
)
{
  LcCleanup();
 
  return TCL_OK;
}