diff --git a/components/finsh/cmd.c b/components/finsh/cmd.c index 9cd292d57..a1b04c38f 100644 --- a/components/finsh/cmd.c +++ b/components/finsh/cmd.c @@ -106,11 +106,11 @@ static long _list_thread(struct rt_list_node *list) rt_kprintf( " --- ------- ---------- ---------- ------ ---------- ---\n"); for (node = list->next; node != list; node = node->next) { - rt_uint8_t stat; + rt_uint8_t stat; thread = rt_list_entry(node, struct rt_thread, list); rt_kprintf("%-*.*s %3d ", maxlen, RT_NAME_MAX, thread->name, thread->current_priority); - stat = (thread->stat & RT_THREAD_STAT_MASK); + stat = (thread->stat & RT_THREAD_STAT_MASK); if (stat == RT_THREAD_READY) rt_kprintf(" ready "); else if (stat == RT_THREAD_SUSPEND) rt_kprintf(" suspend"); else if (stat == RT_THREAD_INIT) rt_kprintf(" init "); @@ -607,7 +607,7 @@ int list_module(void) { module = (struct rt_module *)(rt_list_entry(node, struct rt_object, list)); rt_kprintf("%-*.*s %-04d 0x%08x\n", - maxlen, RT_NAME_MAX, + maxlen, RT_NAME_MAX, module->parent.name, module->nref, module->module_space); } @@ -634,14 +634,14 @@ int list_mod_detail(const char *name) /* list main thread in module */ if (module->module_thread != RT_NULL) { - rt_uint8_t stat; - + rt_uint8_t stat; + rt_kprintf("main thread pri status sp stack size max used left tick error\n"); rt_kprintf("------------- ---- ------- ---------- ---------- ---------- ---------- ---\n"); thread = module->module_thread; rt_kprintf("%-8.*s 0x%02x", RT_NAME_MAX, thread->name, thread->current_priority); - stat = (thread->stat & RT_THREAD_STAT_MASK); + stat = (thread->stat & RT_THREAD_STAT_MASK); if (stat == RT_THREAD_READY) rt_kprintf(" ready "); else if (stat == RT_THREAD_SUSPEND) rt_kprintf(" suspend"); else if (stat == RT_THREAD_INIT) rt_kprintf(" init "); diff --git a/components/finsh/finsh.h b/components/finsh/finsh.h index 2c7815522..4452d4a0d 100644 --- a/components/finsh/finsh.h +++ b/components/finsh/finsh.h @@ -1,11 +1,20 @@ /* * File : finsh.h - * This file is part of RT-Thread RTOS - * COPYRIGHT (C) 2006 - 2010, RT-Thread Development Team + * COPYRIGHT (C) 2006 - 2018, RT-Thread Development Team * - * The license and distribution terms for this file may be - * found in the file LICENSE in this distribution or at - * http://www.rt-thread.org/license/LICENSE + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * * Change Logs: * Date Author Notes @@ -15,11 +24,7 @@ #define __FINSH_H__ #include - -#if defined(_MSC_VER) -#pragma section("FSymTab$f",read) -#pragma section("VSymTab",read) -#endif +#include "finsh_api.h" /* -- the beginning of option -- */ #define FINSH_NAME_MAX 16 /* max length of identifier */ @@ -63,63 +68,47 @@ #include #include -#define FINSH_VERSION_MAJOR 1 -#define FINSH_VERSION_MINOR 0 +#define FINSH_VERSION_MAJOR 1 +#define FINSH_VERSION_MINOR 0 /** * @addtogroup finsh */ /*@{*/ -#define FINSH_ERROR_OK 0 /**< No error */ -#define FINSH_ERROR_INVALID_TOKEN 1 /**< Invalid token */ -#define FINSH_ERROR_EXPECT_TYPE 2 /**< Expect a type */ -#define FINSH_ERROR_UNKNOWN_TYPE 3 /**< Unknown type */ -#define FINSH_ERROR_VARIABLE_EXIST 4 /**< Variable exist */ -#define FINSH_ERROR_EXPECT_OPERATOR 5 /**< Expect a operator */ -#define FINSH_ERROR_MEMORY_FULL 6 /**< Memory full */ -#define FINSH_ERROR_UNKNOWN_OP 7 /**< Unknown operator */ -#define FINSH_ERROR_UNKNOWN_NODE 8 /**< Unknown node */ -#define FINSH_ERROR_EXPECT_CHAR 9 /**< Expect a character */ -#define FINSH_ERROR_UNEXPECT_END 10 /**< Unexpect end */ -#define FINSH_ERROR_UNKNOWN_TOKEN 11 /**< Unknown token */ -#define FINSH_ERROR_NO_FLOAT 12 /**< Float not supported */ -#define FINSH_ERROR_UNKNOWN_SYMBOL 13 /**< Unknown symbol */ -#define FINSH_ERROR_NULL_NODE 14 /**< Null node */ +#define FINSH_ERROR_OK 0 /**< No error */ +#define FINSH_ERROR_INVALID_TOKEN 1 /**< Invalid token */ +#define FINSH_ERROR_EXPECT_TYPE 2 /**< Expect a type */ +#define FINSH_ERROR_UNKNOWN_TYPE 3 /**< Unknown type */ +#define FINSH_ERROR_VARIABLE_EXIST 4 /**< Variable exist */ +#define FINSH_ERROR_EXPECT_OPERATOR 5 /**< Expect a operator */ +#define FINSH_ERROR_MEMORY_FULL 6 /**< Memory full */ +#define FINSH_ERROR_UNKNOWN_OP 7 /**< Unknown operator */ +#define FINSH_ERROR_UNKNOWN_NODE 8 /**< Unknown node */ +#define FINSH_ERROR_EXPECT_CHAR 9 /**< Expect a character */ +#define FINSH_ERROR_UNEXPECT_END 10 /**< Unexpect end */ +#define FINSH_ERROR_UNKNOWN_TOKEN 11 /**< Unknown token */ +#define FINSH_ERROR_NO_FLOAT 12 /**< Float not supported */ +#define FINSH_ERROR_UNKNOWN_SYMBOL 13 /**< Unknown symbol */ +#define FINSH_ERROR_NULL_NODE 14 /**< Null node */ /*@}*/ -typedef long (*syscall_func)(); - -/* system call table */ -struct finsh_syscall -{ - const char* name; /* the name of system call */ -#if defined(FINSH_USING_DESCRIPTION) && defined(FINSH_USING_SYMTAB) - const char* desc; /* description of system call */ -#endif - syscall_func func; /* the function address of system call */ -}; - /* system call item */ struct finsh_syscall_item { - struct finsh_syscall_item* next; /* next item */ - struct finsh_syscall syscall; /* syscall */ + struct finsh_syscall_item* next; /* next item */ + struct finsh_syscall syscall; /* syscall */ }; -extern struct finsh_syscall *_syscall_table_begin, *_syscall_table_end; extern struct finsh_syscall_item *global_syscall_list; -/* find out system call, which should be implemented in user program */ -struct finsh_syscall* finsh_syscall_lookup(const char* name); - /* system variable table */ struct finsh_sysvar { - const char* name; /* the name of variable */ + const char* name; /* the name of variable */ #if defined(FINSH_USING_DESCRIPTION) && defined(FINSH_USING_SYMTAB) - const char* desc; /* description of system variable */ + const char* desc; /* description of system variable */ #endif - uint8_t type; /* the type of variable */ - void* var ; /* the address of variable */ + uint8_t type; /* the type of variable */ + void* var ; /* the address of variable */ }; #if defined(_MSC_VER) || (defined(__GNUC__) && defined(__x86_64__)) @@ -135,8 +124,8 @@ struct finsh_sysvar* finsh_sysvar_next(struct finsh_sysvar* call); /* system variable item */ struct finsh_sysvar_item { - struct finsh_sysvar_item *next; /* next item */ - struct finsh_sysvar sysvar; /* system variable */ + struct finsh_sysvar_item *next; /* next item */ + struct finsh_sysvar sysvar; /* system variable */ }; extern struct finsh_sysvar *_sysvar_table_begin, *_sysvar_table_end; extern struct finsh_sysvar_item* global_sysvar_list; @@ -144,243 +133,60 @@ extern struct finsh_sysvar_item* global_sysvar_list; /* find out system variable, which should be implemented in user program */ struct finsh_sysvar* finsh_sysvar_lookup(const char* name); -#ifdef FINSH_USING_SYMTAB - -#ifdef __TI_COMPILER_VERSION__ -#define __TI_FINSH_EXPORT_FUNCTION(f) PRAGMA(DATA_SECTION(f,"FSymTab")) -#define __TI_FINSH_EXPORT_VAR(v) PRAGMA(DATA_SECTION(v,"VSymTab")) -#endif - - #ifdef FINSH_USING_DESCRIPTION - #ifdef _MSC_VER - #define FINSH_FUNCTION_EXPORT_CMD(name, cmd, desc) \ - const char __fsym_##cmd##_name[] = #cmd; \ - const char __fsym_##cmd##_desc[] = #desc; \ - __declspec(allocate("FSymTab$f")) \ - const struct finsh_syscall __fsym_##cmd = \ - { \ - __fsym_##cmd##_name, \ - __fsym_##cmd##_desc, \ - (syscall_func)&name \ - }; - #pragma comment(linker, "/merge:FSymTab=mytext") - - #define FINSH_VAR_EXPORT(name, type, desc) \ - const char __vsym_##name##_name[] = #name; \ - const char __vsym_##name##_desc[] = #desc; \ - __declspec(allocate("VSymTab")) \ - const struct finsh_sysvar __vsym_##name = \ - { \ - __vsym_##name##_name, \ - __vsym_##name##_desc, \ - type, \ - (void*)&name \ - }; - - #elif defined(__TI_COMPILER_VERSION__) - #define FINSH_FUNCTION_EXPORT_CMD(name, cmd, desc) \ - __TI_FINSH_EXPORT_FUNCTION(__fsym_##cmd); \ - const char __fsym_##cmd##_name[] = #cmd; \ - const char __fsym_##cmd##_desc[] = #desc; \ - const struct finsh_syscall __fsym_##cmd = \ - { \ - __fsym_##cmd##_name, \ - __fsym_##cmd##_desc, \ - (syscall_func)&name \ - }; - - #define FINSH_VAR_EXPORT(name, type, desc) \ - __TI_FINSH_EXPORT_VAR(__vsym_##name); \ - const char __vsym_##name##_name[] = #name; \ - const char __vsym_##name##_desc[] = #desc; \ - const struct finsh_sysvar __vsym_##name = \ - { \ - __vsym_##name##_name, \ - __vsym_##name##_desc, \ - type, \ - (void*)&name \ - }; - - #else - #define FINSH_FUNCTION_EXPORT_CMD(name, cmd, desc) \ - const char __fsym_##cmd##_name[] SECTION(".rodata.name") = #cmd; \ - const char __fsym_##cmd##_desc[] SECTION(".rodata.name") = #desc; \ - const struct finsh_syscall __fsym_##cmd SECTION("FSymTab")= \ - { \ - __fsym_##cmd##_name, \ - __fsym_##cmd##_desc, \ - (syscall_func)&name \ - }; - - #define FINSH_VAR_EXPORT(name, type, desc) \ - const char __vsym_##name##_name[] SECTION(".rodata.name") = #name; \ - const char __vsym_##name##_desc[] SECTION(".rodata.name") = #desc; \ - const struct finsh_sysvar __vsym_##name SECTION("VSymTab")= \ - { \ - __vsym_##name##_name, \ - __vsym_##name##_desc, \ - type, \ - (void*)&name \ - }; - - #endif - #else - #ifdef _MSC_VER - #define FINSH_FUNCTION_EXPORT_CMD(name, cmd, desc) \ - const char __fsym_##cmd##_name[] = #cmd; \ - __declspec(allocate("FSymTab$f")) \ - const struct finsh_syscall __fsym_##cmd = \ - { \ - __fsym_##cmd##_name, \ - (syscall_func)&name \ - }; - #pragma comment(linker, "/merge:FSymTab=mytext") - - #define FINSH_VAR_EXPORT(name, type, desc) \ - const char __vsym_##name##_name[] = #name; \ - __declspec(allocate("VSymTab")) const struct finsh_sysvar __vsym_##name = \ - { \ - __vsym_##name##_name, \ - type, \ - (void*)&name \ - }; - - #elif defined(__TI_COMPILER_VERSION__) - #define FINSH_FUNCTION_EXPORT_CMD(name, cmd, desc) \ - __TI_FINSH_EXPORT_FUNCTION(__fsym_##cmd); \ - const char __fsym_##cmd##_name[] = #cmd; \ - const struct finsh_syscall __fsym_##cmd = \ - { \ - __fsym_##cmd##_name, \ - (syscall_func)&name \ - }; - - #define FINSH_VAR_EXPORT(name, type, desc) \ - __TI_FINSH_EXPORT_VAR(__vsym_##name); \ - const char __vsym_##name##_name[] = #name; \ - const struct finsh_sysvar __vsym_##name = \ - { \ - __vsym_##name##_name, \ - type, \ - (void*)&name \ - }; - - #else - #define FINSH_FUNCTION_EXPORT_CMD(name, cmd, desc) \ - const char __fsym_##cmd##_name[] = #cmd; \ - const struct finsh_syscall __fsym_##cmd SECTION("FSymTab")= \ - { \ - __fsym_##cmd##_name, \ - (syscall_func)&name \ - }; - - #define FINSH_VAR_EXPORT(name, type, desc) \ - const char __vsym_##name##_name[] = #name; \ - const struct finsh_sysvar __vsym_##name SECTION("VSymTab")= \ - { \ - __vsym_##name##_name, \ - type, \ - (void*)&name \ - }; - - #endif - #endif /* end of FINSH_USING_DESCRIPTION */ -#endif /* end of FINSH_USING_SYMTAB */ - -/** - * @ingroup finsh - * - * This macro exports a system function to finsh shell. - * - * @param name the name of function. - * @param desc the description of function, which will show in help. - */ -#define FINSH_FUNCTION_EXPORT(name, desc) \ - FINSH_FUNCTION_EXPORT_CMD(name, name, desc) - -/** - * @ingroup finsh - * - * This macro exports a system function with an alias name to finsh shell. - * - * @param name the name of function. - * @param alias the alias name of function. - * @param desc the description of function, which will show in help. - */ -#define FINSH_FUNCTION_EXPORT_ALIAS(name, alias, desc) \ - FINSH_FUNCTION_EXPORT_CMD(name, alias, desc) - -/** - * @ingroup finsh - * - * This macro exports a command to module shell. - * - * @param command the name of command. - * @param desc the description of command, which will show in help. - */ -#ifdef FINSH_USING_MSH -#define MSH_CMD_EXPORT(command, desc) \ - FINSH_FUNCTION_EXPORT_CMD(command, __cmd_##command, desc) -#define MSH_CMD_EXPORT_ALIAS(command, alias, desc) \ - FINSH_FUNCTION_EXPORT_ALIAS(command, __cmd_##alias, desc) -#else -#define MSH_CMD_EXPORT(command, desc) -#define MSH_CMD_EXPORT_ALIAS(command, alias, desc) -#endif struct finsh_token { - char eof; - char replay; + char eof; + char replay; - int position; - uint8_t current_token; + int position; + uint8_t current_token; - union { - char char_value; - int int_value; - long long_value; - } value; - uint8_t string[FINSH_STRING_MAX]; + union { + char char_value; + int int_value; + long long_value; + } value; + uint8_t string[FINSH_STRING_MAX]; - uint8_t* line; + uint8_t* line; }; -#define FINSH_IDTYPE_VAR 0x01 -#define FINSH_IDTYPE_SYSVAR 0x02 -#define FINSH_IDTYPE_SYSCALL 0x04 -#define FINSH_IDTYPE_ADDRESS 0x08 +#define FINSH_IDTYPE_VAR 0x01 +#define FINSH_IDTYPE_SYSVAR 0x02 +#define FINSH_IDTYPE_SYSCALL 0x04 +#define FINSH_IDTYPE_ADDRESS 0x08 struct finsh_node { - uint8_t node_type; /* node node_type */ - uint8_t data_type; /* node data node_type */ - uint8_t idtype; /* id node information */ + uint8_t node_type; /* node node_type */ + uint8_t data_type; /* node data node_type */ + uint8_t idtype; /* id node information */ - union { /* value node */ - char char_value; - short short_value; - int int_value; - long long_value; - void* ptr; - } value; - union - { - /* point to variable identifier or function identifier */ - struct finsh_var *var; - struct finsh_sysvar *sysvar; - struct finsh_syscall*syscall; - }id; + union { /* value node */ + char char_value; + short short_value; + int int_value; + long long_value; + void* ptr; + } value; + union + { + /* point to variable identifier or function identifier */ + struct finsh_var *var; + struct finsh_sysvar *sysvar; + struct finsh_syscall*syscall; + }id; - /* sibling and child node */ - struct finsh_node *sibling, *child; + /* sibling and child node */ + struct finsh_node *sibling, *child; }; struct finsh_parser { - uint8_t* parser_string; + uint8_t* parser_string; struct finsh_token token; - struct finsh_node* root; + struct finsh_node* root; }; /** @@ -389,21 +195,21 @@ struct finsh_parser * The basic data type in finsh shell */ enum finsh_type { - finsh_type_unknown = 0, /**< unknown data type */ - finsh_type_void, /**< void */ - finsh_type_voidp, /**< void pointer */ - finsh_type_char, /**< char */ - finsh_type_uchar, /**< unsigned char */ - finsh_type_charp, /**< char pointer */ - finsh_type_short, /**< short */ - finsh_type_ushort, /**< unsigned short */ - finsh_type_shortp, /**< short pointer */ - finsh_type_int, /**< int */ - finsh_type_uint, /**< unsigned int */ - finsh_type_intp, /**< int pointer */ - finsh_type_long, /**< long */ - finsh_type_ulong, /**< unsigned long */ - finsh_type_longp /**< long pointer */ + finsh_type_unknown = 0, /**< unknown data type */ + finsh_type_void, /**< void */ + finsh_type_voidp, /**< void pointer */ + finsh_type_char, /**< char */ + finsh_type_uchar, /**< unsigned char */ + finsh_type_charp, /**< char pointer */ + finsh_type_short, /**< short */ + finsh_type_ushort, /**< unsigned short */ + finsh_type_shortp, /**< short pointer */ + finsh_type_int, /**< int */ + finsh_type_uint, /**< unsigned int */ + finsh_type_intp, /**< int pointer */ + finsh_type_long, /**< long */ + finsh_type_ulong, /**< unsigned long */ + finsh_type_longp /**< long pointer */ }; /* init finsh environment */ diff --git a/components/finsh/finsh_api.h b/components/finsh/finsh_api.h new file mode 100644 index 000000000..6bbe410b0 --- /dev/null +++ b/components/finsh/finsh_api.h @@ -0,0 +1,231 @@ +/* + * File : finsh_api.h + * COPYRIGHT (C) 2006 - 2018, RT-Thread Development Team + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Change Logs: + * Date Author Notes + * 2010-03-22 Bernard first version + */ +#ifndef FINSH_API_H__ +#define FINSH_API_H__ + +#if defined(_MSC_VER) +#pragma section("FSymTab$f",read) +#pragma section("VSymTab",read) +#endif + +typedef long (*syscall_func)(void); + +/* system call table */ +struct finsh_syscall +{ + const char* name; /* the name of system call */ +#if defined(FINSH_USING_DESCRIPTION) && defined(FINSH_USING_SYMTAB) + const char* desc; /* description of system call */ +#endif + syscall_func func; /* the function address of system call */ +}; +extern struct finsh_syscall *_syscall_table_begin, *_syscall_table_end; + +/* find out system call, which should be implemented in user program */ +struct finsh_syscall* finsh_syscall_lookup(const char* name); + +#ifdef FINSH_USING_SYMTAB + +#ifdef __TI_COMPILER_VERSION__ +#define __TI_FINSH_EXPORT_FUNCTION(f) PRAGMA(DATA_SECTION(f,"FSymTab")) +#define __TI_FINSH_EXPORT_VAR(v) PRAGMA(DATA_SECTION(v,"VSymTab")) +#endif + + #ifdef FINSH_USING_DESCRIPTION + #ifdef _MSC_VER + #define FINSH_FUNCTION_EXPORT_CMD(name, cmd, desc) \ + const char __fsym_##cmd##_name[] = #cmd; \ + const char __fsym_##cmd##_desc[] = #desc; \ + __declspec(allocate("FSymTab$f")) \ + const struct finsh_syscall __fsym_##cmd = \ + { \ + __fsym_##cmd##_name, \ + __fsym_##cmd##_desc, \ + (syscall_func)&name \ + }; + #pragma comment(linker, "/merge:FSymTab=mytext") + + #define FINSH_VAR_EXPORT(name, type, desc) \ + const char __vsym_##name##_name[] = #name; \ + const char __vsym_##name##_desc[] = #desc; \ + __declspec(allocate("VSymTab")) \ + const struct finsh_sysvar __vsym_##name = \ + { \ + __vsym_##name##_name, \ + __vsym_##name##_desc, \ + type, \ + (void*)&name \ + }; + + #elif defined(__TI_COMPILER_VERSION__) + #define FINSH_FUNCTION_EXPORT_CMD(name, cmd, desc) \ + __TI_FINSH_EXPORT_FUNCTION(__fsym_##cmd); \ + const char __fsym_##cmd##_name[] = #cmd; \ + const char __fsym_##cmd##_desc[] = #desc; \ + const struct finsh_syscall __fsym_##cmd = \ + { \ + __fsym_##cmd##_name, \ + __fsym_##cmd##_desc, \ + (syscall_func)&name \ + }; + + #define FINSH_VAR_EXPORT(name, type, desc) \ + __TI_FINSH_EXPORT_VAR(__vsym_##name); \ + const char __vsym_##name##_name[] = #name; \ + const char __vsym_##name##_desc[] = #desc; \ + const struct finsh_sysvar __vsym_##name = \ + { \ + __vsym_##name##_name, \ + __vsym_##name##_desc, \ + type, \ + (void*)&name \ + }; + + #else + #define FINSH_FUNCTION_EXPORT_CMD(name, cmd, desc) \ + const char __fsym_##cmd##_name[] SECTION(".rodata.name") = #cmd; \ + const char __fsym_##cmd##_desc[] SECTION(".rodata.name") = #desc; \ + const struct finsh_syscall __fsym_##cmd SECTION("FSymTab")= \ + { \ + __fsym_##cmd##_name, \ + __fsym_##cmd##_desc, \ + (syscall_func)&name \ + }; + + #define FINSH_VAR_EXPORT(name, type, desc) \ + const char __vsym_##name##_name[] SECTION(".rodata.name") = #name; \ + const char __vsym_##name##_desc[] SECTION(".rodata.name") = #desc; \ + const struct finsh_sysvar __vsym_##name SECTION("VSymTab")= \ + { \ + __vsym_##name##_name, \ + __vsym_##name##_desc, \ + type, \ + (void*)&name \ + }; + + #endif + #else + #ifdef _MSC_VER + #define FINSH_FUNCTION_EXPORT_CMD(name, cmd, desc) \ + const char __fsym_##cmd##_name[] = #cmd; \ + __declspec(allocate("FSymTab$f")) \ + const struct finsh_syscall __fsym_##cmd = \ + { \ + __fsym_##cmd##_name, \ + (syscall_func)&name \ + }; + #pragma comment(linker, "/merge:FSymTab=mytext") + + #define FINSH_VAR_EXPORT(name, type, desc) \ + const char __vsym_##name##_name[] = #name; \ + __declspec(allocate("VSymTab")) const struct finsh_sysvar __vsym_##name = \ + { \ + __vsym_##name##_name, \ + type, \ + (void*)&name \ + }; + + #elif defined(__TI_COMPILER_VERSION__) + #define FINSH_FUNCTION_EXPORT_CMD(name, cmd, desc) \ + __TI_FINSH_EXPORT_FUNCTION(__fsym_##cmd); \ + const char __fsym_##cmd##_name[] = #cmd; \ + const struct finsh_syscall __fsym_##cmd = \ + { \ + __fsym_##cmd##_name, \ + (syscall_func)&name \ + }; + + #define FINSH_VAR_EXPORT(name, type, desc) \ + __TI_FINSH_EXPORT_VAR(__vsym_##name); \ + const char __vsym_##name##_name[] = #name; \ + const struct finsh_sysvar __vsym_##name = \ + { \ + __vsym_##name##_name, \ + type, \ + (void*)&name \ + }; + + #else + #define FINSH_FUNCTION_EXPORT_CMD(name, cmd, desc) \ + const char __fsym_##cmd##_name[] = #cmd; \ + const struct finsh_syscall __fsym_##cmd SECTION("FSymTab")= \ + { \ + __fsym_##cmd##_name, \ + (syscall_func)&name \ + }; + + #define FINSH_VAR_EXPORT(name, type, desc) \ + const char __vsym_##name##_name[] = #name; \ + const struct finsh_sysvar __vsym_##name SECTION("VSymTab")= \ + { \ + __vsym_##name##_name, \ + type, \ + (void*)&name \ + }; + + #endif + #endif /* end of FINSH_USING_DESCRIPTION */ +#endif /* end of FINSH_USING_SYMTAB */ + +/** + * @ingroup finsh + * + * This macro exports a system function to finsh shell. + * + * @param name the name of function. + * @param desc the description of function, which will show in help. + */ +#define FINSH_FUNCTION_EXPORT(name, desc) \ + FINSH_FUNCTION_EXPORT_CMD(name, name, desc) + +/** + * @ingroup finsh + * + * This macro exports a system function with an alias name to finsh shell. + * + * @param name the name of function. + * @param alias the alias name of function. + * @param desc the description of function, which will show in help. + */ +#define FINSH_FUNCTION_EXPORT_ALIAS(name, alias, desc) \ + FINSH_FUNCTION_EXPORT_CMD(name, alias, desc) + +/** + * @ingroup finsh + * + * This macro exports a command to module shell. + * + * @param command the name of command. + * @param desc the description of command, which will show in help. + */ +#ifdef FINSH_USING_MSH +#define MSH_CMD_EXPORT(command, desc) \ + FINSH_FUNCTION_EXPORT_CMD(command, __cmd_##command, desc) +#define MSH_CMD_EXPORT_ALIAS(command, alias, desc) \ + FINSH_FUNCTION_EXPORT_ALIAS(command, __cmd_##alias, desc) +#else +#define MSH_CMD_EXPORT(command, desc) +#define MSH_CMD_EXPORT_ALIAS(command, alias, desc) +#endif + +#endif diff --git a/components/finsh/finsh_error.c b/components/finsh/finsh_error.c index 2515c03e8..962aee1ad 100644 --- a/components/finsh/finsh_error.c +++ b/components/finsh/finsh_error.c @@ -33,42 +33,42 @@ uint8_t global_errno; static const char * finsh_error_string_table[] = { "No error", - "Invalid token", - "Expect a type", - "Unknown type", - "Variable exist", - "Expect a operater", - "Memory full", - "Unknown operator", - "Unknown node", - "Expect a character", - "Unexpect end", - "Unknown token", - "Float not supported", - "Unknown symbol", - "Null node" + "Invalid token", + "Expect a type", + "Unknown type", + "Variable exist", + "Expect a operater", + "Memory full", + "Unknown operator", + "Unknown node", + "Expect a character", + "Unexpect end", + "Unknown token", + "Float not supported", + "Unknown symbol", + "Null node" }; int finsh_error_init() { - global_errno = FINSH_ERROR_OK; + global_errno = FINSH_ERROR_OK; - return 0; + return 0; } int finsh_error_set(uint8_t type) { - global_errno = type; + global_errno = type; - return 0; + return 0; } uint8_t finsh_errno() { - return global_errno; + return global_errno; } const char* finsh_error_string(uint8_t type) { - return finsh_error_string_table[type]; + return finsh_error_string_table[type]; } diff --git a/components/finsh/finsh_heap.c b/components/finsh/finsh_heap.c index 28ca78bcf..f2f4beb08 100644 --- a/components/finsh/finsh_heap.c +++ b/components/finsh/finsh_heap.c @@ -34,13 +34,13 @@ ALIGN(RT_ALIGN_SIZE) uint8_t finsh_heap[FINSH_HEAP_MAX]; struct finsh_block_header { - uint32_t length; - struct finsh_block_header* next; + uint32_t length; + struct finsh_block_header* next; }; #define BLOCK_HEADER(x) (struct finsh_block_header*)(x) #define finsh_block_get_header(data) (struct finsh_block_header*)((uint8_t*)data - sizeof(struct finsh_block_header)) #define finsh_block_get_data(header) (uint8_t*)((struct finsh_block_header*)header + 1) -#define HEAP_ALIGN_SIZE(size) (((size) + HEAP_ALIGNMENT - 1) & ~(HEAP_ALIGNMENT-1)) +#define HEAP_ALIGN_SIZE(size) (((size) + HEAP_ALIGNMENT - 1) & ~(HEAP_ALIGNMENT-1)) static struct finsh_block_header* free_list; static struct finsh_block_header* allocate_list; @@ -54,12 +54,12 @@ static void finsh_block_merge(struct finsh_block_header** list, struct finsh_blo int finsh_heap_init(void) { - /* clear heap to zero */ - memset(&finsh_heap[0], 0, sizeof(finsh_heap)); + /* clear heap to zero */ + memset(&finsh_heap[0], 0, sizeof(finsh_heap)); - /* init free and alloc list */ + /* init free and alloc list */ free_list = BLOCK_HEADER(&finsh_heap[0]); - free_list->length = FINSH_HEAP_MAX - sizeof(struct finsh_block_header); + free_list->length = FINSH_HEAP_MAX - sizeof(struct finsh_block_header); free_list->next = NULL; allocate_list = NULL; @@ -72,41 +72,41 @@ int finsh_heap_init(void) */ void* finsh_heap_allocate(size_t size) { - struct finsh_block_header* header; + struct finsh_block_header* header; - size = HEAP_ALIGN_SIZE(size); + size = HEAP_ALIGN_SIZE(size); /* find the first fit block */ for (header = free_list; ((header != NULL) && (header->length <= size + sizeof(struct finsh_block_header))); header = header->next) ; - if (header == NULL) - { - finsh_heap_gc(); + if (header == NULL) + { + finsh_heap_gc(); - /* find the first fit block */ - for (header = free_list; - ((header != NULL) && (header->length < size + sizeof(struct finsh_block_header))); - header = header->next) ; + /* find the first fit block */ + for (header = free_list; + ((header != NULL) && (header->length < size + sizeof(struct finsh_block_header))); + header = header->next) ; - /* there is no memory */ - if (header == NULL) return NULL; - } + /* there is no memory */ + if (header == NULL) return NULL; + } /* split block */ - finsh_block_split(header, size); + finsh_block_split(header, size); - /* remove from free list */ - finsh_block_remove(&free_list, header); - header->next = NULL; + /* remove from free list */ + finsh_block_remove(&free_list, header); + header->next = NULL; /* insert to allocate list */ finsh_block_insert(&allocate_list, header); - memset(finsh_block_get_data(header), 0, size); + memset(finsh_block_get_data(header), 0, size); - return finsh_block_get_data(header); + return finsh_block_get_data(header); } /** @@ -117,14 +117,14 @@ void finsh_heap_free(void*ptr) struct finsh_block_header* header; /* get block header */ - header = finsh_block_get_header(ptr); + header = finsh_block_get_header(ptr); /* remove from allocate list */ - finsh_block_remove(&allocate_list, header); + finsh_block_remove(&allocate_list, header); - /* insert to free list */ - finsh_block_insert(&free_list, header); - finsh_block_merge(&free_list, header); + /* insert to free list */ + finsh_block_insert(&free_list, header); + finsh_block_merge(&free_list, header); } /** @@ -132,31 +132,31 @@ void finsh_heap_free(void*ptr) */ static void finsh_heap_gc(void) { - int i; - struct finsh_block_header *header, *temp; + int i; + struct finsh_block_header *header, *temp; - temp = NULL; + temp = NULL; /* find the first fit block */ for (header = allocate_list; header != NULL; ) { - for (i = 0; i < FINSH_VARIABLE_MAX; i ++) - { - if (global_variable[i].type != finsh_type_unknown) - { - if (global_variable[i].value.ptr == finsh_block_get_data(header)) - break; - } - } + for (i = 0; i < FINSH_VARIABLE_MAX; i ++) + { + if (global_variable[i].type != finsh_type_unknown) + { + if (global_variable[i].value.ptr == finsh_block_get_data(header)) + break; + } + } - temp = header; - header = header->next; + temp = header; + header = header->next; - /* this block is an unused block, release it */ - if (i == FINSH_VARIABLE_MAX) - { - finsh_heap_free(finsh_block_get_data(temp)); - } + /* this block is an unused block, release it */ + if (i == FINSH_VARIABLE_MAX) + { + finsh_heap_free(finsh_block_get_data(temp)); + } } } @@ -174,25 +174,25 @@ void finsh_block_insert(struct finsh_block_header** list, struct finsh_block_hea } /* find out insert point */ - node = *list; + node = *list; - if (node > header) - { - /* insert node in the header of list */ - header->next = node; - *list = header; + if (node > header) + { + /* insert node in the header of list */ + header->next = node; + *list = header; - return; - } - else - { - for (node = *list; node; node = node->next) - { - if (node->next > header) break; + return; + } + else + { + for (node = *list; node; node = node->next) + { + if (node->next > header) break; - if (node->next == NULL) break; - } - } + if (node->next == NULL) break; + } + } /* insert node */ if (node->next != NULL) header->next = node->next; @@ -276,7 +276,7 @@ void finsh_block_merge(struct finsh_block_header** list, struct finsh_block_head == (uint8_t*)next_node)) { /* merge three node */ - prev_node->length += header->length + next_node->length + + prev_node->length += header->length + next_node->length + 2 * sizeof(struct finsh_block_header); prev_node->next = next_node->next; diff --git a/components/finsh/finsh_init.c b/components/finsh/finsh_init.c index f4a34791b..a2852092f 100644 --- a/components/finsh/finsh_init.c +++ b/components/finsh/finsh_init.c @@ -37,15 +37,15 @@ int finsh_init(struct finsh_parser* parser) { - finsh_parser_init(parser); + finsh_parser_init(parser); - /* finsh init */ - finsh_node_init(); - finsh_var_init(); - finsh_error_init(); - finsh_heap_init(); + /* finsh init */ + finsh_node_init(); + finsh_var_init(); + finsh_error_init(); + finsh_heap_init(); - return 0; + return 0; } long finsh_stack_bottom() @@ -55,22 +55,22 @@ long finsh_stack_bottom() int finsh_flush(struct finsh_parser* parser) { - finsh_parser_init(parser); + finsh_parser_init(parser); - /* finsh init */ - finsh_node_init(); - finsh_error_init(); + /* finsh init */ + finsh_node_init(); + finsh_error_init(); - return 0; + return 0; } int finsh_reset(struct finsh_parser* parser) { - /* finsh init */ - finsh_node_init(); - finsh_var_init(); - finsh_error_init(); - finsh_heap_init(); + /* finsh init */ + finsh_node_init(); + finsh_var_init(); + finsh_error_init(); + finsh_heap_init(); - return 0; + return 0; } diff --git a/components/finsh/finsh_node.c b/components/finsh/finsh_node.c index 184ac20d6..ae28a6ac8 100644 --- a/components/finsh/finsh_node.c +++ b/components/finsh/finsh_node.c @@ -37,166 +37,166 @@ struct finsh_node global_node_table[FINSH_NODE_MAX]; int finsh_node_init() { - memset(global_node_table, 0, sizeof(global_node_table)); + memset(global_node_table, 0, sizeof(global_node_table)); - return 0; + return 0; } struct finsh_node* finsh_node_allocate(uint8_t type) { - int i; + int i; - /* find an empty entry */ - for (i = 0; i < FINSH_NODE_MAX; i ++) - { - if (global_node_table[i].node_type == FINSH_NODE_UNKNOWN) break; - } + /* find an empty entry */ + for (i = 0; i < FINSH_NODE_MAX; i ++) + { + if (global_node_table[i].node_type == FINSH_NODE_UNKNOWN) break; + } - if (i == FINSH_NODE_MAX) return NULL; + if (i == FINSH_NODE_MAX) return NULL; - /* fill type field */ - global_node_table[i].node_type = type; + /* fill type field */ + global_node_table[i].node_type = type; - /* return this allocated node */ - return &global_node_table[i]; + /* return this allocated node */ + return &global_node_table[i]; } struct finsh_node* finsh_node_new_id(char* id) { - struct finsh_node* node; - void* symbol; - unsigned char type; + struct finsh_node* node; + void* symbol; + unsigned char type; - symbol = NULL; - type = 0; - node = NULL; + symbol = NULL; + type = 0; + node = NULL; - /* lookup variable firstly */ - symbol = (void*)finsh_var_lookup(id); - if (symbol == NULL) - { - /* then lookup system variable */ - symbol = (void*)finsh_sysvar_lookup(id); - if (symbol == NULL) - { - /* then lookup system call */ - symbol = (void*)finsh_syscall_lookup(id); - if (symbol != NULL) type = FINSH_IDTYPE_SYSCALL; - } - else type = FINSH_IDTYPE_SYSVAR; - } - else type = FINSH_IDTYPE_VAR; + /* lookup variable firstly */ + symbol = (void*)finsh_var_lookup(id); + if (symbol == NULL) + { + /* then lookup system variable */ + symbol = (void*)finsh_sysvar_lookup(id); + if (symbol == NULL) + { + /* then lookup system call */ + symbol = (void*)finsh_syscall_lookup(id); + if (symbol != NULL) type = FINSH_IDTYPE_SYSCALL; + } + else type = FINSH_IDTYPE_SYSVAR; + } + else type = FINSH_IDTYPE_VAR; - if (symbol != NULL) - { - /* allocate a new node */ - node = finsh_node_allocate(FINSH_NODE_ID); + if (symbol != NULL) + { + /* allocate a new node */ + node = finsh_node_allocate(FINSH_NODE_ID); - /* allocate node error */ - if (node == NULL) - { - finsh_error_set(FINSH_ERROR_MEMORY_FULL); - return NULL; - } + /* allocate node error */ + if (node == NULL) + { + finsh_error_set(FINSH_ERROR_MEMORY_FULL); + return NULL; + } - /* fill node value according type */ - switch (type) - { - case FINSH_IDTYPE_VAR: - node->id.var = (struct finsh_var*)symbol; - break; + /* fill node value according type */ + switch (type) + { + case FINSH_IDTYPE_VAR: + node->id.var = (struct finsh_var*)symbol; + break; - case FINSH_IDTYPE_SYSVAR: - node->id.sysvar = (struct finsh_sysvar*)symbol; - break; + case FINSH_IDTYPE_SYSVAR: + node->id.sysvar = (struct finsh_sysvar*)symbol; + break; - case FINSH_IDTYPE_SYSCALL: - node->id.syscall = (struct finsh_syscall*)symbol; - break; - } - /* fill identifier type */ - node->idtype = type; - } - else finsh_error_set(FINSH_ERROR_UNKNOWN_SYMBOL); + case FINSH_IDTYPE_SYSCALL: + node->id.syscall = (struct finsh_syscall*)symbol; + break; + } + /* fill identifier type */ + node->idtype = type; + } + else finsh_error_set(FINSH_ERROR_UNKNOWN_SYMBOL); - return node; + return node; } struct finsh_node* finsh_node_new_char(char c) { - struct finsh_node* node; + struct finsh_node* node; - node = finsh_node_allocate(FINSH_NODE_VALUE_CHAR); - if (node == NULL) - { - finsh_error_set(FINSH_ERROR_MEMORY_FULL); - return NULL; - } + node = finsh_node_allocate(FINSH_NODE_VALUE_CHAR); + if (node == NULL) + { + finsh_error_set(FINSH_ERROR_MEMORY_FULL); + return NULL; + } - node->value.char_value = c; - return node; + node->value.char_value = c; + return node; } struct finsh_node* finsh_node_new_int(int i) { - struct finsh_node* node; + struct finsh_node* node; - node = finsh_node_allocate(FINSH_NODE_VALUE_INT); - if (node == NULL) - { - finsh_error_set(FINSH_ERROR_MEMORY_FULL); - return NULL; - } + node = finsh_node_allocate(FINSH_NODE_VALUE_INT); + if (node == NULL) + { + finsh_error_set(FINSH_ERROR_MEMORY_FULL); + return NULL; + } - node->value.int_value = i; - return node; + node->value.int_value = i; + return node; } struct finsh_node* finsh_node_new_long(long l) { - struct finsh_node* node; + struct finsh_node* node; - node = finsh_node_allocate(FINSH_NODE_VALUE_LONG); - if (node == NULL) - { - finsh_error_set(FINSH_ERROR_MEMORY_FULL); - return NULL; - } + node = finsh_node_allocate(FINSH_NODE_VALUE_LONG); + if (node == NULL) + { + finsh_error_set(FINSH_ERROR_MEMORY_FULL); + return NULL; + } - node->value.long_value = l; - return node; + node->value.long_value = l; + return node; } struct finsh_node* finsh_node_new_string(char* s) { - struct finsh_node* node; + struct finsh_node* node; - node = finsh_node_allocate(FINSH_NODE_VALUE_STRING); - if (node == NULL) - { - finsh_error_set(FINSH_ERROR_MEMORY_FULL); - return NULL; - } + node = finsh_node_allocate(FINSH_NODE_VALUE_STRING); + if (node == NULL) + { + finsh_error_set(FINSH_ERROR_MEMORY_FULL); + return NULL; + } - /* make string */ - node->value.ptr = finsh_heap_allocate(strlen(s) + 1); - strncpy(node->value.ptr, s, strlen(s)); - ((uint8_t*)node->value.ptr)[strlen(s)] = '\0'; + /* make string */ + node->value.ptr = finsh_heap_allocate(strlen(s) + 1); + strncpy(node->value.ptr, s, strlen(s)); + ((uint8_t*)node->value.ptr)[strlen(s)] = '\0'; - return node; + return node; } struct finsh_node* finsh_node_new_ptr(void* ptr) { - struct finsh_node* node; + struct finsh_node* node; - node = finsh_node_allocate(FINSH_NODE_VALUE_NULL); - if (node == NULL) - { - finsh_error_set(FINSH_ERROR_MEMORY_FULL); - return NULL; - } + node = finsh_node_allocate(FINSH_NODE_VALUE_NULL); + if (node == NULL) + { + finsh_error_set(FINSH_ERROR_MEMORY_FULL); + return NULL; + } - node->value.ptr = ptr; - return node; + node->value.ptr = ptr; + return node; } diff --git a/components/finsh/finsh_node.h b/components/finsh/finsh_node.h index 722a36872..5e0e4a300 100644 --- a/components/finsh/finsh_node.h +++ b/components/finsh/finsh_node.h @@ -31,46 +31,46 @@ #include -#define FINSH_NODE_UNKNOWN 0 -#define FINSH_NODE_ID 1 +#define FINSH_NODE_UNKNOWN 0 +#define FINSH_NODE_ID 1 -#define FINSH_NODE_VALUE_CHAR 2 -#define FINSH_NODE_VALUE_INT 3 -#define FINSH_NODE_VALUE_LONG 4 -#define FINSH_NODE_VALUE_STRING 5 -#define FINSH_NODE_VALUE_NULL 6 +#define FINSH_NODE_VALUE_CHAR 2 +#define FINSH_NODE_VALUE_INT 3 +#define FINSH_NODE_VALUE_LONG 4 +#define FINSH_NODE_VALUE_STRING 5 +#define FINSH_NODE_VALUE_NULL 6 -#define FINSH_NODE_SYS_ADD 7 -#define FINSH_NODE_SYS_SUB 8 -#define FINSH_NODE_SYS_MUL 9 -#define FINSH_NODE_SYS_DIV 10 -#define FINSH_NODE_SYS_MOD 11 -#define FINSH_NODE_SYS_AND 12 -#define FINSH_NODE_SYS_OR 13 -#define FINSH_NODE_SYS_XOR 14 -#define FINSH_NODE_SYS_BITWISE 15 -#define FINSH_NODE_SYS_SHL 16 -#define FINSH_NODE_SYS_SHR 17 -#define FINSH_NODE_SYS_FUNC 18 -#define FINSH_NODE_SYS_ASSIGN 19 -#define FINSH_NODE_SYS_CAST 20 -#define FINSH_NODE_SYS_PREINC 21 -#define FINSH_NODE_SYS_PREDEC 22 -#define FINSH_NODE_SYS_INC 23 -#define FINSH_NODE_SYS_DEC 24 +#define FINSH_NODE_SYS_ADD 7 +#define FINSH_NODE_SYS_SUB 8 +#define FINSH_NODE_SYS_MUL 9 +#define FINSH_NODE_SYS_DIV 10 +#define FINSH_NODE_SYS_MOD 11 +#define FINSH_NODE_SYS_AND 12 +#define FINSH_NODE_SYS_OR 13 +#define FINSH_NODE_SYS_XOR 14 +#define FINSH_NODE_SYS_BITWISE 15 +#define FINSH_NODE_SYS_SHL 16 +#define FINSH_NODE_SYS_SHR 17 +#define FINSH_NODE_SYS_FUNC 18 +#define FINSH_NODE_SYS_ASSIGN 19 +#define FINSH_NODE_SYS_CAST 20 +#define FINSH_NODE_SYS_PREINC 21 +#define FINSH_NODE_SYS_PREDEC 22 +#define FINSH_NODE_SYS_INC 23 +#define FINSH_NODE_SYS_DEC 24 #define FINSH_NODE_SYS_GETVALUE 25 #define FINSH_NODE_SYS_GETADDR 26 -#define FINSH_NODE_SYS_NULL 27 +#define FINSH_NODE_SYS_NULL 27 -#define FINSH_DATA_TYPE_VOID 0x00 -#define FINSH_DATA_TYPE_BYTE 0x01 -#define FINSH_DATA_TYPE_WORD 0x02 -#define FINSH_DATA_TYPE_DWORD 0x03 -#define FINSH_DATA_TYPE_PTR 0x10 +#define FINSH_DATA_TYPE_VOID 0x00 +#define FINSH_DATA_TYPE_BYTE 0x01 +#define FINSH_DATA_TYPE_WORD 0x02 +#define FINSH_DATA_TYPE_DWORD 0x03 +#define FINSH_DATA_TYPE_PTR 0x10 -#define FINSH_NODE_VALUE 0 -#define FINSH_NODE_ADDRESS 1 -#define FINSH_NODE_FUNCTION 2 +#define FINSH_NODE_VALUE 0 +#define FINSH_NODE_ADDRESS 1 +#define FINSH_NODE_FUNCTION 2 int finsh_node_init(void); @@ -82,7 +82,7 @@ struct finsh_node* finsh_node_new_long(long l); struct finsh_node* finsh_node_new_string(char* s); struct finsh_node* finsh_node_new_ptr(void* ptr); -#define finsh_node_sibling(node) ((node)->sibling) -#define finsh_node_child(node) ((node)->child) +#define finsh_node_sibling(node) ((node)->sibling) +#define finsh_node_child(node) ((node)->child) #endif diff --git a/components/finsh/finsh_ops.c b/components/finsh/finsh_ops.c index 261c52755..cefdf3c25 100644 --- a/components/finsh/finsh_ops.c +++ b/components/finsh/finsh_ops.c @@ -47,8 +47,8 @@ /* --- noop --- */ void OP_no_op() { - /* none */ - return ; + /* none */ + return ; } /* --- add --- */ @@ -56,87 +56,87 @@ void OP_add_byte() { OP_BIN_BYTE(+); - return ; + return ; } void OP_add_word() { OP_BIN_WORD(+); - return ; + return ; } void OP_add_dword() { OP_BIN_DWORD(+); - return ; + return ; } /* --- sub --- */ void OP_sub_byte() { - OP_BIN_BYTE(-); + OP_BIN_BYTE(-); - return ; + return ; } void OP_sub_word() { - OP_BIN_WORD(-); + OP_BIN_WORD(-); - return ; + return ; } void OP_sub_dword() { - OP_BIN_DWORD(-); + OP_BIN_DWORD(-); - return ; + return ; } /* --- div --- */ void OP_div_byte() { - OP_BIN_BYTE(/); + OP_BIN_BYTE(/); - return ; + return ; } void OP_div_word() { - OP_BIN_WORD(/); + OP_BIN_WORD(/); - return ; + return ; } void OP_div_dword() { - OP_BIN_DWORD(/); + OP_BIN_DWORD(/); - return ; + return ; } /* --- mod --- */ void OP_mod_byte() { - OP_BIN_BYTE(%); + OP_BIN_BYTE(%); - return ; + return ; } void OP_mod_word() { - OP_BIN_WORD(%); + OP_BIN_WORD(%); - return ; + return ; } void OP_mod_dword() { - OP_BIN_DWORD(%); + OP_BIN_DWORD(%); - return ; + return ; } /* --- mul --- */ @@ -144,256 +144,256 @@ void OP_mul_byte() { OP_BIN_BYTE(*); - return ; + return ; } void OP_mul_word() { - OP_BIN_WORD(*); + OP_BIN_WORD(*); - return ; + return ; } void OP_mul_dword() { - OP_BIN_DWORD(*); + OP_BIN_DWORD(*); - return ; + return ; } /* --- and --- */ void OP_and_byte() { - OP_BIN_BYTE(&); + OP_BIN_BYTE(&); - return ; + return ; } void OP_and_word() { - OP_BIN_WORD(&); + OP_BIN_WORD(&); - return ; + return ; } void OP_and_dword() { - OP_BIN_DWORD(&); + OP_BIN_DWORD(&); - return ; + return ; } /* --- or --- */ void OP_or_byte() { - OP_BIN_BYTE(|); + OP_BIN_BYTE(|); - return ; + return ; } void OP_or_word() { - OP_BIN_WORD(|); + OP_BIN_WORD(|); - return ; + return ; } void OP_or_dword() { - OP_BIN_DWORD(|); + OP_BIN_DWORD(|); - return ; + return ; } /* --- xor --- */ void OP_xor_byte() { - OP_BIN_BYTE(^); + OP_BIN_BYTE(^); - return ; + return ; } void OP_xor_word() { - OP_BIN_WORD(^); + OP_BIN_WORD(^); - return ; + return ; } void OP_xor_dword() { - OP_BIN_DWORD(^); + OP_BIN_DWORD(^); - return ; + return ; } /* --- bw --- */ void OP_bw_byte() { - (finsh_sp - 1)->char_value = ~ ((finsh_sp - 1)->char_value); + (finsh_sp - 1)->char_value = ~ ((finsh_sp - 1)->char_value); - return ; + return ; } void OP_bw_word() { - (finsh_sp - 1)->short_value = ~ ((finsh_sp - 1)->short_value); + (finsh_sp - 1)->short_value = ~ ((finsh_sp - 1)->short_value); - return ; + return ; } void OP_bw_dword() { - (finsh_sp - 1)->long_value = ~ ((finsh_sp - 1)->long_value); + (finsh_sp - 1)->long_value = ~ ((finsh_sp - 1)->long_value); - return ; + return ; } /* --- shl --- */ void OP_shl_byte() { - OP_BIN_BYTE(<<); + OP_BIN_BYTE(<<); - return ; + return ; } void OP_shl_word() { - OP_BIN_WORD(<<); + OP_BIN_WORD(<<); - return ; + return ; } void OP_shl_dword() { - OP_BIN_DWORD(<<); + OP_BIN_DWORD(<<); - return ; + return ; } /* --- shr --- */ void OP_shr_byte() { - OP_BIN_BYTE(>>); + OP_BIN_BYTE(>>); - return ; + return ; } void OP_shr_word() { - OP_BIN_WORD(>>); + OP_BIN_WORD(>>); - return ; + return ; } void OP_shr_dword() { - OP_BIN_DWORD(>>); + OP_BIN_DWORD(>>); - return ; + return ; } /* --- ld --- */ void OP_ld_byte() { - finsh_sp->char_value = *finsh_pc; + finsh_sp->char_value = *finsh_pc; - finsh_sp++; - finsh_pc++; + finsh_sp++; + finsh_pc++; - return ; + return ; } void OP_ld_word() { - finsh_sp->short_value = FINSH_GET16(finsh_pc); + finsh_sp->short_value = FINSH_GET16(finsh_pc); - finsh_sp ++; - finsh_pc += 2; + finsh_sp ++; + finsh_pc += 2; - return ; + return ; } void OP_ld_dword() { - finsh_sp->long_value = FINSH_GET32(finsh_pc); + finsh_sp->long_value = FINSH_GET32(finsh_pc); - finsh_sp ++; - finsh_pc += 4; + finsh_sp ++; + finsh_pc += 4; - return ; + return ; } void OP_ld_value_byte() { - char* c; + char* c; - c = (char*) (FINSH_GET32(finsh_pc)); + c = (char*) (FINSH_GET32(finsh_pc)); - finsh_sp->char_value = *c; + finsh_sp->char_value = *c; - finsh_sp ++; - finsh_pc += 4; + finsh_sp ++; + finsh_pc += 4; - return; + return; } void OP_ld_value_byte_stack() { - char* c; + char* c; - c = (char *)(finsh_sp - 1)->long_value; - (finsh_sp - 1)->char_value = *c; + c = (char *)(finsh_sp - 1)->long_value; + (finsh_sp - 1)->char_value = *c; - return; + return; } void OP_ld_value_word() { - short* s; + short* s; - s = (short*) (FINSH_GET32(finsh_pc)); + s = (short*) (FINSH_GET32(finsh_pc)); - finsh_sp->short_value = *s; + finsh_sp->short_value = *s; - finsh_sp ++; - finsh_pc += 4; + finsh_sp ++; + finsh_pc += 4; - return; + return; } void OP_ld_value_word_stack() { - short* s; + short* s; - s = (short *)(finsh_sp - 1)->long_value; - (finsh_sp - 1)->short_value = *s; + s = (short *)(finsh_sp - 1)->long_value; + (finsh_sp - 1)->short_value = *s; - return; + return; } void OP_ld_value_dword() { - long* l; + long* l; - l = (long*) (FINSH_GET32(finsh_pc)); + l = (long*) (FINSH_GET32(finsh_pc)); - finsh_sp->long_value = *l; + finsh_sp->long_value = *l; - finsh_sp ++; - finsh_pc += 4; + finsh_sp ++; + finsh_pc += 4; - return; + return; } void OP_ld_value_dword_stack() { - long* l; + long* l; - l = (long *)(finsh_sp - 1)->long_value; - (finsh_sp - 1)->long_value = *l; + l = (long *)(finsh_sp - 1)->long_value; + (finsh_sp - 1)->long_value = *l; - return; + return; } /* --- st --- */ @@ -403,10 +403,10 @@ void OP_ld_value_dword_stack() */ void OP_st_byte() { - *(char*)((finsh_sp - 2)->long_value) = (finsh_sp - 1)->char_value; - finsh_sp --; + *(char*)((finsh_sp - 2)->long_value) = (finsh_sp - 1)->char_value; + finsh_sp --; - return ; + return ; } /* @@ -415,10 +415,10 @@ void OP_st_byte() */ void OP_st_word() { - *(short*)((finsh_sp - 2)->long_value) = (finsh_sp - 1)->short_value; - finsh_sp --; + *(short*)((finsh_sp - 2)->long_value) = (finsh_sp - 1)->short_value; + finsh_sp --; - return ; + return ; } /* @@ -427,196 +427,196 @@ void OP_st_word() */ void OP_st_dword() { - *(long*)((finsh_sp - 2)->long_value) = (finsh_sp - 1)->long_value; - finsh_sp --; + *(long*)((finsh_sp - 2)->long_value) = (finsh_sp - 1)->long_value; + finsh_sp --; - return ; + return ; } /* --- pop --- */ void OP_pop() { - finsh_sp --; - return ; + finsh_sp --; + return ; } /* --- call --- */ void OP_call() { - /* the max number of arg*/ - unsigned long parameterv[16]; - unsigned int parameters, i; + /* the max number of arg*/ + unsigned long parameterv[16]; + unsigned int parameters, i; - typedef unsigned long var_t; - typedef var_t (*op_func)(); - op_func f; - var_t r; + typedef unsigned long var_t; + typedef var_t (*op_func)(); + op_func f; + var_t r; - parameters = *finsh_pc ++; + parameters = *finsh_pc ++; - i = 0; finsh_sp --; - while (i < parameters) - { - parameterv[parameters - 1 - i] = finsh_sp->long_value; - finsh_sp --; - i++; - } + i = 0; finsh_sp --; + while (i < parameters) + { + parameterv[parameters - 1 - i] = finsh_sp->long_value; + finsh_sp --; + i++; + } - f = (op_func)(finsh_sp->long_value); - switch (parameters) - { - case 0: - r = f(0); - break; + f = (op_func)(finsh_sp->long_value); + switch (parameters) + { + case 0: + r = f(0); + break; - case 1: - r = f(parameterv[0]); - break; + case 1: + r = f(parameterv[0]); + break; - case 2: - r = f(parameterv[0], parameterv[1]); - break; + case 2: + r = f(parameterv[0], parameterv[1]); + break; - case 3: - r = f(parameterv[0], parameterv[1], parameterv[2]); - break; + case 3: + r = f(parameterv[0], parameterv[1], parameterv[2]); + break; - case 4: - r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3]); - break; + case 4: + r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3]); + break; - case 5: - r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], - parameterv[4]); - break; + case 5: + r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], + parameterv[4]); + break; - case 6: - r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], - parameterv[4], parameterv[5]); - break; + case 6: + r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], + parameterv[4], parameterv[5]); + break; - case 7: - r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], - parameterv[4], parameterv[5], parameterv[6]); - break; + case 7: + r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], + parameterv[4], parameterv[5], parameterv[6]); + break; - case 8: - r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], - parameterv[4], parameterv[5], parameterv[6], parameterv[7]); - break; + case 8: + r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], + parameterv[4], parameterv[5], parameterv[6], parameterv[7]); + break; - case 9: - r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], - parameterv[4], parameterv[5], parameterv[6], parameterv[7], - parameterv[8]); - break; + case 9: + r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], + parameterv[4], parameterv[5], parameterv[6], parameterv[7], + parameterv[8]); + break; - case 10: - r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], - parameterv[4], parameterv[5], parameterv[6], parameterv[7], - parameterv[8], parameterv[9]); - break; + case 10: + r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], + parameterv[4], parameterv[5], parameterv[6], parameterv[7], + parameterv[8], parameterv[9]); + break; - case 11: - r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], - parameterv[4], parameterv[5], parameterv[6], parameterv[7], - parameterv[8], parameterv[9], parameterv[10]); - break; + case 11: + r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], + parameterv[4], parameterv[5], parameterv[6], parameterv[7], + parameterv[8], parameterv[9], parameterv[10]); + break; - case 12: - r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], - parameterv[4], parameterv[5], parameterv[6], parameterv[7], - parameterv[8], parameterv[9], parameterv[10], parameterv[11]); - break; + case 12: + r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], + parameterv[4], parameterv[5], parameterv[6], parameterv[7], + parameterv[8], parameterv[9], parameterv[10], parameterv[11]); + break; - case 13: - r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], - parameterv[4], parameterv[5], parameterv[6], parameterv[7], - parameterv[8], parameterv[9], parameterv[10], parameterv[11], - parameterv[12]); - break; + case 13: + r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], + parameterv[4], parameterv[5], parameterv[6], parameterv[7], + parameterv[8], parameterv[9], parameterv[10], parameterv[11], + parameterv[12]); + break; - case 14: - r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], - parameterv[4], parameterv[5], parameterv[6], parameterv[7], - parameterv[8], parameterv[9], parameterv[10], parameterv[11], - parameterv[12], parameterv[13]); - break; + case 14: + r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], + parameterv[4], parameterv[5], parameterv[6], parameterv[7], + parameterv[8], parameterv[9], parameterv[10], parameterv[11], + parameterv[12], parameterv[13]); + break; - case 15: - r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], - parameterv[4], parameterv[5], parameterv[6], parameterv[7], - parameterv[8], parameterv[9], parameterv[10], parameterv[11], - parameterv[12], parameterv[13], parameterv[14]); - break; + case 15: + r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], + parameterv[4], parameterv[5], parameterv[6], parameterv[7], + parameterv[8], parameterv[9], parameterv[10], parameterv[11], + parameterv[12], parameterv[13], parameterv[14]); + break; - case 16: - r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], - parameterv[4], parameterv[5], parameterv[6], parameterv[7], - parameterv[8], parameterv[9], parameterv[10], parameterv[11], - parameterv[12], parameterv[13], parameterv[14], parameterv[15]); - break; + case 16: + r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3], + parameterv[4], parameterv[5], parameterv[6], parameterv[7], + parameterv[8], parameterv[9], parameterv[10], parameterv[11], + parameterv[12], parameterv[13], parameterv[14], parameterv[15]); + break; - default: - r = 0; - break; - } + default: + r = 0; + break; + } - finsh_sp->long_value = r; - finsh_sp ++; + finsh_sp->long_value = r; + finsh_sp ++; - return ; + return ; } const op_func op_table[] = { - /* 00 */ OP_no_op, - /* 01 */ OP_add_byte, - /* 02 */ OP_add_word, - /* 03 */ OP_add_dword, - /* 04 */ OP_sub_byte, - /* 05 */ OP_sub_word, - /* 06 */ OP_sub_dword, - /* 07 */ OP_div_byte, - /* 08 */ OP_div_word, - /* 09 */ OP_div_dword, - /* 10 */ OP_mod_byte, - /* 11 */ OP_mod_word, - /* 12 */ OP_mod_dword, - /* 13 */ OP_mul_byte, - /* 14 */ OP_mul_word, - /* 15 */ OP_mul_dword, - /* 16 */ OP_and_byte, - /* 17 */ OP_and_word, - /* 18 */ OP_and_dword, - /* 19 */ OP_or_byte, - /* 20 */ OP_or_word, - /* 21 */ OP_or_dword, - /* 22 */ OP_xor_byte, - /* 23 */ OP_xor_word, - /* 24 */ OP_xor_dword, - /* 25 */ OP_bw_byte, - /* 26 */ OP_bw_word, - /* 27 */ OP_bw_dword, - /* 28 */ OP_shl_byte, - /* 29 */ OP_shl_word, - /* 30 */ OP_shl_dword, - /* 31 */ OP_shr_byte, - /* 32 */ OP_shr_word, - /* 33 */ OP_shr_dword, - /* 34 */ OP_ld_byte, - /* 35 */ OP_ld_word, - /* 36 */ OP_ld_dword, - /* 37 */ OP_ld_value_byte, - /* 38 */ OP_ld_value_word, - /* 39 */ OP_ld_value_dword, - /* 40 */ OP_st_byte, - /* 41 */ OP_st_word, - /* 42 */ OP_st_dword, - /* 43 */ OP_pop, - /* 44 */ OP_call, - /* 45 */ OP_ld_value_byte_stack, - /* 46 */ OP_ld_value_word_stack, - /* 47 */ OP_ld_value_dword_stack, - NULL + /* 00 */ OP_no_op, + /* 01 */ OP_add_byte, + /* 02 */ OP_add_word, + /* 03 */ OP_add_dword, + /* 04 */ OP_sub_byte, + /* 05 */ OP_sub_word, + /* 06 */ OP_sub_dword, + /* 07 */ OP_div_byte, + /* 08 */ OP_div_word, + /* 09 */ OP_div_dword, + /* 10 */ OP_mod_byte, + /* 11 */ OP_mod_word, + /* 12 */ OP_mod_dword, + /* 13 */ OP_mul_byte, + /* 14 */ OP_mul_word, + /* 15 */ OP_mul_dword, + /* 16 */ OP_and_byte, + /* 17 */ OP_and_word, + /* 18 */ OP_and_dword, + /* 19 */ OP_or_byte, + /* 20 */ OP_or_word, + /* 21 */ OP_or_dword, + /* 22 */ OP_xor_byte, + /* 23 */ OP_xor_word, + /* 24 */ OP_xor_dword, + /* 25 */ OP_bw_byte, + /* 26 */ OP_bw_word, + /* 27 */ OP_bw_dword, + /* 28 */ OP_shl_byte, + /* 29 */ OP_shl_word, + /* 30 */ OP_shl_dword, + /* 31 */ OP_shr_byte, + /* 32 */ OP_shr_word, + /* 33 */ OP_shr_dword, + /* 34 */ OP_ld_byte, + /* 35 */ OP_ld_word, + /* 36 */ OP_ld_dword, + /* 37 */ OP_ld_value_byte, + /* 38 */ OP_ld_value_word, + /* 39 */ OP_ld_value_dword, + /* 40 */ OP_st_byte, + /* 41 */ OP_st_word, + /* 42 */ OP_st_dword, + /* 43 */ OP_pop, + /* 44 */ OP_call, + /* 45 */ OP_ld_value_byte_stack, + /* 46 */ OP_ld_value_word_stack, + /* 47 */ OP_ld_value_dword_stack, + NULL }; diff --git a/components/finsh/finsh_parser.c b/components/finsh/finsh_parser.c index c937e4247..aa8550916 100644 --- a/components/finsh/finsh_parser.c +++ b/components/finsh/finsh_parser.c @@ -62,333 +62,333 @@ static struct finsh_node* proc_primary_expr(struct finsh_parser* self); static struct finsh_node* proc_param_list(struct finsh_parser* self); static struct finsh_node* proc_expr_statement(struct finsh_parser* self); static struct finsh_node* make_sys_node(uint8_t type, struct finsh_node* node1, - struct finsh_node* node2); + struct finsh_node* node2); /* check token */ #define check_token(token, lex, type) if ( (token) != (type) ) \ - { \ - finsh_error_set(FINSH_ERROR_INVALID_TOKEN); \ - finsh_token_replay(lex); \ - } + { \ + finsh_error_set(FINSH_ERROR_INVALID_TOKEN); \ + finsh_token_replay(lex); \ + } /* is the token a data type? */ -#define is_base_type(token) ((token) == finsh_token_type_void \ +#define is_base_type(token) ((token) == finsh_token_type_void \ || (token) == finsh_token_type_char \ - || (token) == finsh_token_type_short \ - || (token) == finsh_token_type_int \ - || (token) == finsh_token_type_long) + || (token) == finsh_token_type_short \ + || (token) == finsh_token_type_int \ + || (token) == finsh_token_type_long) /* get the next token */ -#define next_token(token, lex) (token) = finsh_token_token(lex) +#define next_token(token, lex) (token) = finsh_token_token(lex) /* match a specified token */ -#define match_token(token, lex, type) next_token(token, lex); \ - check_token(token, lex, type) +#define match_token(token, lex, type) next_token(token, lex); \ + check_token(token, lex, type) /* process for function and variable declaration. decl_variable -> type declaration_list ';' declarator_list -> declarator_list ',' declarator - | declarator + | declarator declarator -> identifier - | identifier ASSIGN expr_assign + | identifier ASSIGN expr_assign */ static struct finsh_node* proc_variable_decl(struct finsh_parser* self) { - enum finsh_token_type token; - enum finsh_type type; - char id[FINSH_NAME_MAX + 1]; + enum finsh_token_type token; + enum finsh_type type; + char id[FINSH_NAME_MAX + 1]; - struct finsh_node *node; - struct finsh_node *end; - struct finsh_node *assign; + struct finsh_node *node; + struct finsh_node *end; + struct finsh_node *assign; node = NULL; - end = NULL; + end = NULL; - /* get type */ - type = proc_type(self); + /* get type */ + type = proc_type(self); - /*process id.*/ - if (proc_identifier(self, id) == 0) - { - /* if add variable failed */ - if (finsh_var_insert(id, type) < 0) - { - finsh_error_set(FINSH_ERROR_VARIABLE_EXIST); - } - } + /*process id.*/ + if (proc_identifier(self, id) == 0) + { + /* if add variable failed */ + if (finsh_var_insert(id, type) < 0) + { + finsh_error_set(FINSH_ERROR_VARIABLE_EXIST); + } + } - next_token(token, &(self->token)); - switch ( token ) - { - case finsh_token_type_comma:/*',', it's a variable_list declaration.*/ - if (proc_identifier(self, id) == 0) - { - /* if add variable failed */ - if (finsh_var_insert(id, type) < 0) - { - finsh_error_set(FINSH_ERROR_VARIABLE_EXIST); - } - } + next_token(token, &(self->token)); + switch ( token ) + { + case finsh_token_type_comma:/*',', it's a variable_list declaration.*/ + if (proc_identifier(self, id) == 0) + { + /* if add variable failed */ + if (finsh_var_insert(id, type) < 0) + { + finsh_error_set(FINSH_ERROR_VARIABLE_EXIST); + } + } - next_token(token, &(self->token)); - if ( token == finsh_token_type_assign ) - { - /* get the right side of assign expression */ - assign = proc_assign_expr(self); + next_token(token, &(self->token)); + if ( token == finsh_token_type_assign ) + { + /* get the right side of assign expression */ + assign = proc_assign_expr(self); - if (assign != NULL) - { - struct finsh_node* idnode; + if (assign != NULL) + { + struct finsh_node* idnode; - idnode = finsh_node_new_id(id); - end = make_sys_node(FINSH_NODE_SYS_ASSIGN, idnode, assign); - node = end; + idnode = finsh_node_new_id(id); + end = make_sys_node(FINSH_NODE_SYS_ASSIGN, idnode, assign); + node = end; - next_token(token, &(self->token)); - } - } + next_token(token, &(self->token)); + } + } - while ( token == finsh_token_type_comma ) - { - if (proc_identifier(self, id) == 0) - { - /* if add variable failed */ - if (finsh_var_insert(id, type) < 0) - { - finsh_error_set(FINSH_ERROR_VARIABLE_EXIST); - } - } + while ( token == finsh_token_type_comma ) + { + if (proc_identifier(self, id) == 0) + { + /* if add variable failed */ + if (finsh_var_insert(id, type) < 0) + { + finsh_error_set(FINSH_ERROR_VARIABLE_EXIST); + } + } - next_token(token, &(self->token)); - if ( token == finsh_token_type_assign ) - { - /* get the right side of assign expression */ - assign = proc_assign_expr(self); + next_token(token, &(self->token)); + if ( token == finsh_token_type_assign ) + { + /* get the right side of assign expression */ + assign = proc_assign_expr(self); - if (assign != NULL) - { - struct finsh_node* idnode; + if (assign != NULL) + { + struct finsh_node* idnode; - idnode = finsh_node_new_id(id); + idnode = finsh_node_new_id(id); - /* make assign expression node */ - if (node != NULL) - { - finsh_node_sibling(end) = make_sys_node(FINSH_NODE_SYS_ASSIGN, idnode, assign); - end = finsh_node_sibling(end); - } - else - { - end = make_sys_node(FINSH_NODE_SYS_ASSIGN, idnode, assign); - node = end; - } + /* make assign expression node */ + if (node != NULL) + { + finsh_node_sibling(end) = make_sys_node(FINSH_NODE_SYS_ASSIGN, idnode, assign); + end = finsh_node_sibling(end); + } + else + { + end = make_sys_node(FINSH_NODE_SYS_ASSIGN, idnode, assign); + node = end; + } - next_token(token, &(self->token)); - } - } - } + next_token(token, &(self->token)); + } + } + } - check_token(token, &(self->token), finsh_token_type_semicolon); - return node; + check_token(token, &(self->token), finsh_token_type_semicolon); + return node; - case finsh_token_type_assign:/*'=', it's a variable with assign declaration.*/ - { - struct finsh_node *idnode; + case finsh_token_type_assign:/*'=', it's a variable with assign declaration.*/ + { + struct finsh_node *idnode; - assign = proc_assign_expr(self); - if (assign != NULL) - { - idnode = finsh_node_new_id(id); + assign = proc_assign_expr(self); + if (assign != NULL) + { + idnode = finsh_node_new_id(id); - /* make assign expression node */ - end = make_sys_node(FINSH_NODE_SYS_ASSIGN, idnode, assign); - node = end; + /* make assign expression node */ + end = make_sys_node(FINSH_NODE_SYS_ASSIGN, idnode, assign); + node = end; - next_token(token, &(self->token)); - } + next_token(token, &(self->token)); + } - while ( token == finsh_token_type_comma ) - { - if (proc_identifier(self, id) == 0) - { - /* if add variable failed */ - if (finsh_var_insert(id, type) < 0) - { - finsh_error_set(FINSH_ERROR_VARIABLE_EXIST); - } - } + while ( token == finsh_token_type_comma ) + { + if (proc_identifier(self, id) == 0) + { + /* if add variable failed */ + if (finsh_var_insert(id, type) < 0) + { + finsh_error_set(FINSH_ERROR_VARIABLE_EXIST); + } + } - next_token(token, &(self->token)); - if (token == finsh_token_type_assign) - { - /* get the right side of assign expression */ - assign = proc_assign_expr(self); + next_token(token, &(self->token)); + if (token == finsh_token_type_assign) + { + /* get the right side of assign expression */ + assign = proc_assign_expr(self); - if (assign != NULL) - { - idnode = finsh_node_new_id(id); + if (assign != NULL) + { + idnode = finsh_node_new_id(id); - /* make assign expression node */ - if (node != NULL) - { - finsh_node_sibling(end) = make_sys_node(FINSH_NODE_SYS_ASSIGN, idnode, assign); - end = finsh_node_sibling(end); - } - else - { - end = make_sys_node(FINSH_NODE_SYS_ASSIGN, idnode, assign); - node = end; - } + /* make assign expression node */ + if (node != NULL) + { + finsh_node_sibling(end) = make_sys_node(FINSH_NODE_SYS_ASSIGN, idnode, assign); + end = finsh_node_sibling(end); + } + else + { + end = make_sys_node(FINSH_NODE_SYS_ASSIGN, idnode, assign); + node = end; + } - next_token(token, &(self->token)); - } - } - } + next_token(token, &(self->token)); + } + } + } - check_token(token, &(self->token), finsh_token_type_semicolon); - return node; - } + check_token(token, &(self->token), finsh_token_type_semicolon); + return node; + } - case finsh_token_type_semicolon:/*';', it's a variable declaration.*/ - return node; + case finsh_token_type_semicolon:/*';', it's a variable declaration.*/ + return node; - default: - finsh_error_set(FINSH_ERROR_EXPECT_TYPE); + default: + finsh_error_set(FINSH_ERROR_EXPECT_TYPE); - return NULL; - } + return NULL; + } } /* type -> type_prefix type_basic | type_basic type_prefix -> UNSIGNED type_basic -> VOID - | CHAR - | SHORT - | INT - | STRING + | CHAR + | SHORT + | INT + | STRING */ static enum finsh_type proc_type(struct finsh_parser* self) { - enum finsh_type type; - enum finsh_token_type token; + enum finsh_type type; + enum finsh_token_type token; - /* set init type */ - type = finsh_type_unknown; + /* set init type */ + type = finsh_type_unknown; - next_token(token, &(self->token)); - if ( is_base_type(token) ) /* base_type */ - { - switch (token) - { - case finsh_token_type_void: - type = finsh_type_void; - break; + next_token(token, &(self->token)); + if ( is_base_type(token) ) /* base_type */ + { + switch (token) + { + case finsh_token_type_void: + type = finsh_type_void; + break; - case finsh_token_type_char: - type = finsh_type_char; - break; + case finsh_token_type_char: + type = finsh_type_char; + break; - case finsh_token_type_short: - type = finsh_type_short; - break; + case finsh_token_type_short: + type = finsh_type_short; + break; - case finsh_token_type_int: - type = finsh_type_int; - break; + case finsh_token_type_int: + type = finsh_type_int; + break; - case finsh_token_type_long: - type = finsh_type_long; - break; + case finsh_token_type_long: + type = finsh_type_long; + break; - default: - goto __return; - } - } - else if ( token == finsh_token_type_unsigned ) /* unsigned base_type */ - { - next_token(token, &(self->token)); - if ( is_base_type(token) ) - { - switch (token) - { - case finsh_token_type_char: - type = finsh_type_uchar; - break; + default: + goto __return; + } + } + else if ( token == finsh_token_type_unsigned ) /* unsigned base_type */ + { + next_token(token, &(self->token)); + if ( is_base_type(token) ) + { + switch (token) + { + case finsh_token_type_char: + type = finsh_type_uchar; + break; - case finsh_token_type_short: - type = finsh_type_ushort; - break; + case finsh_token_type_short: + type = finsh_type_ushort; + break; - case finsh_token_type_int: - type = finsh_type_uint; - break; + case finsh_token_type_int: + type = finsh_type_uint; + break; - case finsh_token_type_long: - type = finsh_type_ulong; - break; + case finsh_token_type_long: + type = finsh_type_ulong; + break; - default: - goto __return; - } - } - else - { - finsh_token_replay(&(self->token)); - finsh_error_set(FINSH_ERROR_EXPECT_TYPE); - } - } - else - { - goto __return; - } + default: + goto __return; + } + } + else + { + finsh_token_replay(&(self->token)); + finsh_error_set(FINSH_ERROR_EXPECT_TYPE); + } + } + else + { + goto __return; + } - /* parse for pointer */ - next_token(token, &(self->token)); - if (token == finsh_token_type_mul) - { - switch (type) - { - case finsh_type_void: - type = finsh_type_voidp; - break; + /* parse for pointer */ + next_token(token, &(self->token)); + if (token == finsh_token_type_mul) + { + switch (type) + { + case finsh_type_void: + type = finsh_type_voidp; + break; - case finsh_type_char: - case finsh_type_uchar: - type = finsh_type_charp; - break; + case finsh_type_char: + case finsh_type_uchar: + type = finsh_type_charp; + break; - case finsh_type_short: - case finsh_type_ushort: - type = finsh_type_shortp; - break; + case finsh_type_short: + case finsh_type_ushort: + type = finsh_type_shortp; + break; - case finsh_type_int: - case finsh_type_uint: - type = finsh_type_intp; - break; + case finsh_type_int: + case finsh_type_uint: + type = finsh_type_intp; + break; - case finsh_type_long: - case finsh_type_ulong: - type = finsh_type_longp; - break; + case finsh_type_long: + case finsh_type_ulong: + type = finsh_type_longp; + break; - default: - type = finsh_type_voidp; - break; - } - } - else finsh_token_replay(&(self->token)); + default: + type = finsh_type_voidp; + break; + } + } + else finsh_token_replay(&(self->token)); - return type; + return type; __return: - finsh_token_replay(&(self->token)); - finsh_error_set(FINSH_ERROR_UNKNOWN_TYPE); + finsh_token_replay(&(self->token)); + finsh_error_set(FINSH_ERROR_UNKNOWN_TYPE); - return type; + return type; } /* @@ -396,35 +396,35 @@ identifier -> IDENTIFIER */ static int proc_identifier(struct finsh_parser* self, char* id) { - enum finsh_token_type token; + enum finsh_token_type token; - match_token(token, &(self->token), finsh_token_type_identifier); + match_token(token, &(self->token), finsh_token_type_identifier); - strncpy(id, (char*)self->token.string, FINSH_NAME_MAX); + strncpy(id, (char*)self->token.string, FINSH_NAME_MAX); - return 0; + return 0; } /* statement_expr -> ';' - | expr ';' + | expr ';' */ static struct finsh_node* proc_expr_statement(struct finsh_parser* self) { - enum finsh_token_type token; - struct finsh_node* expr; + enum finsh_token_type token; + struct finsh_node* expr; - expr = NULL; - next_token(token, &(self->token)); - if ( token != finsh_token_type_semicolon ) - { - finsh_token_replay(&(self->token)); - expr = proc_expr(self); + expr = NULL; + next_token(token, &(self->token)); + if ( token != finsh_token_type_semicolon ) + { + finsh_token_replay(&(self->token)); + expr = proc_expr(self); - match_token(token, &(self->token), finsh_token_type_semicolon); - } + match_token(token, &(self->token), finsh_token_type_semicolon); + } - return expr; + return expr; } /* @@ -432,308 +432,308 @@ expr -> expr_assign */ static struct finsh_node* proc_expr(struct finsh_parser* self) { - return proc_assign_expr(self); + return proc_assign_expr(self); } /* expr_assign -> expr_inclusive_or - | expr_unary ASSIGN expr_assign + | expr_unary ASSIGN expr_assign */ static struct finsh_node* proc_assign_expr(struct finsh_parser* self) { - enum finsh_token_type token; - struct finsh_node* or; - struct finsh_node* assign; + enum finsh_token_type token; + struct finsh_node* or; + struct finsh_node* assign; - or = proc_inclusive_or_expr(self); + or = proc_inclusive_or_expr(self); - next_token(token, &(self->token)); + next_token(token, &(self->token)); - if (token == finsh_token_type_assign) - { - assign = proc_assign_expr(self); + if (token == finsh_token_type_assign) + { + assign = proc_assign_expr(self); - return make_sys_node(FINSH_NODE_SYS_ASSIGN, or, assign); - } - else finsh_token_replay(&(self->token)); + return make_sys_node(FINSH_NODE_SYS_ASSIGN, or, assign); + } + else finsh_token_replay(&(self->token)); - return or; + return or; } /* expr_inclusive_or -> expr_exclusive_or - | expr_inclusive_or '|' expr_exclusive_or + | expr_inclusive_or '|' expr_exclusive_or */ static struct finsh_node* proc_inclusive_or_expr(struct finsh_parser* self) { - enum finsh_token_type token; - struct finsh_node* xor; - struct finsh_node* xor_new; + enum finsh_token_type token; + struct finsh_node* xor; + struct finsh_node* xor_new; - xor = proc_exclusive_or_expr(self); + xor = proc_exclusive_or_expr(self); - next_token(token, &(self->token)); - while ( token == finsh_token_type_or ) - { - xor_new = proc_exclusive_or_expr(self); + next_token(token, &(self->token)); + while ( token == finsh_token_type_or ) + { + xor_new = proc_exclusive_or_expr(self); - if (xor_new == NULL) finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR); - else xor = make_sys_node(FINSH_NODE_SYS_OR, xor, xor_new); + if (xor_new == NULL) finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR); + else xor = make_sys_node(FINSH_NODE_SYS_OR, xor, xor_new); - next_token(token, &(self->token)); - } + next_token(token, &(self->token)); + } - finsh_token_replay(&(self->token)); - return xor; + finsh_token_replay(&(self->token)); + return xor; } /* expr_exclusive_or -> expr_and - | expr_exclusive '^' expr_and + | expr_exclusive '^' expr_and */ static struct finsh_node* proc_exclusive_or_expr(struct finsh_parser* self) { - enum finsh_token_type token; - struct finsh_node* and; - struct finsh_node* and_new; + enum finsh_token_type token; + struct finsh_node* and; + struct finsh_node* and_new; - and = proc_and_expr(self); - next_token(token, &(self->token)); - while ( token == finsh_token_type_xor ) - { - and_new = proc_and_expr(self); - if (and_new == NULL) finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR); - else and = make_sys_node(FINSH_NODE_SYS_XOR, and, and_new); + and = proc_and_expr(self); + next_token(token, &(self->token)); + while ( token == finsh_token_type_xor ) + { + and_new = proc_and_expr(self); + if (and_new == NULL) finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR); + else and = make_sys_node(FINSH_NODE_SYS_XOR, and, and_new); - next_token(token, &(self->token)); - } + next_token(token, &(self->token)); + } - finsh_token_replay(&(self->token)); - return and; + finsh_token_replay(&(self->token)); + return and; } /* expr_and -> expr_shift - | expr_and '&' expr_shift + | expr_and '&' expr_shift */ static struct finsh_node* proc_and_expr(struct finsh_parser* self) { - enum finsh_token_type token; - struct finsh_node* shift; - struct finsh_node* shift_new; + enum finsh_token_type token; + struct finsh_node* shift; + struct finsh_node* shift_new; - shift = proc_shift_expr(self); + shift = proc_shift_expr(self); - next_token(token, &(self->token)); - while ( token == finsh_token_type_and ) - { - shift_new = proc_shift_expr(self); + next_token(token, &(self->token)); + while ( token == finsh_token_type_and ) + { + shift_new = proc_shift_expr(self); - if (shift_new == NULL) finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR); - else shift = make_sys_node(FINSH_NODE_SYS_AND, shift, shift_new); + if (shift_new == NULL) finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR); + else shift = make_sys_node(FINSH_NODE_SYS_AND, shift, shift_new); - next_token(token, &(self->token)); - } + next_token(token, &(self->token)); + } - finsh_token_replay(&(self->token)); - return shift; + finsh_token_replay(&(self->token)); + return shift; } /* expr_shift -> expr_additive - | expr_shift '<<' expr_additive - | expr_shift '>>' expr_additive + | expr_shift '<<' expr_additive + | expr_shift '>>' expr_additive */ static struct finsh_node* proc_shift_expr(struct finsh_parser* self) { - enum finsh_token_type token; - struct finsh_node* add; - struct finsh_node* add_new; + enum finsh_token_type token; + struct finsh_node* add; + struct finsh_node* add_new; - add = proc_additive_expr(self); + add = proc_additive_expr(self); - next_token(token, &(self->token)); - while ( token == finsh_token_type_shl || token == finsh_token_type_shr) - { - add_new = proc_additive_expr(self); - if (add_new == NULL) finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR); - else - { - switch (token) - { - case finsh_token_type_shl: - add = make_sys_node(FINSH_NODE_SYS_SHL, add, add_new); - break; - case finsh_token_type_shr: - add = make_sys_node(FINSH_NODE_SYS_SHR, add, add_new); - break; - default: - finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR); - break; - } - } - next_token(token, &(self->token)); - } + next_token(token, &(self->token)); + while ( token == finsh_token_type_shl || token == finsh_token_type_shr) + { + add_new = proc_additive_expr(self); + if (add_new == NULL) finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR); + else + { + switch (token) + { + case finsh_token_type_shl: + add = make_sys_node(FINSH_NODE_SYS_SHL, add, add_new); + break; + case finsh_token_type_shr: + add = make_sys_node(FINSH_NODE_SYS_SHR, add, add_new); + break; + default: + finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR); + break; + } + } + next_token(token, &(self->token)); + } - finsh_token_replay(&(self->token)); - return add; + finsh_token_replay(&(self->token)); + return add; } /* expr_additive -> expr_multiplicative - | expr_additive SUB expr_multiplicative - | expr_additive ADD expr_multiplicative + | expr_additive SUB expr_multiplicative + | expr_additive ADD expr_multiplicative */ static struct finsh_node* proc_additive_expr(struct finsh_parser* self) { - enum finsh_token_type token; - struct finsh_node* mul; - struct finsh_node* mul_new; + enum finsh_token_type token; + struct finsh_node* mul; + struct finsh_node* mul_new; - mul = proc_multiplicative_expr(self); + mul = proc_multiplicative_expr(self); - next_token(token, &(self->token)); - while ( token == finsh_token_type_sub || token == finsh_token_type_add ) - { - mul_new = proc_multiplicative_expr(self); - if (mul_new == NULL) finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR); - else - { - switch (token) - { - case finsh_token_type_sub: - mul = make_sys_node(FINSH_NODE_SYS_SUB, mul, mul_new); - break; - case finsh_token_type_add: - mul = make_sys_node(FINSH_NODE_SYS_ADD, mul, mul_new); - break; - default: - finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR); - break; - } - } - next_token(token, &(self->token)); - } + next_token(token, &(self->token)); + while ( token == finsh_token_type_sub || token == finsh_token_type_add ) + { + mul_new = proc_multiplicative_expr(self); + if (mul_new == NULL) finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR); + else + { + switch (token) + { + case finsh_token_type_sub: + mul = make_sys_node(FINSH_NODE_SYS_SUB, mul, mul_new); + break; + case finsh_token_type_add: + mul = make_sys_node(FINSH_NODE_SYS_ADD, mul, mul_new); + break; + default: + finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR); + break; + } + } + next_token(token, &(self->token)); + } - finsh_token_replay(&(self->token)); - return mul; + finsh_token_replay(&(self->token)); + return mul; } /* expr_multiplicative -> expr_cast - | expr_multiplicative '*' expr_cast - | expr_multiplicative '/' expr_cast - | expr_multiplicative '%' expr_cast + | expr_multiplicative '*' expr_cast + | expr_multiplicative '/' expr_cast + | expr_multiplicative '%' expr_cast */ static struct finsh_node* proc_multiplicative_expr(struct finsh_parser* self) { - enum finsh_token_type token; - struct finsh_node* cast; - struct finsh_node* cast_new; + enum finsh_token_type token; + struct finsh_node* cast; + struct finsh_node* cast_new; - cast = proc_cast_expr(self); - next_token(token, &(self->token)); - while (token == finsh_token_type_mul || - token == finsh_token_type_div || - token == finsh_token_type_mod ) - { - cast_new = proc_cast_expr(self); - if (cast_new == NULL) finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR); - else - { - switch (token) - { - case finsh_token_type_mul: - cast = make_sys_node(FINSH_NODE_SYS_MUL, cast, cast_new); - break; + cast = proc_cast_expr(self); + next_token(token, &(self->token)); + while (token == finsh_token_type_mul || + token == finsh_token_type_div || + token == finsh_token_type_mod ) + { + cast_new = proc_cast_expr(self); + if (cast_new == NULL) finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR); + else + { + switch (token) + { + case finsh_token_type_mul: + cast = make_sys_node(FINSH_NODE_SYS_MUL, cast, cast_new); + break; - case finsh_token_type_div: - cast = make_sys_node(FINSH_NODE_SYS_DIV, cast, cast_new); - break; + case finsh_token_type_div: + cast = make_sys_node(FINSH_NODE_SYS_DIV, cast, cast_new); + break; - case finsh_token_type_mod: - cast = make_sys_node(FINSH_NODE_SYS_MOD, cast, cast_new); - break; + case finsh_token_type_mod: + cast = make_sys_node(FINSH_NODE_SYS_MOD, cast, cast_new); + break; - default: - finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR); - break; - } - } - next_token(token, &(self->token)); - } + default: + finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR); + break; + } + } + next_token(token, &(self->token)); + } - finsh_token_replay(&(self->token)); - return cast; + finsh_token_replay(&(self->token)); + return cast; } /* 20060313, add recast parse expr_cast -> expr_unary - | '(' type ')' expr_cast + | '(' type ')' expr_cast */ static struct finsh_node* proc_cast_expr(struct finsh_parser* self) { - enum finsh_token_type token; - enum finsh_type type; - struct finsh_node* cast; + enum finsh_token_type token; + enum finsh_type type; + struct finsh_node* cast; - next_token(token, &(self->token)); - if (token == finsh_token_type_left_paren) - { - type = proc_type(self); - match_token(token, &(self->token), finsh_token_type_right_paren); + next_token(token, &(self->token)); + if (token == finsh_token_type_left_paren) + { + type = proc_type(self); + match_token(token, &(self->token), finsh_token_type_right_paren); - cast = proc_cast_expr(self); - if (cast != NULL) - { - cast->data_type = type; - return cast; - } - } + cast = proc_cast_expr(self); + if (cast != NULL) + { + cast->data_type = type; + return cast; + } + } - finsh_token_replay(&(self->token)); - return proc_unary_expr(self); + finsh_token_replay(&(self->token)); + return proc_unary_expr(self); } /* 20050921, add '*' and '&' expr_unary -> expr_postfix - | ADD expr_cast - | INC expr_cast - | SUB expr_cast - | DEC expr_cast - | '~' expr_cast - | '*' expr_cast - | '&' expr_cast + | ADD expr_cast + | INC expr_cast + | SUB expr_cast + | DEC expr_cast + | '~' expr_cast + | '*' expr_cast + | '&' expr_cast */ static struct finsh_node* proc_unary_expr(struct finsh_parser* self) { - enum finsh_token_type token; - struct finsh_node *cast; + enum finsh_token_type token; + struct finsh_node *cast; - next_token(token, &(self->token)); - switch (token) - { - case finsh_token_type_add: /* + */ - cast = proc_cast_expr(self); - return cast; + next_token(token, &(self->token)); + switch (token) + { + case finsh_token_type_add: /* + */ + cast = proc_cast_expr(self); + return cast; - case finsh_token_type_inc: /* ++ */ - cast = proc_cast_expr(self); - return make_sys_node(FINSH_NODE_SYS_PREINC, cast, NULL); + case finsh_token_type_inc: /* ++ */ + cast = proc_cast_expr(self); + return make_sys_node(FINSH_NODE_SYS_PREINC, cast, NULL); - case finsh_token_type_sub: /* - */ - cast = proc_cast_expr(self); - return make_sys_node(FINSH_NODE_SYS_SUB, finsh_node_new_long(0), cast); + case finsh_token_type_sub: /* - */ + cast = proc_cast_expr(self); + return make_sys_node(FINSH_NODE_SYS_SUB, finsh_node_new_long(0), cast); - case finsh_token_type_dec: /* -- */ - cast = proc_cast_expr(self); - return make_sys_node(FINSH_NODE_SYS_PREDEC, cast, NULL); + case finsh_token_type_dec: /* -- */ + cast = proc_cast_expr(self); + return make_sys_node(FINSH_NODE_SYS_PREDEC, cast, NULL); - case finsh_token_type_bitwise: /* ~ */ - cast = proc_cast_expr(self); - return make_sys_node(FINSH_NODE_SYS_BITWISE, cast, NULL); + case finsh_token_type_bitwise: /* ~ */ + cast = proc_cast_expr(self); + return make_sys_node(FINSH_NODE_SYS_BITWISE, cast, NULL); case finsh_token_type_mul: /* * */ cast = proc_cast_expr(self); @@ -743,147 +743,147 @@ static struct finsh_node* proc_unary_expr(struct finsh_parser* self) cast = proc_cast_expr(self); return make_sys_node(FINSH_NODE_SYS_GETADDR, cast, NULL); - default: - finsh_token_replay(&(self->token)); - return proc_postfix_expr(self); - } + default: + finsh_token_replay(&(self->token)); + return proc_postfix_expr(self); + } } /* expr_postfix -> expr_primary - | expr_postfix INC - | expr_postfix DEC - | expr_postfix '(' param_list ')' + | expr_postfix INC + | expr_postfix DEC + | expr_postfix '(' param_list ')' */ static struct finsh_node* proc_postfix_expr(struct finsh_parser* self) { - enum finsh_token_type token; - struct finsh_node* postfix; + enum finsh_token_type token; + struct finsh_node* postfix; - postfix = proc_primary_expr(self); + postfix = proc_primary_expr(self); - next_token(token, &(self->token)); - while ( token == finsh_token_type_inc || - token == finsh_token_type_dec || - token == finsh_token_type_left_paren ) - { - switch (token) - { - case finsh_token_type_inc :/* '++' */ - postfix = make_sys_node(FINSH_NODE_SYS_INC, postfix, NULL); - break; + next_token(token, &(self->token)); + while ( token == finsh_token_type_inc || + token == finsh_token_type_dec || + token == finsh_token_type_left_paren ) + { + switch (token) + { + case finsh_token_type_inc :/* '++' */ + postfix = make_sys_node(FINSH_NODE_SYS_INC, postfix, NULL); + break; - case finsh_token_type_dec :/* '--' */ - postfix = make_sys_node(FINSH_NODE_SYS_DEC, postfix, NULL); - break; + case finsh_token_type_dec :/* '--' */ + postfix = make_sys_node(FINSH_NODE_SYS_DEC, postfix, NULL); + break; - case finsh_token_type_left_paren :/* '(' */ - { - struct finsh_node* param_list; + case finsh_token_type_left_paren :/* '(' */ + { + struct finsh_node* param_list; - param_list = NULL; - next_token(token, &(self->token)); - if (token != finsh_token_type_right_paren) - { - finsh_token_replay(&(self->token)); - param_list = proc_param_list(self); + param_list = NULL; + next_token(token, &(self->token)); + if (token != finsh_token_type_right_paren) + { + finsh_token_replay(&(self->token)); + param_list = proc_param_list(self); - match_token(token, &(self->token), finsh_token_type_right_paren); - } + match_token(token, &(self->token), finsh_token_type_right_paren); + } - postfix = make_sys_node(FINSH_NODE_SYS_FUNC, postfix, param_list); - } - break; + postfix = make_sys_node(FINSH_NODE_SYS_FUNC, postfix, param_list); + } + break; - default: - break; - } + default: + break; + } - next_token(token, &(self->token)); - } + next_token(token, &(self->token)); + } - finsh_token_replay(&(self->token)); - return postfix; + finsh_token_replay(&(self->token)); + return postfix; } /* expr_primary -> literal - | '(' expr ')' - | identifier + | '(' expr ')' + | identifier */ static struct finsh_node* proc_primary_expr(struct finsh_parser* self) { - enum finsh_token_type token; - struct finsh_node* expr; + enum finsh_token_type token; + struct finsh_node* expr; - next_token(token, &(self->token)); - switch ( token ) - { - case finsh_token_type_identifier: - { - char id[FINSH_NAME_MAX + 1]; + next_token(token, &(self->token)); + switch ( token ) + { + case finsh_token_type_identifier: + { + char id[FINSH_NAME_MAX + 1]; - finsh_token_replay(&(self->token)); - proc_identifier(self, id); - return finsh_node_new_id(id); - } + finsh_token_replay(&(self->token)); + proc_identifier(self, id); + return finsh_node_new_id(id); + } - case finsh_token_type_left_paren: - expr = proc_expr(self); - match_token(token, &(self->token), finsh_token_type_right_paren); - return expr; + case finsh_token_type_left_paren: + expr = proc_expr(self); + match_token(token, &(self->token), finsh_token_type_right_paren); + return expr; - case finsh_token_type_value_int: - return finsh_node_new_int(self->token.value.int_value); + case finsh_token_type_value_int: + return finsh_node_new_int(self->token.value.int_value); - case finsh_token_type_value_long: - return finsh_node_new_long(self->token.value.long_value); + case finsh_token_type_value_long: + return finsh_node_new_long(self->token.value.long_value); - case finsh_token_type_value_char: - return finsh_node_new_char(self->token.value.char_value); + case finsh_token_type_value_char: + return finsh_node_new_char(self->token.value.char_value); - case finsh_token_type_value_string: - return finsh_node_new_string((char*)self->token.string); + case finsh_token_type_value_string: + return finsh_node_new_string((char*)self->token.string); - case finsh_token_type_value_null: - return finsh_node_new_ptr(NULL); + case finsh_token_type_value_null: + return finsh_node_new_ptr(NULL); - default: - finsh_error_set(FINSH_ERROR_INVALID_TOKEN); - break; - } + default: + finsh_error_set(FINSH_ERROR_INVALID_TOKEN); + break; + } - return NULL; + return NULL; } /* param_list -> empty - | expr_assign - | param_list ',' expr_assign + | expr_assign + | param_list ',' expr_assign */ static struct finsh_node* proc_param_list(struct finsh_parser* self) { - enum finsh_token_type token; - struct finsh_node *node, *assign; + enum finsh_token_type token; + struct finsh_node *node, *assign; - assign = proc_assign_expr(self); - if (assign == NULL) return NULL; - node = assign; + assign = proc_assign_expr(self); + if (assign == NULL) return NULL; + node = assign; - next_token(token, &(self->token)); - while (token == finsh_token_type_comma ) - { - finsh_node_sibling(assign) = proc_assign_expr(self); + next_token(token, &(self->token)); + while (token == finsh_token_type_comma ) + { + finsh_node_sibling(assign) = proc_assign_expr(self); - if (finsh_node_sibling(assign) != NULL) assign = finsh_node_sibling(assign); - else finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR); + if (finsh_node_sibling(assign) != NULL) assign = finsh_node_sibling(assign); + else finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR); - next_token(token, &(self->token)); - } + next_token(token, &(self->token)); + } - finsh_token_replay(&(self->token)); + finsh_token_replay(&(self->token)); - return node; + return node; } /* @@ -896,18 +896,18 @@ node1__ */ static struct finsh_node* make_sys_node(uint8_t type, struct finsh_node* node1, struct finsh_node* node2) { - struct finsh_node* node; + struct finsh_node* node; - node = finsh_node_allocate(type); + node = finsh_node_allocate(type); - if ((node1 != NULL) && (node != NULL)) - { - finsh_node_child(node) = node1; - finsh_node_sibling(node1) = node2; - } - else finsh_error_set(FINSH_ERROR_NULL_NODE); + if ((node1 != NULL) && (node != NULL)) + { + finsh_node_child(node) = node1; + finsh_node_sibling(node1) = node2; + } + else finsh_error_set(FINSH_ERROR_NULL_NODE); - return node; + return node; } /* @@ -915,91 +915,91 @@ start -> statement_expr | decl_variable */ void finsh_parser_run(struct finsh_parser* self, const uint8_t* string) { - enum finsh_token_type token; - struct finsh_node *node; + enum finsh_token_type token; + struct finsh_node *node; node = NULL; - /* init parser */ - self->parser_string = (uint8_t*)string; + /* init parser */ + self->parser_string = (uint8_t*)string; - /* init token */ - finsh_token_init(&(self->token), self->parser_string); + /* init token */ + finsh_token_init(&(self->token), self->parser_string); - /* get next token */ - next_token(token, &(self->token)); - while (token != finsh_token_type_eof && token != finsh_token_type_bad) - { - switch (token) - { + /* get next token */ + next_token(token, &(self->token)); + while (token != finsh_token_type_eof && token != finsh_token_type_bad) + { + switch (token) + { case finsh_token_type_identifier: /* process expr_statement */ finsh_token_replay(&(self->token)); - if (self->root != NULL) - { - finsh_node_sibling(node) = proc_expr_statement(self); - if (finsh_node_sibling(node) != NULL) - node = finsh_node_sibling(node); - } - else - { - node = proc_expr_statement(self); - self->root = node; - } - break; - - default: - if (is_base_type(token) || token == finsh_token_type_unsigned) + if (self->root != NULL) { - /* variable decl */ - finsh_token_replay(&(self->token)); - - if (self->root != NULL) - { - finsh_node_sibling(node) = proc_variable_decl(self); - if (finsh_node_sibling(node) != NULL) - node = finsh_node_sibling(node); - } - else - { - node = proc_variable_decl(self); - self->root = node; - } + finsh_node_sibling(node) = proc_expr_statement(self); + if (finsh_node_sibling(node) != NULL) + node = finsh_node_sibling(node); } else { - /* process expr_statement */ + node = proc_expr_statement(self); + self->root = node; + } + break; + + default: + if (is_base_type(token) || token == finsh_token_type_unsigned) + { + /* variable decl */ finsh_token_replay(&(self->token)); - if (self->root != NULL) - { + if (self->root != NULL) + { + finsh_node_sibling(node) = proc_variable_decl(self); + if (finsh_node_sibling(node) != NULL) + node = finsh_node_sibling(node); + } + else + { + node = proc_variable_decl(self); + self->root = node; + } + } + else + { + /* process expr_statement */ + finsh_token_replay(&(self->token)); + + if (self->root != NULL) + { finsh_node_sibling(node) = proc_expr_statement(self); - if (finsh_node_sibling(node) != NULL) - node = finsh_node_sibling(node); - else next_token(token, &(self->token)); - } - else - { - node = proc_expr_statement(self); - self->root = node; - } + if (finsh_node_sibling(node) != NULL) + node = finsh_node_sibling(node); + else next_token(token, &(self->token)); + } + else + { + node = proc_expr_statement(self); + self->root = node; + } } - break; - } + break; + } - /* no root found, break out */ - if (self->root == NULL) break; + /* no root found, break out */ + if (self->root == NULL) break; /* get next token */ - next_token(token, &(self->token)); - } + next_token(token, &(self->token)); + } } int finsh_parser_init(struct finsh_parser* self) { - memset(self, 0, sizeof(struct finsh_parser)); + memset(self, 0, sizeof(struct finsh_parser)); - return 0; + return 0; } diff --git a/components/finsh/finsh_token.c b/components/finsh/finsh_token.c index 8b51c9994..a9fd0ac7d 100644 --- a/components/finsh/finsh_token.c +++ b/components/finsh/finsh_token.c @@ -33,31 +33,31 @@ #include "finsh_token.h" #include "finsh_error.h" -#define is_alpha(ch) ((ch | 0x20) - 'a') < 26u -#define is_digit(ch) ((ch) >= '0' && (ch) <= '9') -#define is_xdigit(ch) (((ch) >= '0' && (ch) <= '9') || (((ch | 0x20) - 'a') < 6u)) +#define is_alpha(ch) ((ch | 0x20) - 'a') < 26u +#define is_digit(ch) ((ch) >= '0' && (ch) <= '9') +#define is_xdigit(ch) (((ch) >= '0' && (ch) <= '9') || (((ch | 0x20) - 'a') < 6u)) #define is_separator(ch) !(((ch) >= 'a' && (ch) <= 'z') \ || ((ch) >= 'A' && (ch) <= 'Z') || ((ch) >= '0' && (ch) <= '9') || ((ch) == '_')) #define is_eof(self) (self)->eof struct name_table { - char* name; - enum finsh_token_type type; + char* name; + enum finsh_token_type type; }; /* keyword */ static const struct name_table finsh_name_table[] = { - {"void", finsh_token_type_void}, - {"char", finsh_token_type_char}, - {"short", finsh_token_type_short}, - {"int", finsh_token_type_int}, - {"long", finsh_token_type_long}, - {"unsigned", finsh_token_type_unsigned}, + {"void", finsh_token_type_void}, + {"char", finsh_token_type_char}, + {"short", finsh_token_type_short}, + {"int", finsh_token_type_int}, + {"long", finsh_token_type_long}, + {"unsigned", finsh_token_type_unsigned}, - {"NULL", finsh_token_type_value_null}, - {"null", finsh_token_type_value_null} + {"NULL", finsh_token_type_value_null}, + {"null", finsh_token_type_value_null} }; static char token_next_char(struct finsh_token* self); @@ -73,52 +73,52 @@ static int token_proc_escape(struct finsh_token* self); void finsh_token_init(struct finsh_token* self, uint8_t* line) { - memset(self, 0, sizeof(struct finsh_token)); + memset(self, 0, sizeof(struct finsh_token)); - self->line = line; + self->line = line; } enum finsh_token_type finsh_token_token(struct finsh_token* self) { - if ( self->replay ) self->replay = 0; - else token_run(self); + if ( self->replay ) self->replay = 0; + else token_run(self); - return (enum finsh_token_type)self->current_token; + return (enum finsh_token_type)self->current_token; } void finsh_token_get_token(struct finsh_token* self, uint8_t* token) { - strncpy((char*)token, (char*)self->string, FINSH_NAME_MAX); + strncpy((char*)token, (char*)self->string, FINSH_NAME_MAX); } int token_get_string(struct finsh_token* self, uint8_t* str) { - unsigned char *p=str; - char ch; + unsigned char *p=str; + char ch; - ch = token_next_char(self); - if (is_eof(self)) return -1; + ch = token_next_char(self); + if (is_eof(self)) return -1; - str[0] = '\0'; + str[0] = '\0'; - if ( is_digit(ch) )/*the first character of identifier is not a digit.*/ - { - token_prev_char(self); - return -1; - } + if ( is_digit(ch) )/*the first character of identifier is not a digit.*/ + { + token_prev_char(self); + return -1; + } - while (!is_separator(ch) && !is_eof(self)) - { - *p++ = ch; + while (!is_separator(ch) && !is_eof(self)) + { + *p++ = ch; - ch = token_next_char(self); - } - self->eof = 0; + ch = token_next_char(self); + } + self->eof = 0; - token_prev_char(self); - *p = '\0'; + token_prev_char(self); + *p = '\0'; - return 0; + return 0; } /* @@ -126,350 +126,350 @@ get next character. */ static char token_next_char(struct finsh_token* self) { - if (self->eof) return '\0'; + if (self->eof) return '\0'; - if (self->position == (int)strlen((char*)self->line) || self->line[self->position] =='\n') - { - self->eof = 1; - self->position = 0; - return '\0'; - } + if (self->position == (int)strlen((char*)self->line) || self->line[self->position] =='\n') + { + self->eof = 1; + self->position = 0; + return '\0'; + } - return self->line[self->position++]; + return self->line[self->position++]; } static void token_prev_char(struct finsh_token* self) { - if ( self->eof ) return; + if ( self->eof ) return; - if ( self->position == 0 ) return; + if ( self->position == 0 ) return; else self->position--; } static void token_run(struct finsh_token* self) { - char ch; + char ch; - token_trim_space(self); /* first trim space and tab. */ - token_get_string(self, &(self->string[0])); + token_trim_space(self); /* first trim space and tab. */ + token_get_string(self, &(self->string[0])); - if ( is_eof(self) ) /*if it is eof, break;*/ - { - self->current_token = finsh_token_type_eof; - return ; - } + if ( is_eof(self) ) /*if it is eof, break;*/ + { + self->current_token = finsh_token_type_eof; + return ; + } - if (self->string[0] != '\0') /*It is a key word or a identifier.*/ - { - if ( !token_match_name(self, (char*)self->string) ) - { - self->current_token = finsh_token_type_identifier; - } - } - else/*It is a operator character.*/ - { - ch = token_next_char(self); + if (self->string[0] != '\0') /*It is a key word or a identifier.*/ + { + if ( !token_match_name(self, (char*)self->string) ) + { + self->current_token = finsh_token_type_identifier; + } + } + else/*It is a operator character.*/ + { + ch = token_next_char(self); - switch ( ch ) - { - case '(': - self->current_token = finsh_token_type_left_paren; - break; + switch ( ch ) + { + case '(': + self->current_token = finsh_token_type_left_paren; + break; - case ')': - self->current_token = finsh_token_type_right_paren; - break; + case ')': + self->current_token = finsh_token_type_right_paren; + break; - case ',': - self->current_token = finsh_token_type_comma; - break; + case ',': + self->current_token = finsh_token_type_comma; + break; - case ';': - self->current_token = finsh_token_type_semicolon; - break; + case ';': + self->current_token = finsh_token_type_semicolon; + break; - case '&': - self->current_token = finsh_token_type_and; - break; + case '&': + self->current_token = finsh_token_type_and; + break; - case '*': - self->current_token = finsh_token_type_mul; - break; + case '*': + self->current_token = finsh_token_type_mul; + break; - case '+': - ch = token_next_char(self); + case '+': + ch = token_next_char(self); - if ( ch == '+' ) - { - self->current_token = finsh_token_type_inc; - } - else - { - token_prev_char(self); - self->current_token = finsh_token_type_add; - } - break; + if ( ch == '+' ) + { + self->current_token = finsh_token_type_inc; + } + else + { + token_prev_char(self); + self->current_token = finsh_token_type_add; + } + break; - case '-': - ch = token_next_char(self); + case '-': + ch = token_next_char(self); - if ( ch == '-' ) - { - self->current_token = finsh_token_type_dec; - } - else - { - token_prev_char(self); - self->current_token = finsh_token_type_sub; - } - break; + if ( ch == '-' ) + { + self->current_token = finsh_token_type_dec; + } + else + { + token_prev_char(self); + self->current_token = finsh_token_type_sub; + } + break; - case '/': - ch = token_next_char(self); - if (ch == '/') - { - /* line comments, set to end of file */ - self->current_token = finsh_token_type_eof; - } - else - { - token_prev_char(self); - self->current_token = finsh_token_type_div; - } - break; + case '/': + ch = token_next_char(self); + if (ch == '/') + { + /* line comments, set to end of file */ + self->current_token = finsh_token_type_eof; + } + else + { + token_prev_char(self); + self->current_token = finsh_token_type_div; + } + break; - case '<': - ch = token_next_char(self); + case '<': + ch = token_next_char(self); - if ( ch == '<' ) - { - self->current_token = finsh_token_type_shl; - } - else - { - token_prev_char(self); - self->current_token = finsh_token_type_bad; - } - break; + if ( ch == '<' ) + { + self->current_token = finsh_token_type_shl; + } + else + { + token_prev_char(self); + self->current_token = finsh_token_type_bad; + } + break; - case '>': - ch = token_next_char(self); + case '>': + ch = token_next_char(self); - if ( ch == '>' ) - { - self->current_token = finsh_token_type_shr; - } - else - { - token_prev_char(self); - self->current_token = finsh_token_type_bad; - } - break; + if ( ch == '>' ) + { + self->current_token = finsh_token_type_shr; + } + else + { + token_prev_char(self); + self->current_token = finsh_token_type_bad; + } + break; - case '|': - self->current_token = finsh_token_type_or; - break; + case '|': + self->current_token = finsh_token_type_or; + break; - case '%': - self->current_token = finsh_token_type_mod; - break; + case '%': + self->current_token = finsh_token_type_mod; + break; - case '~': - self->current_token = finsh_token_type_bitwise; - break; + case '~': + self->current_token = finsh_token_type_bitwise; + break; - case '^': - self->current_token = finsh_token_type_xor; - break; + case '^': + self->current_token = finsh_token_type_xor; + break; - case '=': - self->current_token = finsh_token_type_assign; - break; + case '=': + self->current_token = finsh_token_type_assign; + break; - case '\'': - self->value.char_value = token_proc_char(self); - self->current_token = finsh_token_type_value_char; - break; + case '\'': + self->value.char_value = token_proc_char(self); + self->current_token = finsh_token_type_value_char; + break; - case '"': - token_proc_string(self); - self->current_token = finsh_token_type_value_string; - break; + case '"': + token_proc_string(self); + self->current_token = finsh_token_type_value_string; + break; - default: - if ( is_digit(ch) ) - { - token_prev_char(self); - token_proc_number(self); - break; - } + default: + if ( is_digit(ch) ) + { + token_prev_char(self); + token_proc_number(self); + break; + } - finsh_error_set(FINSH_ERROR_UNKNOWN_TOKEN); - self->current_token = finsh_token_type_bad; + finsh_error_set(FINSH_ERROR_UNKNOWN_TOKEN); + self->current_token = finsh_token_type_bad; - break; - } - } + break; + } + } } static int token_match_name(struct finsh_token* self, const char* str) { - int i; + int i; - for (i = 0; i < sizeof(finsh_name_table)/sizeof(struct name_table); i++) - { - if ( strcmp(finsh_name_table[i].name, str)==0 ) - { - self->current_token = finsh_name_table[i].type; - return 1; - } - } + for (i = 0; i < sizeof(finsh_name_table)/sizeof(struct name_table); i++) + { + if ( strcmp(finsh_name_table[i].name, str)==0 ) + { + self->current_token = finsh_name_table[i].type; + return 1; + } + } - return 0; + return 0; } static void token_trim_space(struct finsh_token* self) { - char ch; - while ( (ch = token_next_char(self)) ==' ' || - ch == '\t' || + char ch; + while ( (ch = token_next_char(self)) ==' ' || + ch == '\t' || ch == '\r'); - token_prev_char(self); + token_prev_char(self); } static char token_proc_char(struct finsh_token* self) { - char ch; - char buf[4], *p; + char ch; + char buf[4], *p; - p = buf; - ch = token_next_char(self); + p = buf; + ch = token_next_char(self); - if ( ch == '\\' ) - { - ch = token_next_char(self); - switch ( ch ) - { - case 'n': ch = '\n'; break; - case 't': ch = '\t'; break; - case 'v': ch = '\v'; break; - case 'b': ch = '\b'; break; - case 'r': ch = '\r'; break; - case '\\': ch = '\\'; break; - case '\'': ch = '\''; break; - default : - while ( is_digit(ch) )/*for '\113' char*/ - { - ch = token_next_char(self); - *p++ = ch; - } + if ( ch == '\\' ) + { + ch = token_next_char(self); + switch ( ch ) + { + case 'n': ch = '\n'; break; + case 't': ch = '\t'; break; + case 'v': ch = '\v'; break; + case 'b': ch = '\b'; break; + case 'r': ch = '\r'; break; + case '\\': ch = '\\'; break; + case '\'': ch = '\''; break; + default : + while ( is_digit(ch) )/*for '\113' char*/ + { + ch = token_next_char(self); + *p++ = ch; + } - token_prev_char(self); - *p = '\0'; - ch = atoi(p); - break; - } - } + token_prev_char(self); + *p = '\0'; + ch = atoi(p); + break; + } + } - if ( token_next_char(self) != '\'' ) - { - token_prev_char(self); - finsh_error_set(FINSH_ERROR_EXPECT_CHAR); - return ch; - } + if ( token_next_char(self) != '\'' ) + { + token_prev_char(self); + finsh_error_set(FINSH_ERROR_EXPECT_CHAR); + return ch; + } - return ch; + return ch; } static uint8_t* token_proc_string(struct finsh_token* self) { - uint8_t* p; + uint8_t* p; - for ( p = &self->string[0]; p - &(self->string[0]) < FINSH_STRING_MAX; ) - { - char ch = token_next_char(self); + for ( p = &self->string[0]; p - &(self->string[0]) < FINSH_STRING_MAX; ) + { + char ch = token_next_char(self); - if ( is_eof(self) ) - { - finsh_error_set(FINSH_ERROR_UNEXPECT_END); - return NULL;; - } - if ( ch == '\\' ) - { - ch = token_proc_escape(self); - } - else if ( ch == '"' )/*end of string.*/ - { - *p = '\0'; - return self->string; - } + if ( is_eof(self) ) + { + finsh_error_set(FINSH_ERROR_UNEXPECT_END); + return NULL;; + } + if ( ch == '\\' ) + { + ch = token_proc_escape(self); + } + else if ( ch == '"' )/*end of string.*/ + { + *p = '\0'; + return self->string; + } - *p++ = ch; - } + *p++ = ch; + } - return NULL; + return NULL; } static int token_proc_escape(struct finsh_token* self) { - char ch; - int result=0; + char ch; + int result=0; - ch = token_next_char(self); - switch (ch) - { - case 'n': - result = '\n'; - break; - case 't': - result = '\t'; - break; - case 'v': - result = '\v'; - break; - case 'b': - result = '\b'; - break; - case 'r': - result = '\r'; - break; - case 'f': - result = '\f'; - break; - case 'a': - result = '\007'; - break; - case '"': - result = '"'; - break; - case 'x': - case 'X': - result = 0; - ch = token_next_char(self); - while (is_xdigit(ch)) - { - result = result * 16 + ((ch < 'A') ? (ch - '0') : (ch | 0x20) - 'a' + 10); - ch = token_next_char(self); - } - token_prev_char(self); - break; - default: - if ( (ch - '0') < 8u) - { - result = 0; - while ( (ch - '0') < 8u ) - { - result = result*8 + ch - '0'; - ch = token_next_char(self); - } + ch = token_next_char(self); + switch (ch) + { + case 'n': + result = '\n'; + break; + case 't': + result = '\t'; + break; + case 'v': + result = '\v'; + break; + case 'b': + result = '\b'; + break; + case 'r': + result = '\r'; + break; + case 'f': + result = '\f'; + break; + case 'a': + result = '\007'; + break; + case '"': + result = '"'; + break; + case 'x': + case 'X': + result = 0; + ch = token_next_char(self); + while (is_xdigit(ch)) + { + result = result * 16 + ((ch < 'A') ? (ch - '0') : (ch | 0x20) - 'a' + 10); + ch = token_next_char(self); + } + token_prev_char(self); + break; + default: + if ( (ch - '0') < 8u) + { + result = 0; + while ( (ch - '0') < 8u ) + { + result = result*8 + ch - '0'; + ch = token_next_char(self); + } - token_prev_char(self); - } - break; - } + token_prev_char(self); + } + break; + } - return result; + return result; } /* @@ -477,89 +477,89 @@ static int token_proc_escape(struct finsh_token* self) */ static void token_proc_number(struct finsh_token* self) { - char ch; - char *p, buf[128]; - long value; + char ch; + char *p, buf[128]; + long value; - value = 0; - p = buf; + value = 0; + p = buf; - ch = token_next_char(self); - if ( ch == '0' ) - { - int b; - ch = token_next_char(self); - if ( ch == 'x' || ch == 'X' )/*it's a hex number*/ - { - b = 16; - ch = token_next_char(self); - while ( is_digit(ch) || is_alpha(ch) ) - { - *p++ = ch; - ch = token_next_char(self); - } + ch = token_next_char(self); + if ( ch == '0' ) + { + int b; + ch = token_next_char(self); + if ( ch == 'x' || ch == 'X' )/*it's a hex number*/ + { + b = 16; + ch = token_next_char(self); + while ( is_digit(ch) || is_alpha(ch) ) + { + *p++ = ch; + ch = token_next_char(self); + } - *p = '\0'; - } - else if ( ch == 'b' || ch == 'B' ) - { - b = 2; - ch = token_next_char(self); - while ( (ch=='0')||(ch=='1') ) - { - *p++ = ch; - ch = token_next_char(self); - } + *p = '\0'; + } + else if ( ch == 'b' || ch == 'B' ) + { + b = 2; + ch = token_next_char(self); + while ( (ch=='0')||(ch=='1') ) + { + *p++ = ch; + ch = token_next_char(self); + } - *p = '\0'; - } - else if ( '0' <= ch && ch <= '7' ) - { - b = 8; - while ( '0' <= ch && ch <= '7' ) - { - *p++ = ch; - ch = token_next_char(self); - } + *p = '\0'; + } + else if ( '0' <= ch && ch <= '7' ) + { + b = 8; + while ( '0' <= ch && ch <= '7' ) + { + *p++ = ch; + ch = token_next_char(self); + } - *p = '\0'; - } - else - { - token_prev_char(self); + *p = '\0'; + } + else + { + token_prev_char(self); - /* made as 0 value */ - self->value.int_value = 0; - self->current_token = finsh_token_type_value_int; - return; - } + /* made as 0 value */ + self->value.int_value = 0; + self->current_token = finsh_token_type_value_int; + return; + } - self->value.int_value = token_spec_number(buf, strlen(buf), b); - self->current_token = finsh_token_type_value_int; - } - else - { - while ( is_digit(ch) ) - { - value = value*10 + ( ch - '0' ); - ch = token_next_char(self); - } + self->value.int_value = token_spec_number(buf, strlen(buf), b); + self->current_token = finsh_token_type_value_int; + } + else + { + while ( is_digit(ch) ) + { + value = value*10 + ( ch - '0' ); + ch = token_next_char(self); + } - self->value.int_value = value; - self->current_token = finsh_token_type_value_int; - } + self->value.int_value = value; + self->current_token = finsh_token_type_value_int; + } - switch ( ch ) - { - case 'l': - case 'L': - self->current_token = finsh_token_type_value_long; - break; + switch ( ch ) + { + case 'l': + case 'L': + self->current_token = finsh_token_type_value_long; + break; - default: - token_prev_char(self); - break; - } + default: + token_prev_char(self); + break; + } } /*use 64 bit number*/ @@ -567,51 +567,51 @@ static void token_proc_number(struct finsh_token* self) static long token_spec_number(char* string, int length, int b) { - char* p; - int t; - int i, j, shift=1; - unsigned int bn[BN_SIZE], v; - long d; + char* p; + int t; + int i, j, shift=1; + unsigned int bn[BN_SIZE], v; + long d; - p = string; - i = 0; + p = string; + i = 0; - switch ( b ) - { - case 16: shift = 4; - break; - case 8: shift = 3; - break; - case 2: shift = 1; - break; - default: break; - } + switch ( b ) + { + case 16: shift = 4; + break; + case 8: shift = 3; + break; + case 2: shift = 1; + break; + default: break; + } - for ( j=0; j='a' && t <='f' ) - { - t = t - 'a' +10; - } - else if ( t >='A' && t <='F' ) - { - t = t - 'A' +10; - } - else t = t - '0'; + while ( i='a' && t <='f' ) + { + t = t - 'a' +10; + } + else if ( t >='A' && t <='F' ) + { + t = t - 'A' +10; + } + else t = t - '0'; - for ( j=0; j> (32 - shift); - } - i++; - } + for ( j=0; j> (32 - shift); + } + i++; + } - d = (long)bn[0]; + d = (long)bn[0]; - return d; + return d; } diff --git a/components/finsh/finsh_token.h b/components/finsh/finsh_token.h index 57c002c3f..fd7e2597c 100644 --- a/components/finsh/finsh_token.h +++ b/components/finsh/finsh_token.h @@ -33,42 +33,42 @@ enum finsh_token_type { - finsh_token_type_left_paren = 1, /* ( */ - finsh_token_type_right_paren , /* ) */ - finsh_token_type_comma , /* , */ - finsh_token_type_semicolon , /* ; */ - finsh_token_type_mul , /* * */ - finsh_token_type_add , /* + */ - finsh_token_type_inc , /* ++ */ - finsh_token_type_sub , /* - */ - finsh_token_type_dec , /* -- */ - finsh_token_type_div , /* / */ - finsh_token_type_mod , /* % */ - finsh_token_type_assign , /* = */ - finsh_token_type_and, /* & */ - finsh_token_type_or, /* | */ - finsh_token_type_xor, /* ^ */ - finsh_token_type_bitwise, /* ~ */ - finsh_token_type_shl, /* << */ - finsh_token_type_shr, /* >> */ - finsh_token_type_comments, /* // */ - /*-- data type --*/ - finsh_token_type_void, /* void */ - finsh_token_type_char, /* char */ - finsh_token_type_short, /* short */ - finsh_token_type_int, /* int */ - finsh_token_type_long, /* long */ - finsh_token_type_unsigned, /* unsigned */ + finsh_token_type_left_paren = 1, /* ( */ + finsh_token_type_right_paren , /* ) */ + finsh_token_type_comma , /* , */ + finsh_token_type_semicolon , /* ; */ + finsh_token_type_mul , /* * */ + finsh_token_type_add , /* + */ + finsh_token_type_inc , /* ++ */ + finsh_token_type_sub , /* - */ + finsh_token_type_dec , /* -- */ + finsh_token_type_div , /* / */ + finsh_token_type_mod , /* % */ + finsh_token_type_assign , /* = */ + finsh_token_type_and, /* & */ + finsh_token_type_or, /* | */ + finsh_token_type_xor, /* ^ */ + finsh_token_type_bitwise, /* ~ */ + finsh_token_type_shl, /* << */ + finsh_token_type_shr, /* >> */ + finsh_token_type_comments, /* // */ + /*-- data type --*/ + finsh_token_type_void, /* void */ + finsh_token_type_char, /* char */ + finsh_token_type_short, /* short */ + finsh_token_type_int, /* int */ + finsh_token_type_long, /* long */ + finsh_token_type_unsigned, /* unsigned */ /* data value type */ finsh_token_type_value_char, /* v:char */ finsh_token_type_value_int, /* v:int */ finsh_token_type_value_long, /* v:long */ finsh_token_type_value_string, /* v:string */ - finsh_token_type_value_null, /* NULL */ - /*-- others --*/ - finsh_token_type_identifier, /* ID */ - finsh_token_type_bad, /* bad token */ - finsh_token_type_eof + finsh_token_type_value_null, /* NULL */ + /*-- others --*/ + finsh_token_type_identifier, /* ID */ + finsh_token_type_bad, /* bad token */ + finsh_token_type_eof }; #define finsh_token_position(self) (self)->position diff --git a/components/finsh/finsh_var.c b/components/finsh/finsh_var.c index 86a97559f..7e3949264 100644 --- a/components/finsh/finsh_var.c +++ b/components/finsh/finsh_var.c @@ -36,126 +36,126 @@ struct finsh_sysvar_item* global_sysvar_list; int finsh_var_init() { - memset(global_variable, 0, sizeof(global_variable)); + memset(global_variable, 0, sizeof(global_variable)); - return 0; + return 0; } int finsh_var_insert(const char* name, int type) { - int i, empty; + int i, empty; - empty = -1; - for (i = 0; i < FINSH_VARIABLE_MAX; i ++) - { - /* there is a same name variable exist. */ - if (strncmp(global_variable[i].name, name, FINSH_NAME_MAX) == 0) - return -1; + empty = -1; + for (i = 0; i < FINSH_VARIABLE_MAX; i ++) + { + /* there is a same name variable exist. */ + if (strncmp(global_variable[i].name, name, FINSH_NAME_MAX) == 0) + return -1; - if (global_variable[i].type == finsh_type_unknown && empty == -1) - { - empty = i; - } - } + if (global_variable[i].type == finsh_type_unknown && empty == -1) + { + empty = i; + } + } - /* there is no empty entry */ - if (empty == -1) return -1; + /* there is no empty entry */ + if (empty == -1) return -1; - /* insert entry */ - strncpy(global_variable[empty].name, name, FINSH_NAME_MAX); - global_variable[empty].type = type; + /* insert entry */ + strncpy(global_variable[empty].name, name, FINSH_NAME_MAX); + global_variable[empty].type = type; - /* return the offset */ - return empty; + /* return the offset */ + return empty; } int finsh_var_delete(const char* name) { - int i; + int i; - for (i = 0; i < FINSH_VARIABLE_MAX; i ++) - { - if (strncmp(global_variable[i].name, name, FINSH_NAME_MAX) == 0) - break; - } + for (i = 0; i < FINSH_VARIABLE_MAX; i ++) + { + if (strncmp(global_variable[i].name, name, FINSH_NAME_MAX) == 0) + break; + } - /* can't find variable */ - if (i == FINSH_VARIABLE_MAX) return -1; + /* can't find variable */ + if (i == FINSH_VARIABLE_MAX) return -1; - memset(&global_variable[i], 0, sizeof(struct finsh_var)); + memset(&global_variable[i], 0, sizeof(struct finsh_var)); - return 0; + return 0; } struct finsh_var* finsh_var_lookup(const char* name) { - int i; + int i; - for (i = 0; i < FINSH_VARIABLE_MAX; i ++) - { - if (strncmp(global_variable[i].name, name, FINSH_NAME_MAX) == 0) - break; - } + for (i = 0; i < FINSH_VARIABLE_MAX; i ++) + { + if (strncmp(global_variable[i].name, name, FINSH_NAME_MAX) == 0) + break; + } - /* can't find variable */ - if (i == FINSH_VARIABLE_MAX) return NULL; + /* can't find variable */ + if (i == FINSH_VARIABLE_MAX) return NULL; - return &global_variable[i]; + return &global_variable[i]; } #ifdef RT_USING_HEAP void finsh_sysvar_append(const char* name, uint8_t type, void* var_addr) { - /* create a sysvar */ - struct finsh_sysvar_item* item; + /* create a sysvar */ + struct finsh_sysvar_item* item; - item = (struct finsh_sysvar_item*) rt_malloc (sizeof(struct finsh_sysvar_item)); - if (item != NULL) - { - item->next = NULL; - item->sysvar.name = rt_strdup(name); - item->sysvar.type = type; - item->sysvar.var = var_addr; + item = (struct finsh_sysvar_item*) rt_malloc (sizeof(struct finsh_sysvar_item)); + if (item != NULL) + { + item->next = NULL; + item->sysvar.name = rt_strdup(name); + item->sysvar.type = type; + item->sysvar.var = var_addr; - if (global_sysvar_list == NULL) - { - global_sysvar_list = item; - } - else - { - item->next = global_sysvar_list; - global_sysvar_list = item; - } - } + if (global_sysvar_list == NULL) + { + global_sysvar_list = item; + } + else + { + item->next = global_sysvar_list; + global_sysvar_list = item; + } + } } #endif struct finsh_sysvar* finsh_sysvar_lookup(const char* name) { - struct finsh_sysvar* index; - struct finsh_sysvar_item* item; + struct finsh_sysvar* index; + struct finsh_sysvar_item* item; - for (index = _sysvar_table_begin; - index < _sysvar_table_end; - FINSH_NEXT_SYSVAR(index)) - { - if (strcmp(index->name, name) == 0) - return index; - } + for (index = _sysvar_table_begin; + index < _sysvar_table_end; + FINSH_NEXT_SYSVAR(index)) + { + if (strcmp(index->name, name) == 0) + return index; + } - /* find in sysvar list */ - item = global_sysvar_list; - while (item != NULL) - { - if (strncmp(item->sysvar.name, name, strlen(name)) == 0) - { - return &(item->sysvar); - } + /* find in sysvar list */ + item = global_sysvar_list; + while (item != NULL) + { + if (strncmp(item->sysvar.name, name, strlen(name)) == 0) + { + return &(item->sysvar); + } - /* move to next item */ - item = item->next; - } + /* move to next item */ + item = item->next; + } - /* can't find variable */ - return NULL; + /* can't find variable */ + return NULL; } diff --git a/components/finsh/finsh_var.h b/components/finsh/finsh_var.h index d3b88fa53..f8013ac9d 100644 --- a/components/finsh/finsh_var.h +++ b/components/finsh/finsh_var.h @@ -37,18 +37,18 @@ */ struct finsh_var { - char name[FINSH_NAME_MAX + 1]; /* the name of variable */ + char name[FINSH_NAME_MAX + 1]; /* the name of variable */ - uint8_t type; /* the type of variable */ + uint8_t type; /* the type of variable */ - /* variable value */ - union { - char char_value; - short short_value; - int int_value; - long long_value; - void* ptr; - }value; + /* variable value */ + union { + char char_value; + short short_value; + int int_value; + long long_value; + void* ptr; + }value; }; extern struct finsh_var global_variable[]; diff --git a/components/finsh/finsh_vm.c b/components/finsh/finsh_vm.c index 49b1a3194..8a3b8949e 100644 --- a/components/finsh/finsh_vm.c +++ b/components/finsh/finsh_vm.c @@ -33,12 +33,12 @@ #include "finsh_var.h" /* stack */ -union finsh_value finsh_vm_stack[FINSH_STACK_MAX]; +union finsh_value finsh_vm_stack[FINSH_STACK_MAX]; /* text segment */ -uint8_t text_segment[FINSH_TEXT_MAX]; +uint8_t text_segment[FINSH_TEXT_MAX]; -union finsh_value* finsh_sp; /* stack pointer */ -uint8_t* finsh_pc; /* PC */ +union finsh_value* finsh_sp; /* stack pointer */ +uint8_t* finsh_pc; /* PC */ /* syscall list, for dynamic system call register */ struct finsh_syscall_item* global_syscall_list = NULL; @@ -46,359 +46,359 @@ struct finsh_syscall_item* global_syscall_list = NULL; // #define FINSH_VM_DISASSEMBLE void finsh_vm_run() { - uint8_t op; + uint8_t op; - /* if you want to disassemble the byte code, please define FINSH_VM_DISASSEMBLE */ + /* if you want to disassemble the byte code, please define FINSH_VM_DISASSEMBLE */ #ifdef FINSH_VM_DISASSEMBLE - void finsh_disassemble(); - finsh_disassemble(); + void finsh_disassemble(); + finsh_disassemble(); #endif - /* set sp(stack pointer) to the beginning of stack */ - finsh_sp = &finsh_vm_stack[0]; + /* set sp(stack pointer) to the beginning of stack */ + finsh_sp = &finsh_vm_stack[0]; - /* set pc to the beginning of text segment */ - finsh_pc = &text_segment[0]; + /* set pc to the beginning of text segment */ + finsh_pc = &text_segment[0]; - while ((finsh_pc - &text_segment[0] >= 0) && - (finsh_pc - &text_segment[0] < FINSH_TEXT_MAX)) - { - /* get op */ - op = *finsh_pc++; + while ((finsh_pc - &text_segment[0] >= 0) && + (finsh_pc - &text_segment[0] < FINSH_TEXT_MAX)) + { + /* get op */ + op = *finsh_pc++; - /* call op function */ - op_table[op](); - } + /* call op function */ + op_table[op](); + } } #ifdef RT_USING_HEAP void finsh_syscall_append(const char* name, syscall_func func) { - /* create the syscall */ - struct finsh_syscall_item* item; + /* create the syscall */ + struct finsh_syscall_item* item; - item = (struct finsh_syscall_item*)rt_malloc(sizeof(struct finsh_syscall_item)); - if (item != RT_NULL) - { - item->next = NULL; - item->syscall.name = rt_strdup(name); - item->syscall.func = func; + item = (struct finsh_syscall_item*)rt_malloc(sizeof(struct finsh_syscall_item)); + if (item != RT_NULL) + { + item->next = NULL; + item->syscall.name = rt_strdup(name); + item->syscall.func = func; - if (global_syscall_list == NULL) - { - global_syscall_list = item; - } - else - { - item->next = global_syscall_list; - global_syscall_list = item; - } - } + if (global_syscall_list == NULL) + { + global_syscall_list = item; + } + else + { + item->next = global_syscall_list; + global_syscall_list = item; + } + } } #endif #if defined(_MSC_VER) || (defined(__GNUC__) && defined(__x86_64__)) struct finsh_syscall* finsh_syscall_next(struct finsh_syscall* call) { - unsigned int *ptr; - ptr = (unsigned int*) (call + 1); - while ((*ptr == 0) && ((unsigned int*)ptr < (unsigned int*) _syscall_table_end)) - ptr ++; + unsigned int *ptr; + ptr = (unsigned int*) (call + 1); + while ((*ptr == 0) && ((unsigned int*)ptr < (unsigned int*) _syscall_table_end)) + ptr ++; - return (struct finsh_syscall*)ptr; + return (struct finsh_syscall*)ptr; } struct finsh_sysvar* finsh_sysvar_next(struct finsh_sysvar* call) { - unsigned int *ptr; - ptr = (unsigned int*) (call + 1); - while ((*ptr == 0) && ((unsigned int*)ptr < (unsigned int*) _sysvar_table_end)) - ptr ++; + unsigned int *ptr; + ptr = (unsigned int*) (call + 1); + while ((*ptr == 0) && ((unsigned int*)ptr < (unsigned int*) _sysvar_table_end)) + ptr ++; - return (struct finsh_sysvar*)ptr; + return (struct finsh_sysvar*)ptr; } #endif struct finsh_syscall* finsh_syscall_lookup(const char* name) { - struct finsh_syscall* index; - struct finsh_syscall_item* item; + struct finsh_syscall* index; + struct finsh_syscall_item* item; - for (index = _syscall_table_begin; index < _syscall_table_end; FINSH_NEXT_SYSCALL(index)) - { - if (strcmp(index->name, name) == 0) - return index; - } + for (index = _syscall_table_begin; index < _syscall_table_end; FINSH_NEXT_SYSCALL(index)) + { + if (strcmp(index->name, name) == 0) + return index; + } - /* find on syscall list */ - item = global_syscall_list; - while (item != NULL) - { - if (strncmp(item->syscall.name, name, strlen(name)) == 0) - { - return &(item->syscall); - } + /* find on syscall list */ + item = global_syscall_list; + while (item != NULL) + { + if (strncmp(item->syscall.name, name, strlen(name)) == 0) + { + return &(item->syscall); + } - item = item->next; - } + item = item->next; + } - return NULL; + return NULL; } #ifdef FINSH_VM_DISASSEMBLE void finsh_disassemble() { - uint8_t *pc, op; + uint8_t *pc, op; - pc = &text_segment[0]; - while (*pc != 0) - { - op = *pc; - switch (op) - { - case FINSH_OP_ADD_BYTE: - pc ++; - rt_kprintf("addb\n"); - break; + pc = &text_segment[0]; + while (*pc != 0) + { + op = *pc; + switch (op) + { + case FINSH_OP_ADD_BYTE: + pc ++; + rt_kprintf("addb\n"); + break; - case FINSH_OP_SUB_BYTE: - pc ++; - rt_kprintf("subb\n"); - break; + case FINSH_OP_SUB_BYTE: + pc ++; + rt_kprintf("subb\n"); + break; - case FINSH_OP_DIV_BYTE: - pc ++; - rt_kprintf("divb\n"); - break; + case FINSH_OP_DIV_BYTE: + pc ++; + rt_kprintf("divb\n"); + break; - case FINSH_OP_MOD_BYTE: - pc ++; - rt_kprintf("modb\n"); - break; + case FINSH_OP_MOD_BYTE: + pc ++; + rt_kprintf("modb\n"); + break; - case FINSH_OP_MUL_BYTE: - pc ++; - rt_kprintf("mulb\n"); - break; + case FINSH_OP_MUL_BYTE: + pc ++; + rt_kprintf("mulb\n"); + break; - case FINSH_OP_AND_BYTE: - pc ++; - rt_kprintf("andb\n"); - break; + case FINSH_OP_AND_BYTE: + pc ++; + rt_kprintf("andb\n"); + break; - case FINSH_OP_OR_BYTE: - pc ++; - rt_kprintf("orb\n"); - break; + case FINSH_OP_OR_BYTE: + pc ++; + rt_kprintf("orb\n"); + break; - case FINSH_OP_XOR_BYTE: - pc ++; - rt_kprintf("xorb\n"); - break; + case FINSH_OP_XOR_BYTE: + pc ++; + rt_kprintf("xorb\n"); + break; - case FINSH_OP_BITWISE_BYTE: - pc ++; - rt_kprintf("bwb\n"); - break; + case FINSH_OP_BITWISE_BYTE: + pc ++; + rt_kprintf("bwb\n"); + break; - case FINSH_OP_SHL_BYTE: - pc ++; - rt_kprintf("shlb\n"); - break; + case FINSH_OP_SHL_BYTE: + pc ++; + rt_kprintf("shlb\n"); + break; - case FINSH_OP_SHR_BYTE: - pc ++; - rt_kprintf("shrb\n"); - break; + case FINSH_OP_SHR_BYTE: + pc ++; + rt_kprintf("shrb\n"); + break; - case FINSH_OP_LD_BYTE: - pc ++; - rt_kprintf("ldb %d\n", *pc++); - break; + case FINSH_OP_LD_BYTE: + pc ++; + rt_kprintf("ldb %d\n", *pc++); + break; - case FINSH_OP_LD_VALUE_BYTE: - pc ++; - rt_kprintf("ldb [0x%x]\n", FINSH_GET32(pc)); - pc += 4; - break; + case FINSH_OP_LD_VALUE_BYTE: + pc ++; + rt_kprintf("ldb [0x%x]\n", FINSH_GET32(pc)); + pc += 4; + break; - case FINSH_OP_ST_BYTE: - pc ++; - rt_kprintf("stb\n"); - break; + case FINSH_OP_ST_BYTE: + pc ++; + rt_kprintf("stb\n"); + break; - case FINSH_OP_ADD_WORD: - pc ++; - rt_kprintf("addw\n"); - break; + case FINSH_OP_ADD_WORD: + pc ++; + rt_kprintf("addw\n"); + break; - case FINSH_OP_SUB_WORD: - pc ++; - rt_kprintf("subw\n"); - break; + case FINSH_OP_SUB_WORD: + pc ++; + rt_kprintf("subw\n"); + break; - case FINSH_OP_DIV_WORD: - pc ++; - rt_kprintf("divw\n"); - break; + case FINSH_OP_DIV_WORD: + pc ++; + rt_kprintf("divw\n"); + break; - case FINSH_OP_MOD_WORD: - pc ++; - rt_kprintf("modw\n"); - break; + case FINSH_OP_MOD_WORD: + pc ++; + rt_kprintf("modw\n"); + break; - case FINSH_OP_MUL_WORD: - pc ++; - rt_kprintf("mulw\n"); - break; + case FINSH_OP_MUL_WORD: + pc ++; + rt_kprintf("mulw\n"); + break; - case FINSH_OP_AND_WORD: - pc ++; - rt_kprintf("andw\n"); - break; + case FINSH_OP_AND_WORD: + pc ++; + rt_kprintf("andw\n"); + break; - case FINSH_OP_OR_WORD: - pc ++; - rt_kprintf("orw\n"); - break; + case FINSH_OP_OR_WORD: + pc ++; + rt_kprintf("orw\n"); + break; - case FINSH_OP_XOR_WORD: - pc ++; - rt_kprintf("xorw\n"); - break; + case FINSH_OP_XOR_WORD: + pc ++; + rt_kprintf("xorw\n"); + break; - case FINSH_OP_BITWISE_WORD: - pc ++; - rt_kprintf("bww\n"); - break; + case FINSH_OP_BITWISE_WORD: + pc ++; + rt_kprintf("bww\n"); + break; - case FINSH_OP_SHL_WORD: - pc ++; - rt_kprintf("shlw\n"); - break; + case FINSH_OP_SHL_WORD: + pc ++; + rt_kprintf("shlw\n"); + break; - case FINSH_OP_SHR_WORD: - pc ++; - rt_kprintf("shrw\n"); - break; + case FINSH_OP_SHR_WORD: + pc ++; + rt_kprintf("shrw\n"); + break; - case FINSH_OP_LD_WORD: - pc ++; - rt_kprintf("ldw %d\n", FINSH_GET16(pc)); - pc += 2; - break; + case FINSH_OP_LD_WORD: + pc ++; + rt_kprintf("ldw %d\n", FINSH_GET16(pc)); + pc += 2; + break; - case FINSH_OP_LD_VALUE_WORD: - pc ++; - rt_kprintf("ldw [0x%x]\n", FINSH_GET32(pc)); - pc += 4; - break; + case FINSH_OP_LD_VALUE_WORD: + pc ++; + rt_kprintf("ldw [0x%x]\n", FINSH_GET32(pc)); + pc += 4; + break; - case FINSH_OP_ST_WORD: - pc ++; - rt_kprintf("stw\n"); - break; + case FINSH_OP_ST_WORD: + pc ++; + rt_kprintf("stw\n"); + break; - case FINSH_OP_ADD_DWORD: - pc ++; - rt_kprintf("addd\n"); - break; + case FINSH_OP_ADD_DWORD: + pc ++; + rt_kprintf("addd\n"); + break; - case FINSH_OP_SUB_DWORD: - pc ++; - rt_kprintf("subd\n"); - break; + case FINSH_OP_SUB_DWORD: + pc ++; + rt_kprintf("subd\n"); + break; - case FINSH_OP_DIV_DWORD: - pc ++; - rt_kprintf("divd\n"); - break; + case FINSH_OP_DIV_DWORD: + pc ++; + rt_kprintf("divd\n"); + break; - case FINSH_OP_MOD_DWORD: - pc ++; - rt_kprintf("modd\n"); - break; + case FINSH_OP_MOD_DWORD: + pc ++; + rt_kprintf("modd\n"); + break; - case FINSH_OP_MUL_DWORD: - pc ++; - rt_kprintf("muld\n"); - break; + case FINSH_OP_MUL_DWORD: + pc ++; + rt_kprintf("muld\n"); + break; - case FINSH_OP_AND_DWORD: - pc ++; - rt_kprintf("andd\n"); - break; + case FINSH_OP_AND_DWORD: + pc ++; + rt_kprintf("andd\n"); + break; - case FINSH_OP_OR_DWORD: - pc ++; - rt_kprintf("ord\n"); - break; + case FINSH_OP_OR_DWORD: + pc ++; + rt_kprintf("ord\n"); + break; - case FINSH_OP_XOR_DWORD: - pc ++; - rt_kprintf("xord\n"); - break; + case FINSH_OP_XOR_DWORD: + pc ++; + rt_kprintf("xord\n"); + break; - case FINSH_OP_BITWISE_DWORD: - pc ++; - rt_kprintf("bwd\n"); - break; + case FINSH_OP_BITWISE_DWORD: + pc ++; + rt_kprintf("bwd\n"); + break; - case FINSH_OP_SHL_DWORD: - pc ++; - rt_kprintf("shld\n"); - break; + case FINSH_OP_SHL_DWORD: + pc ++; + rt_kprintf("shld\n"); + break; - case FINSH_OP_SHR_DWORD: - pc ++; - rt_kprintf("shrd\n"); - break; + case FINSH_OP_SHR_DWORD: + pc ++; + rt_kprintf("shrd\n"); + break; - case FINSH_OP_LD_DWORD: - pc ++; - rt_kprintf("ldd 0x%x\n", FINSH_GET32(pc)); - pc += 4; - break; + case FINSH_OP_LD_DWORD: + pc ++; + rt_kprintf("ldd 0x%x\n", FINSH_GET32(pc)); + pc += 4; + break; - case FINSH_OP_LD_VALUE_DWORD: - pc ++; - rt_kprintf("ldd [0x%x]\n", FINSH_GET32(pc)); - pc += 4; - break; + case FINSH_OP_LD_VALUE_DWORD: + pc ++; + rt_kprintf("ldd [0x%x]\n", FINSH_GET32(pc)); + pc += 4; + break; - case FINSH_OP_ST_DWORD: - pc ++; - rt_kprintf("std\n"); - break; + case FINSH_OP_ST_DWORD: + pc ++; + rt_kprintf("std\n"); + break; - case FINSH_OP_POP: - rt_kprintf("pop\n"); - pc ++; - break; + case FINSH_OP_POP: + rt_kprintf("pop\n"); + pc ++; + break; - case FINSH_OP_SYSCALL: - pc ++; - rt_kprintf("syscall %d\n", *pc++); - break; + case FINSH_OP_SYSCALL: + pc ++; + rt_kprintf("syscall %d\n", *pc++); + break; - case FINSH_OP_LD_VALUE_BYTE_STACK: - pc ++; - rt_kprintf("ldb [sp]\n"); - break; + case FINSH_OP_LD_VALUE_BYTE_STACK: + pc ++; + rt_kprintf("ldb [sp]\n"); + break; - case FINSH_OP_LD_VALUE_WORD_STACK: - pc ++; - rt_kprintf("ldw [sp]\n"); - break; + case FINSH_OP_LD_VALUE_WORD_STACK: + pc ++; + rt_kprintf("ldw [sp]\n"); + break; - case FINSH_OP_LD_VALUE_DWORD_STACK: - pc ++; - rt_kprintf("ldd [sp]\n"); - break; + case FINSH_OP_LD_VALUE_DWORD_STACK: + pc ++; + rt_kprintf("ldd [sp]\n"); + break; - default: - return; - } - } + default: + return; + } + } } #endif diff --git a/components/finsh/finsh_vm.h b/components/finsh/finsh_vm.h index 2401f7fe4..478a75714 100644 --- a/components/finsh/finsh_vm.h +++ b/components/finsh/finsh_vm.h @@ -34,19 +34,19 @@ #include "finsh_var.h" union finsh_value { - char char_value; - short short_value; - long long_value; - void* ptr; + char char_value; + short short_value; + long long_value; + void* ptr; }; -extern union finsh_value* finsh_sp; /* stack pointer */ -extern uint8_t* finsh_pc; /* PC */ +extern union finsh_value* finsh_sp; /* stack pointer */ +extern uint8_t* finsh_pc; /* PC */ /* stack */ -extern union finsh_value finsh_vm_stack[FINSH_STACK_MAX]; +extern union finsh_value finsh_vm_stack[FINSH_STACK_MAX]; /* text segment */ -extern uint8_t text_segment[FINSH_TEXT_MAX]; +extern uint8_t text_segment[FINSH_TEXT_MAX]; void finsh_vm_run(void); //void finsh_disassemble(void); diff --git a/components/finsh/msh_cmd.c b/components/finsh/msh_cmd.c index f184f1f33..7e9fd68a5 100644 --- a/components/finsh/msh_cmd.c +++ b/components/finsh/msh_cmd.c @@ -191,7 +191,7 @@ int cmd_cd(int argc, char **argv) { if (chdir(argv[1]) != 0) { - rt_kprintf("No such directory: %s\n", argv[1]); + rt_kprintf("No such directory: %s\n", argv[1]); } } @@ -262,7 +262,7 @@ int cmd_df(int argc, char** argv) { df("/"); } - else + else { if ((strcmp(argv[1], "--help") == 0) || (strcmp(argv[1], "-h") == 0)) { @@ -280,31 +280,31 @@ FINSH_FUNCTION_EXPORT_ALIAS(cmd_df, __cmd_df, disk free); int cmd_echo(int argc, char** argv) { - if (argc == 2) - { - rt_kprintf("%s\n", argv[1]); - } - else if (argc == 3) - { - int fd; + if (argc == 2) + { + rt_kprintf("%s\n", argv[1]); + } + else if (argc == 3) + { + int fd; - fd = open(argv[2], O_RDWR | O_APPEND | O_CREAT, 0); - if (fd >= 0) - { - write (fd, argv[1], strlen(argv[1])); - close(fd); - } - else - { - rt_kprintf("open file:%s failed!\n", argv[2]); - } - } - else - { - rt_kprintf("Usage: echo \"string\" [filename]\n"); - } + fd = open(argv[2], O_RDWR | O_APPEND | O_CREAT, 0); + if (fd >= 0) + { + write (fd, argv[1], strlen(argv[1])); + close(fd); + } + else + { + rt_kprintf("open file:%s failed!\n", argv[2]); + } + } + else + { + rt_kprintf("Usage: echo \"string\" [filename]\n"); + } - return 0; + return 0; } FINSH_FUNCTION_EXPORT_ALIAS(cmd_echo, __cmd_echo, echo string to file); #endif diff --git a/components/finsh/shell.c b/components/finsh/shell.c index 2a0637ec2..fc13a92b1 100644 --- a/components/finsh/shell.c +++ b/components/finsh/shell.c @@ -233,7 +233,7 @@ static void finsh_wait_auth(void) rt_size_t cur_pos = 0; /* password not set */ if (rt_strlen(finsh_get_password()) == 0) return; - + while (1) { rt_kprintf("Password for login: "); diff --git a/components/finsh/symbol.c b/components/finsh/symbol.c index 5aedd91d6..8e026c4a1 100644 --- a/components/finsh/symbol.c +++ b/components/finsh/symbol.c @@ -42,39 +42,39 @@ long list_mempool(void); long list_timer(void); #ifdef FINSH_USING_SYMTAB -struct finsh_syscall *_syscall_table_begin = NULL; -struct finsh_syscall *_syscall_table_end = NULL; -struct finsh_sysvar *_sysvar_table_begin = NULL; -struct finsh_sysvar *_sysvar_table_end = NULL; +struct finsh_syscall *_syscall_table_begin = NULL; +struct finsh_syscall *_syscall_table_end = NULL; +struct finsh_sysvar *_sysvar_table_begin = NULL; +struct finsh_sysvar *_sysvar_table_end = NULL; #else struct finsh_syscall _syscall_table[] = { - {"hello", hello}, - {"version", version}, - {"list", list}, - {"list_thread", list_thread}, + {"hello", hello}, + {"version", version}, + {"list", list}, + {"list_thread", list_thread}, #ifdef RT_USING_SEMAPHORE - {"list_sem", list_sem}, + {"list_sem", list_sem}, #endif #ifdef RT_USING_MUTEX - {"list_mutex", list_mutex}, + {"list_mutex", list_mutex}, #endif #ifdef RT_USING_FEVENT - {"list_fevent", list_fevent}, + {"list_fevent", list_fevent}, #endif #ifdef RT_USING_EVENT - {"list_event", list_event}, + {"list_event", list_event}, #endif #ifdef RT_USING_MAILBOX - {"list_mb", list_mailbox}, + {"list_mb", list_mailbox}, #endif #ifdef RT_USING_MESSAGEQUEUE - {"list_mq", list_msgqueue}, + {"list_mq", list_msgqueue}, #endif #ifdef RT_USING_MEMPOOL - {"list_memp", list_mempool}, + {"list_memp", list_mempool}, #endif - {"list_timer", list_timer}, + {"list_timer", list_timer}, }; struct finsh_syscall *_syscall_table_begin = &_syscall_table[0]; struct finsh_syscall *_syscall_table_end = &_syscall_table[sizeof(_syscall_table) / sizeof(struct finsh_syscall)]; diff --git a/include/rtthread.h b/include/rtthread.h index 7671c63cd..9378b83cf 100644 --- a/include/rtthread.h +++ b/include/rtthread.h @@ -564,7 +564,7 @@ void rt_assert_handler(const char *ex, const char *func, rt_size_t line); #endif /* RT_DEBUG */ #ifdef RT_USING_FINSH -#include +#include #endif /**@}*/