[finsh] convert tab to space and split export API to finsh_api.h

19 files changed, 2328 insertions, 2291 deletions

diff --git a/components/finsh/cmd.c b/components/finsh/cmd.c
index 9cd292d570..a1b04c38fa 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 2c7815522c..4452d4a0d6 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 <rtthread.h>
-
-#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 <stdint.h>
 #include <string.h>
 
-#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 0000000000..6bbe410b0b
--- /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 2515c03e83..962aee1ad3 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 28ca78bcfb..f2f4beb08d 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 f4a34791be..a2852092f9 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 184ac20d60..ae28a6ac81 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 722a368727..5e0e4a300c 100644
--- a/components/finsh/finsh_node.h
+++ b/components/finsh/finsh_node.h
@@ -31,46 +31,46 @@
 
 #include <finsh.h>
 
-#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 261c527556..cefdf3c252 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 c937e42472..aa85509162 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;
-			}
+            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:
+        default:
             if (is_base_type(token) || token == finsh_token_type_unsigned)
             {
-            	/* variable decl */
-            	finsh_token_replay(&(self->token));
+                /* 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;
-				}
+                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 */
+                /* process expr_statement */
                 finsh_token_replay(&(self->token));
 
-				if (self->root != NULL)
-				{
+                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 8b51c99941..a9fd0ac7d0 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<BN_SIZE ; j++) bn[j] = 0;
+    for ( j=0; j<BN_SIZE ; j++) bn[j] = 0;
 
-	while ( i<length )
-	{
-		t = *p++;
-		if ( t>='a' && t <='f' )
-		{
-			t = t - 'a' +10;
-		}
-		else if ( t >='A' && t <='F' )
-		{
-			t = t - 'A' +10;
-		}
-		else t = t - '0';
+    while ( i<length )
+    {
+        t = *p++;
+        if ( t>='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<BN_SIZE ; j++)
-		{
-			v = bn[j];
-			bn[j] = (v<<shift) | t;
-			t = v >> (32 - shift);
-		}
-		i++;
-	}
+        for ( j=0; j<BN_SIZE ; j++)
+        {
+            v = bn[j];
+            bn[j] = (v<<shift) | t;
+            t = v >> (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 57c002c3fb..fd7e2597cd 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 86a97559f1..7e39492644 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 d3b88fa53e..f8013ac9d3 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 49b1a3194b..8a3b8949e5 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 2401f7fe4a..478a757146 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 f184f1f33d..7e9fd68a5f 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 2a0637ec2c..fc13a92b13 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 5aedd91d61..8e026c4a1b 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)];