Skip to content

R
rt-thread

BaiXuePrincess / rt-thread
与 Fork 源项目一致

Fork自 RT-Thread / rt-thread

通知 1
Star 0
Fork 0
R
rt-thread
提交 6a624356 编写于 作者: B bernard
浏览文件
操作

[Finsh] code cleanup

上级 1f8a0668
隐藏空白更改
内联 并排
Showing with 876 addition and 904 deletion
components/finsh/finsh.h
浏览文件 @ 6a624356
...@@ -69,6 +69,8 @@ typedef unsigned long u_long; ...@@ -69,6 +69,8 @@ typedef unsigned long u_long;
!defined(__ADSPBLACKFIN__) && \ !defined(__ADSPBLACKFIN__) && \
!defined(_MSC_VER) !defined(_MSC_VER)
/* only for GNU GCC */
#if !(defined(__GNUC__) && defined(__x86_64__)) #if !(defined(__GNUC__) && defined(__x86_64__))
typedef unsigned int size_t; typedef unsigned int size_t;
#else #else
...@@ -79,13 +81,6 @@ typedef unsigned int size_t; ...@@ -79,13 +81,6 @@ typedef unsigned int size_t;
#define NULL RT_NULL #define NULL RT_NULL
#endif #endif
#define memset rt_memset
#define strlen rt_strlen
#define strncpy rt_strncpy
#define strncmp rt_strncmp
int strcmp (const char *s1, const char *s2);
char *strdup(const char *s);
#else #else
/* use libc of armcc */ /* use libc of armcc */
#include <ctype.h> #include <ctype.h>
...@@ -94,8 +89,8 @@ char *strdup(const char *s); ...@@ -94,8 +89,8 @@ char *strdup(const char *s);
#endif #endif
#endif #endif
#define FINSH_VERSION_MAJOR 0 #define FINSH_VERSION_MAJOR 1
#define FINSH_VERSION_MINOR 5 #define FINSH_VERSION_MINOR 0
/** /**
* @addtogroup finsh * @addtogroup finsh
......
components/finsh/finsh_compiler.c
浏览文件 @ 6a624356
...@@ -33,901 +33,904 @@ ...@@ -33,901 +33,904 @@
#include "finsh_var.h" #include "finsh_var.h"
#include "finsh_ops.h" #include "finsh_ops.h"
union finsh_value* finsh_compile_sp; /* stack pointer */ union finsh_value* finsh_compile_sp; /* stack pointer */
u_char* finsh_compile_pc; /* PC */ u_char* finsh_compile_pc; /* PC */
#define finsh_code_byte(x) do { *finsh_compile_pc = (x); finsh_compile_pc ++; } while(0) #define finsh_code_byte(x) do { *finsh_compile_pc = (x); finsh_compile_pc ++; } while(0)
#define finsh_code_word(x) do { FINSH_SET16(finsh_compile_pc, x); finsh_compile_pc +=2; } while(0) #define finsh_code_word(x) do { FINSH_SET16(finsh_compile_pc, x); finsh_compile_pc +=2; } while(0)
#define finsh_code_dword(x) do { FINSH_SET32(finsh_compile_pc, x); finsh_compile_pc +=4; } while(0) #define finsh_code_dword(x) do { FINSH_SET32(finsh_compile_pc, x); finsh_compile_pc +=4; } while(0)
static int finsh_compile(struct finsh_node* node) static int finsh_compile(struct finsh_node* node)
{ {
if (node != NULL) if (node != NULL)
{ {
/* compile child node */ /* compile child node */
if (finsh_node_child(node) != NULL) if (finsh_node_child(node) != NULL)
finsh_compile(finsh_node_child(node)); finsh_compile(finsh_node_child(node));
/* compile current node */ /* compile current node */
switch (node->node_type) switch (node->node_type)
{ {
case FINSH_NODE_ID: case FINSH_NODE_ID:
{ {
/* identifier::syscall */ /* identifier::syscall */
if (node->idtype & FINSH_IDTYPE_SYSCALL) if (node->idtype & FINSH_IDTYPE_SYSCALL)
{ {
/* load address */ /* load address */
finsh_code_byte(FINSH_OP_LD_DWORD); finsh_code_byte(FINSH_OP_LD_DWORD);
finsh_code_dword((long)node->id.syscall->func); finsh_code_dword((long)node->id.syscall->func);
} }
/* identifier::sysvar */ /* identifier::sysvar */
else if (node->idtype & FINSH_IDTYPE_SYSVAR) else if (node->idtype & FINSH_IDTYPE_SYSVAR)
{ {
struct finsh_sysvar* sysvar; struct finsh_sysvar* sysvar;
sysvar = node->id.sysvar; sysvar = node->id.sysvar;
if (sysvar != NULL) if (sysvar != NULL)
{ {
switch (sysvar->type) switch (sysvar->type)
{ {
case finsh_type_char: case finsh_type_char:
case finsh_type_uchar: case finsh_type_uchar:
if (node->idtype & FINSH_IDTYPE_ADDRESS) if (node->idtype & FINSH_IDTYPE_ADDRESS)
{ {
/* load address */ /* load address */
finsh_code_byte(FINSH_OP_LD_DWORD); finsh_code_byte(FINSH_OP_LD_DWORD);
} }
else else
{ {
/* load value */ /* load value */
finsh_code_byte(FINSH_OP_LD_VALUE_BYTE); finsh_code_byte(FINSH_OP_LD_VALUE_BYTE);
} }
finsh_code_dword((long)(sysvar->var)); finsh_code_dword((long)(sysvar->var));
break; break;
case finsh_type_short: case finsh_type_short:
case finsh_type_ushort: case finsh_type_ushort:
if (node->idtype & FINSH_IDTYPE_ADDRESS) if (node->idtype & FINSH_IDTYPE_ADDRESS)
{ {
/* load address */ /* load address */
finsh_code_byte(FINSH_OP_LD_DWORD); finsh_code_byte(FINSH_OP_LD_DWORD);
} }
else else
{ {
/* load value */ /* load value */
finsh_code_byte(FINSH_OP_LD_VALUE_WORD); finsh_code_byte(FINSH_OP_LD_VALUE_WORD);
} }
finsh_code_dword((long)(sysvar->var)); finsh_code_dword((long)(sysvar->var));
break; break;
case finsh_type_int: case finsh_type_int:
case finsh_type_uint: case finsh_type_uint:
case finsh_type_long: case finsh_type_long:
case finsh_type_ulong: case finsh_type_ulong:
case finsh_type_charp: case finsh_type_charp:
case finsh_type_shortp: case finsh_type_shortp:
case finsh_type_intp: case finsh_type_intp:
case finsh_type_longp: case finsh_type_longp:
if (node->idtype & FINSH_IDTYPE_ADDRESS) if (node->idtype & FINSH_IDTYPE_ADDRESS)
{ {
/* load address */ /* load address */
finsh_code_byte(FINSH_OP_LD_DWORD); finsh_code_byte(FINSH_OP_LD_DWORD);
} }
else else
{ {
/* load value */ /* load value */
finsh_code_byte(FINSH_OP_LD_VALUE_DWORD); finsh_code_byte(FINSH_OP_LD_VALUE_DWORD);
} }
finsh_code_dword((long)(sysvar->var)); finsh_code_dword((long)(sysvar->var));
break; break;
} }
} }
} }
/* identifier::var */ /* identifier::var */
else else
{ {
struct finsh_var* var; struct finsh_var* var;
var = node->id.var; var = node->id.var;
if (var != NULL) if (var != NULL)
{ {
switch (var->type) switch (var->type)
{ {
case finsh_type_char: case finsh_type_char:
case finsh_type_uchar: case finsh_type_uchar:
if (node->idtype & FINSH_IDTYPE_ADDRESS) if (node->idtype & FINSH_IDTYPE_ADDRESS)
{ {
/* load address */ /* load address */
finsh_code_byte(FINSH_OP_LD_DWORD); finsh_code_byte(FINSH_OP_LD_DWORD);
} }
else else
{ {
/* load value */ /* load value */
finsh_code_byte(FINSH_OP_LD_VALUE_BYTE); finsh_code_byte(FINSH_OP_LD_VALUE_BYTE);
} }
finsh_code_dword((long)&(var->value.char_value)); finsh_code_dword((long)&(var->value.char_value));
break; break;
case finsh_type_short: case finsh_type_short:
case finsh_type_ushort: case finsh_type_ushort:
if (node->idtype & FINSH_IDTYPE_ADDRESS) if (node->idtype & FINSH_IDTYPE_ADDRESS)
{ {
/* load address */ /* load address */
finsh_code_byte(FINSH_OP_LD_DWORD); finsh_code_byte(FINSH_OP_LD_DWORD);
} }
else else
{ {
/* load value */ /* load value */
finsh_code_byte(FINSH_OP_LD_VALUE_WORD); finsh_code_byte(FINSH_OP_LD_VALUE_WORD);
} }
finsh_code_dword((long)&(var->value.short_value)); finsh_code_dword((long)&(var->value.short_value));
break; break;
case finsh_type_int: case finsh_type_int:
case finsh_type_uint: case finsh_type_uint:
case finsh_type_long: case finsh_type_long:
case finsh_type_ulong: case finsh_type_ulong:
case finsh_type_charp: case finsh_type_charp:
case finsh_type_shortp: case finsh_type_shortp:
case finsh_type_intp: case finsh_type_intp:
case finsh_type_longp: case finsh_type_longp:
if (node->idtype & FINSH_IDTYPE_ADDRESS) if (node->idtype & FINSH_IDTYPE_ADDRESS)
{ {
/* load address */ /* load address */
finsh_code_byte(FINSH_OP_LD_DWORD); finsh_code_byte(FINSH_OP_LD_DWORD);
} }
else else
{ {
/* load value */ /* load value */
finsh_code_byte(FINSH_OP_LD_VALUE_DWORD); finsh_code_byte(FINSH_OP_LD_VALUE_DWORD);
} }
finsh_code_dword((long)&(var->value.long_value)); finsh_code_dword((long)&(var->value.long_value));
break; break;
} }
} }
} }
} }
break; break;
/* load const */ /* load const */
case FINSH_NODE_VALUE_CHAR: case FINSH_NODE_VALUE_CHAR:
finsh_code_byte(FINSH_OP_LD_BYTE); finsh_code_byte(FINSH_OP_LD_BYTE);
finsh_code_byte(node->value.char_value); finsh_code_byte(node->value.char_value);
break; break;
case FINSH_NODE_VALUE_INT: case FINSH_NODE_VALUE_INT:
case FINSH_NODE_VALUE_LONG: case FINSH_NODE_VALUE_LONG:
finsh_code_byte(FINSH_OP_LD_DWORD); finsh_code_byte(FINSH_OP_LD_DWORD);
finsh_code_dword(node->value.long_value); finsh_code_dword(node->value.long_value);
break; break;
case FINSH_NODE_VALUE_NULL: case FINSH_NODE_VALUE_NULL:
case FINSH_NODE_VALUE_STRING: case FINSH_NODE_VALUE_STRING:
finsh_code_byte(FINSH_OP_LD_DWORD); finsh_code_byte(FINSH_OP_LD_DWORD);
finsh_code_dword((u_long)node->value.ptr); finsh_code_dword((u_long)node->value.ptr);
break; break;
/* arithmetic operation */ /* arithmetic operation */
case FINSH_NODE_SYS_ADD: case FINSH_NODE_SYS_ADD:
if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_ADD_BYTE); if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_ADD_BYTE);
else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_ADD_WORD); else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_ADD_WORD);
else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_ADD_DWORD); else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_ADD_DWORD);
break; break;
case FINSH_NODE_SYS_SUB: case FINSH_NODE_SYS_SUB:
if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_SUB_BYTE); if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_SUB_BYTE);
else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_SUB_WORD); else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_SUB_WORD);
else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_SUB_DWORD); else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_SUB_DWORD);
break; break;
case FINSH_NODE_SYS_MUL: case FINSH_NODE_SYS_MUL:
if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_MUL_BYTE); if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_MUL_BYTE);
else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_MUL_WORD); else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_MUL_WORD);
else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_MUL_DWORD); else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_MUL_DWORD);
break; break;
case FINSH_NODE_SYS_DIV: case FINSH_NODE_SYS_DIV:
if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_DIV_BYTE); if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_DIV_BYTE);
else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_DIV_WORD); else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_DIV_WORD);
else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_DIV_DWORD); else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_DIV_DWORD);
break; break;
case FINSH_NODE_SYS_MOD: case FINSH_NODE_SYS_MOD:
if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_MOD_BYTE); if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_MOD_BYTE);
else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_MOD_WORD); else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_MOD_WORD);
else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_MOD_DWORD); else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_MOD_DWORD);
break; break;
/* bit operation */ /* bit operation */
case FINSH_NODE_SYS_AND: case FINSH_NODE_SYS_AND:
if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_AND_BYTE); if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_AND_BYTE);
else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_AND_WORD); else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_AND_WORD);
else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_AND_DWORD); else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_AND_DWORD);
break; break;
case FINSH_NODE_SYS_OR: case FINSH_NODE_SYS_OR:
if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_OR_BYTE); if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_OR_BYTE);
else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_OR_WORD); else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_OR_WORD);
else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_OR_DWORD); else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_OR_DWORD);
break; break;
case FINSH_NODE_SYS_XOR: case FINSH_NODE_SYS_XOR:
if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_XOR_BYTE); if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_XOR_BYTE);
else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_XOR_WORD); else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_XOR_WORD);
else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_XOR_DWORD); else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_XOR_DWORD);
break; break;
case FINSH_NODE_SYS_BITWISE: case FINSH_NODE_SYS_BITWISE:
if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_BITWISE_BYTE); if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_BITWISE_BYTE);
else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_BITWISE_WORD); else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_BITWISE_WORD);
else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_BITWISE_DWORD); else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_BITWISE_DWORD);
break; break;
case FINSH_NODE_SYS_SHL: case FINSH_NODE_SYS_SHL:
if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_SHL_BYTE); if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_SHL_BYTE);
else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_SHL_WORD); else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_SHL_WORD);
else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_SHL_DWORD); else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_SHL_DWORD);
break; break;
case FINSH_NODE_SYS_SHR: case FINSH_NODE_SYS_SHR:
if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_SHR_BYTE); if (node->data_type == FINSH_DATA_TYPE_BYTE) finsh_code_byte(FINSH_OP_SHR_BYTE);
else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_SHR_WORD); else if (node->data_type == FINSH_DATA_TYPE_WORD) finsh_code_byte(FINSH_OP_SHR_WORD);
else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_SHR_DWORD); else if (node->data_type == FINSH_DATA_TYPE_DWORD) finsh_code_byte(FINSH_OP_SHR_DWORD);
break; break;
/* syscall */ /* syscall */
case FINSH_NODE_SYS_FUNC: case FINSH_NODE_SYS_FUNC:
{ {
int parameters; int parameters;
struct finsh_node* sibling; struct finsh_node* sibling;
parameters = 0; parameters = 0;
sibling = finsh_node_sibling(finsh_node_child(node)); if (finsh_node_child(node) != NULL)
while (sibling != NULL) {
{ sibling = finsh_node_sibling(finsh_node_child(node));
parameters ++; while (sibling != NULL)
sibling = finsh_node_sibling(sibling); {
} parameters ++;
sibling = finsh_node_sibling(sibling);
/* load address of function */ }
// finsh_code_dword((long)&(node->var->value.ptr));
/* load address of function */
/* syscall parameters */ // finsh_code_dword((long)&(node->var->value.ptr));
finsh_code_byte(FINSH_OP_SYSCALL);
finsh_code_byte(parameters); /* syscall parameters */
} finsh_code_byte(FINSH_OP_SYSCALL);
break; finsh_code_byte(parameters);
}
/* assign expression */ }
case FINSH_NODE_SYS_ASSIGN: break;
if (finsh_node_child(node)->node_type == FINSH_NODE_ID)
{ /* assign expression */
switch (finsh_node_child(node)->data_type) case FINSH_NODE_SYS_ASSIGN:
{ if (finsh_node_child(node) && finsh_node_child(node)->node_type == FINSH_NODE_ID)
case FINSH_DATA_TYPE_BYTE: {
finsh_code_byte(FINSH_OP_ST_BYTE); switch (finsh_node_child(node)->data_type)
{
/* load value again */ case FINSH_DATA_TYPE_BYTE:
finsh_code_byte(FINSH_OP_LD_VALUE_BYTE_STACK); finsh_code_byte(FINSH_OP_ST_BYTE);
break;
/* load value again */
case FINSH_DATA_TYPE_WORD: finsh_code_byte(FINSH_OP_LD_VALUE_BYTE_STACK);
finsh_code_byte(FINSH_OP_ST_WORD); break;
/* load value again */ case FINSH_DATA_TYPE_WORD:
finsh_code_byte(FINSH_OP_LD_VALUE_WORD_STACK); finsh_code_byte(FINSH_OP_ST_WORD);
break;
/* load value again */
case FINSH_DATA_TYPE_DWORD: finsh_code_byte(FINSH_OP_LD_VALUE_WORD_STACK);
finsh_code_byte(FINSH_OP_ST_DWORD); break;
/* load value again */ case FINSH_DATA_TYPE_DWORD:
finsh_code_byte(FINSH_OP_LD_VALUE_DWORD_STACK); finsh_code_byte(FINSH_OP_ST_DWORD);
break;
/* load value again */
default: finsh_code_byte(FINSH_OP_LD_VALUE_DWORD_STACK);
finsh_error_set(FINSH_ERROR_UNKNOWN_TYPE); break;
}
} default:
else if (finsh_node_child(node)->node_type == FINSH_NODE_SYS_GETVALUE) finsh_error_set(FINSH_ERROR_UNKNOWN_TYPE);
{ }
switch ((finsh_node_child(node)->data_type) & 0x0F) }
{ else if (finsh_node_child(node)->node_type == FINSH_NODE_SYS_GETVALUE)
case FINSH_DATA_TYPE_BYTE: {
finsh_code_byte(FINSH_OP_ST_BYTE); switch ((finsh_node_child(node)->data_type) & 0x0F)
{
/* load value again */ case FINSH_DATA_TYPE_BYTE:
finsh_code_byte(FINSH_OP_LD_VALUE_BYTE_STACK); finsh_code_byte(FINSH_OP_ST_BYTE);
break;
/* load value again */
case FINSH_DATA_TYPE_WORD: finsh_code_byte(FINSH_OP_LD_VALUE_BYTE_STACK);
finsh_code_byte(FINSH_OP_ST_WORD); break;
/* load value again */ case FINSH_DATA_TYPE_WORD:
finsh_code_byte(FINSH_OP_LD_VALUE_WORD_STACK); finsh_code_byte(FINSH_OP_ST_WORD);
break;
/* load value again */
case FINSH_DATA_TYPE_DWORD: finsh_code_byte(FINSH_OP_LD_VALUE_WORD_STACK);
finsh_code_byte(FINSH_OP_ST_DWORD); break;
/* load value again */ case FINSH_DATA_TYPE_DWORD:
finsh_code_byte(FINSH_OP_LD_VALUE_DWORD_STACK); finsh_code_byte(FINSH_OP_ST_DWORD);
break;
/* load value again */
default: finsh_code_byte(FINSH_OP_LD_VALUE_DWORD_STACK);
finsh_error_set(FINSH_ERROR_UNKNOWN_TYPE); break;
}
} default:
break; finsh_error_set(FINSH_ERROR_UNKNOWN_TYPE);
}
/* pre-increase */ }
case FINSH_NODE_SYS_PREINC: break;
if (finsh_node_child(node)->node_type == FINSH_NODE_ID)
{ /* pre-increase */
struct finsh_var* var; case FINSH_NODE_SYS_PREINC:
var = finsh_node_child(node)->id.var; if (finsh_node_child(node) && finsh_node_child(node)->node_type == FINSH_NODE_ID)
{
/* ld_dword &id */ struct finsh_var* var;
// finsh_code_byte(FINSH_OP_LD_DWORD); var = finsh_node_child(node)->id.var;
switch (node->data_type) /* ld_dword &id */
{ // finsh_code_byte(FINSH_OP_LD_DWORD);
case FINSH_DATA_TYPE_BYTE:
/* address */ switch (node->data_type)
// finsh_code_dword((long)&(var->value.char_value)); {
case FINSH_DATA_TYPE_BYTE:
/* ld_value_byte &id */ /* address */
finsh_code_byte(FINSH_OP_LD_VALUE_BYTE); // finsh_code_dword((long)&(var->value.char_value));
finsh_code_dword((long)&(var->value.char_value));
/* ld_value_byte &id */
/* ld_byte 1 */ finsh_code_byte(FINSH_OP_LD_VALUE_BYTE);
finsh_code_byte(FINSH_OP_LD_BYTE); finsh_code_dword((long)&(var->value.char_value));
finsh_code_byte(1);
/* ld_byte 1 */
/* add_byte */ finsh_code_byte(FINSH_OP_LD_BYTE);
finsh_code_byte(FINSH_OP_ADD_BYTE); finsh_code_byte(1);
/* st_byte */
finsh_code_byte(FINSH_OP_ST_BYTE); /* add_byte */
finsh_code_byte(FINSH_OP_ADD_BYTE);
/* load value again */ /* st_byte */
finsh_code_byte(FINSH_OP_LD_VALUE_DWORD_STACK); finsh_code_byte(FINSH_OP_ST_BYTE);
break; /* load value again */
finsh_code_byte(FINSH_OP_LD_VALUE_DWORD_STACK);
case FINSH_DATA_TYPE_WORD:
/* address */ break;
// finsh_code_dword((long)&(var->value.short_value));
case FINSH_DATA_TYPE_WORD:
/* ld_value_word &id */ /* address */
finsh_code_byte(FINSH_OP_LD_VALUE_WORD); // finsh_code_dword((long)&(var->value.short_value));
finsh_code_dword((long)&(var->value.short_value));
/* ld_value_word &id */
/* ld_word 1 */ finsh_code_byte(FINSH_OP_LD_VALUE_WORD);
finsh_code_byte(FINSH_OP_LD_WORD); finsh_code_dword((long)&(var->value.short_value));
finsh_code_word(1);
/* ld_word 1 */
/* add_word */ finsh_code_byte(FINSH_OP_LD_WORD);
finsh_code_byte(FINSH_OP_ADD_WORD); finsh_code_word(1);
/* st_word */
finsh_code_byte(FINSH_OP_ST_WORD); /* add_word */
finsh_code_byte(FINSH_OP_ADD_WORD);
/* load value again */ /* st_word */
finsh_code_byte(FINSH_OP_LD_VALUE_DWORD_STACK); finsh_code_byte(FINSH_OP_ST_WORD);
break; /* load value again */
finsh_code_byte(FINSH_OP_LD_VALUE_DWORD_STACK);
case FINSH_DATA_TYPE_DWORD:
/* address */ break;
// finsh_code_dword((long)&(var->value.long_value));
case FINSH_DATA_TYPE_DWORD:
/* ld_dword &id */ /* address */
finsh_code_byte(FINSH_OP_LD_VALUE_DWORD); // finsh_code_dword((long)&(var->value.long_value));
finsh_code_dword((long)&(var->value.long_value));
/* ld_dword &id */
/* ld_dword 1 */ finsh_code_byte(FINSH_OP_LD_VALUE_DWORD);
finsh_code_byte(FINSH_OP_LD_DWORD); finsh_code_dword((long)&(var->value.long_value));
finsh_code_dword(1);
/* ld_dword 1 */
/* add_dword */ finsh_code_byte(FINSH_OP_LD_DWORD);
finsh_code_byte(FINSH_OP_ADD_DWORD); finsh_code_dword(1);
/* st_dword */
finsh_code_byte(FINSH_OP_ST_DWORD); /* add_dword */
finsh_code_byte(FINSH_OP_ADD_DWORD);
/* load value again */ /* st_dword */
finsh_code_byte(FINSH_OP_LD_VALUE_DWORD_STACK); finsh_code_byte(FINSH_OP_ST_DWORD);
break; /* load value again */
} finsh_code_byte(FINSH_OP_LD_VALUE_DWORD_STACK);
}
break; break;
}
/* pre-decrease */ }
case FINSH_NODE_SYS_PREDEC: break;
if (finsh_node_child(node)->node_type == FINSH_NODE_ID)
{ /* pre-decrease */
struct finsh_var* var; case FINSH_NODE_SYS_PREDEC:
var = finsh_node_child(node)->id.var; if (finsh_node_child(node) && finsh_node_child(node)->node_type == FINSH_NODE_ID)
{
/* ld_dword &id */ struct finsh_var* var;
// finsh_code_byte(FINSH_OP_LD_DWORD); var = finsh_node_child(node)->id.var;
switch (node->data_type) /* ld_dword &id */
{ // finsh_code_byte(FINSH_OP_LD_DWORD);
case FINSH_DATA_TYPE_BYTE:
/* address */ switch (node->data_type)
// finsh_code_dword((long)&(var->value.char_value)); {
case FINSH_DATA_TYPE_BYTE:
/* ld_value_byte &id */ /* address */
finsh_code_byte(FINSH_OP_LD_VALUE_BYTE); // finsh_code_dword((long)&(var->value.char_value));
finsh_code_dword((long)&(var->value.char_value));
/* ld_value_byte &id */
/* ld_byte 1 */ finsh_code_byte(FINSH_OP_LD_VALUE_BYTE);
finsh_code_byte(FINSH_OP_LD_BYTE); finsh_code_dword((long)&(var->value.char_value));
finsh_code_byte(1);
/* ld_byte 1 */
/* add_byte */ finsh_code_byte(FINSH_OP_LD_BYTE);
finsh_code_byte(FINSH_OP_SUB_BYTE); finsh_code_byte(1);
/* st_byte */
finsh_code_byte(FINSH_OP_ST_BYTE); /* add_byte */
finsh_code_byte(FINSH_OP_SUB_BYTE);
/* load value again */ /* st_byte */
finsh_code_byte(FINSH_OP_LD_VALUE_DWORD_STACK); finsh_code_byte(FINSH_OP_ST_BYTE);
break; /* load value again */
finsh_code_byte(FINSH_OP_LD_VALUE_DWORD_STACK);
case FINSH_DATA_TYPE_WORD:
/* address */ break;
// finsh_code_dword((long)&(var->value.short_value));
case FINSH_DATA_TYPE_WORD:
/* ld_value_word &id */ /* address */
finsh_code_byte(FINSH_OP_LD_VALUE_WORD); // finsh_code_dword((long)&(var->value.short_value));
finsh_code_dword((long)&(var->value.short_value));
/* ld_value_word &id */
/* ld_word 1 */ finsh_code_byte(FINSH_OP_LD_VALUE_WORD);
finsh_code_byte(FINSH_OP_LD_WORD); finsh_code_dword((long)&(var->value.short_value));
finsh_code_word(1);
/* ld_word 1 */
/* add_word */ finsh_code_byte(FINSH_OP_LD_WORD);
finsh_code_byte(FINSH_OP_SUB_WORD); finsh_code_word(1);
/* st_word */
finsh_code_byte(FINSH_OP_ST_WORD); /* add_word */
finsh_code_byte(FINSH_OP_SUB_WORD);
/* load value again */ /* st_word */
finsh_code_byte(FINSH_OP_LD_VALUE_DWORD_STACK); finsh_code_byte(FINSH_OP_ST_WORD);
break; /* load value again */
finsh_code_byte(FINSH_OP_LD_VALUE_DWORD_STACK);
case FINSH_DATA_TYPE_DWORD:
/* address */ break;
// finsh_code_dword((long)&(var->value.long_value));
case FINSH_DATA_TYPE_DWORD:
/* ld_dword &id */ /* address */
finsh_code_byte(FINSH_OP_LD_VALUE_DWORD); // finsh_code_dword((long)&(var->value.long_value));
finsh_code_dword((long)&(var->value.long_value));
/* ld_dword &id */
/* ld_dword 1 */ finsh_code_byte(FINSH_OP_LD_VALUE_DWORD);
finsh_code_byte(FINSH_OP_LD_DWORD); finsh_code_dword((long)&(var->value.long_value));
finsh_code_dword(1);
/* ld_dword 1 */
/* add_dword */ finsh_code_byte(FINSH_OP_LD_DWORD);
finsh_code_byte(FINSH_OP_SUB_DWORD); finsh_code_dword(1);
/* st_dword */
finsh_code_byte(FINSH_OP_ST_DWORD); /* add_dword */
finsh_code_byte(FINSH_OP_SUB_DWORD);
/* load value again */ /* st_dword */
finsh_code_byte(FINSH_OP_LD_VALUE_DWORD_STACK); finsh_code_byte(FINSH_OP_ST_DWORD);
break; /* load value again */
} finsh_code_byte(FINSH_OP_LD_VALUE_DWORD_STACK);
}
break; break;
}
/* increase */ }
case FINSH_NODE_SYS_INC: break;
if (finsh_node_child(node)->node_type == FINSH_NODE_ID)
{ /* increase */
struct finsh_var* var; case FINSH_NODE_SYS_INC:
var = finsh_node_child(node)->id.var; if (finsh_node_child(node) && finsh_node_child(node)->node_type == FINSH_NODE_ID)
{
switch (node->data_type) struct finsh_var* var;
{ var = finsh_node_child(node)->id.var;
case FINSH_DATA_TYPE_BYTE:
/* ld_value_byte &id */ switch (node->data_type)
// finsh_code_byte(FINSH_OP_LD_VALUE_BYTE); {
// finsh_code_dword((long)&(var->value.char_value)); case FINSH_DATA_TYPE_BYTE:
/* ld_value_byte &id */
/* ld_dword &id */ // finsh_code_byte(FINSH_OP_LD_VALUE_BYTE);
finsh_code_byte(FINSH_OP_LD_DWORD); // finsh_code_dword((long)&(var->value.char_value));
finsh_code_dword((long)&(var->value.char_value));
/* ld_dword &id */
/* ld_value_byte &id */ finsh_code_byte(FINSH_OP_LD_DWORD);
finsh_code_byte(FINSH_OP_LD_VALUE_BYTE); finsh_code_dword((long)&(var->value.char_value));
finsh_code_dword((long)&(var->value.char_value));
/* ld_value_byte &id */
/* ld_byte 1 */ finsh_code_byte(FINSH_OP_LD_VALUE_BYTE);
finsh_code_byte(FINSH_OP_LD_BYTE); finsh_code_dword((long)&(var->value.char_value));
finsh_code_byte(1);
/* ld_byte 1 */
/* add_byte */ finsh_code_byte(FINSH_OP_LD_BYTE);
finsh_code_byte(FINSH_OP_ADD_BYTE); finsh_code_byte(1);
/* get byte */
finsh_code_byte(FINSH_OP_ST_BYTE); /* add_byte */
finsh_code_byte(FINSH_OP_ADD_BYTE);
/* pop */ /* get byte */
finsh_code_byte(FINSH_OP_POP); finsh_code_byte(FINSH_OP_ST_BYTE);
break;
/* pop */
case FINSH_DATA_TYPE_WORD: finsh_code_byte(FINSH_OP_POP);
/* ld_value_word &id */ break;
// finsh_code_byte(FINSH_OP_LD_VALUE_WORD);
// finsh_code_dword((long)&(var->value.short_value)); case FINSH_DATA_TYPE_WORD:
/* ld_value_word &id */
/* ld_dword &id */ // finsh_code_byte(FINSH_OP_LD_VALUE_WORD);
finsh_code_byte(FINSH_OP_LD_DWORD); // finsh_code_dword((long)&(var->value.short_value));
finsh_code_dword((long)&(var->value.short_value));
/* ld_dword &id */
/* ld_value_word &id */ finsh_code_byte(FINSH_OP_LD_DWORD);
finsh_code_byte(FINSH_OP_LD_VALUE_WORD); finsh_code_dword((long)&(var->value.short_value));
finsh_code_dword((long)&(var->value.short_value));
/* ld_value_word &id */
/* ld_word 1 */ finsh_code_byte(FINSH_OP_LD_VALUE_WORD);
finsh_code_byte(FINSH_OP_LD_WORD); finsh_code_dword((long)&(var->value.short_value));
finsh_code_word(1);
/* ld_word 1 */
/* add_byte */ finsh_code_byte(FINSH_OP_LD_WORD);
finsh_code_byte(FINSH_OP_ADD_WORD); finsh_code_word(1);
/* get byte */
finsh_code_byte(FINSH_OP_ST_WORD); /* add_byte */
finsh_code_byte(FINSH_OP_ADD_WORD);
/* pop */ /* get byte */
finsh_code_byte(FINSH_OP_POP); finsh_code_byte(FINSH_OP_ST_WORD);
break;
/* pop */
case FINSH_DATA_TYPE_DWORD: finsh_code_byte(FINSH_OP_POP);
/* ld_value_dword &id */ break;
// finsh_code_byte(FINSH_OP_LD_VALUE_DWORD);
// finsh_code_dword((long)&(var->value.long_value)); case FINSH_DATA_TYPE_DWORD:
/* ld_value_dword &id */
/* ld_dword &id */ // finsh_code_byte(FINSH_OP_LD_VALUE_DWORD);
finsh_code_byte(FINSH_OP_LD_DWORD); // finsh_code_dword((long)&(var->value.long_value));
finsh_code_dword((long)&(var->value.long_value));
/* ld_dword &id */
/* ld_value_dword &id */ finsh_code_byte(FINSH_OP_LD_DWORD);
finsh_code_byte(FINSH_OP_LD_VALUE_DWORD); finsh_code_dword((long)&(var->value.long_value));
finsh_code_dword((long)&(var->value.long_value));
/* ld_value_dword &id */
/* ld_dword 1 */ finsh_code_byte(FINSH_OP_LD_VALUE_DWORD);
finsh_code_byte(FINSH_OP_LD_DWORD); finsh_code_dword((long)&(var->value.long_value));
finsh_code_dword(1);
/* ld_dword 1 */
/* add_byte */ finsh_code_byte(FINSH_OP_LD_DWORD);
finsh_code_byte(FINSH_OP_ADD_DWORD); finsh_code_dword(1);
/* get byte */
finsh_code_byte(FINSH_OP_ST_DWORD); /* add_byte */
finsh_code_byte(FINSH_OP_ADD_DWORD);
/* pop */ /* get byte */
finsh_code_byte(FINSH_OP_POP); finsh_code_byte(FINSH_OP_ST_DWORD);
break;
} /* pop */
} finsh_code_byte(FINSH_OP_POP);
break; break;
}
/* decrease */ }
case FINSH_NODE_SYS_DEC: break;
if (finsh_node_child(node)->node_type == FINSH_NODE_ID)
{ /* decrease */
struct finsh_var* var; case FINSH_NODE_SYS_DEC:
var = finsh_node_child(node)->id.var; if (finsh_node_child(node) && finsh_node_child(node)->node_type == FINSH_NODE_ID)
{
switch (node->data_type) struct finsh_var* var;
{ var = finsh_node_child(node)->id.var;
case FINSH_DATA_TYPE_BYTE:
/* ld_value_byte &id */ switch (node->data_type)
// finsh_code_byte(FINSH_OP_LD_VALUE_BYTE); {
// finsh_code_dword((long)&(var->value.char_value)); case FINSH_DATA_TYPE_BYTE:
/* ld_value_byte &id */
/* ld_dword &id */ // finsh_code_byte(FINSH_OP_LD_VALUE_BYTE);
finsh_code_byte(FINSH_OP_LD_DWORD); // finsh_code_dword((long)&(var->value.char_value));
finsh_code_dword((long)&(var->value.char_value));
/* ld_dword &id */
/* ld_value_byte &id */ finsh_code_byte(FINSH_OP_LD_DWORD);
finsh_code_byte(FINSH_OP_LD_VALUE_BYTE); finsh_code_dword((long)&(var->value.char_value));
finsh_code_dword((long)&(var->value.char_value));
/* ld_value_byte &id */
/* ld_byte 1 */ finsh_code_byte(FINSH_OP_LD_VALUE_BYTE);
finsh_code_byte(FINSH_OP_LD_BYTE); finsh_code_dword((long)&(var->value.char_value));
finsh_code_byte(1);
/* ld_byte 1 */
/* add_byte */ finsh_code_byte(FINSH_OP_LD_BYTE);
finsh_code_byte(FINSH_OP_SUB_BYTE); finsh_code_byte(1);
/* get byte */
finsh_code_byte(FINSH_OP_ST_BYTE); /* add_byte */
finsh_code_byte(FINSH_OP_SUB_BYTE);
/* pop */ /* get byte */
finsh_code_byte(FINSH_OP_POP); finsh_code_byte(FINSH_OP_ST_BYTE);
break;
/* pop */
case FINSH_DATA_TYPE_WORD: finsh_code_byte(FINSH_OP_POP);
/* ld_value_word &id */ break;
// finsh_code_byte(FINSH_OP_LD_VALUE_WORD);
// finsh_code_dword((long)&(var->value.short_value)); case FINSH_DATA_TYPE_WORD:
/* ld_value_word &id */
/* ld_dword &id */ // finsh_code_byte(FINSH_OP_LD_VALUE_WORD);
finsh_code_byte(FINSH_OP_LD_DWORD); // finsh_code_dword((long)&(var->value.short_value));
finsh_code_dword((long)&(var->value.short_value));
/* ld_dword &id */
/* ld_value_word &id */ finsh_code_byte(FINSH_OP_LD_DWORD);
finsh_code_byte(FINSH_OP_LD_VALUE_WORD); finsh_code_dword((long)&(var->value.short_value));
finsh_code_dword((long)&(var->value.short_value));
/* ld_value_word &id */
/* ld_word 1 */ finsh_code_byte(FINSH_OP_LD_VALUE_WORD);
finsh_code_byte(FINSH_OP_LD_WORD); finsh_code_dword((long)&(var->value.short_value));
finsh_code_word(1);
/* ld_word 1 */
/* add_byte */ finsh_code_byte(FINSH_OP_LD_WORD);
finsh_code_byte(FINSH_OP_SUB_WORD); finsh_code_word(1);
/* get byte */
finsh_code_byte(FINSH_OP_ST_WORD); /* add_byte */
finsh_code_byte(FINSH_OP_SUB_WORD);
/* pop */ /* get byte */
finsh_code_byte(FINSH_OP_POP); finsh_code_byte(FINSH_OP_ST_WORD);
break;
/* pop */
case FINSH_DATA_TYPE_DWORD: finsh_code_byte(FINSH_OP_POP);
/* ld_value_dword &id */ break;
// finsh_code_byte(FINSH_OP_LD_VALUE_DWORD);
// finsh_code_dword((long)&(var->value.long_value)); case FINSH_DATA_TYPE_DWORD:
/* ld_value_dword &id */
/* ld_dword &id */ // finsh_code_byte(FINSH_OP_LD_VALUE_DWORD);
finsh_code_byte(FINSH_OP_LD_DWORD); // finsh_code_dword((long)&(var->value.long_value));
finsh_code_dword((long)&(var->value.long_value));
/* ld_dword &id */
/* ld_value_dword &id */ finsh_code_byte(FINSH_OP_LD_DWORD);
finsh_code_byte(FINSH_OP_LD_VALUE_DWORD); finsh_code_dword((long)&(var->value.long_value));
finsh_code_dword((long)&(var->value.long_value));
/* ld_value_dword &id */
/* ld_dword 1 */ finsh_code_byte(FINSH_OP_LD_VALUE_DWORD);
finsh_code_byte(FINSH_OP_LD_DWORD); finsh_code_dword((long)&(var->value.long_value));
finsh_code_dword(1);
/* ld_dword 1 */
/* add_byte */ finsh_code_byte(FINSH_OP_LD_DWORD);
finsh_code_byte(FINSH_OP_SUB_DWORD); finsh_code_dword(1);
/* get byte */
finsh_code_byte(FINSH_OP_ST_DWORD); /* add_byte */
finsh_code_byte(FINSH_OP_SUB_DWORD);
/* pop */ /* get byte */
finsh_code_byte(FINSH_OP_POP); finsh_code_byte(FINSH_OP_ST_DWORD);
break;
} /* pop */
} finsh_code_byte(FINSH_OP_POP);
break; break;
}
case FINSH_NODE_SYS_NULL: }
finsh_code_dword(0); break;
break;
case FINSH_NODE_SYS_NULL:
case FINSH_NODE_SYS_GETVALUE: finsh_code_dword(0);
if (node->idtype & FINSH_IDTYPE_ADDRESS) break;
{
/* nothing will be generated */ case FINSH_NODE_SYS_GETVALUE:
} if (node->idtype & FINSH_IDTYPE_ADDRESS)
else {
{ /* nothing will be generated */
switch (node->data_type) }
{ else
case FINSH_DATA_TYPE_BYTE: {
finsh_code_byte(FINSH_OP_LD_VALUE_BYTE_STACK); switch (node->data_type)
break; {
case FINSH_DATA_TYPE_WORD: case FINSH_DATA_TYPE_BYTE:
finsh_code_byte(FINSH_OP_LD_VALUE_WORD_STACK); finsh_code_byte(FINSH_OP_LD_VALUE_BYTE_STACK);
break; break;
case FINSH_DATA_TYPE_DWORD: case FINSH_DATA_TYPE_WORD:
finsh_code_byte(FINSH_OP_LD_VALUE_DWORD_STACK); finsh_code_byte(FINSH_OP_LD_VALUE_WORD_STACK);
break; break;
default: case FINSH_DATA_TYPE_DWORD:
break; finsh_code_byte(FINSH_OP_LD_VALUE_DWORD_STACK);
} break;
} default:
break; break;
}
case FINSH_NODE_SYS_GETADDR: }
/* nothing will be generated */ break;
break;
case FINSH_NODE_SYS_GETADDR:
default: /* nothing will be generated */
finsh_error_set(FINSH_ERROR_UNKNOWN_NODE); break;
break;
} default:
finsh_error_set(FINSH_ERROR_UNKNOWN_NODE);
/* compile sibling node */ break;
if (finsh_node_sibling(node) != NULL) }
/* compile sibling node */
if (finsh_node_sibling(node) != NULL)
finsh_compile(finsh_node_sibling(node)); finsh_compile(finsh_node_sibling(node));
} }
return 0; return 0;
} }
static int finsh_type_check(struct finsh_node* node, u_char is_addr) static int finsh_type_check(struct finsh_node* node, u_char is_addr)
{ {
if (node != NULL) if (node != NULL)
{ {
/* address & value */ /* address & value */
if (node->node_type == FINSH_NODE_SYS_ASSIGN || if (node->node_type == FINSH_NODE_SYS_ASSIGN ||
node->node_type == FINSH_NODE_SYS_PREINC || node->node_type == FINSH_NODE_SYS_PREINC ||
node->node_type == FINSH_NODE_SYS_PREDEC || node->node_type == FINSH_NODE_SYS_PREDEC ||
node->node_type == FINSH_NODE_SYS_GETADDR) node->node_type == FINSH_NODE_SYS_GETADDR)
{ {
/* address */ /* address */
finsh_type_check(finsh_node_child(node), FINSH_IDTYPE_ADDRESS); finsh_type_check(finsh_node_child(node), FINSH_IDTYPE_ADDRESS);
} }
else if (node->node_type == FINSH_NODE_SYS_GETVALUE && is_addr) else if (node->node_type == FINSH_NODE_SYS_GETVALUE && is_addr)
{ {
/* change the attribute of getvalue in left expr */ /* change the attribute of getvalue in left expr */
finsh_type_check(finsh_node_child(node), 0); finsh_type_check(finsh_node_child(node), 0);
} }
else else
{ {
/* transfer 'av' to child node */ /* transfer 'av' to child node */
finsh_type_check(finsh_node_child(node), is_addr); finsh_type_check(finsh_node_child(node), is_addr);
} }
/* always does not load address in sibling */ /* always does not load address in sibling */
finsh_type_check(finsh_node_sibling(node), FINSH_NODE_VALUE); finsh_type_check(finsh_node_sibling(node), FINSH_NODE_VALUE);
/** set attribute of current node */ /** set attribute of current node */
/* make sure the current node is address or value */ /* make sure the current node is address or value */
if (node->idtype != FINSH_IDTYPE_SYSCALL) node->idtype |= is_addr; if (node->idtype != FINSH_IDTYPE_SYSCALL) node->idtype |= is_addr;
if (finsh_node_child(node) != NULL) if (finsh_node_child(node) != NULL)
{ {
node->data_type = finsh_node_child(node)->data_type; node->data_type = finsh_node_child(node)->data_type;
return 0; return 0;
} }
if (node->node_type == FINSH_NODE_ID) if (node->node_type == FINSH_NODE_ID)
{ {
if (node->idtype & FINSH_IDTYPE_VAR) if (node->idtype & FINSH_IDTYPE_VAR)
{ {
struct finsh_var* var; struct finsh_var* var;
var = node->id.var; var = node->id.var;
if (var != NULL) if (var != NULL)
{ {
switch (var->type) switch (var->type)
{ {
case finsh_type_void: case finsh_type_void:
node->data_type = FINSH_DATA_TYPE_VOID; node->data_type = FINSH_DATA_TYPE_VOID;
break; break;
case finsh_type_char: case finsh_type_char:
case finsh_type_uchar: case finsh_type_uchar:
node->data_type = FINSH_DATA_TYPE_BYTE; node->data_type = FINSH_DATA_TYPE_BYTE;
break; break;
case finsh_type_short: case finsh_type_short:
case finsh_type_ushort: case finsh_type_ushort:
node->data_type = FINSH_DATA_TYPE_WORD; node->data_type = FINSH_DATA_TYPE_WORD;
break; break;
case finsh_type_int: case finsh_type_int:
case finsh_type_uint: case finsh_type_uint:
case finsh_type_long: case finsh_type_long:
case finsh_type_ulong: case finsh_type_ulong:
node->data_type = FINSH_DATA_TYPE_DWORD; node->data_type = FINSH_DATA_TYPE_DWORD;
break; break;
case finsh_type_charp: case finsh_type_charp:
case finsh_type_voidp: case finsh_type_voidp:
case finsh_type_shortp: case finsh_type_shortp:
case finsh_type_intp: case finsh_type_intp:
case finsh_type_longp: case finsh_type_longp:
node->data_type = FINSH_DATA_TYPE_DWORD; node->data_type = FINSH_DATA_TYPE_DWORD;
break; break;
default: default:
finsh_error_set(FINSH_ERROR_UNKNOWN_TYPE); finsh_error_set(FINSH_ERROR_UNKNOWN_TYPE);
break; break;
} }
} }
} }
else if (node->idtype & FINSH_IDTYPE_SYSVAR) else if (node->idtype & FINSH_IDTYPE_SYSVAR)
{ {
struct finsh_sysvar *sysvar; struct finsh_sysvar *sysvar;
sysvar = node->id.sysvar; sysvar = node->id.sysvar;
if (sysvar != NULL) if (sysvar != NULL)
{ {
switch (sysvar->type) switch (sysvar->type)
{ {
case finsh_type_void: case finsh_type_void:
node->data_type = FINSH_DATA_TYPE_VOID; node->data_type = FINSH_DATA_TYPE_VOID;
break; break;
case finsh_type_char: case finsh_type_char:
case finsh_type_uchar: case finsh_type_uchar:
node->data_type = FINSH_DATA_TYPE_BYTE; node->data_type = FINSH_DATA_TYPE_BYTE;
break; break;
case finsh_type_short: case finsh_type_short:
case finsh_type_ushort: case finsh_type_ushort:
node->data_type = FINSH_DATA_TYPE_WORD; node->data_type = FINSH_DATA_TYPE_WORD;
break; break;
case finsh_type_int: case finsh_type_int:
case finsh_type_uint: case finsh_type_uint:
case finsh_type_long: case finsh_type_long:
case finsh_type_ulong: case finsh_type_ulong:
node->data_type = FINSH_DATA_TYPE_DWORD; node->data_type = FINSH_DATA_TYPE_DWORD;
break; break;
case finsh_type_charp: case finsh_type_charp:
case finsh_type_voidp: case finsh_type_voidp:
case finsh_type_shortp: case finsh_type_shortp:
case finsh_type_intp: case finsh_type_intp:
case finsh_type_longp: case finsh_type_longp:
node->data_type = FINSH_DATA_TYPE_DWORD; node->data_type = FINSH_DATA_TYPE_DWORD;
break; break;
default: default:
finsh_error_set(FINSH_ERROR_UNKNOWN_TYPE); finsh_error_set(FINSH_ERROR_UNKNOWN_TYPE);
break; break;
} }
} }
} }
} }
else if (node->node_type == FINSH_NODE_VALUE_CHAR) else if (node->node_type == FINSH_NODE_VALUE_CHAR)
{ {
node->data_type = FINSH_DATA_TYPE_BYTE; node->data_type = FINSH_DATA_TYPE_BYTE;
} }
else if (node->node_type == FINSH_NODE_VALUE_INT || else if (node->node_type == FINSH_NODE_VALUE_INT ||
node->node_type == FINSH_NODE_VALUE_LONG || node->node_type == FINSH_NODE_VALUE_LONG ||
node->node_type == FINSH_NODE_VALUE_STRING || node->node_type == FINSH_NODE_VALUE_STRING ||
node->node_type == FINSH_NODE_VALUE_NULL) node->node_type == FINSH_NODE_VALUE_NULL)
{ {
node->data_type = FINSH_DATA_TYPE_DWORD; node->data_type = FINSH_DATA_TYPE_DWORD;
} }
} }
return 0; return 0;
} }
int finsh_compiler_run(struct finsh_node* node) int finsh_compiler_run(struct finsh_node* node)
{ {
struct finsh_node* sibling; struct finsh_node* sibling;
/* type check */ /* type check */
finsh_type_check(node, FINSH_NODE_VALUE); finsh_type_check(node, FINSH_NODE_VALUE);
/* clean text segment and vm stack */ /* clean text segment and vm stack */
memset(&text_segment[0], 0, sizeof(text_segment)); memset(&text_segment[0], 0, sizeof(text_segment));
memset(&finsh_vm_stack[0], 0, sizeof(finsh_vm_stack[0])); memset(&finsh_vm_stack[0], 0, sizeof(finsh_vm_stack[0]));
/* reset compile stack pointer and pc */ /* reset compile stack pointer and pc */
finsh_compile_sp = &finsh_vm_stack[0]; finsh_compile_sp = &finsh_vm_stack[0];
finsh_compile_pc = &text_segment[0]; finsh_compile_pc = &text_segment[0];
/* compile node */ /* compile node */
sibling = node; sibling = node;
while (sibling != NULL) while (sibling != NULL)
{ {
struct finsh_node* current_node; struct finsh_node* current_node;
current_node = sibling; current_node = sibling;
/* get sibling node */ /* get sibling node */
sibling = current_node->sibling; sibling = current_node->sibling;
/* clean sibling node */ /* clean sibling node */
current_node->sibling = NULL; current_node->sibling = NULL;
finsh_compile(current_node); finsh_compile(current_node);
/* pop current value */ /* pop current value */
if (sibling != NULL) finsh_code_byte(FINSH_OP_POP); if (sibling != NULL) finsh_code_byte(FINSH_OP_POP);
} }
return 0; return 0;
......
components/finsh/finsh_token.c
浏览文件 @ 6a624356
...@@ -473,17 +473,16 @@ static int token_proc_escape(struct finsh_token* self) ...@@ -473,17 +473,16 @@ static int token_proc_escape(struct finsh_token* self)
static void token_proc_number(struct finsh_token* self) static void token_proc_number(struct finsh_token* self)
{ {
char ch; char ch;
int b;
char *p, buf[128]; char *p, buf[128];
long value; long value;
value = 0; value = 0;
p = buf; p = buf;
b = 10;
ch = token_next_char(self); ch = token_next_char(self);
if ( ch == '0' ) if ( ch == '0' )
{ {
int b;
ch = token_next_char(self); ch = token_next_char(self);
if ( ch == 'x' || ch == 'X' )/*it's a hex number*/ if ( ch == 'x' || ch == 'X' )/*it's a hex number*/
{ {
......
components/finsh/finsh_var.c
浏览文件 @ 6a624356
...@@ -104,7 +104,6 @@ struct finsh_var* finsh_var_lookup(const char* name) ...@@ -104,7 +104,6 @@ struct finsh_var* finsh_var_lookup(const char* name)
} }
#ifdef RT_USING_HEAP #ifdef RT_USING_HEAP
extern char *strdup(const char *s);
void finsh_sysvar_append(const char* name, u_char type, void* var_addr) void finsh_sysvar_append(const char* name, u_char type, void* var_addr)
{ {
/* create a sysvar */ /* create a sysvar */
...@@ -114,7 +113,7 @@ void finsh_sysvar_append(const char* name, u_char type, void* var_addr) ...@@ -114,7 +113,7 @@ void finsh_sysvar_append(const char* name, u_char type, void* var_addr)
if (item != NULL) if (item != NULL)
{ {
item->next = NULL; item->next = NULL;
item->sysvar.name = strdup(name); item->sysvar.name = rt_strdup(name);
item->sysvar.type = type; item->sysvar.type = type;
item->sysvar.var = var_addr; item->sysvar.var = var_addr;
......
components/finsh/finsh_vm.c
浏览文件 @ 6a624356
...@@ -72,7 +72,6 @@ void finsh_vm_run() ...@@ -72,7 +72,6 @@ void finsh_vm_run()
} }
#ifdef RT_USING_HEAP #ifdef RT_USING_HEAP
extern char *strdup(const char *s);
void finsh_syscall_append(const char* name, syscall_func func) void finsh_syscall_append(const char* name, syscall_func func)
{ {
/* create the syscall */ /* create the syscall */
...@@ -82,7 +81,7 @@ void finsh_syscall_append(const char* name, syscall_func func) ...@@ -82,7 +81,7 @@ void finsh_syscall_append(const char* name, syscall_func func)
if (item != RT_NULL) if (item != RT_NULL)
{ {
item->next = NULL; item->next = NULL;
item->syscall.name = strdup(name); item->syscall.name = rt_strdup(name);
item->syscall.func = func; item->syscall.func = func;
if (global_syscall_list == NULL) if (global_syscall_list == NULL)
......
components/finsh/shell.c
浏览文件 @ 6a624356
...@@ -54,29 +54,6 @@ ALIGN(RT_ALIGN_SIZE) ...@@ -54,29 +54,6 @@ ALIGN(RT_ALIGN_SIZE)
static char finsh_thread_stack[FINSH_THREAD_STACK_SIZE]; static char finsh_thread_stack[FINSH_THREAD_STACK_SIZE];
struct finsh_shell* shell; struct finsh_shell* shell;
#if !defined (RT_USING_NEWLIB) && !defined (RT_USING_MINILIBC)
int strcmp (const char *s1, const char *s2)
{
while (*s1 && *s1 == *s2) s1++, s2++;
return (*s1 - *s2);
}
#ifdef RT_USING_HEAP
char *strdup(const char *s)
{
size_t len = strlen(s) + 1;
char *tmp = (char *)rt_malloc(len);
if(!tmp) return NULL;
rt_memcpy(tmp, s, len);
return tmp;
}
#endif
#endif
#if defined(RT_USING_DFS) && defined(DFS_USING_WORKDIR) #if defined(RT_USING_DFS) && defined(DFS_USING_WORKDIR)
#include <dfs_posix.h> #include <dfs_posix.h>
const char* finsh_get_prompt() const char* finsh_get_prompt()
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或