784 lines
24 KiB
C
Executable File
784 lines
24 KiB
C
Executable File
/*
|
||
* Copyright (c) 2019-2025 Allwinner Technology Co., Ltd. ALL rights reserved.
|
||
*
|
||
* Allwinner is a trademark of Allwinner Technology Co.,Ltd., registered in
|
||
* the the People's Republic of China and other countries.
|
||
* All Allwinner Technology Co.,Ltd. trademarks are used with permission.
|
||
*
|
||
* DISCLAIMER
|
||
* THIRD PARTY LICENCES MAY BE REQUIRED TO IMPLEMENT THE SOLUTION/PRODUCT.
|
||
* IF YOU NEED TO INTEGRATE THIRD PARTY’S TECHNOLOGY (SONY, DTS, DOLBY, AVS OR MPEGLA, ETC.)
|
||
* IN ALLWINNERS’SDK OR PRODUCTS, YOU SHALL BE SOLELY RESPONSIBLE TO OBTAIN
|
||
* ALL APPROPRIATELY REQUIRED THIRD PARTY LICENCES.
|
||
* ALLWINNER SHALL HAVE NO WARRANTY, INDEMNITY OR OTHER OBLIGATIONS WITH RESPECT TO MATTERS
|
||
* COVERED UNDER ANY REQUIRED THIRD PARTY LICENSE.
|
||
* YOU ARE SOLELY RESPONSIBLE FOR YOUR USAGE OF THIRD PARTY’S TECHNOLOGY.
|
||
*
|
||
*
|
||
* THIS SOFTWARE IS PROVIDED BY ALLWINNER"AS IS" AND TO THE MAXIMUM EXTENT
|
||
* PERMITTED BY LAW, ALLWINNER EXPRESSLY DISCLAIMS ALL WARRANTIES OF ANY KIND,
|
||
* WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING WITHOUT LIMITATION REGARDING
|
||
* THE TITLE, NON-INFRINGEMENT, ACCURACY, CONDITION, COMPLETENESS, PERFORMANCE
|
||
* OR MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
||
* IN NO EVENT SHALL ALLWINNER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||
* LOSS OF USE, DATA, OR PROFITS, OR BUSINESS INTERRUPTION)
|
||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||
*/
|
||
#include <stdio.h>
|
||
#include <string.h>
|
||
|
||
#include <typedef.h>
|
||
#include "log.h"
|
||
#include "kapi.h"
|
||
|
||
#include <hal_mem.h>
|
||
|
||
#define SCRIPT_DEBUG_PRINTF(fmt, arg...) //printf("\e[35m[script]\e[0m"fmt"\n", ##arg)
|
||
|
||
#define DATA_TYPE(x) ((x->pattern>>16) & 0xffff)
|
||
#define DATA_WORD(x) ((x.pattern>> 0) & 0xffff)
|
||
|
||
#define SCRIPT_GET_MAIN_KEY(x, i) (script_main_key_t *)(x->script_mod_buf + \
|
||
(sizeof(script_head_t)) + i * sizeof(script_main_key_t))
|
||
|
||
#define SCRIPT_GET_SUB_KEY(x, m, i) (script_sub_key_t *)(x->script_mod_buf + \
|
||
(m->offset<<2) + (i * sizeof(script_sub_key_t)))
|
||
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* _test_str_length
|
||
*
|
||
* 函数名称：测试传进的字符串的长度
|
||
*
|
||
* 参数列表：str
|
||
*
|
||
* 返回值 ：
|
||
*
|
||
* 说明 ：
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
static int32_t _test_str_length(char *str)
|
||
{
|
||
int32_t length = 0;
|
||
|
||
while (str[length++])
|
||
{
|
||
if (length > 32)
|
||
{
|
||
length = 32;
|
||
break;
|
||
}
|
||
}
|
||
|
||
return length;
|
||
}
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* script_parser_init
|
||
*
|
||
* 函数名称：
|
||
*
|
||
* 参数列表：script_buf: 脚本数据池不能是malloc出来的 size:脚本数据字节数
|
||
*
|
||
* 返回值 ：
|
||
*
|
||
* 说明 ：
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
void *script_parser_init(char *script_buf, unsigned long size)
|
||
{
|
||
script_parser_t *parser;
|
||
script_head_t *script_head;
|
||
|
||
if (script_buf)
|
||
{
|
||
parser = hal_malloc(sizeof(script_parser_t));
|
||
|
||
if (NULL == parser)
|
||
{
|
||
return NULL;
|
||
}
|
||
#ifndef CONFIG_SYSCONF_BUILDIN
|
||
parser->script_mod_buf = hal_malloc(size);
|
||
if (NULL == parser->script_mod_buf)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
parser->script_mod_buf_size = size;
|
||
|
||
{
|
||
char *p;
|
||
|
||
p = parser->script_mod_buf;
|
||
while (size--)
|
||
{
|
||
*p++ = *script_buf++;
|
||
}
|
||
}
|
||
|
||
#else
|
||
parser->script_mod_buf = script_buf;
|
||
parser->script_mod_buf_size = size;
|
||
#endif
|
||
script_head = (script_head_t *)(parser->script_mod_buf);
|
||
parser->script_main_key_count = script_head->main_key_count;
|
||
|
||
return (void *)parser;
|
||
}
|
||
else
|
||
{
|
||
return NULL;
|
||
}
|
||
}
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* script_parser_exit
|
||
*
|
||
* 函数名称：
|
||
*
|
||
* 参数列表：NULL
|
||
*
|
||
* 返回值 ：
|
||
*
|
||
* 说明 ：
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
int32_t script_parser_exit(void *hparser)
|
||
{
|
||
script_parser_t *parser;
|
||
|
||
parser = (script_parser_t *)hparser;
|
||
if (NULL == parser)
|
||
{
|
||
return SCRIPT_PARSER_EMPTY_BUFFER;
|
||
}
|
||
|
||
if (parser->script_mod_buf)
|
||
{
|
||
|
||
#ifndef CONFIG_SYSCONF_BUILDIN
|
||
hal_free(parser->script_mod_buf);
|
||
#endif
|
||
parser->script_mod_buf = NULL;
|
||
}
|
||
parser->script_main_key_count = 0;
|
||
parser->script_mod_buf_size = 0;
|
||
|
||
#ifndef CONFIG_SYSCONF_BUILDIN
|
||
hal_free(parser);
|
||
#endif
|
||
|
||
return SCRIPT_PARSER_OK;
|
||
}
|
||
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* script_parser_fetch
|
||
*
|
||
* 函数名称：
|
||
*
|
||
* 参数列表：
|
||
*
|
||
* 返回值 ：
|
||
*
|
||
* 说明 ：根据传进的主键，子键，取得对应的数值
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
int32_t script_parser_fetch(void *hparser, char *main_name, char *sub_name, int value[], int count)
|
||
{
|
||
char main_bkname[32], sub_bkname[32];
|
||
char *main_char, *sub_char;
|
||
script_main_key_t *main_key = NULL;
|
||
script_sub_key_t *sub_key = NULL;
|
||
int32_t i, j;
|
||
int32_t pattern, word_count;
|
||
script_parser_t *parser;
|
||
|
||
parser = (script_parser_t *)hparser;
|
||
if (NULL == parser)
|
||
{
|
||
return SCRIPT_PARSER_EMPTY_BUFFER;
|
||
}
|
||
|
||
//检查脚本buffer是否存在
|
||
if (!parser->script_mod_buf)
|
||
{
|
||
return SCRIPT_PARSER_EMPTY_BUFFER;
|
||
}
|
||
//检查主键名称和子键名称是否为空
|
||
if ((main_name == NULL) || (sub_name == NULL))
|
||
{
|
||
return SCRIPT_PARSER_KEYNAME_NULL;
|
||
}
|
||
//检查数据buffer是否为空
|
||
if (value == NULL)
|
||
{
|
||
return SCRIPT_PARSER_DATA_VALUE_NULL;
|
||
}
|
||
//保存主键名称和子键名称，如果超过31字节则截取31字节
|
||
main_char = main_name;
|
||
if (_test_str_length(main_name) > 31)
|
||
{
|
||
memset(main_bkname, 0, 32);
|
||
strncpy(main_bkname, main_name, 31);
|
||
main_char = main_bkname;
|
||
}
|
||
sub_char = sub_name;
|
||
if (_test_str_length(sub_name) > 31)
|
||
{
|
||
memset(sub_bkname, 0, 32);
|
||
strncpy(sub_bkname, sub_name, 31);
|
||
sub_char = sub_bkname;
|
||
}
|
||
|
||
for (i = 0; i < parser->script_main_key_count; i++)
|
||
{
|
||
main_key = (script_main_key_t *)(parser->script_mod_buf + (sizeof(script_head_t)) + i * sizeof(script_main_key_t));
|
||
if (strcmp(main_key->main_name, main_char)) //如果主键不匹配，寻找下一个主键
|
||
{
|
||
continue;
|
||
}
|
||
//主键匹配，寻找子键名称匹配
|
||
for (j = 0; j < main_key->lenth; j++)
|
||
{
|
||
sub_key = (script_sub_key_t *)(parser->script_mod_buf + (main_key->offset << 2) + (j * sizeof(script_sub_key_t)));
|
||
if (strcmp(sub_key->sub_name, sub_char)) //如果主键不匹配，寻找下一个主键
|
||
{
|
||
continue;
|
||
}
|
||
pattern = (sub_key->pattern >> 16) & 0xffff; //获取数据的类型
|
||
word_count = (sub_key->pattern >> 0) & 0xffff; //获取所占用的word个数
|
||
//取出数据
|
||
switch (pattern)
|
||
{
|
||
case DATA_TYPE_SINGLE_WORD: //单word数据类型
|
||
value[0] = *(int *)(parser->script_mod_buf + (sub_key->offset << 2));
|
||
break;
|
||
|
||
case DATA_TYPE_STRING: //字符串数据类型
|
||
if (count < word_count)
|
||
{
|
||
word_count = count;
|
||
}
|
||
memcpy((char *)value, parser->script_mod_buf + (sub_key->offset << 2), word_count << 2);
|
||
break;
|
||
|
||
case DATA_TYPE_MULTI_WORD:
|
||
break;
|
||
case DATA_TYPE_GPIO_WORD: //多word数据类型
|
||
{
|
||
user_gpio_set_t *user_gpio_cfg = (user_gpio_set_t *)value;
|
||
//发现是GPIO类型，检查是否足够存放用户数据
|
||
if (sizeof(user_gpio_set_t) > (count << 2))
|
||
{
|
||
return SCRIPT_PARSER_BUFFER_NOT_ENOUGH;
|
||
}
|
||
strncpy(user_gpio_cfg->gpio_name, sub_char, strlen(sub_char) + 1);
|
||
memcpy(&user_gpio_cfg->port, parser->script_mod_buf + (sub_key->offset << 2), sizeof(user_gpio_set_t) - 32);
|
||
|
||
break;
|
||
}
|
||
}
|
||
|
||
return SCRIPT_PARSER_OK;
|
||
}
|
||
}
|
||
|
||
return SCRIPT_PARSER_KEY_NOT_FIND;
|
||
}
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* script_parser_subkey_count
|
||
*
|
||
* 函数名称：
|
||
*
|
||
* 参数列表：
|
||
*
|
||
* 返回值 ：
|
||
*
|
||
* 说明 ：根据传进的主键，取得主键下的子键个数
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
int32_t script_parser_subkey_count(void *hparser, char *main_name)
|
||
{
|
||
char main_bkname[32];
|
||
char *main_char;
|
||
script_main_key_t *main_key = NULL;
|
||
int32_t i;
|
||
script_parser_t *parser;
|
||
|
||
parser = (script_parser_t *)hparser;
|
||
if (NULL == parser)
|
||
{
|
||
return SCRIPT_PARSER_EMPTY_BUFFER;
|
||
}
|
||
|
||
//检查脚本buffer是否存在
|
||
if (!parser->script_mod_buf)
|
||
{
|
||
return SCRIPT_PARSER_EMPTY_BUFFER;
|
||
}
|
||
//检查主键名称和子键名称是否为空
|
||
if (main_name == NULL)
|
||
{
|
||
return SCRIPT_PARSER_KEYNAME_NULL;
|
||
}
|
||
//保存主键名称和子键名称，如果超过31字节则截取31字节
|
||
main_char = main_name;
|
||
if (_test_str_length(main_name) > 31)
|
||
{
|
||
memset(main_bkname, 0, 32);
|
||
strncpy(main_bkname, main_name, 31);
|
||
main_char = main_bkname;
|
||
}
|
||
|
||
for (i = 0; i < parser->script_main_key_count; i++)
|
||
{
|
||
main_key = (script_main_key_t *)(parser->script_mod_buf + (sizeof(script_head_t)) + i * sizeof(script_main_key_t));
|
||
if (strcmp(main_key->main_name, main_char)) //如果主键不匹配，寻找下一个主键
|
||
{
|
||
continue;
|
||
}
|
||
|
||
return main_key->lenth; //返回当前主键下的子键个数
|
||
}
|
||
|
||
return -1; //-1 表示没有对应的主键
|
||
}
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* script_parser_mainkey_count
|
||
*
|
||
* 函数名称：
|
||
*
|
||
* 参数列表：
|
||
*
|
||
* 返回值 ：
|
||
*
|
||
* 说明 ：根据传进的主键，取得主键的个数
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
int32_t script_parser_mainkey_count(void *hparser)
|
||
{
|
||
script_parser_t *parser;
|
||
|
||
parser = (script_parser_t *)hparser;
|
||
if (NULL == parser)
|
||
{
|
||
return SCRIPT_PARSER_EMPTY_BUFFER;
|
||
}
|
||
|
||
//检查脚本buffer是否存在
|
||
if (!parser->script_mod_buf)
|
||
{
|
||
return SCRIPT_PARSER_EMPTY_BUFFER;
|
||
}
|
||
|
||
return parser->script_main_key_count;
|
||
}
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* script_parser_mainkey_get_gpio_count
|
||
*
|
||
* 函数名称：
|
||
*
|
||
* 参数列表：
|
||
*
|
||
* 返回值 ：
|
||
*
|
||
* 说明 ：根据传进的主键，取得主键的GPIO个数
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
int32_t script_parser_mainkey_get_gpio_count(void *hparser, char *main_name)
|
||
{
|
||
char main_bkname[32];
|
||
char *main_char;
|
||
script_main_key_t *main_key = NULL;
|
||
script_sub_key_t *sub_key = NULL;
|
||
int32_t i, j;
|
||
int32_t pattern, gpio_count = 0;
|
||
script_parser_t *parser;
|
||
|
||
parser = (script_parser_t *)hparser;
|
||
if (NULL == parser)
|
||
{
|
||
return SCRIPT_PARSER_EMPTY_BUFFER;
|
||
}
|
||
|
||
//检查脚本buffer是否存在
|
||
if (!parser->script_mod_buf)
|
||
{
|
||
return SCRIPT_PARSER_EMPTY_BUFFER;
|
||
}
|
||
//检查主键名称和子键名称是否为空
|
||
if (main_name == NULL)
|
||
{
|
||
return SCRIPT_PARSER_KEYNAME_NULL;
|
||
}
|
||
//保存主键名称和子键名称，如果超过31字节则截取31字节
|
||
main_char = main_name;
|
||
if (_test_str_length(main_name) > 31)
|
||
{
|
||
memset(main_bkname, 0, 32);
|
||
strncpy(main_bkname, main_name, 31);
|
||
main_char = main_bkname;
|
||
}
|
||
|
||
for (i = 0; i < parser->script_main_key_count; i++)
|
||
{
|
||
main_key = (script_main_key_t *)(parser->script_mod_buf + (sizeof(script_head_t)) + i * sizeof(script_main_key_t));
|
||
if (strcmp(main_key->main_name, main_char)) //如果主键不匹配，寻找下一个主键
|
||
{
|
||
continue;
|
||
}
|
||
//主键匹配，寻找子键名称匹配
|
||
for (j = 0; j < main_key->lenth; j++)
|
||
{
|
||
sub_key = (script_sub_key_t *)(parser->script_mod_buf + (main_key->offset << 2) + (j * sizeof(script_sub_key_t)));
|
||
|
||
pattern = (sub_key->pattern >> 16) & 0xffff; //获取数据的类型
|
||
//取出数据
|
||
if (DATA_TYPE_GPIO_WORD == pattern)
|
||
{
|
||
gpio_count ++;
|
||
}
|
||
}
|
||
}
|
||
|
||
return gpio_count;
|
||
}
|
||
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* script_parser_subkey_get_cfg
|
||
*
|
||
* 函数名称：
|
||
*
|
||
* 参数列表：
|
||
*
|
||
* 返回值 ：
|
||
*
|
||
* 说明 ：根据传进的主键与子键，取得子键下的配置信息
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
int32_t script_parser_subkey_get_gpio_cfg(void *hparser, char *main_name, char *sub_name, void *data_cfg, int cfg_type)
|
||
{
|
||
char main_bkname[32];
|
||
char *main_char;
|
||
char *sub_char;
|
||
script_main_key_t *main_key = NULL;
|
||
script_sub_key_t *sub_key = NULL;
|
||
int32_t i, j;
|
||
int32_t pattern;
|
||
script_parser_t *parser;
|
||
int32_t word_count;
|
||
|
||
parser = (script_parser_t *)hparser;
|
||
if (NULL == parser)
|
||
{
|
||
return SCRIPT_PARSER_EMPTY_BUFFER;
|
||
}
|
||
|
||
//检查脚本buffer是否存在
|
||
if (!parser->script_mod_buf)
|
||
{
|
||
return SCRIPT_PARSER_EMPTY_BUFFER;
|
||
}
|
||
//检查主键名称和子键名称是否为空
|
||
if (main_name == NULL)
|
||
{
|
||
return SCRIPT_PARSER_KEYNAME_NULL;
|
||
}
|
||
if (sub_name == NULL)
|
||
{
|
||
return SCRIPT_PARSER_KEYNAME_NULL;
|
||
}
|
||
|
||
//保存主键名称和子键名称，如果超过31字节则截取31字节
|
||
main_char = main_name;
|
||
sub_char = sub_name;
|
||
if (_test_str_length(main_name) > 31)
|
||
{
|
||
rt_memset(main_bkname, 0, 32);
|
||
rt_strncpy(main_bkname, main_name, 31);
|
||
main_char = main_bkname;
|
||
}
|
||
if (_test_str_length(sub_name) > 31)
|
||
{
|
||
rt_memset(main_bkname, 0, 32);
|
||
rt_strncpy(main_bkname, sub_name, 31);
|
||
sub_char = main_bkname;
|
||
}
|
||
|
||
for (i = 0; i < parser->script_main_key_count; i++)
|
||
{
|
||
main_key = SCRIPT_GET_MAIN_KEY(parser, i);
|
||
if (rt_strcmp(main_key->main_name, main_char)) //如果主键不匹配，寻找下一个主键
|
||
{
|
||
continue;
|
||
}
|
||
//主键匹配，寻找子键名称匹配
|
||
for (j = 0; j < main_key->lenth; j++)
|
||
{
|
||
sub_key = SCRIPT_GET_SUB_KEY(parser, main_key, j);
|
||
pattern = DATA_TYPE(sub_key); //获取数据的类型
|
||
word_count = (sub_key->pattern >> 0) & 0xffff;
|
||
|
||
if(rt_strcmp(sub_key->sub_name, sub_char))//如果子键不匹配，寻找下一个子键
|
||
continue;
|
||
|
||
//取出数据
|
||
switch (cfg_type){
|
||
case DATA_TYPE_GPIO_WORD:
|
||
{
|
||
if(DATA_TYPE_GPIO_WORD == pattern)
|
||
{
|
||
user_gpio_set_t *user_gpio_cfg = (user_gpio_set_t *)data_cfg;
|
||
rt_strncpy(user_gpio_cfg[0].gpio_name, sub_key->sub_name, rt_strlen(sub_key->sub_name) + 1);
|
||
rt_memcpy(&user_gpio_cfg[0].port, parser->script_mod_buf + (sub_key->offset << 2), sizeof(user_gpio_set_t) - 32);
|
||
SCRIPT_DEBUG_PRINTF("\t%s = P%c%d", user_gpio_cfg->gpio_name,
|
||
user_gpio_cfg->port + 0x40, user_gpio_cfg->port_num);
|
||
}
|
||
else
|
||
{
|
||
continue; // 如果子键Data Type不匹配，寻找下一个子键
|
||
}
|
||
return SCRIPT_PARSER_OK;
|
||
break;
|
||
}
|
||
case DATA_TYPE_STRING:
|
||
{
|
||
if(DATA_TYPE_STRING == pattern)
|
||
{
|
||
char *str_cfg = (char *)data_cfg;
|
||
memcpy(str_cfg, parser->script_mod_buf + (sub_key->offset << 2),
|
||
word_count << 2);
|
||
SCRIPT_DEBUG_PRINTF("\t%s = %s", sub_key->sub_name, str_cfg);
|
||
}
|
||
else
|
||
{
|
||
continue;
|
||
}
|
||
return SCRIPT_PARSER_OK;
|
||
break;
|
||
}
|
||
case DATA_TYPE_SINGLE_WORD:
|
||
{
|
||
if(DATA_TYPE_SINGLE_WORD == pattern)
|
||
{
|
||
int *int_cfg = (int *)data_cfg;
|
||
int_cfg[0] = *(int *)(parser->script_mod_buf + (sub_key->offset << 2));
|
||
SCRIPT_DEBUG_PRINTF("\t%s = 0x%x", sub_key->sub_name, int_cfg[0]);
|
||
}
|
||
else
|
||
{
|
||
continue;
|
||
}
|
||
return SCRIPT_PARSER_OK;
|
||
break;
|
||
}
|
||
// case DATA_TYPE_MULTI_WORD:
|
||
// {
|
||
// break;
|
||
// }
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
return SCRIPT_PARSER_KEY_NOT_FIND;
|
||
}
|
||
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* script_parser_mainkey_get_gpio_cfg
|
||
*
|
||
* 函数名称：
|
||
*
|
||
* 参数列表：
|
||
*
|
||
* 返回值 ：
|
||
*
|
||
* 说明 ：根据传进的主键，取得主键下GPIO的配置信息
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
int32_t script_parser_mainkey_get_gpio_cfg(void *hparser, char *main_name, void *gpio_cfg, int gpio_count)
|
||
{
|
||
char main_bkname[32];
|
||
char *main_char;
|
||
script_main_key_t *main_key = NULL;
|
||
script_sub_key_t *sub_key = NULL;
|
||
user_gpio_set_t *user_gpio_cfg = (user_gpio_set_t *)gpio_cfg;
|
||
int32_t i, j;
|
||
int32_t pattern, user_index;
|
||
script_parser_t *parser;
|
||
|
||
parser = (script_parser_t *)hparser;
|
||
if (NULL == parser)
|
||
{
|
||
return SCRIPT_PARSER_EMPTY_BUFFER;
|
||
}
|
||
|
||
//检查脚本buffer是否存在
|
||
if (!parser->script_mod_buf)
|
||
{
|
||
return SCRIPT_PARSER_EMPTY_BUFFER;
|
||
}
|
||
//检查主键名称和子键名称是否为空
|
||
if (main_name == NULL)
|
||
{
|
||
return SCRIPT_PARSER_KEYNAME_NULL;
|
||
}
|
||
//首先清空用户buffer
|
||
memset(user_gpio_cfg, 0, sizeof(user_gpio_set_t) * gpio_count);
|
||
//保存主键名称和子键名称，如果超过31字节则截取31字节
|
||
main_char = main_name;
|
||
if (_test_str_length(main_name) > 31)
|
||
{
|
||
memset(main_bkname, 0, 32);
|
||
strncpy(main_bkname, main_name, 31);
|
||
main_char = main_bkname;
|
||
}
|
||
|
||
for (i = 0; i < parser->script_main_key_count; i++)
|
||
{
|
||
main_key = (script_main_key_t *)(parser->script_mod_buf + (sizeof(script_head_t)) + i * sizeof(script_main_key_t));
|
||
if (strcmp(main_key->main_name, main_char)) //如果主键不匹配，寻找下一个主键
|
||
{
|
||
continue;
|
||
}
|
||
//主键匹配，寻找子键名称匹配
|
||
user_index = 0;
|
||
for (j = 0; j < main_key->lenth; j++)
|
||
{
|
||
sub_key = (script_sub_key_t *)(parser->script_mod_buf + (main_key->offset << 2) + (j * sizeof(script_sub_key_t)));
|
||
pattern = (sub_key->pattern >> 16) & 0xffff; //获取数据的类型
|
||
//取出数据
|
||
if (DATA_TYPE_GPIO_WORD == pattern)
|
||
{
|
||
strncpy(user_gpio_cfg[user_index].gpio_name, sub_key->sub_name, strlen(sub_key->sub_name) + 1);
|
||
memcpy(&user_gpio_cfg[user_index].port, parser->script_mod_buf + (sub_key->offset << 2), sizeof(user_gpio_set_t) - 32);
|
||
user_index++;
|
||
if (user_index >= gpio_count)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return SCRIPT_PARSER_OK;
|
||
}
|
||
|
||
return SCRIPT_PARSER_KEY_NOT_FIND;
|
||
}
|
||
|
||
void script_dump(void *hparser)
|
||
{
|
||
script_main_key_t *main_key = NULL;
|
||
script_sub_key_t *sub_key = NULL;
|
||
int value[64];
|
||
int32_t i, j;
|
||
int32_t pattern, word_count;
|
||
script_parser_t *parser;
|
||
|
||
static const char *type_name[] =
|
||
{
|
||
"Null",
|
||
"SINGLE_WORD",
|
||
"STRING",
|
||
"MULTI_WORD",
|
||
"GPIO_WORD",
|
||
};
|
||
|
||
parser = (script_parser_t *)hparser;
|
||
if (NULL == parser)
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (!parser->script_mod_buf)
|
||
{
|
||
return;
|
||
}
|
||
|
||
SCRIPT_DEBUG_PRINTF("main_key cnt:%d", parser->script_main_key_count);
|
||
for (i = 0; i < parser->script_main_key_count; i++)
|
||
{
|
||
main_key = SCRIPT_GET_MAIN_KEY(parser, i);
|
||
SCRIPT_DEBUG_PRINTF("main_key: %s, sub key cnt:%d", main_key->main_name,
|
||
main_key->lenth);
|
||
|
||
for (j = 0; j < main_key->lenth; j++)
|
||
{
|
||
sub_key = SCRIPT_GET_SUB_KEY(parser, main_key, j);
|
||
pattern = DATA_TYPE(sub_key);
|
||
word_count = (sub_key->pattern >> 0) & 0xffff;
|
||
|
||
switch (pattern)
|
||
{
|
||
case DATA_TYPE_SINGLE_WORD: //单word数据类型
|
||
value[0] = *(int *)(parser->script_mod_buf + (sub_key->offset << 2));
|
||
SCRIPT_DEBUG_PRINTF("\t%s = 0x%x", sub_key->sub_name, value[0]);
|
||
break;
|
||
case DATA_TYPE_STRING: //字符串数据类型
|
||
memcpy((char *)value, parser->script_mod_buf + (sub_key->offset << 2),
|
||
word_count << 2);
|
||
SCRIPT_DEBUG_PRINTF("\t%s = %s", sub_key->sub_name, (char *)value);
|
||
break;
|
||
case DATA_TYPE_MULTI_WORD:
|
||
SCRIPT_DEBUG_PRINTF("\t%s = ???(not support)", sub_key->sub_name);
|
||
break;
|
||
case DATA_TYPE_GPIO_WORD: //多word数据类型
|
||
{
|
||
user_gpio_set_t *gpio_cfg = (user_gpio_set_t *)value;
|
||
//发现是GPIO类型，检查是否足够存放用户数据
|
||
if (sizeof(user_gpio_set_t) > 64)
|
||
{
|
||
return;
|
||
}
|
||
memcpy(&gpio_cfg->port, parser->script_mod_buf +
|
||
(sub_key->offset << 2), sizeof(user_gpio_set_t) - 32);
|
||
SCRIPT_DEBUG_PRINTF("\t%s = P%c%d", sub_key->sub_name,
|
||
gpio_cfg->port + 0x40, gpio_cfg->port_num);
|
||
break;
|
||
}
|
||
default:
|
||
SCRIPT_DEBUG_PRINTF("\t%s = %ld(not support)", sub_key->sub_name, pattern);
|
||
}
|
||
}
|
||
}
|
||
}
|