From 0384e1932321633c4d1961aad21cd9fe0578925f Mon Sep 17 00:00:00 2001
From: Valk Richard Li <48872266+ValKmjolnir@users.noreply.github.com>
Date: Thu, 10 Oct 2019 10:33:49 -0500
Subject: [PATCH] Prepare for abstract syntax tree

---
 version1.0/ast.h           |   94 ++++
 version1.0/ast_generator.h | 1029 ++++++++++++++++++++++++++++++++++++
 2 files changed, 1123 insertions(+)
 create mode 100644 version1.0/ast_generator.h

diff --git a/version1.0/ast.h b/version1.0/ast.h
index 53adf86..d8b3fc8 100644
--- a/version1.0/ast.h
+++ b/version1.0/ast.h
@@ -9,6 +9,7 @@ class abstract_syntax_tree
 		std::list<abstract_syntax_tree> children;
 		double var_number;
 		std::string var_string;
+		std::string id_name;
 	public:
 		abstract_syntax_tree()
 		{
@@ -17,6 +18,7 @@ class abstract_syntax_tree
 			children.clear();
 			var_number=0;
 			var_string="";
+			id_name="ukn";
 		}
 		abstract_syntax_tree(const abstract_syntax_tree& temp)
 		{
@@ -32,6 +34,55 @@ class abstract_syntax_tree
 			var_number=temp.var_number;
 			var_string=temp.var_string;
 		}
+		void print_ast_node(int tab_num)
+		{
+			for(int i=0;i<tab_num;++i)
+				std::cout<<" ";
+			if(ast_node_type==__number)
+			{
+				std::cout<<"[ Number:";
+				std::cout<<var_number;
+				std::cout<<" ]"<<std::endl;
+				return;
+			}
+			else if(ast_node_type==__string)
+			{
+				std::cout<<"[ String:"<<var_string<<" ]"<<std::endl;
+				return;
+			}
+			std::cout<<"{ [ Type:";
+			print_token(ast_node_type);
+			std::cout<<" ]"<<std::endl;
+			for(std::list<abstract_syntax_tree>::iterator i=children.begin();i!=children.end();++i)
+				i->print_ast_node(tab_num+1);
+			for(int i=0;i<tab_num;++i)
+				std::cout<<" ";
+			std::cout<<"}"<<std::endl;
+			return;
+		}
+		// for if
+		void set_if_expr(abstract_syntax_tree condition,abstract_syntax_tree statements)
+		{
+			ast_node_type=__if;
+			children.push_back(condition);
+			children.push_back(statements);
+			return;
+		}
+		// for elsif
+		void set_elsif_expr(abstract_syntax_tree condition,abstract_syntax_tree statements)
+		{
+			ast_node_type=__elsif;
+			children.push_back(condition);
+			children.push_back(statements);
+			return;
+		}
+		// for else
+		void set_else_expr(abstract_syntax_tree statements)
+		{
+			ast_node_type=__else;
+			children.push_back(statements);
+			return;
+		}
 		// for statement block
 		void set_block()
 		{
@@ -57,6 +108,41 @@ class abstract_syntax_tree
 			children.push_back(f_child);
 			return;
 		}
+		// for leaf node identifier
+		void set_node_to_identifier(std::string& str)
+		{
+			ast_node_type=__id;
+			id_name=str;
+			return;
+		}
+		// for leaf node call
+		void set_node_to_call_function()
+		{
+			ast_node_type=__call_function;
+			return;
+		}
+		void set_node_to_list_search()
+		{
+			ast_node_type=__list_search;
+			return;
+		}
+		void set_node_to_hash_search()
+		{
+			ast_node_type=__hash_search;
+			return;
+		}
+		// for leaf node list
+		void set_node_to_list()
+		{
+			ast_node_type=__list;
+			return;
+		}
+		// for leaf node hash
+		void set_node_to_hash()
+		{
+			ast_node_type=__hash;
+			return;
+		}
 		// for leaf node string
 		void set_node_to_string(std::string& str)
 		{
@@ -64,6 +150,10 @@ class abstract_syntax_tree
 			var_string=str;
 			return;
 		}
+		std::string get_string()
+		{
+			return var_string;
+		}
 		// for leaf node number
 		void set_node_to_number(std::string& str)
 		{
@@ -139,6 +229,10 @@ class abstract_syntax_tree
 			}
 			return;
 		}
+		double get_number()
+		{
+			return var_number;
+		}
 };
 
 
diff --git a/version1.0/ast_generator.h b/version1.0/ast_generator.h
new file mode 100644
index 0000000..5194e39
--- /dev/null
+++ b/version1.0/ast_generator.h
@@ -0,0 +1,1029 @@
+#ifndef __AST_GENERATOR_H__
+#define __AST_GENERATOR_H__
+
+class generator
+{
+	private:
+		abstract_syntax_tree root;
+		std::stack<token> parse;
+		std::stack<abstract_syntax_tree> node_cache;
+		token this_token;
+	public:
+		generator()
+		{
+			this_token.type=0;
+		}
+		void get_token()
+		{
+			if(parse.empty())
+			{
+				this_token.type=0;
+				return;
+			}
+			this_token=parse.top();
+			parse.pop();
+			return;
+		}
+		void gen_process(std::list<token>& lexer)
+		{
+			while(!parse.empty())
+				parse.pop();
+			std::stack<token> temp;
+			for(std::list<token>::iterator i=lexer.begin();i!=lexer.end();++i)
+			{
+				token temp_parse;
+				temp_parse=*i;
+				temp.push(temp_parse);//push this into stack
+			}
+			if(temp.empty())
+			{
+				std::cout<<">>[Abstract-syntax-tree] warning: empty lexer list."<<std::endl;
+				return;
+			}
+			while(!temp.empty())
+			{
+				parse.push(temp.top());
+				temp.pop();
+			}
+			return;
+		}
+		void print_ast()
+		{
+			std::cout<<">>\n[Abstract-syntax-tree]"<<std::endl;
+			root.print_ast_node(0);
+			return;
+		}
+		void run()
+		{
+			
+			return;
+		}
+		void gen_main_work();
+		void in_curve_calc_expr();
+		void number_begin_expr();
+		void string_begin_expr();
+		void identifier_begin_expr();
+		void call_list_expr();
+		void call_function_expr();
+		void call_hash_expr();
+		void list_generate_expr();
+		void hash_generate_expr();
+		void definition_expr();
+		void assignment_expr();
+		void loop_expr();
+		bool else_if_check();
+		void if_else_expr();
+		void add_sub_operator_expr();
+		void mul_div_operator_expr();
+		void link_operator_expr();
+		void compare_operator_expr();
+		void one_operator_expr();
+		void check_semi_at_end();
+		void statements_block();
+		void function_generate_expr();
+		void return_expr();
+};
+void generator::check_semi_at_end()
+{
+	get_token();
+	return;
+}
+void generator::return_expr()
+{
+	get_token();
+	switch(this_token.type)
+	{
+		case __number:number_begin_expr();break;
+		case __string:string_begin_expr();break;
+		case __id:identifier_begin_expr();break;
+		case __func:function_generate_expr();break;
+		case __left_bracket:list_generate_expr();break;
+		case __left_brace:hash_generate_expr();break;
+		case __semi:parse.push(this_token);break;
+		default:break;
+	}
+	return;
+}
+void generator::statements_block()
+{
+	get_token();
+	get_token();
+	while(this_token.type!=__right_brace)
+	{
+		token t;
+		switch(this_token.type)
+		{
+			case __var:definition_expr();check_semi_at_end();break;
+			case __id:identifier_begin_expr();check_semi_at_end();break;
+			case __number:number_begin_expr();check_semi_at_end();break;
+			case __string:string_begin_expr();check_semi_at_end();break;
+			case __if:parse.push(this_token);if_else_expr();break;
+			case __left_curve:
+				t=this_token;
+				get_token();
+				if(this_token.type==__var)
+				{
+					parse.push(t);
+					definition_expr();
+				}
+				else
+				{
+					in_curve_calc_expr();
+				}
+				check_semi_at_end();
+				break;
+			case __add_operator:
+			case __sub_operator:
+			case __nor_operator:one_operator_expr();break;
+			case __while:
+			case __for:
+			case __foreach:
+			case __forindex:parse.push(this_token);loop_expr();break;
+			case __continue:
+			case __break:check_semi_at_end();break;
+			case __semi:break;
+			case __return:return_expr();check_semi_at_end();break;
+			default:break;
+		}
+		get_token();
+	}
+	return;
+}
+void generator::function_generate_expr()
+{
+	get_token();
+	if(this_token.type==__left_brace)
+		parse.push(this_token);
+	else if(this_token.type==__left_curve)
+	{
+		get_token();
+		while(this_token.type!=__right_curve)
+		{
+			if(this_token.type==__id)
+			{
+				get_token();
+				if(this_token.type==__right_curve)
+					parse.push(this_token);
+			}
+			else if(this_token.type==__dynamic_id)
+			{
+				get_token();
+				parse.push(this_token);
+			}
+			get_token();
+		}
+	}
+	statements_block();
+	return;
+}
+void generator::list_generate_expr()
+{
+	get_token();
+	while(this_token.type!=__right_bracket)
+	{
+		switch(this_token.type)
+		{
+			case __number:number_begin_expr();break;
+			case __string:string_begin_expr();break;
+			case __id:identifier_begin_expr();break;
+			case __left_bracket:list_generate_expr();break;
+			case __left_brace:hash_generate_expr();break;
+			case __left_curve:in_curve_calc_expr();break;
+			default:break;
+		}
+		get_token();
+		if(this_token.type==__comma)
+			get_token();
+	}
+	return;
+}
+void generator::hash_generate_expr()
+{
+	get_token();
+	while(this_token.type!=__right_brace)
+	{
+		switch(this_token.type)
+		{
+			case __number:number_begin_expr();break;
+			case __string:string_begin_expr();break;
+			case __id:identifier_begin_expr();break;
+			default:break;
+		}
+		get_token();
+		get_token();
+		switch(this_token.type)
+		{
+			case __number:number_begin_expr();break;
+			case __string:string_begin_expr();break;
+			case __id:identifier_begin_expr();break;
+			case __func:function_generate_expr();break;
+			case __left_bracket:list_generate_expr();break;
+			case __left_brace:hash_generate_expr();break;
+			case __left_curve:in_curve_calc_expr();break;
+			default:break;
+		}
+		get_token();
+		if(this_token.type==__comma)
+			get_token();
+	}
+	return;
+}
+void generator::definition_expr()
+{
+	get_token();
+	if(this_token.type==__left_curve)
+	{
+		while(this_token.type!=__right_curve)
+		{
+			get_token();
+			get_token();
+			if(this_token.type==__right_curve)
+				break;
+		}
+	}
+	get_token();
+	if(this_token.type==__semi)
+	{
+		parse.push(this_token);
+		return;
+	}
+	get_token();
+	token t;
+	t.line=this_token.line;
+	t.type=__semi;
+	switch(this_token.type)
+	{
+		case __number:number_begin_expr();break;
+		case __string:string_begin_expr();break;
+		case __id:identifier_begin_expr();break;
+		case __func:function_generate_expr();parse.push(t);break;
+		case __add_operator:
+		case __sub_operator:
+		case __nor_operator:one_operator_expr();break;
+		case __left_bracket:list_generate_expr();break;
+		case __left_brace:hash_generate_expr();break;
+		case __left_curve:in_curve_calc_expr();break;
+		default:break;
+	}
+	return;
+}
+void generator::assignment_expr()
+{
+	get_token();
+	switch(this_token.type)
+	{
+		case __number:number_begin_expr();break;
+		case __string:string_begin_expr();break;
+		case __id:identifier_begin_expr();break;
+		case __func:function_generate_expr();break;
+		case __add_operator:
+		case __sub_operator:
+		case __nor_operator:one_operator_expr();break;
+		case __left_bracket:list_generate_expr();break;
+		case __left_brace:hash_generate_expr();break;
+		case __left_curve:in_curve_calc_expr();break;
+		default:break;
+	}
+	return;
+}
+bool generator::else_if_check()
+{
+	token temp=this_token;
+	if(this_token.type!=__else)
+		return false;
+	else
+	{
+		get_token();
+		if(this_token.type!=__if)
+		{
+			parse.push(this_token);
+			this_token=temp;// to avoid when recognizing 'else' without 'if' 
+			
+			return false;
+		}
+	}
+	return true;
+}
+void generator::if_else_expr()
+{
+	get_token();
+	get_token();
+	get_token();
+	switch(this_token.type)
+	{
+		case __add_operator:
+		case __sub_operator:
+		case __nor_operator:one_operator_expr();break;
+		case __number:number_begin_expr();break;
+		case __string:string_begin_expr();break;
+		case __id:identifier_begin_expr();break;
+		case __left_curve:in_curve_calc_expr();break;
+		default:break;
+	}
+	get_token();
+	get_token();
+	if(this_token.type==__left_brace)
+	{
+		// if without { then only one statement is behind it
+		parse.push(this_token);
+		statements_block();
+	}
+	else
+	{
+		token t;
+		switch(this_token.type)
+		{
+			case __var:definition_expr();check_semi_at_end();break;
+			case __id:identifier_begin_expr();check_semi_at_end();break;
+			case __number:number_begin_expr();check_semi_at_end();break;
+			case __string:string_begin_expr();check_semi_at_end();break;
+			case __if:parse.push(this_token);if_else_expr();break;
+			case __left_curve:
+				t=this_token;
+				get_token();
+				if(this_token.type==__var)
+				{
+					parse.push(t);
+					definition_expr();
+				}
+				else
+				{
+					in_curve_calc_expr();
+				}
+				check_semi_at_end();
+				break;
+			case __add_operator:
+			case __sub_operator:
+			case __nor_operator:one_operator_expr();break;
+			case __while:
+			case __for:
+			case __foreach:
+			case __forindex:parse.push(this_token);loop_expr();break;
+			case __continue:
+			case __break:check_semi_at_end();break;
+			case __semi:break;
+			case __return:return_expr();check_semi_at_end();break;
+			default:break;
+		}
+	}
+	if(parse.empty())
+		return;
+	get_token();
+	while(this_token.type==__elsif || else_if_check())
+	{
+		get_token();
+		get_token();
+		switch(this_token.type)
+		{
+			case __add_operator:
+			case __sub_operator:
+			case __nor_operator:one_operator_expr();break;
+			case __number:number_begin_expr();break;
+			case __string:string_begin_expr();break;
+			case __id:identifier_begin_expr();break;
+			default:break;
+		}
+		get_token();
+		get_token();
+		if(this_token.type==__left_brace)
+		{
+			// if without { then only one statement is behind it
+			parse.push(this_token);
+			statements_block();
+		}
+		else
+		{
+			token t;
+			switch(this_token.type)
+			{
+				case __var:definition_expr();check_semi_at_end();break;
+				case __id:identifier_begin_expr();check_semi_at_end();break;
+				case __number:number_begin_expr();check_semi_at_end();break;
+				case __string:string_begin_expr();check_semi_at_end();break;
+				case __if:parse.push(this_token);if_else_expr();break;
+				case __left_curve:
+					t=this_token;
+					get_token();
+					if(this_token.type==__var)
+					{
+						parse.push(t);
+						definition_expr();
+					}
+					else
+					{
+						in_curve_calc_expr();
+					}
+					check_semi_at_end();
+					break;
+				case __add_operator:
+				case __sub_operator:
+				case __nor_operator:one_operator_expr();break;
+				case __while:
+				case __for:
+				case __foreach:
+				case __forindex:parse.push(this_token);loop_expr();break;
+				case __continue:
+				case __break:check_semi_at_end();break;
+				case __semi:break;
+				case __return:return_expr();check_semi_at_end();break;
+				default:break;
+			}
+		}
+		if(parse.empty())
+			return;
+		get_token();
+	}
+	if(this_token.type==__else)
+	{
+		get_token();
+		if(this_token.type==__left_brace)
+		{
+			// if without { then only one statement is behind it
+			parse.push(this_token);
+			statements_block();
+		}
+		else
+		{
+			token t;
+			switch(this_token.type)
+			{
+				case __var:definition_expr();check_semi_at_end();break;
+				case __id:identifier_begin_expr();check_semi_at_end();break;
+				case __number:number_begin_expr();check_semi_at_end();break;
+				case __string:string_begin_expr();check_semi_at_end();break;
+				case __if:parse.push(this_token);if_else_expr();break;
+				case __left_curve:
+					t=this_token;
+					get_token();
+					if(this_token.type==__var)
+					{
+						parse.push(t);
+						definition_expr();
+					}
+					else
+					{
+						in_curve_calc_expr();
+					}
+					check_semi_at_end();
+					break;
+				case __add_operator:
+				case __sub_operator:
+				case __nor_operator:one_operator_expr();break;
+				case __while:
+				case __for:
+				case __foreach:
+				case __forindex:parse.push(this_token);loop_expr();break;
+				case __continue:
+				case __break:check_semi_at_end();break;
+				case __semi:break;
+				case __return:return_expr();check_semi_at_end();break;
+				default:break;
+			}
+		}
+	}
+	else
+		parse.push(this_token);
+	return;
+}
+void generator::loop_expr()
+{
+	get_token();
+	if(this_token.type==__while)
+	{
+		get_token();
+		get_token();
+		switch(this_token.type)
+		{
+			case __add_operator:
+			case __sub_operator:
+			case __nor_operator:one_operator_expr();break;
+			case __number:number_begin_expr();break;
+			case __string:string_begin_expr();break;
+			case __id:identifier_begin_expr();break;
+			case __left_curve:in_curve_calc_expr();break;
+			default:break;
+		}
+		get_token();
+		get_token();
+		if(this_token.type==__left_brace)
+		{
+			// if without { then only one statement is behind it
+			parse.push(this_token);
+			statements_block();
+		}
+		else
+		{
+			token t;
+			switch(this_token.type)
+			{
+				case __var:definition_expr();check_semi_at_end();break;
+				case __id:identifier_begin_expr();check_semi_at_end();break;
+				case __number:number_begin_expr();check_semi_at_end();break;
+				case __string:string_begin_expr();check_semi_at_end();break;
+				case __if:parse.push(this_token);if_else_expr();break;
+				case __left_curve:
+					t=this_token;
+					get_token();
+					if(this_token.type==__var)
+					{
+						parse.push(t);
+						definition_expr();
+					}
+					else
+					{
+						in_curve_calc_expr();
+					}
+					check_semi_at_end();
+					break;
+				case __add_operator:
+				case __sub_operator:
+				case __nor_operator:one_operator_expr();break;
+				case __while:
+				case __for:
+				case __foreach:
+				case __forindex:parse.push(this_token);loop_expr();break;
+				case __continue:
+				case __break:check_semi_at_end();break;
+				case __semi:break;
+				case __return:return_expr();check_semi_at_end();break;
+				default:break;
+			}
+		}
+	}
+	else if(this_token.type==__for)
+	{
+		get_token();
+		get_token();
+		switch(this_token.type)
+		{
+			case __var:definition_expr();break;
+			case __id:identifier_begin_expr();break;
+			case __semi:parse.push(this_token);break;
+			default:break;
+		}
+		check_semi_at_end();
+		get_token();
+		switch(this_token.type)
+		{
+			case __add_operator:
+			case __sub_operator:
+			case __nor_operator:one_operator_expr();break;
+			case __id:identifier_begin_expr();break;
+			case __number:number_begin_expr();break;
+			case __string:string_begin_expr();break;
+			case __left_curve:in_curve_calc_expr();break;
+			case __semi:parse.push(this_token);break;
+			default:break;
+		}
+		check_semi_at_end();
+		get_token();
+		switch(this_token.type)
+		{
+			case __id:identifier_begin_expr();break;
+			case __number:number_begin_expr();break;
+			case __string:string_begin_expr();break;
+			case __left_curve:in_curve_calc_expr();break;
+			case __right_curve:parse.push(this_token);break;
+			default:break;
+		}
+		get_token();
+		get_token();
+		if(this_token.type==__left_brace)
+		{
+			// if without { then only one statement is behind it
+			parse.push(this_token);
+			statements_block();
+		}
+		else
+		{
+			token t;
+			switch(this_token.type)
+			{
+				case __var:definition_expr();check_semi_at_end();break;
+				case __id:identifier_begin_expr();check_semi_at_end();break;
+				case __number:number_begin_expr();check_semi_at_end();break;
+				case __string:string_begin_expr();check_semi_at_end();break;
+				case __if:parse.push(this_token);if_else_expr();break;
+				case __left_curve:
+					t=this_token;
+					get_token();
+					if(this_token.type==__var)
+					{
+						parse.push(t);
+						definition_expr();
+					}
+					else
+					{
+						in_curve_calc_expr();
+					}
+					check_semi_at_end();
+					break;
+				case __add_operator:
+				case __sub_operator:
+				case __nor_operator:one_operator_expr();break;
+				case __while:
+				case __for:
+				case __foreach:
+				case __forindex:parse.push(this_token);loop_expr();break;
+				case __continue:
+				case __break:check_semi_at_end();break;
+				case __semi:break;
+				case __return:return_expr();check_semi_at_end();break;
+				default:break;
+			}
+		}
+	}
+	else if(this_token.type==__forindex || this_token.type==__foreach)
+	{
+		get_token();
+		get_token();
+		switch(this_token.type)
+		{
+			case __var:definition_expr();break;
+			case __id:identifier_begin_expr();break;
+			case __semi:parse.push(this_token);break;
+			default:break;
+		}
+		check_semi_at_end();
+		get_token();
+		switch(this_token.type)
+		{
+			case __id:identifier_begin_expr();break;
+			case __number:number_begin_expr();break;
+			case __string:string_begin_expr();break;
+			case __left_curve:in_curve_calc_expr();break;
+			case __left_bracket:list_generate_expr();break;
+			case __right_curve:parse.push(this_token);break;
+			default:break;
+		}
+		get_token();
+		get_token();
+		if(this_token.type==__left_brace)
+		{
+			// if without { then only one statement is behind it
+			parse.push(this_token);
+			statements_block();
+		}
+		else
+		{
+			token t;
+			switch(this_token.type)
+			{
+				case __var:definition_expr();check_semi_at_end();break;
+				case __id:identifier_begin_expr();check_semi_at_end();break;
+				case __number:number_begin_expr();check_semi_at_end();break;
+				case __string:string_begin_expr();check_semi_at_end();break;
+				case __if:parse.push(this_token);if_else_expr();break;
+				case __left_curve:
+					t=this_token;
+					get_token();
+					if(this_token.type==__var)
+					{
+						parse.push(t);
+						definition_expr();
+					}
+					else
+					{
+						in_curve_calc_expr();
+					}
+					check_semi_at_end();
+					break;
+				case __add_operator:
+				case __sub_operator:
+				case __nor_operator:one_operator_expr();break;
+				case __while:
+				case __for:
+				case __foreach:
+				case __forindex:parse.push(this_token);loop_expr();break;
+				case __continue:
+				case __break:check_semi_at_end();break;
+				case __semi:break;
+				case __return:return_expr();check_semi_at_end();break;
+				default:break;
+			}
+		}
+	}
+	return;
+}
+void generator::add_sub_operator_expr()
+{
+	get_token();
+	switch(this_token.type)
+	{
+		case __number:number_begin_expr();break;
+		case __string:string_begin_expr();break;
+		case __id:identifier_begin_expr();break;
+		case __left_curve:in_curve_calc_expr();break;
+		default:break;
+	}
+	return;
+}
+void generator::mul_div_operator_expr()
+{
+	get_token();
+	switch(this_token.type)
+	{
+		case __number:number_begin_expr();break;
+		case __string:string_begin_expr();break;
+		case __id:identifier_begin_expr();break;
+		case __left_curve:in_curve_calc_expr();break;
+		default:break;
+	}
+	return;
+}
+void generator::link_operator_expr()
+{
+	get_token();
+	switch(this_token.type)
+	{
+		case __number:number_begin_expr();break;
+		case __string:string_begin_expr();break;
+		case __id:identifier_begin_expr();break;
+		case __left_curve:in_curve_calc_expr();break;
+		default:break;
+	}
+	return;
+}
+void generator::compare_operator_expr()
+{
+	get_token();
+	switch(this_token.type)
+	{
+		case __number:number_begin_expr();break;
+		case __string:string_begin_expr();break;
+		case __id:identifier_begin_expr();break;
+		case __left_curve:in_curve_calc_expr();break;
+		case __add_operator:
+		case __sub_operator:
+		case __nor_operator:one_operator_expr();break;
+		default:break;
+	}
+	return;
+}
+void generator::one_operator_expr()
+{
+	get_token();
+	switch(this_token.type)
+	{
+		case __number:number_begin_expr();break;
+		case __string:string_begin_expr();break;
+		case __id:identifier_begin_expr();break;
+		case __left_curve:in_curve_calc_expr();break;
+		default:break;
+	}
+	return;
+}
+void generator::in_curve_calc_expr()
+{
+	get_token();
+	switch(this_token.type)
+	{
+		case __add_operator:
+		case __sub_operator:
+		case __nor_operator:one_operator_expr();break;
+		case __number:number_begin_expr();break;
+		case __string:string_begin_expr();break;
+		case __id:identifier_begin_expr();break;
+		case __left_curve:in_curve_calc_expr();break;
+		default:parse.push(this_token);break;
+	}
+	get_token();
+	get_token();
+	switch(this_token.type)
+	{
+		case __add_operator:
+		case __sub_operator:add_sub_operator_expr();break;
+		case __mul_operator:
+		case __div_operator:mul_div_operator_expr();break;
+		case __link_operator:link_operator_expr();break;
+		case __and_operator:
+		case __or_operator:
+		case __cmp_equal:
+		case __cmp_not_equal:
+		case __cmp_less:
+		case __cmp_more:
+		case __cmp_less_or_equal:
+		case __cmp_more_or_equal:compare_operator_expr();break;
+		default:parse.push(this_token);break;
+	}
+	return;
+}
+void generator::number_begin_expr()
+{
+	get_token();
+	switch(this_token.type)
+	{
+		case __add_operator:
+		case __sub_operator:add_sub_operator_expr();break;
+		case __mul_operator:
+		case __div_operator:mul_div_operator_expr();break;
+		case __link_operator:link_operator_expr();break;
+		case __and_operator:
+		case __or_operator:
+		case __cmp_equal:
+		case __cmp_not_equal:
+		case __cmp_less:
+		case __cmp_more:
+		case __cmp_less_or_equal:
+		case __cmp_more_or_equal:compare_operator_expr();break;
+		default:parse.push(this_token);break;
+	}
+	return;
+}
+void generator::string_begin_expr()
+{
+	get_token();
+	switch(this_token.type)
+	{
+		case __add_operator:
+		case __sub_operator:add_sub_operator_expr();break;
+		case __mul_operator:
+		case __div_operator:mul_div_operator_expr();break;
+		case __link_operator:link_operator_expr();break;
+		case __and_operator:
+		case __or_operator:
+		case __cmp_equal:
+		case __cmp_not_equal:
+		case __cmp_less:
+		case __cmp_more:
+		case __cmp_less_or_equal:
+		case __cmp_more_or_equal:compare_operator_expr();break;
+		default:parse.push(this_token);break;
+	}
+	return;
+}
+void generator::call_list_expr()
+{
+	get_token();
+	switch(this_token.type)
+	{
+		case __number:number_begin_expr();break;
+		case __string:string_begin_expr();break;
+		case __id:identifier_begin_expr();break;
+		case __left_curve:in_curve_calc_expr();break;
+		default:break;
+	}
+	get_token();
+	if(this_token.type==__colon)// to check if there is [number:number] or [number:]
+	{
+		get_token();
+		switch(this_token.type)
+		{
+			case __number:number_begin_expr();break;
+			case __string:string_begin_expr();break;
+			case __id:identifier_begin_expr();break;
+			case __left_curve:in_curve_calc_expr();break;
+			case __right_bracket:return;break;// this is [number:]
+		}
+		get_token();
+		get_token();
+		switch(this_token.type)
+		{
+			case __left_bracket:call_list_expr();break;
+			case __left_curve:call_function_expr();break;
+			case __dot:call_hash_expr();break;
+			default:parse.push(this_token);break;
+		}
+	}
+	else if(this_token.type==__right_bracket)
+	{
+		get_token();
+		switch(this_token.type)
+		{
+			case __left_bracket:call_list_expr();break;
+			case __left_curve:call_function_expr();break;
+			case __dot:call_hash_expr();break;
+			default:parse.push(this_token);break;
+		}
+	}
+	return;
+}
+void generator::call_function_expr()
+{
+	get_token();
+	while(this_token.type!=__right_curve)
+	{
+		switch(this_token.type)
+		{
+			case __number:number_begin_expr();break;
+			case __string:string_begin_expr();break;
+			case __id:identifier_begin_expr();break;
+			case __left_bracket:list_generate_expr();break;
+			case __left_brace:hash_generate_expr();break;
+			case __left_curve:in_curve_calc_expr();break;
+			case __func:function_generate_expr();break;
+			default:break;
+		}
+		get_token();
+		if(this_token.type==__comma)
+			get_token();
+	}
+	get_token();
+	switch(this_token.type)
+	{
+		case __left_bracket:call_list_expr();break;
+		case __left_curve:call_function_expr();break;
+		case __dot:call_hash_expr();break;
+		default:parse.push(this_token);break;
+	}
+	return;
+}
+void generator::call_hash_expr()
+{
+	get_token();
+	identifier_begin_expr();
+	return;
+}
+void generator::identifier_begin_expr()
+{
+	// __id has been checked
+	get_token();
+	switch(this_token.type)
+	{
+		case __left_bracket:call_list_expr();break;
+		case __left_curve:call_function_expr();break;
+		case __dot:call_hash_expr();break;
+		case __add_operator:
+		case __sub_operator:add_sub_operator_expr();break;
+		case __mul_operator:
+		case __div_operator:mul_div_operator_expr();break;
+		case __link_operator:link_operator_expr();break;
+		case __and_operator:
+		case __or_operator:
+		case __cmp_equal:
+		case __cmp_not_equal:
+		case __cmp_less:
+		case __cmp_more:
+		case __cmp_less_or_equal:
+		case __cmp_more_or_equal:compare_operator_expr();break;
+		default:parse.push(this_token);break;
+	}
+	get_token();
+	switch(this_token.type)
+	{
+		case __add_operator:
+		case __sub_operator:add_sub_operator_expr();break;
+		case __mul_operator:
+		case __div_operator:mul_div_operator_expr();break;
+		case __link_operator:link_operator_expr();break;
+		case __and_operator:
+		case __or_operator:
+		case __cmp_equal:
+		case __cmp_not_equal:
+		case __cmp_less:
+		case __cmp_more:
+		case __cmp_less_or_equal:
+		case __cmp_more_or_equal:compare_operator_expr();break;
+		case __equal:
+		case __add_equal:
+		case __sub_equal:
+		case __mul_equal:
+		case __div_equal:
+		case __link_equal:assignment_expr();break;
+		default:parse.push(this_token);break;
+	}
+	return;
+}
+void generator::gen_main_work()
+{
+	while(!parse.empty())
+	{
+		get_token();
+		token t;
+		switch(this_token.type)
+		{
+			case __var:definition_expr();check_semi_at_end();break;
+			case __id:identifier_begin_expr();check_semi_at_end();break;
+			case __number:number_begin_expr();check_semi_at_end();break;
+			case __string:string_begin_expr();check_semi_at_end();break;
+			case __left_curve:
+				t=this_token;
+				get_token();
+				if(this_token.type==__var)
+				{
+					parse.push(t);
+					definition_expr();
+				}
+				else
+				{
+					in_curve_calc_expr();
+				}
+				check_semi_at_end();
+				break;
+			case __if:parse.push(this_token);if_else_expr();break;
+			case __add_operator:
+			case __sub_operator:
+			case __nor_operator:one_operator_expr();break;
+			case __while:
+			case __for:
+			case __foreach:
+			case __forindex:parse.push(this_token);loop_expr();break;
+			case __semi:break;
+			default:break;
+		}
+	}
+	std::cout<<">>[Abstract-syntax-tree] complete generation."<<std::endl;
+	return;
+}
+
+#endif