245 lines
6.9 KiB
C
245 lines
6.9 KiB
C
/*
|
|
* Copyright (c) 2006-2022, RT-Thread Development Team
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Change Logs:
|
|
* Date Author Notes
|
|
* 2021-06-04 WillianChan first version
|
|
* 2021-06-08 WillianChan support to MS VC++ compiler
|
|
*/
|
|
|
|
#include <var_export.h>
|
|
|
|
static const ve_exporter_t *ve_exporter_table = RT_NULL;
|
|
static rt_size_t ve_exporter_num = 0;
|
|
|
|
/* for IAR compiler */
|
|
#if defined(__ICCARM__) || defined(__ICCRX__)
|
|
#pragma section="VarExpTab"
|
|
#endif
|
|
|
|
/* for ARM C and IAR Compiler */
|
|
#if defined(__ARMCC_VERSION) || defined (__ICCARM__) || defined(__ICCRX__)
|
|
static rt_used const struct ve_exporter __ve_table_start
|
|
rt_section("0.""VarExpTab") = {"ve_start", "ve_start", 0};
|
|
|
|
static rt_used const struct ve_exporter __ve_table_end
|
|
rt_section("2.""VarExpTab") = {"ve_end", "ve_end", 2};
|
|
#endif
|
|
|
|
/* for MS VC++ compiler */
|
|
#if defined(_MSC_VER)
|
|
#pragma section("VarExpTab$a", read)
|
|
__declspec(allocate("VarExpTab$a"))
|
|
rt_used const struct ve_exporter __ve_table_start = { "ve_start", "ve_start", 0};
|
|
|
|
#pragma section("VarExpTab$z", read)
|
|
__declspec(allocate("VarExpTab$z"))
|
|
rt_used const struct ve_exporter __ve_table_end = { "ve_end", "ve_end", 2};
|
|
|
|
/* Find var objects in VarExpTab segments */
|
|
static int ve_init_find_obj(unsigned int *begin, unsigned int *end, ve_exporter_t *table)
|
|
{
|
|
int obj_count = 0;
|
|
|
|
while (begin < end)
|
|
{
|
|
if (*begin != RT_NULL)
|
|
{
|
|
*table++ = *((struct ve_exporter *)begin);
|
|
begin += sizeof(struct ve_exporter) / sizeof(unsigned int);
|
|
obj_count += 1;
|
|
}
|
|
else
|
|
{
|
|
begin++;
|
|
}
|
|
}
|
|
|
|
return obj_count;
|
|
}
|
|
#endif /* _MSC_VER */
|
|
|
|
/* initialize var export */
|
|
int var_export_init(void)
|
|
{
|
|
/* initialize the var export table.*/
|
|
#if defined(__ARMCC_VERSION) /* for ARM C Compiler */
|
|
ve_exporter_table = &__ve_table_start + 1;
|
|
ve_exporter_num = &__ve_table_end - &__ve_table_start;
|
|
#elif defined (__IAR_SYSTEMS_ICC__) /* for IAR Compiler */
|
|
ve_exporter_table = &__ve_table_start + 1;
|
|
ve_exporter_num = &__ve_table_end - &__ve_table_start - 1;
|
|
#elif defined (__GNUC__) /* for GCC Compiler */
|
|
extern const int __ve_table_start;
|
|
extern const int __ve_table_end;
|
|
ve_exporter_table = (const ve_exporter_t *)&__ve_table_start;
|
|
ve_exporter_num = (const ve_exporter_t *)&__ve_table_end - ve_exporter_table;
|
|
#elif defined (_MSC_VER) /* for MS VC++ compiler */
|
|
unsigned int *ptr_begin = (unsigned int *)&__ve_table_start;
|
|
unsigned int *ptr_end = (unsigned int *)&__ve_table_end;
|
|
static ve_exporter_t ve_exporter_tab[2048];
|
|
static char __vexp_strbuf1[1024];
|
|
static char __vexp_strbuf2[1024];
|
|
ve_exporter_t ve_exporter_temp;
|
|
rt_size_t index_i, index_j;
|
|
|
|
/* past the three members in first ptr_begin */
|
|
ptr_begin += (sizeof(struct ve_exporter) / sizeof(unsigned int));
|
|
while (*ptr_begin == 0) ptr_begin++;
|
|
do ptr_end--; while (*ptr_end == 0);
|
|
|
|
/* Find var objects in custom segments to solve the problem of holes in objects in different files */
|
|
ve_exporter_num = ve_init_find_obj(ptr_begin, ptr_end, ve_exporter_tab);
|
|
|
|
/* check if the ve_exporter_num is out of bounds */
|
|
RT_ASSERT(ve_exporter_num < (sizeof(ve_exporter_tab) / sizeof(ve_exporter_t)));
|
|
|
|
/* bubble sort algorithms */
|
|
for (index_i = 0; index_i < (ve_exporter_num - 1); index_i++)
|
|
{
|
|
for (index_j = 0; index_j < ((ve_exporter_num - 1) - index_i); index_j++)
|
|
{
|
|
/* splice ve_exporter's module and ve_exporter's identifier into a complete string */
|
|
rt_snprintf(__vexp_strbuf1,
|
|
sizeof(__vexp_strbuf1),
|
|
"%s%s",
|
|
ve_exporter_tab[index_j].module,
|
|
ve_exporter_tab[index_j].identifier);
|
|
rt_snprintf(__vexp_strbuf2,
|
|
sizeof(__vexp_strbuf2),
|
|
"%s%s",
|
|
ve_exporter_tab[index_j + 1].module,
|
|
ve_exporter_tab[index_j + 1].identifier);
|
|
if (rt_strcmp(__vexp_strbuf1, __vexp_strbuf2) > 0)
|
|
{
|
|
ve_exporter_temp = ve_exporter_tab[index_j];
|
|
ve_exporter_tab[index_j] = ve_exporter_tab[index_j + 1];
|
|
ve_exporter_tab[index_j + 1] = ve_exporter_temp;
|
|
}
|
|
}
|
|
}
|
|
|
|
ve_exporter_table = ve_exporter_tab;
|
|
#endif /* __ARMCC_VERSION */
|
|
|
|
return ve_exporter_num;
|
|
}
|
|
INIT_PREV_EXPORT(var_export_init);
|
|
|
|
/* initialize module */
|
|
int ve_module_init(ve_module_t *mod, const char *module)
|
|
{
|
|
const ve_exporter_t *exporter = ve_exporter_table;
|
|
rt_bool_t first_exist = RT_FALSE;
|
|
rt_size_t found_index;
|
|
|
|
for (found_index = 0; found_index < ve_exporter_num; found_index++)
|
|
{
|
|
if (!rt_strcmp(exporter->module, module))
|
|
{
|
|
if (first_exist == RT_FALSE)
|
|
{
|
|
mod->begin = exporter;
|
|
first_exist = RT_TRUE;
|
|
}
|
|
mod->end = exporter;
|
|
}
|
|
exporter++;
|
|
}
|
|
|
|
if (first_exist == RT_FALSE)
|
|
{
|
|
return -RT_ERROR;
|
|
}
|
|
|
|
return RT_EOK;
|
|
}
|
|
|
|
/* initialize iterator */
|
|
void ve_iter_init(ve_module_t *mod, ve_iterator_t *iter)
|
|
{
|
|
if (iter)
|
|
{
|
|
iter->exp_index = mod->begin;
|
|
iter->exp_end = mod->end;
|
|
}
|
|
}
|
|
|
|
/* iterate backward */
|
|
const ve_exporter_t *ve_iter_next(ve_iterator_t *iter)
|
|
{
|
|
if (iter->exp_index <= iter->exp_end)
|
|
{
|
|
return iter->exp_index++;
|
|
}
|
|
else
|
|
{
|
|
return RT_NULL;
|
|
}
|
|
}
|
|
|
|
/* binary search based on identifier */
|
|
const ve_exporter_t *ve_binary_search(ve_module_t *mod, const char *identifier)
|
|
{
|
|
int ve_low_num = 0;
|
|
int ve_high_num = mod->end - mod->begin;
|
|
int ve_mid_num = 0;
|
|
int strcmp_rst = 0;
|
|
|
|
while ((ve_low_num <= ve_high_num) && (ve_high_num >= 0) && (ve_low_num >= 0))
|
|
{
|
|
ve_mid_num = (ve_high_num + ve_low_num) / 2;
|
|
strcmp_rst = rt_strcmp(mod->begin[ve_mid_num].identifier, identifier);
|
|
|
|
if (strcmp_rst == 0)
|
|
{
|
|
return &mod->begin[ve_mid_num];
|
|
}
|
|
else if (strcmp_rst > 0)
|
|
{
|
|
ve_high_num = ve_mid_num - 1;
|
|
}
|
|
else
|
|
{
|
|
ve_low_num = ve_mid_num + 1;
|
|
}
|
|
}
|
|
|
|
return RT_NULL;
|
|
}
|
|
|
|
/* get the value by identifier */
|
|
rt_base_t ve_value_get(ve_module_t *mod, const char *identifier)
|
|
{
|
|
const ve_exporter_t *exporter = ve_binary_search(mod, identifier);
|
|
|
|
if (exporter)
|
|
{
|
|
return exporter->value;
|
|
}
|
|
else
|
|
{
|
|
return VE_NOT_FOUND;
|
|
}
|
|
}
|
|
|
|
/* check if this value exists in the module*/
|
|
rt_bool_t ve_value_exist(ve_module_t *mod, const char *identifier)
|
|
{
|
|
if (ve_binary_search(mod, identifier))
|
|
{
|
|
return RT_TRUE;
|
|
}
|
|
else
|
|
{
|
|
return RT_FALSE;
|
|
}
|
|
}
|
|
|
|
rt_size_t ve_value_count(ve_module_t *mod)
|
|
{
|
|
return mod->end - mod->begin + 1;
|
|
}
|