LibLcConfig_atl.c

Go to the documentation of this file.

 
/* LABEL-NO */
 
#define   META_FILE_NAME          "LibLcConfig_atl.c"
 
#include  "LibLcConfig_private_atl.h"
 
#undef OtClass_ARGS
#define OtClass_ARGS  OBJCMD_ARGS
 
#define OT_SETUP_hdl_static \
  int __skip=1;\
  /* printAry2("cmd",objc,objv); */ \
  MK_UNUSED OT_LC_RT_T  alcrt = clientData; \
  MK_UNUSED OT_MK_RT_T  amkrt = alcrt->amkrt; \
  MK_UNUSED MK_RT       mkrt  = alcrt->mkrt; \
  MK_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 'atl_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 'atl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
 
/*****************************************************************************/
/*                                                                           */
/*                                helper                                     */
/*                                                                           */
/*****************************************************************************/
 
// BEGIN-Enum-ToString - created by 'atl_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 'atl_MqC.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// BEGIN-enum - created by 'atl_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;
  check_LNG(Tcl_GetIndexFromObjStruct (interp, enumE, &keys,
      sizeof(struct LookupClassS), "enum", TCL_EXACT, &index)) return TCL_ERROR;
  *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;
  check_LNG(MK(EnumFlagWorker)(MK_RT_CALL interp,keys,enumE,&index)) return TCL_ERROR;
  *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;
  check_LNG(Tcl_GetIndexFromObjStruct (interp, enumE, &keys,
      sizeof(struct LookupClassS), "enum", TCL_EXACT, &index)) return TCL_ERROR;
  *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;
  check_LNG(Tcl_GetIndexFromObjStruct (interp, enumE, &keys,
      sizeof(struct LookupClassS), "enum", TCL_EXACT, &index)) return TCL_ERROR;
  *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;
  check_LNG(Tcl_GetIndexFromObjStruct (interp, enumE, &keys,
      sizeof(struct LookupClassS), "enum", TCL_EXACT, &index)) return TCL_ERROR;
  *ret = keys[index].val;
  return TCL_OK;
}
 
// END-enum - created by 'atl_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 'atl_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_ATL_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_ATL_API
 
// END-LcConfig - created by 'atl_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 'atl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  // doc-key: LcConfig,EnumFunc,sco
  { "::LcConfig::ConfigFormatE_FromInt"    , NS(LcConfig_ConfigFormatE_FromInt)    },
  { "::LcConfig::ConfigOptionsEF_FromInt"  , NS(LcConfig_ConfigOptionsEF_FromInt)  },
  { "::LcConfig::ConfigTypeE_FromInt"      , NS(LcConfig_ConfigTypeE_FromInt)      },
  { "::LcConfig::ErrorE_FromInt"           , NS(LcConfig_ErrorE_FromInt)           },
  { "::LcConfig::ErrorTypeE_FromInt"       , NS(LcConfig_ErrorTypeE_FromInt)       },
 
  // doc-key: LcConfig,EnumFunc,sm_
  { "::LcConfig::ConfigFormatE_ToInt"      , NS(LcConfig_ConfigFormatE_ToInt)      },
  { "::LcConfig::ConfigFormatE_ToString"   , NS(LcConfig_ConfigFormatE_ToString)   },
  { "::LcConfig::ConfigOptionsEF_ToInt"    , NS(LcConfig_ConfigOptionsEF_ToInt)    },
  { "::LcConfig::ConfigOptionsEF_ToString" , NS(LcConfig_ConfigOptionsEF_ToString) },
  { "::LcConfig::ConfigTypeE_ToInt"        , NS(LcConfig_ConfigTypeE_ToInt)        },
  { "::LcConfig::ConfigTypeE_ToString"     , NS(LcConfig_ConfigTypeE_ToString)     },
  { "::LcConfig::ErrorE_ToInt"             , NS(LcConfig_ErrorE_ToInt)             },
  { "::LcConfig::ErrorE_ToString"          , NS(LcConfig_ErrorE_ToString)          },
  { "::LcConfig::ErrorTypeE_ToInt"         , NS(LcConfig_ErrorTypeE_ToInt)         },
  { "::LcConfig::ErrorTypeE_ToString"      , NS(LcConfig_ErrorTypeE_ToString)      },
 
  // doc-key: LcConfig,Setup,sm_
  { "::LcConfig::Cleanup"                  , NS(LcConfig_Cleanup)                  },
  { "::LcConfig::Setup"                    , NS(LcConfig_Setup)                    },
 
  // END-CLASS - created by 'atl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
  { NULL }
};
 
// ---------------------------------------------------------------------------------------
// not used.
 
__attribute__((unused))  const static OtObjProcDefS NS(sInstanceDef)[] = {
  // BEGIN-OBJ - created by 'atl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  // → no data
 
  // END-OBJ - created by 'atl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
  { NULL }
};
 
// ---------------------------------------------------------------------------------------
 
void NS(LcConfig_ns_delete)(ClientData clientData) 
{
  OT_LC_RT_T alcrt = clientData;
    assert(alcrt != NULL);
  MkRtSetup_RT(alcrt->mkrt);
 
#ifdef OT_DEBUG_NAMESPACE_DELETE
  OT_DEBUG_NAMESPACE_DELETE(MK_COLOR_YELLOW,"::LcConfig with alcrt<%p>","LC",alcrt);
#endif
  OT_ENV_T interp = alcrt->interp;
  //alcrt->status = OT_MK_RT_STATUS_ONEXIT;
 
  // BEGIN-CLASS-delete-2 - created by 'atl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  OT_NS_T ns;
    ns = Tcl_FindNamespace(interp,"::LcSettingC",NULL,TCL_GLOBAL_ONLY);
      if (ns) Tcl_DeleteNamespace(ns);
    ns = Tcl_FindNamespace(interp,"::LcConfigC",NULL,TCL_GLOBAL_ONLY);
      if (ns) Tcl_DeleteNamespace(ns);
 
  // END-CLASS-delete-2 - created by 'atl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
    #define AtlRtFree(tok) if (alcrt->tok) { Tcl_DecrRefCount(alcrt->tok); alcrt->tok = NULL; }
      #define regTclObj2(t,v)   AtlRtFree(t)
      #define regTclObj(t)      AtlRtFree(t)
      #define regTclCmd(t)      AtlRtFree(t)
      #include "LibLcConfig_registry_atl.h"
      #undef regTclCmd
      #undef regTclObj
      #undef regTclObj2
 
  // BEGIN-CLASS-delete - created by 'atl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  if (alcrt->AtlLcSettingC)         Tcl_DecrRefCount(alcrt->AtlLcSettingC)         ;
  if (alcrt->AtlLcSettingC_MK_NULL) Tcl_DecrRefCount(alcrt->AtlLcSettingC_MK_NULL) ;
  if (alcrt->AtlLcConfigC)          Tcl_DecrRefCount(alcrt->AtlLcConfigC)          ;
  if (alcrt->AtlLcConfigC_MK_NULL)  Tcl_DecrRefCount(alcrt->AtlLcConfigC_MK_NULL)  ;
 
  // END-CLASS-delete - created by 'atl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  alcrt->signature = 0x0;
}
 
MkThreadLocal OT_LC_RT_S alcrtR = {0};
 
OT_ATL_EXTERN int
Atllcconfig_Init (
  Tcl_Interp * interp
)
{
  // check for the right tcl version
  if (Tcl_InitStubs (interp, "8.5", false) == NULL) {
    return TCL_ERROR;
  }
 
  // setup liblcconfig
  LcSetup();
  MkRtSetup_NULL;
 
  // announce my package
  check_LNG (Tcl_PkgProvideEx (interp, "atllcconfig", META_VERSION, &alcrtR ));
 
  // pkg_mkIndex hack → only "Tcl_PkgProvide" is required
  if (Tcl_GetVar(interp,"::tcl::newPkgs", TCL_GLOBAL_ONLY) != NULL) return TCL_OK;
 
  // dependency.
  OT_MK_RT_T amkrt = NULL;
  MK_STRN ver = Tcl_PkgRequireEx(interp, "atlmkkernel", META_VERSION, 1, (ClientData*) &amkrt);
    if (ver == NULL) return TCL_ERROR;
 
  // create local runtime
  OT_LC_RT_T alcrt = &alcrtR;
    alcrt->signature = OT_LC_RT_SIG;
    alcrt->interp = interp;
    alcrt->mkrt = MK_RT_PTR;
    alcrt->amkrt = amkrt;
 
    if (alcrt->signature != OT_LC_RT_SIG) {
      Tcl_SetErrorCode(interp, "ATLLC", "INIT", "SIGNATURE", "INVALID", NULL);
      Tcl_SetResult(interp,"error: ATLLC setup failed with INVALID signature", TCL_STATIC);
      return TCL_ERROR;
    }
 
    // register "access" objects
    #define regTclObj2(t,v)   alcrt->t = alcrt->t ? alcrt->t : ({ OT_OBJ_T val=STR2VAL(v); Tcl_IncrRefCount(val); val;})
    #define regTclObj(t)      regTclObj2(t,#t)
    #define regTclCmd(t)      regTclObj2(t,#t)
    #include "LibLcConfig_registry_atl.h"
    #undef regTclCmd
    #undef regTclObj
    #undef regTclObj2
 
  // create ::LcConfig
  OT_NS_T ns = Tcl_FindNamespace(interp,"::LcConfig",NULL,TCL_GLOBAL_ONLY);
    if (ns == NULL) {
      ns = Tcl_CreateNamespace(interp,"::LcConfig",alcrt,NS(LcConfig_ns_delete));
        if (ns == NULL) return TCL_ERROR;
    }
 
  // add PACKAGE commands
  check_LNG( MK(FillNamespace)(interp,LC(sOtClassDef),alcrt));
 
  // BEGIN-CLASS-call-init - created by 'atl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  check_LNG( NS(pLcConfigC_Init)  (OT_LC_CALL ns) ) return TCL_ERROR;
  check_LNG( NS(pLcSettingC_Init) (OT_LC_CALL ns) ) return TCL_ERROR;
 
  // END-CLASS-call-init - created by 'atl_MqS.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
  return TCL_OK;
}
 
OT_ATL_EXTERN int
Atllcconfig_Unload (
  Tcl_Interp * interp,
  int flags
)
{
  OT_NS_T ns = Tcl_FindNamespace(interp,"::LcConfig",NULL,TCL_GLOBAL_ONLY);
    if (ns) Tcl_DeleteNamespace(ns);
 
  LcCleanup();
 
  return TCL_OK;
}