finsh_compiler.c.svn-base

RT-Thread是发展中的下一代微内核嵌入式实时操作系统

				case FINSH_DATA_TYPE_WORD:
					/* address */
					// finsh_code_dword((long)&(var->value.short_value));

					/* ld_value_word &id */
					finsh_code_byte(FINSH_OP_LD_VALUE_WORD);
					finsh_code_dword((long)&(var->value.short_value));

					/* ld_word 1 */
					finsh_code_byte(FINSH_OP_LD_WORD);
					finsh_code_word(1);

					/* add_word */
					finsh_code_byte(FINSH_OP_SUB_WORD);
					/* st_word */
					finsh_code_byte(FINSH_OP_ST_WORD);

					/* load value again */
					finsh_code_byte(FINSH_OP_LD_VALUE_DWORD_STACK);

					break;

				case FINSH_DATA_TYPE_DWORD:
					/* address */
					// finsh_code_dword((long)&(var->value.long_value));

					/* ld_dword &id */
					finsh_code_byte(FINSH_OP_LD_VALUE_DWORD);
					finsh_code_dword((long)&(var->value.long_value));

					/* ld_dword 1 */
					finsh_code_byte(FINSH_OP_LD_DWORD);
					finsh_code_dword(1);

					/* add_dword */
					finsh_code_byte(FINSH_OP_SUB_DWORD);
					/* st_dword */
					finsh_code_byte(FINSH_OP_ST_DWORD);

					/* load value again */
					finsh_code_byte(FINSH_OP_LD_VALUE_DWORD_STACK);

					break;
				}
			}
			break;

		/* increase */
		case FINSH_NODE_SYS_INC:
			if (finsh_node_child(node)->node_type == FINSH_NODE_ID)
			{
				struct finsh_var* var;
				var = finsh_node_child(node)->id.var;

				switch (node->data_type)
				{
				case FINSH_DATA_TYPE_BYTE:
					/* ld_value_byte &id */
					// finsh_code_byte(FINSH_OP_LD_VALUE_BYTE);
					// finsh_code_dword((long)&(var->value.char_value));

					/* ld_dword &id */
					finsh_code_byte(FINSH_OP_LD_DWORD);
					finsh_code_dword((long)&(var->value.char_value));

					/* ld_value_byte &id */
					finsh_code_byte(FINSH_OP_LD_VALUE_BYTE);
					finsh_code_dword((long)&(var->value.char_value));

					/* ld_byte 1 */
					finsh_code_byte(FINSH_OP_LD_BYTE);
					finsh_code_byte(1);

					/* add_byte */
					finsh_code_byte(FINSH_OP_ADD_BYTE);
					/* get byte */
					finsh_code_byte(FINSH_OP_ST_BYTE);

					/* pop */
					finsh_code_byte(FINSH_OP_POP);
					break;

				case FINSH_DATA_TYPE_WORD:
					/* ld_value_word &id */
					// finsh_code_byte(FINSH_OP_LD_VALUE_WORD);
					// finsh_code_dword((long)&(var->value.short_value));

					/* ld_dword &id */
					finsh_code_byte(FINSH_OP_LD_DWORD);
					finsh_code_dword((long)&(var->value.short_value));

					/* ld_value_word &id */
					finsh_code_byte(FINSH_OP_LD_VALUE_WORD);
					finsh_code_dword((long)&(var->value.short_value));

					/* ld_word 1 */
					finsh_code_byte(FINSH_OP_LD_WORD);
					finsh_code_word(1);

					/* add_byte */
					finsh_code_byte(FINSH_OP_ADD_WORD);
					/* get byte */
					finsh_code_byte(FINSH_OP_ST_WORD);

					/* pop */
					finsh_code_byte(FINSH_OP_POP);
					break;

				case FINSH_DATA_TYPE_DWORD:
					/* ld_value_dword &id */
					// finsh_code_byte(FINSH_OP_LD_VALUE_DWORD);
					// finsh_code_dword((long)&(var->value.long_value));

					/* ld_dword &id */
					finsh_code_byte(FINSH_OP_LD_DWORD);
					finsh_code_dword((long)&(var->value.long_value));

					/* ld_value_dword &id */
					finsh_code_byte(FINSH_OP_LD_VALUE_DWORD);
					finsh_code_dword((long)&(var->value.long_value));

					/* ld_dword 1 */
					finsh_code_byte(FINSH_OP_LD_DWORD);
					finsh_code_dword(1);

					/* add_byte */
					finsh_code_byte(FINSH_OP_ADD_DWORD);
					/* get byte */
					finsh_code_byte(FINSH_OP_ST_DWORD);

					/* pop */
					finsh_code_byte(FINSH_OP_POP);
					break;
				}
			}
			break;

		/* decrease */
		case FINSH_NODE_SYS_DEC:
			if (finsh_node_child(node)->node_type == FINSH_NODE_ID)
			{
				struct finsh_var* var;
				var = finsh_node_child(node)->id.var;

				switch (node->data_type)
				{
				case FINSH_DATA_TYPE_BYTE:
					/* ld_value_byte &id */
					// finsh_code_byte(FINSH_OP_LD_VALUE_BYTE);
					// finsh_code_dword((long)&(var->value.char_value));

					/* ld_dword &id */
					finsh_code_byte(FINSH_OP_LD_DWORD);
					finsh_code_dword((long)&(var->value.char_value));

					/* ld_value_byte &id */
					finsh_code_byte(FINSH_OP_LD_VALUE_BYTE);
					finsh_code_dword((long)&(var->value.char_value));

					/* ld_byte 1 */
					finsh_code_byte(FINSH_OP_LD_BYTE);
					finsh_code_byte(1);

					/* add_byte */
					finsh_code_byte(FINSH_OP_SUB_BYTE);
					/* get byte */
					finsh_code_byte(FINSH_OP_ST_BYTE);

					/* pop */
					finsh_code_byte(FINSH_OP_POP);
					break;

				case FINSH_DATA_TYPE_WORD:
					/* ld_value_word &id */
					// finsh_code_byte(FINSH_OP_LD_VALUE_WORD);
					// finsh_code_dword((long)&(var->value.short_value));

					/* ld_dword &id */
					finsh_code_byte(FINSH_OP_LD_DWORD);
					finsh_code_dword((long)&(var->value.short_value));

					/* ld_value_word &id */
					finsh_code_byte(FINSH_OP_LD_VALUE_WORD);
					finsh_code_dword((long)&(var->value.short_value));

					/* ld_word 1 */
					finsh_code_byte(FINSH_OP_LD_WORD);
					finsh_code_word(1);

					/* add_byte */
					finsh_code_byte(FINSH_OP_SUB_WORD);
					/* get byte */
					finsh_code_byte(FINSH_OP_ST_WORD);

					/* pop */
					finsh_code_byte(FINSH_OP_POP);
					break;

				case FINSH_DATA_TYPE_DWORD:
					/* ld_value_dword &id */
					// finsh_code_byte(FINSH_OP_LD_VALUE_DWORD);
					// finsh_code_dword((long)&(var->value.long_value));

					/* ld_dword &id */
					finsh_code_byte(FINSH_OP_LD_DWORD);
					finsh_code_dword((long)&(var->value.long_value));

					/* ld_value_dword &id */
					finsh_code_byte(FINSH_OP_LD_VALUE_DWORD);
					finsh_code_dword((long)&(var->value.long_value));

					/* ld_dword 1 */
					finsh_code_byte(FINSH_OP_LD_DWORD);
					finsh_code_dword(1);

					/* add_byte */
					finsh_code_byte(FINSH_OP_SUB_DWORD);
					/* get byte */
					finsh_code_byte(FINSH_OP_ST_DWORD);

					/* pop */
					finsh_code_byte(FINSH_OP_POP);
					break;
				}
			}
			break;

		case FINSH_NODE_SYS_NULL:
			finsh_code_dword(0);
			break;

		case FINSH_NODE_SYS_GETVALUE:
			if (node->idtype & FINSH_IDTYPE_ADDRESS)
			{
				/* nothing will be generated */
			}
			else
			{
				switch (node->data_type)
				{
				case FINSH_DATA_TYPE_BYTE:
					finsh_code_byte(FINSH_OP_LD_VALUE_BYTE_STACK);
					break;
				case FINSH_DATA_TYPE_WORD:
					finsh_code_byte(FINSH_OP_LD_VALUE_WORD_STACK);
					break;
				case FINSH_DATA_TYPE_DWORD:
					finsh_code_byte(FINSH_OP_LD_VALUE_DWORD_STACK);
					break;
				default:
					break;
				}
			}
			break;

		case FINSH_NODE_SYS_GETADDR:
			/* nothing will be generated */
			break;

		default:
			finsh_error_set(FINSH_ERROR_UNKNOWN_NODE);
			break;
		}

		/* compile sibling node */
		if (finsh_node_sibling(node) != NULL)
            finsh_compile(finsh_node_sibling(node));
	}

	return 0;
}

static int finsh_type_check(struct finsh_node* node, u_char is_addr)
{
	if (node != NULL)
	{
		/* address & value */
		if (node->node_type == FINSH_NODE_SYS_ASSIGN ||
			node->node_type == FINSH_NODE_SYS_PREINC ||
			node->node_type == FINSH_NODE_SYS_PREDEC ||
			node->node_type == FINSH_NODE_SYS_GETADDR)
		{
			/* address */
			finsh_type_check(finsh_node_child(node), FINSH_IDTYPE_ADDRESS);
		}
		else if (node->node_type == FINSH_NODE_SYS_GETVALUE && is_addr)
		{
			/* change the attribute of getvalue in left expr */
			finsh_type_check(finsh_node_child(node), 0);
		}
		else
		{
			/* transfer 'av' to child node */
			finsh_type_check(finsh_node_child(node), is_addr);
		}

		/* always does not load address in sibling */
		finsh_type_check(finsh_node_sibling(node), FINSH_NODE_VALUE);

		/** set attribute of current node */

		/* make sure the current node is address or value */
		if (node->idtype != FINSH_IDTYPE_SYSCALL) node->idtype |= is_addr;

		if (finsh_node_child(node) != NULL)
		{
			node->data_type = finsh_node_child(node)->data_type;
			return 0;
		}

		if (node->node_type == FINSH_NODE_ID)
		{
			if (node->idtype & FINSH_IDTYPE_VAR)
			{
				struct finsh_var* var;

				var = node->id.var;
				if (var != NULL)
				{
					switch (var->type)
					{
					case finsh_type_void:
						node->data_type = FINSH_DATA_TYPE_VOID;
						break;

					case finsh_type_char:
					case finsh_type_uchar:
						node->data_type = FINSH_DATA_TYPE_BYTE;
						break;

					case finsh_type_short:
					case finsh_type_ushort:
						node->data_type = FINSH_DATA_TYPE_WORD;
						break;

					case finsh_type_int:
					case finsh_type_uint:
					case finsh_type_long:
					case finsh_type_ulong:
						node->data_type = FINSH_DATA_TYPE_DWORD;
						break;

					case finsh_type_charp:
					case finsh_type_voidp:
					case finsh_type_shortp:
					case finsh_type_intp:
					case finsh_type_longp:
						node->data_type = FINSH_DATA_TYPE_DWORD;
						break;

					default:
						finsh_error_set(FINSH_ERROR_UNKNOWN_TYPE);
						break;
					}
				}
			}
			else if (node->idtype & FINSH_IDTYPE_SYSVAR)
			{
				struct finsh_sysvar *sysvar;

				sysvar = node->id.sysvar;
				if (sysvar != NULL)
				{
					switch (sysvar->type)
					{
					case finsh_type_void:
						node->data_type = FINSH_DATA_TYPE_VOID;
						break;

					case finsh_type_char:
					case finsh_type_uchar:
						node->data_type = FINSH_DATA_TYPE_BYTE;
						break;

					case finsh_type_short:
					case finsh_type_ushort:
						node->data_type = FINSH_DATA_TYPE_WORD;
						break;

					case finsh_type_int:
					case finsh_type_uint:
					case finsh_type_long:
					case finsh_type_ulong:
						node->data_type = FINSH_DATA_TYPE_DWORD;
						break;

					case finsh_type_charp:
					case finsh_type_voidp:
					case finsh_type_shortp:
					case finsh_type_intp:
					case finsh_type_longp:
						node->data_type = FINSH_DATA_TYPE_DWORD;
						break;

					default:
						finsh_error_set(FINSH_ERROR_UNKNOWN_TYPE);
						break;
					}
				}
			}
		}
		else if (node->node_type == FINSH_NODE_VALUE_CHAR)
		{
			node->data_type = FINSH_DATA_TYPE_BYTE;
		}
		else if (node->node_type == FINSH_NODE_VALUE_INT ||
			node->node_type == FINSH_NODE_VALUE_LONG 	||
			node->node_type == FINSH_NODE_VALUE_STRING 	||
			node->node_type == FINSH_NODE_VALUE_NULL)
		{
			node->data_type = FINSH_DATA_TYPE_DWORD;
		}
	}
	return 0;
}

int finsh_compiler_run(struct finsh_node* node)
{
    struct finsh_node* sibling;

	/* type check */
	finsh_type_check(node, FINSH_NODE_VALUE);

	/* clean text segment and vm stack */
	memset(&text_segment[0], 0, sizeof(text_segment));
	memset(&finsh_vm_stack[0], 0, sizeof(finsh_vm_stack[0]));

	/* reset compile stack pointer and pc */
	finsh_compile_sp = &finsh_vm_stack[0];
	finsh_compile_pc = &text_segment[0];

    /* compile node */
    sibling = node;
    while (sibling != NULL)
    {
    	struct finsh_node* current_node;
    	current_node = sibling;

		/* get sibling node */
    	sibling = current_node->sibling;

		/* clean sibling node */
    	current_node->sibling = NULL;
    	finsh_compile(current_node);

		/* pop current value */
    	if (sibling != NULL) finsh_code_byte(FINSH_OP_POP);
    }

    return 0;
}