script.h

一个脚本语言的解释器

		else
			++token; // skip ';'
		return se;
	}

	expression * read_expression(token_t &token)
	{
		expression *exp = read_list_expression(token); // exp || exp
		if(token != '=') return exp;
		else
		{
			++token;
			expression_assign *ea = new expression_assign();
			set_debug_info(ea, token);
			ea->set_left(exp);
			DEREF(exp);
			exp = read_expression(token);
			ea->set_right(exp);
			DEREF(exp);
			return ea;
		}
	}

	expression * read_list_expression(token_t &token)
	{
		expression * exp = logic_or_expression(token);
		if(token == ',')
		{
			expression_list * exps = new expression_list();
			set_debug_info(exps, token);
			exps->list.add(exp);
			DEREF(exp);
			while(token == ',')
			{
				++token; // skip ','
				exp = logic_or_expression(token);
				exps->list.add(exp);
				DEREF(exp);
			}
			exp = exps;
		}
		return exp;
	}

	expression * logic_or_expression(token_t &token)
	{
		expression * exp = logic_and_expression(token);
		while(token == "||")
		{
			++token;
			expression *e = logic_and_expression(token);
			expression_logic_or * elo = new expression_logic_or();
			elo->set_left(exp);
			DEREF(exp);
			elo->set_right(e);
			DEREF(e);
			exp = elo;
		}
		return exp;
	}

	expression * logic_and_expression(token_t &token)
	{
		expression * exp = equality_expression(token);
		while(token == "&&")
		{
			++token;
			expression *e = equality_expression(token);
			expression_logic_and * ela = new expression_logic_and();
			set_debug_info(ela, token);
			ela->set_left(exp);
			DEREF(exp);
			ela->set_right(e);
			DEREF(e);
			exp = ela;
		}
		return exp;
	}

	expression * equality_expression(token_t &token)
	{
		expression * exp = relational_expression(token);
		while(token == "==" || token == "!=")
		{
			binary_expression * ee;
			if(token == "==") ee = new expression_equal();
			else ee = new expression_unequal();
			set_debug_info(ee, token);
			++token;

			expression *e = relational_expression(token);
			ee->set_left(exp);
			DEREF(exp);
			ee->set_right(e);
			DEREF(e);
			exp = ee;
		}
		return exp;
	}

	expression * relational_expression(token_t &token)
	{
		expression * exp = additive_expression(token);
		while(token == ">=" || token == "<=" || token == ">" || token == "<")
		{
			binary_expression * ee;
			if(token == ">") ee = new expression_greater();
			else if(token == "<") ee = new expression_less();
			else if(token == ">=") ee = new expression_greater_equal();
			else if(token == "<=") ee = new expression_less_equal();
			set_debug_info(ee, token);
			++token;

			expression *e = additive_expression(token);
			ee->set_left(exp);
			DEREF(exp);
			ee->set_right(e);
			DEREF(e);
			exp = ee;
		}
		return exp;
	}

	expression * additive_expression(token_t &token)
	{
		expression * exp = multiplicative_expression(token);
		while(token == '+' || token == '-')
		{
			binary_expression * ee;
			if(token == '+') ee = new expression_add();
			else ee = new expression_substract();
			set_debug_info(ee, token);
			++token;

			expression *e = multiplicative_expression(token);
			ee->set_left(exp);
			DEREF(exp);
			ee->set_right(e);
			DEREF(e);
			exp = ee;
		}
		return exp;
	}

	expression * multiplicative_expression(token_t &token)
	{
		expression * exp = suffix_expression(token);
		while(token == '*' || token == '/' || token == '%')
		{
			binary_expression * ee;
			if(token == '*') ee = new expression_multiply();
			else if(token == '/') ee = new expression_divide();
			else ee = new expression_mod();
			set_debug_info(ee, token);
			++token;

			expression *e = suffix_expression(token);
			ee->set_left(exp);
			DEREF(exp);
			ee->set_right(e);
			DEREF(e);
			exp = ee;
		}
		return exp;
	}

	expression * suffix_expression(token_t &token)
	{
		if(token == '!')
		{
			expression_logic_not * exp = new expression_logic_not();
			set_debug_info(exp, token);
			++token;
			expression *e = postfix_expression(token);
			exp->set_child(e);
			DEREF(e);
			return exp;
		}
		if(token == '-')
		{
			expression_substract * exp = new expression_substract();
			set_debug_info(exp, token);
			++token;
			expression *e = postfix_expression(token);
			exp->set_right(e);
			DEREF(e);
			return exp;
		}
		else
		{
			return postfix_expression(token);
		}
	}
	
	void read_arguments(expression_func_call *ee, token_t &token)
	{
		++token;
		while(token != ')')
		{
			expression * arg = read_expression(token);
			ee->add_argument(arg);
			DEREF(arg);
			if(token == ',') ++token;
			else if(token == ')') break;
			else
			{
				ERROR_TOK(UnexpectedToken, "read_arguments(): ',' or ')' is expected.", token);
				break;
			}
		}
		if(token == ')') ++token; // skip ')';
	}
	expression * postfix_expression(token_t &token)
	{
		expression * exp = element_expression(token);
		while(token == '[' || token == '(' || token == '.')
		{
			if(token == '[')
			{
				++token;
				expression_subscribe *ee = new expression_subscribe();
				set_debug_info(ee, token);

				expression *e = read_expression(token);
				ee->set_left(exp);
				DEREF(exp);
				ee->set_right(e);
				DEREF(e);
				exp = ee;

				if(token != ']')
					ERROR_TOK(UnexpectedToken, "postfix_expression(): ']' is expected.", token);
				else
					++token; // skip ']'
			}
			else if(token == '(')
			{
				expression_func_call *ee = new expression_func_call();
				set_debug_info(ee, token);

				ee->set_function(exp);
				DEREF(exp);
				// read arguments
				read_arguments(ee, token);
				exp = ee;
			}
			else
			{
				++token;
				expression_member * ee = new expression_member();
				set_debug_info(ee, token);

				expression *e = element_expression(token);
				ee->set_left(exp);
				DEREF(exp);
				ee->set_right(e);
				DEREF(e);
				exp = ee;
			}
		}
		return exp;
	}

	/*expression * member_expression(token_t &token)
	{
		expression * exp = element_expression(token);
		while(token == '.')
		{
			++token;
			expression_member * ee = new expression_member();
			set_debug_info(ee, token);

			expression *e = element_expression(token);
			ee->set_left(exp);
			DEREF(exp);
			ee->set_right(e);
			DEREF(e);
			exp = ee;
		}
		return exp;
	}*/

	expression * element_expression(token_t &token)
	{
		if(token == "new")
		{
			return new_expression(++token);
		}
		else if( token == "function" || token == "object" )
		{
			return anonymous_function_expression(++token);
		}
		else if(token[0] == '\'' || token[0] == '\"')
		{
			expression_literal *el = new expression_literal();
			el->set_literal(token.ToContent(), expression_literal::t_str);
			set_debug_info(el, token);
			++token;
			return el;
		}
		else if(CppLex::IsDigit(token[0]))
		{
			expression_literal *el = new expression_literal();
			el->set_literal(token.ToString(), expression_literal::t_num);
			set_debug_info(el, token);
			++token;
			return el;
		}
		else return identifier_expression(token);
	}

	expression * new_expression(token_t &token)
	{
		// read object name
		expression * name = identifier_expression(token);
		// read argument list
		expression_new * expnew = new expression_new();
		expnew->set_function(name);
		set_debug_info(expnew, token);
		read_arguments(expnew, token);
		DEREF(name);
		return expnew;
	}

	expression * anonymous_function_expression(token_t &token)
	{
		char funcname[128];
		sprintf(funcname, "%s_%d", "anonymous", token.Line());
		expression_anonymous * func = new expression_anonymous(funcname);
		set_debug_info(func, token);
		// read parameter list
		id_list * param = read_parameter(token);
		func->function_tree->set_param_list(param);
		// read function body
		statement * s = read_compound_statement(token);
		func->function_tree->set_body(s);
		DEREF(param);
		DEREF(s);
		return func;
	}

	expression * identifier_expression(token_t &token)
	{
		expression *e = 0;
		if(token == "null")
			e = new expression_null();
		else if(token == "true")
			e = new expression_bool(true);
		else if(token == "false")
			e = new expression_bool(false);
		else if(token == "this")
			e = new expression_this();
		else if(token == "(")
		{
			expression * parenthesis = read_expression(++token);
			if(token != ')') ERROR_TOK(UnexpectedToken, "identifier_expression() - parenthesis: ')' is expected.", token);
			e = parenthesis;
		}
		else
		{
			if(!is_identifier(token.ToString()))
			{
				ERROR_TOK(UnexpectedToken, "identifier_expression(): identifier is expected.", token);
				return 0;
			}
			expression_identifier *ei = new expression_identifier();
			ei->set_identifier(token.ToString());
			e = ei;
		}
		set_debug_info(e, token);
		++token;
		return e;
	}

private:
	debug_files * _df;

	void set_debug_info(expression * e, token_t &token)
	{
		e->set_debug_info(_df);
		e->debug_file = _df->get_last_file();
		e->debug_line = token.Line();
	}

};

__END_NAMESPACE__