LcConfig_Enum_ATL_API

LcConfig PACKAGE - definition of the enum type … More...

Collaboration diagram for LcConfig_Enum_ATL_API:

Functions
static OT_ProcRet	atllcconfig_LcConfig_ConfigFormatE_FromInt (OtClass_ARGS)
	Atl: (static) LcConfigFormatE [LcConfig::ConfigFormatE_FromInt value:int32] → C-API return the LcConfigFormatE from integer …
static OT_ProcRet	atllcconfig_LcConfig_ConfigOptionsEF_FromInt (OtClass_ARGS)
	Atl: (static) LcConfigOptionsEF [LcConfig::ConfigOptionsEF_FromInt value:int32] → C-API return the LcConfigOptionsEF from integer …
static OT_ProcRet	atllcconfig_LcConfig_ConfigTypeE_FromInt (OtClass_ARGS)
	Atl: (static) LcConfigTypeE [LcConfig::ConfigTypeE_FromInt value:int32] → C-API return the LcConfigTypeE from integer …
static OT_ProcRet	atllcconfig_LcConfig_ErrorE_FromInt (OtClass_ARGS)
	Atl: (static) LcErrorE [LcConfig::ErrorE_FromInt value:int32] → C-API return the LcErrorE from integer …
static OT_ProcRet	atllcconfig_LcConfig_ErrorTypeE_FromInt (OtClass_ARGS)
	Atl: (static) LcErrorTypeE [LcConfig::ErrorTypeE_FromInt value:int32] → C-API return the LcErrorTypeE from integer …
static OT_ProcRet	atllcconfig_LcConfig_ConfigFormatE_ToInt (OtClass_ARGS)
	Atl: (static) int32 [LcConfig::ConfigFormatE_ToInt value:LcConfigFormatE] → C-API return the LcConfigFormatE as integer …
static OT_ProcRet	atllcconfig_LcConfig_ConfigFormatE_ToString (OtClass_ARGS)
	Atl: (static) string [LcConfig::ConfigFormatE_ToString value:LcConfigFormatE] → C-API return the LcConfigFormatE as string …
static OT_ProcRet	atllcconfig_LcConfig_ConfigOptionsEF_ToInt (OtClass_ARGS)
	Atl: (static) int32 [LcConfig::ConfigOptionsEF_ToInt value:LcConfigOptionsEF] → C-API return the LcConfigOptionsEF as integer …
static OT_ProcRet	atllcconfig_LcConfig_ConfigOptionsEF_ToString (OtClass_ARGS)
	Atl: (static) string [LcConfig::ConfigOptionsEF_ToString value:LcConfigOptionsEF] → C-API return the LcConfigOptionsEF as string …
static OT_ProcRet	atllcconfig_LcConfig_ConfigTypeE_ToInt (OtClass_ARGS)
	Atl: (static) int32 [LcConfig::ConfigTypeE_ToInt value:LcConfigTypeE] → C-API return the LcConfigTypeE as integer …
static OT_ProcRet	atllcconfig_LcConfig_ConfigTypeE_ToString (OtClass_ARGS)
	Atl: (static) string [LcConfig::ConfigTypeE_ToString value:LcConfigTypeE] → C-API return the LcConfigTypeE as string …
static OT_ProcRet	atllcconfig_LcConfig_ErrorE_ToInt (OtClass_ARGS)
	Atl: (static) int32 [LcConfig::ErrorE_ToInt value:LcErrorE] → C-API return the LcErrorE as integer …
static OT_ProcRet	atllcconfig_LcConfig_ErrorE_ToString (OtClass_ARGS)
	Atl: (static) string [LcConfig::ErrorE_ToString value:LcErrorE] → C-API return the LcErrorE as string …
static OT_ProcRet	atllcconfig_LcConfig_ErrorTypeE_ToInt (OtClass_ARGS)
	Atl: (static) int32 [LcConfig::ErrorTypeE_ToInt value:LcErrorTypeE] → C-API return the LcErrorTypeE as integer …
static OT_ProcRet	atllcconfig_LcConfig_ErrorTypeE_ToString (OtClass_ARGS)
	Atl: (static) string [LcConfig::ErrorTypeE_ToString value:LcErrorTypeE] → C-API return the LcErrorTypeE as string …

Enum To String
OT_OBJ_T	atllcconfig_LcConfigFormatE_ToString (const enum LcConfigFormatE type)
OT_OBJ_T	atllcconfig_LcConfigOptionsEF_ToString (const enum LcConfigOptionsEF type)
OT_OBJ_T	atllcconfig_LcConfigTypeE_ToString (const enum LcConfigTypeE type)
OT_OBJ_T	atllcconfig_LcErrorE_ToString (const enum LcErrorE type)
OT_OBJ_T	atllcconfig_LcErrorTypeE_ToString (const enum LcErrorTypeE type)

Enum From Obj
int	atllcconfig_Get_LcConfigFormatE_FromObj (MK_RT mkrt, OT_ENV_T interp, OT_OBJ_T enumE, enum LcConfigFormatE *ret)
int	atllcconfig_Get_LcConfigOptionsEF_FromObj (MK_RT mkrt, OT_ENV_T interp, OT_OBJ_T enumE, enum LcConfigOptionsEF *ret)
int	atllcconfig_Get_LcConfigTypeE_FromObj (MK_RT mkrt, OT_ENV_T interp, OT_OBJ_T enumE, enum LcConfigTypeE *ret)
int	atllcconfig_Get_LcErrorE_FromObj (MK_RT mkrt, OT_ENV_T interp, OT_OBJ_T enumE, enum LcErrorE *ret)
int	atllcconfig_Get_LcErrorTypeE_FromObj (MK_RT mkrt, OT_ENV_T interp, OT_OBJ_T enumE, enum LcErrorTypeE *ret)

Detailed Description

LcConfig PACKAGE - definition of the enum type …

read more at: MkKernel_Enum_C_API

Tcl has no build-in-enum-datatyp but theKernel support a enum using the data-type-checking API.

A C-enum like :

enum LcConfigFormatE {
  CONFIG_FORMAT_DEFAULT=0,
  CONFIG_FORMAT_HEX=1,
};

will be compiled into a internal atl-c-check-proc :

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;
}

to return the integer identifier for an enum-definition-string or an error if string is not valid.

• "CONFIG_FORMAT_DEFAULT" = CONFIG_FORMAT_DEFAULT = 0

A valid string for an enum-value is any unique abbreviation of the original enum-value:

• "CONFIG_FORMAT_DEFAULT" = "FORMAT_DEFAULT" = "DEFAULT" = 0

The atl-c-check-proc is used in a atl-c-api-wrapper like :

static OT_ProcRet NS(LcConfigC_SetDefaultFormat) (LcConfigC_ARGS) {
  OT_SETUP_hdl
  OT_SETUP_ONEARG(SetDefaultFormat_doc)
  LcConfigFormatE format = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (LcConfigFormatE,format))   // << atl-c-check-proc
  OT_CHECK_NOARGS
  if (hdl->nat == NULL) OT_ERROR_LNG_RETURN_HDL_NAT_NULL(hdl);
  config_set_default_format (hdl->nat, format);
  OT_retObj_SET_None
  goto end;
  error:
  OT_retObj_SET_Error
  end:
  OT_retObj_RETURN
}

The usage of an enum-value in the atl-code is quite simple, just use the string.

package require atllcconfig
namespace import atllcconfig::*
 
# create the configuration object
LcConfigC create cfg
 
# use CONFIG_FORMAT_HEX : 
# If a non-default format has not been set for a setting with SettingSetFormat, this configuration-wide 
# default format will be used instead when that setting is written to a file or stream.
cfg SetDefaultFormat FORMAT_HEX

read more at: MkKernel_Enum_C_API

Function Documentation

atllcconfig_Get_LcConfigFormatE_FromObj()

int atllcconfig_Get_LcConfigFormatE_FromObj	(	MK_RT	mkrt,
		OT_ENV_T	interp,
		OT_OBJ_T	enumE,
		enum LcConfigFormatE *	ret )

Definition at line 192 of file LibLcConfig_atl.c.

                                                                                                            {
  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;
}

atllcconfig_Get_LcConfigOptionsEF_FromObj()

int atllcconfig_Get_LcConfigOptionsEF_FromObj	(	MK_RT	mkrt,
		OT_ENV_T	interp,
		OT_OBJ_T	enumE,
		enum LcConfigOptionsEF *	ret )

Definition at line 210 of file LibLcConfig_atl.c.

                                                                                                                {
  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;
}

atllcconfig_Get_LcConfigTypeE_FromObj()

int atllcconfig_Get_LcConfigTypeE_FromObj	(	MK_RT	mkrt,
		OT_ENV_T	interp,
		OT_OBJ_T	enumE,
		enum LcConfigTypeE *	ret )

Definition at line 248 of file LibLcConfig_atl.c.

                                                                                                        {
  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;
}

atllcconfig_Get_LcErrorE_FromObj()

int atllcconfig_Get_LcErrorE_FromObj	(	MK_RT	mkrt,
		OT_ENV_T	interp,
		OT_OBJ_T	enumE,
		enum LcErrorE *	ret )

Definition at line 287 of file LibLcConfig_atl.c.

                                                                                              {
  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;
}

atllcconfig_Get_LcErrorTypeE_FromObj()

int atllcconfig_Get_LcErrorTypeE_FromObj	(	MK_RT	mkrt,
		OT_ENV_T	interp,
		OT_OBJ_T	enumE,
		enum LcErrorTypeE *	ret )

Definition at line 303 of file LibLcConfig_atl.c.

                                                                                                      {
  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;
}

atllcconfig_LcConfig_ConfigFormatE_FromInt()

static OT_ProcRet atllcconfig_LcConfig_ConfigFormatE_FromInt ( OtClass_ARGS )

static

Atl: (static) LcConfigFormatE [LcConfig::ConfigFormatE_FromInt value:int32] → C-API
return the LcConfigFormatE from integer …

Definition at line 417 of file LibLcConfig_atl.c.

                                                                    {
  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;
}

atllcconfig_LcConfig_ConfigFormatE_ToInt()

static OT_ProcRet atllcconfig_LcConfig_ConfigFormatE_ToInt ( OtClass_ARGS )

static

Atl: (static) int32 [LcConfig::ConfigFormatE_ToInt value:LcConfigFormatE] → C-API
return the LcConfigFormatE as integer …

Definition at line 504 of file LibLcConfig_atl.c.

                                                                  {
  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;
}

atllcconfig_LcConfig_ConfigFormatE_ToString()

static OT_ProcRet atllcconfig_LcConfig_ConfigFormatE_ToString ( OtClass_ARGS )

static

Atl: (static) string [LcConfig::ConfigFormatE_ToString value:LcConfigFormatE] → C-API
return the LcConfigFormatE as string …

Definition at line 519 of file LibLcConfig_atl.c.

                                                                     {
  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;
}

atllcconfig_LcConfig_ConfigOptionsEF_FromInt()

static OT_ProcRet atllcconfig_LcConfig_ConfigOptionsEF_FromInt ( OtClass_ARGS )

static

Atl: (static) LcConfigOptionsEF [LcConfig::ConfigOptionsEF_FromInt value:int32] → C-API
return the LcConfigOptionsEF from integer …

Definition at line 434 of file LibLcConfig_atl.c.

                                                                      {
  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;
}

atllcconfig_LcConfig_ConfigOptionsEF_ToInt()

static OT_ProcRet atllcconfig_LcConfig_ConfigOptionsEF_ToInt ( OtClass_ARGS )

static

Atl: (static) int32 [LcConfig::ConfigOptionsEF_ToInt value:LcConfigOptionsEF] → C-API
return the LcConfigOptionsEF as integer …

Definition at line 534 of file LibLcConfig_atl.c.

                                                                    {
  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;
}

atllcconfig_LcConfig_ConfigOptionsEF_ToString()

static OT_ProcRet atllcconfig_LcConfig_ConfigOptionsEF_ToString ( OtClass_ARGS )

static

Atl: (static) string [LcConfig::ConfigOptionsEF_ToString value:LcConfigOptionsEF] → C-API
return the LcConfigOptionsEF as string …

Definition at line 549 of file LibLcConfig_atl.c.

                                                                       {
  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;
}

atllcconfig_LcConfig_ConfigTypeE_FromInt()

static OT_ProcRet atllcconfig_LcConfig_ConfigTypeE_FromInt ( OtClass_ARGS )

static

Atl: (static) LcConfigTypeE [LcConfig::ConfigTypeE_FromInt value:int32] → C-API
return the LcConfigTypeE from integer …

Definition at line 451 of file LibLcConfig_atl.c.

                                                                  {
  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;
}

atllcconfig_LcConfig_ConfigTypeE_ToInt()

static OT_ProcRet atllcconfig_LcConfig_ConfigTypeE_ToInt ( OtClass_ARGS )

static

Atl: (static) int32 [LcConfig::ConfigTypeE_ToInt value:LcConfigTypeE] → C-API
return the LcConfigTypeE as integer …

Definition at line 564 of file LibLcConfig_atl.c.

                                                                {
  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;
}

atllcconfig_LcConfig_ConfigTypeE_ToString()

static OT_ProcRet atllcconfig_LcConfig_ConfigTypeE_ToString ( OtClass_ARGS )

static

Atl: (static) string [LcConfig::ConfigTypeE_ToString value:LcConfigTypeE] → C-API
return the LcConfigTypeE as string …

Definition at line 579 of file LibLcConfig_atl.c.

                                                                   {
  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;
}

atllcconfig_LcConfig_ErrorE_FromInt()

static OT_ProcRet atllcconfig_LcConfig_ErrorE_FromInt ( OtClass_ARGS )

static

Atl: (static) LcErrorE [LcConfig::ErrorE_FromInt value:int32] → C-API
return the LcErrorE from integer …

Definition at line 468 of file LibLcConfig_atl.c.

                                                             {
  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;
}

atllcconfig_LcConfig_ErrorE_ToInt()

static OT_ProcRet atllcconfig_LcConfig_ErrorE_ToInt ( OtClass_ARGS )

static

Atl: (static) int32 [LcConfig::ErrorE_ToInt value:LcErrorE] → C-API
return the LcErrorE as integer …

Definition at line 594 of file LibLcConfig_atl.c.

                                                           {
  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;
}

atllcconfig_LcConfig_ErrorE_ToString()

static OT_ProcRet atllcconfig_LcConfig_ErrorE_ToString ( OtClass_ARGS )

static

Atl: (static) string [LcConfig::ErrorE_ToString value:LcErrorE] → C-API
return the LcErrorE as string …

Definition at line 609 of file LibLcConfig_atl.c.

                                                              {
  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;
}

atllcconfig_LcConfig_ErrorTypeE_FromInt()

static OT_ProcRet atllcconfig_LcConfig_ErrorTypeE_FromInt ( OtClass_ARGS )

static

Atl: (static) LcErrorTypeE [LcConfig::ErrorTypeE_FromInt value:int32] → C-API
return the LcErrorTypeE from integer …

Definition at line 485 of file LibLcConfig_atl.c.

                                                                 {
  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;
}

atllcconfig_LcConfig_ErrorTypeE_ToInt()

static OT_ProcRet atllcconfig_LcConfig_ErrorTypeE_ToInt ( OtClass_ARGS )

static

Atl: (static) int32 [LcConfig::ErrorTypeE_ToInt value:LcErrorTypeE] → C-API
return the LcErrorTypeE as integer …

Definition at line 624 of file LibLcConfig_atl.c.

                                                               {
  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;
}

atllcconfig_LcConfig_ErrorTypeE_ToString()

static OT_ProcRet atllcconfig_LcConfig_ErrorTypeE_ToString ( OtClass_ARGS )

static

Atl: (static) string [LcConfig::ErrorTypeE_ToString value:LcErrorTypeE] → C-API
return the LcErrorTypeE as string …

Definition at line 639 of file LibLcConfig_atl.c.

                                                                  {
  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;
}

atllcconfig_LcConfigFormatE_ToString()

OT_OBJ_T atllcconfig_LcConfigFormatE_ToString

(

const enum LcConfigFormatE

type

)

Definition at line 119 of file LibLcConfig_atl.c.

{
  switch (type) {
    case CONFIG_FORMAT_DEFAULT : return ot_fixstrobj("DEFAULT") ;
    case CONFIG_FORMAT_HEX     : return ot_fixstrobj("HEX"    ) ;
  }
  return ot_fixstrobj("NOTHING");
}

atllcconfig_LcConfigOptionsEF_ToString()

OT_OBJ_T atllcconfig_LcConfigOptionsEF_ToString

(

const enum LcConfigOptionsEF

type

)

Definition at line 128 of file LibLcConfig_atl.c.

{
  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;
  }
}

atllcconfig_LcConfigTypeE_ToString()

OT_OBJ_T atllcconfig_LcConfigTypeE_ToString

(

const enum LcConfigTypeE

type

)

Definition at line 146 of file LibLcConfig_atl.c.

{
  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");
}

atllcconfig_LcErrorE_ToString()

OT_OBJ_T atllcconfig_LcErrorE_ToString

(

const enum LcErrorE

type

)

Definition at line 162 of file LibLcConfig_atl.c.

{
  switch (type) {
    case CONFIG_FALSE : return ot_fixstrobj("FALSE") ;
    case CONFIG_TRUE  : return ot_fixstrobj("TRUE" ) ;
  }
  return ot_fixstrobj("NOTHING");
}

atllcconfig_LcErrorTypeE_ToString()

OT_OBJ_T atllcconfig_LcErrorTypeE_ToString

(

const enum LcErrorTypeE

type

)

Definition at line 171 of file LibLcConfig_atl.c.

{
  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");
}