diff --git a/version1.2/hello.nas b/version1.2/hello.nas
new file mode 100644
index 0000000..fdc302d
--- /dev/null
+++ b/version1.2/hello.nas
@@ -0,0 +1 @@
+print("hello world!\n");
\ No newline at end of file
diff --git a/version1.2/nasal_parser.h b/version1.2/nasal_parser.h
index 63e3de8..d40b6f0 100644
--- a/version1.2/nasal_parser.h
+++ b/version1.2/nasal_parser.h
@@ -247,7 +247,7 @@ abstract_syntax_tree nasal_parser::function_generate_expr()
 		while(this_token.type!=__right_curve)
 		{
 			temp.set_clear();
-			if(this_token.type==__id)
+			if(this_token.type==__id || this_token.type==__dynamic_id)
 			{
 				temp.set_node_type(__id);
 				temp.set_var_name(this_token.content);
diff --git a/version1.2/nasal_runtime.h b/version1.2/nasal_runtime.h
index 67cd1dc..5c6784d 100644
--- a/version1.2/nasal_runtime.h
+++ b/version1.2/nasal_runtime.h
@@ -42,8 +42,43 @@ class var
 			std::cout<<"[ type: ";print_token(type);std::cout<<" ]";
 			std::cout<<"[ name: "<<name<<" ]";
 			std::cout<<"[ number: "<<number<<" ]";
-			std::cout<<"[ string: "<<str<<" ]";
-			std::cout<<std::endl;
+			std::cout<<"[ string: "<<str<<" ]"<<std::endl;
+			std::cout<<"[ function: ";
+			function.print_tree(1);
+			std::cout<<" ]"<<std::endl;
+			return;
+		}
+		void print_detail()
+		{
+			switch(type)
+			{
+				case __function:
+					std::cout<<std::endl<<">>[Runtime-error] function type cannot be printed."<<std::endl;
+					break;
+				case __number:
+					std::cout<<number;
+					break;
+				case __string:
+					for(int i=1;i<str.length()-1;++i)
+					{
+						if(str[i]!='\\')
+							std::cout<<str[i];
+						else
+						{
+							switch(str[i+1])
+							{
+								case 'n':std::cout<<"\n";++i;break;
+								case 't':std::cout<<"\t";++i;break;
+								case 'r':std::cout<<"\r";++i;break;
+								case '\\':std::cout<<"\\";++i;break;
+								case '\'':std::cout<<"\'";++i;break;
+								case '\"':std::cout<<"\"";++i;break;
+								default:std::cout<<"\\";break;
+							}
+						}
+					}
+					break;
+			}
 			return;
 		}
 		void set_type(const int var_type)
@@ -91,6 +126,10 @@ class var
 			var_hash.push_back(p);
 			return;
 		}
+		int get_type()
+		{
+			return type;
+		}
 		std::string get_name()
 		{
 			return name;
@@ -121,18 +160,21 @@ class var_scope_manager
 {
 	private:
 		std::list<std::list<var>> scope_list;
+		std::list<int> scope_type;
 		var error_var;
 	public:
 		var_scope_manager()
 		{
 			scope_list.clear();
-			std::string str="err_ret";
+			std::string str="__nas_strc_error_ret";
 			error_var.set_name(str);
+			error_var.set_type(__null_type);
 			return;
 		}
 		void set_clear()
 		{
 			scope_list.clear();
+			scope_type.clear();
 			return;
 		}
 		var& search_var(std::string str)
@@ -141,40 +183,66 @@ class var_scope_manager
 				for(std::list<var>::iterator j=i->begin();j!=i->end();++j)
 					if(j->get_name()==str)
 						return *j;
-			std::cout<<">>[Runtime] could not find the var named '"<<str<<"' ."<<std::endl;
+			std::cout<<std::endl<<">>[Runtime-error] could not find the var '"<<str<<"' ."<<std::endl;
 			return error_var;
 		}
 		void add_var(var new_var)
 		{
-			for(std::list<std::list<var>>::iterator i=scope_list.begin();i!=scope_list.end();++i)
+			std::list<std::list<var>>::iterator i=scope_list.begin();
+			std::list<int>::iterator t=scope_type.begin();
+			// get global scopes
+			for(;i!=scope_list.end();++i,++t)
+			{
+				if(*t!=__function)
+				{
+					for(std::list<var>::iterator j=i->begin();j!=i->end();++j)
+						if(j->get_name()==new_var.get_name())
+						{
+							std::cout<<std::endl<<">>[Runtime-error] redeclaration of var '"<<new_var.get_name()<<"' ."<<std::endl;
+							return;
+						}
+				}
+			}
+			// get parameters_list scope
+			i=scope_list.end();
+			--i;
+			t=scope_type.end();
+			--t;
+			if(*t==__function)
+			{
 				for(std::list<var>::iterator j=i->begin();j!=i->end();++j)
 					if(j->get_name()==new_var.get_name())
 					{
-						std::cout<<">>[Runtime] redeclaration of var '"<<new_var.get_name()<<"' ."<<std::endl;
+						std::cout<<std::endl<<">>[Runtime-error] redeclaration of var '"<<new_var.get_name()<<"' ."<<std::endl;
 						return;
 					}
+			}
 			if(!scope_list.empty())
 			{
-				std::list<std::list<var>>::iterator i=scope_list.end();
+				i=scope_list.end();
 				--i;
 				i->push_back(new_var);
 			}
 			else
-				std::cout<<">>[Runtime] empty scope list."<<std::endl;
+				std::cout<<std::endl<<">>[Runtime-error] empty scope list."<<std::endl;
 			return;
 		}
-		void add_new_scope()
+		void add_new_scope(int type)
 		{
 			std::list<var> new_list;
 			scope_list.push_back(new_list);
+			scope_type.push_back(type);
 			return;
 		}
 		void pop_last_scope()
 		{
 			if(!scope_list.empty())
+			{
 				scope_list.pop_back();
+				scope_type.pop_back();
+			}
 			else
-				std::cout<<">>[Runtime] scope poped empty thing."<<std::endl;
+				std::cout<<std::endl<<">>[Runtime-error] scope poped empty thing."<<std::endl;
 			return;
 		}
 };
@@ -195,9 +263,10 @@ class nasal_runtime
 			std::cout<<">>[Runtime] process begins."<<std::endl;
 			int time_beg,time_end;
 			time_beg=time(NULL);
+			scope.set_clear();
 			run_root(root);
 			time_end=time(NULL);
-			std::cout<<">>[Runtime] process exited after "<<time_beg-time_end<<" sec(s)."<<std::endl;
+			std::cout<<std::endl<<">>[Runtime] process exited after "<<time_beg-time_end<<" sec(s)."<<std::endl;
 			return;
 		}
 		void set_root(abstract_syntax_tree& tree)
@@ -211,17 +280,21 @@ class nasal_runtime
 		void run_assignment(abstract_syntax_tree& tree);
 		void run_loop(abstract_syntax_tree& tree);
 		void run_if_else(abstract_syntax_tree& tree);
-		void run_block(abstract_syntax_tree& tree);
+		void run_block(abstract_syntax_tree& tree,int run_type);
 		void run_root(abstract_syntax_tree& tree);
 		var run_calculation(abstract_syntax_tree& tree);
 		var run_function(abstract_syntax_tree& tree);
+		var list_generation(abstract_syntax_tree& tree);
+		var hash_generation(abstract_syntax_tree& tree);
+		var list_search(abstract_syntax_tree& tree);
+		var hash_search(abstract_syntax_tree& tree);
 		var identifier_call(abstract_syntax_tree& tree);
 		var scalar_call(abstract_syntax_tree& tree);
 };
 
 void nasal_runtime::run_root(abstract_syntax_tree& tree)
 {
-	scope.add_new_scope();
+	scope.add_new_scope(__root);
 	if(!tree.get_children().empty())
 	{
 		for(std::list<abstract_syntax_tree>::iterator i=tree.get_children().begin();i!=tree.get_children().end();++i)
@@ -322,14 +395,14 @@ void nasal_runtime::run_definition(abstract_syntax_tree& tree)
 			case __id:
 			case __hash_search:
 			case __list_search:
-				new_var=identifier_call(*iter);
 				break;
 			case __number:
 			case __string:
 				new_var=scalar_call(*iter);
 				break;
 			case __function:
-				;
+				new_var.set_type(__function);
+				new_var.set_function(*iter);
 				break;
 			case __list:
 				break;
@@ -357,9 +430,9 @@ void nasal_runtime::run_if_else(abstract_syntax_tree& tree)
 {
 	return;
 }
-void nasal_runtime::run_block(abstract_syntax_tree& tree)
+void nasal_runtime::run_block(abstract_syntax_tree& tree,int run_type)
 {
-	scope.add_new_scope();
+	scope.add_new_scope(run_type);
 	
 	scope.pop_last_scope();
 	return;
@@ -367,22 +440,175 @@ void nasal_runtime::run_block(abstract_syntax_tree& tree)
 
 var nasal_runtime::run_calculation(abstract_syntax_tree& tree)
 {
-	var null_var;
-	return null_var;
+	var ret_var;
+	var left_child;
+	var right_child;
+	
+	std::list<abstract_syntax_tree>::iterator i;
+	i=tree.get_children().begin();
+	switch(i->get_type())
+	{
+		case __id:left_child=identifier_call(*i);break;
+		case __number:
+		case __string:left_child=scalar_call(*i);break;
+		case __call_function:left_child=run_function(*i);break;
+		case __list_search:left_child=list_search(*i);break;
+		case __hash_search:left_child=hash_search(*i);break;
+		case __or_operator:
+		case __and_operator:
+		case __add_operator:
+		case __mul_operator:
+		case __div_operator:
+		case __link_operator:
+		case __nor_operator:
+		case __sub_operator:
+		case __cmp_equal:
+		case __cmp_not_equal:
+		case __cmp_less:
+		case __cmp_less_or_equal:
+		case __cmp_more:
+		case __cmp_more_or_equal:left_child=run_calculation(*i);break;
+		default:std::cout<<">>[Runtime-error] invalid var."<<std::endl;break;
+	}
+	++i;
+	if(i==tree.get_children().end())
+		return left_child;
+	switch(i->get_type())
+	{
+		case __id:right_child=identifier_call(*i);break;
+		case __number:
+		case __string:right_child=scalar_call(*i);break;
+		case __call_function:right_child=run_function(*i);break;
+		case __list_search:right_child=list_search(*i);break;
+		case __hash_search:right_child=hash_search(*i);break;
+		case __or_operator:
+		case __and_operator:
+		case __add_operator:
+		case __mul_operator:
+		case __div_operator:
+		case __link_operator:
+		case __nor_operator:
+		case __sub_operator:
+		case __cmp_equal:
+		case __cmp_not_equal:
+		case __cmp_less:
+		case __cmp_less_or_equal:
+		case __cmp_more:
+		case __cmp_more_or_equal:right_child=run_calculation(*i);break;
+		default:std::cout<<">>[Runtime-error] invalid var."<<std::endl;break;
+	}
+	switch(tree.get_type())
+	{
+		case __or_operator:
+		case __and_operator:
+			break;
+		case __add_operator:
+		case __mul_operator:
+		case __div_operator:
+		case __link_operator:
+			break;
+		case __nor_operator:
+		case __sub_operator:
+			break;
+		case __cmp_equal:
+		case __cmp_not_equal:
+		case __cmp_less:
+		case __cmp_less_or_equal:
+		case __cmp_more:
+		case __cmp_more_or_equal:
+			break;
+	}
+	return ret_var;
 }
 var nasal_runtime::run_function(abstract_syntax_tree& tree)
 {
-	var null_var;
-	return null_var;
+	var ret_var;
+	scope.add_new_scope(__function);
+	if(tree.get_var_name()=="print")
+	{
+		std::list<var> dynamic_para;
+		var list_member;
+		for(std::list<abstract_syntax_tree>::iterator i=tree.get_children().begin();i!=tree.get_children().end();++i)
+		{
+			switch(i->get_type())
+			{
+				case __id:list_member=identifier_call(*i);break;
+				case __number:
+				case __string:list_member=scalar_call(*i);break;
+				case __call_function:list_member=run_function(*i);break;
+				case __list_search:list_member=list_search(*i);break;
+				case __hash_search:list_member=hash_search(*i);break;
+				case __or_operator:
+				case __and_operator:
+				case __add_operator:
+				case __mul_operator:
+				case __div_operator:
+				case __link_operator:
+				case __nor_operator:
+				case __sub_operator:
+				case __cmp_equal:
+				case __cmp_not_equal:
+				case __cmp_less:
+				case __cmp_less_or_equal:
+				case __cmp_more:
+				case __cmp_more_or_equal:list_member=run_calculation(*i);break;
+				default:std::cout<<">>[Runtime-error] invalid var."<<std::endl;break;
+			}
+			dynamic_para.push_back(list_member);
+		}
+		for(std::list<var>::iterator i=dynamic_para.begin();i!=dynamic_para.end();++i)
+			i->print_detail();
+	}
+	scope.pop_last_scope();
+	return ret_var;
+}
+var nasal_runtime::list_generation(abstract_syntax_tree& tree)
+{
+	var new_list;
+	new_list.set_type(__list);
+	return new_list;
+}
+var nasal_runtime::hash_generation(abstract_syntax_tree& tree)
+{
+	var new_hash;
+	new_hash.set_type(__hash);
+	return new_hash;
+}
+var nasal_runtime::list_search(abstract_syntax_tree& tree)
+{
+	var ret_var;
+	return ret_var;
+}
+var nasal_runtime::hash_search(abstract_syntax_tree& tree)
+{
+	var ret_var;
+	return ret_var;
 }
 var nasal_runtime::identifier_call(abstract_syntax_tree& tree)
 {
-	var null_var;
-	return null_var;
+	var ret_var;
+	ret_var=scope.search_var(tree.get_var_name());
+	if(ret_var.get_type()==__null_type)
+		return ret_var;
+	if(ret_var.get_type()==__number)
+		std::cout<<ret_var.get_number()<<std::endl;
+	else if(ret_var.get_type()==__string)
+		std::cout<<ret_var.get_string()<<std::endl;
+	return ret_var;
 }
 var nasal_runtime::scalar_call(abstract_syntax_tree& tree)
 {
-	var null_var;
-	return null_var;
+	var ret_var;
+	if(tree.get_type()==__number)
+	{
+		ret_var.set_type(__number);
+		ret_var.set_number(tree.get_var_number());
+	}
+	else if(tree.get_type()==__string)
+	{
+		ret_var.set_type(__string);
+		ret_var.set_string(tree.get_var_string());
+	}
+	return ret_var;
 }
 #endif