using System;

namespace TreeConverter
{

	public class system_lib_initializer
	{

		private compiled_type_node _bool_type;
		private compiled_type_node _integer_type;
		private compiled_type_node _real_type;
		private compiled_type_node _char_type;
		private compiled_type_node _string_type;

		private compiled_type_node _pointer_type;
		private basic_function_node _int_add;
		private basic_function_node _int_sub;

		private unit_node _system_unit;

		private bool_const_node _true_constant;
		private bool_const_node _false_constant;

		private constant_definition_node _true_constant_definition;
		private constant_definition_node _false_constant_definition;

		public unit_node system_unit
		{
			get
			{
				return _system_unit;
			}
		}

		public basic_function_node int_add
		{
			get
			{
				return _int_add;
			}
		}

		public basic_function_node int_sub
		{
			get
			{
				return _int_sub;
			}
		}

		//private base_interface_node _ipascal_enumerable;

		/*public base_interface_node ipascal_enumerable
		{
			get
			{
				return _ipascal_enumerable;
			}
		}*/

		public type_node bool_type
		{
			get
			{
				return _bool_type;
			}
		}

		public type_node integer_type
		{
			get
			{
				return _integer_type;
			}
		}

		public type_node real_type
		{
			get
			{
				return _real_type;
			}
		}

		public type_node char_type
		{
			get
			{
				return _char_type;
			}
		}

		public type_node string_type
		{
			get
			{
				return _string_type;
			}
		}

		public type_node pointer_type
		{
			get
			{
				return _pointer_type;
			}
		}
		private basic_function_node make_common_binary_operation(string operator_name,compiled_type_node def_type,compiled_type_node left,
			compiled_type_node right,SemanticTree.basic_function_type bft,type_node ret_value_type)
		{
			parameterArrayList pars=new parameterArrayList();
			basic_function_node bfn=new basic_function_node(bft,pars,ret_value_type);
			bfn.is_overload=true;
			basic_parameter par_left=new basic_parameter(compiler_string_consts.left_param_name,left,
				SemanticTree.parameter_type.value,bfn);
			basic_parameter par_right=new basic_parameter(compiler_string_consts.right_param_name,right,
				SemanticTree.parameter_type.value,bfn);
			pars.Add(par_left);
			pars.Add(par_right);
			def_type.add_additional_name(operator_name,new SymbolInfo(bfn));
			return bfn;
		}

		private void make_unary_operator(string operator_name,compiled_type_node to,SemanticTree.basic_function_type bft)
		{
			make_unary_operator(operator_name,to,bft,to);
		}

		private void make_unary_operator(string operator_name,compiled_type_node to,
			SemanticTree.basic_function_type bft,type_node ret_value_type)
		{
			parameterArrayList pars=new parameterArrayList();
			basic_function_node bfn=new basic_function_node(bft,pars,ret_value_type);
			bfn.is_overload=true;
			basic_parameter par=new basic_parameter(compiler_string_consts.unary_param_name,to,
				SemanticTree.parameter_type.value,bfn);
			pars.Add(par);
			to.add_additional_name(operator_name,new SymbolInfo(bfn));
		}

		private basic_function_node make_binary_operator(string operator_name,compiled_type_node to,SemanticTree.basic_function_type bft)
		{
			return make_binary_operator(operator_name,to,bft,to);
		}

		private basic_function_node make_binary_operator(string operator_name,compiled_type_node to,
			SemanticTree.basic_function_type bft,type_node ret_value_type)
		{
			/*parameterArrayList pars=new parameterArrayList();
			basic_function_node bfn=new basic_function_node(bft,pars,ret_value_type);
			basic_parameter par_left=new basic_parameter(compiler_string_consts.left_param_name,to,
				SemanticTree.parameter_type.value,bfn);
			basic_parameter par_right=new basic_parameter(compiler_string_consts.right_param_name,to,
				SemanticTree.parameter_type.value,bfn);
			pars.Add(par_left);
			pars.Add(par_right);
			to.add_additional_name(operator_name,new SymbolInfo(bfn));*/
			return make_common_binary_operation(operator_name,to,to,to,bft,ret_value_type);
		}

		private void make_type_conversion(compiled_type_node from,compiled_type_node to,type_compare tc,
			SemanticTree.basic_function_type bft)
		{
			parameterArrayList pars=new parameterArrayList();
			basic_function_node conv_method=new basic_function_node(bft,pars,to);
			basic_parameter bp=new basic_parameter(compiler_string_consts.unary_param_name,
				from,SemanticTree.parameter_type.value,conv_method);
			pars.Add(bp);

			type_intersection_node inter_node=new type_intersection_node(tc);
			inter_node.this_to_another=new type_conversion_factory(conv_method);
			from.add_intersection_node(to,inter_node);
		}

		private void make_assign_operator(compiled_type_node ctn,SemanticTree.basic_function_type bft)
		{
			make_compiled_object_operator(compiler_string_consts.assign_name,ctn,bft,SemanticTree.parameter_type.var);
		}

		private void make_compiled_object_operator(string name,compiled_type_node tp,SemanticTree.basic_function_type bft,
			SemanticTree.parameter_type first_param_type)
		{
			parameterArrayList pars=new parameterArrayList();
			basic_function_node bfn=new basic_function_node(bft,pars,tp);
			bfn.is_overload=true;
			basic_parameter to=new basic_parameter(compiler_string_consts.left_param_name,tp,
				first_param_type,bfn);
			basic_parameter from=new basic_parameter(compiler_string_consts.right_param_name,tp,
				SemanticTree.parameter_type.value,bfn);
			pars.Add(to);
			pars.Add(from);
			tp.add_additional_name(name,new SymbolInfo(bfn));
		}

		private void make_compiled_object_operator(string name,compiled_type_node tp,SemanticTree.basic_function_type bft)
		{
			make_compiled_object_operator(name,tp,bft,SemanticTree.parameter_type.value);
		}

		private void make_reference_object_assign_operator(compiled_type_node tp)
		{
			make_compiled_object_operator(compiler_string_consts.assign_name,tp,
				SemanticTree.basic_function_type.objassign,SemanticTree.parameter_type.var);
		}

		private void make_reference_object_eq_operator(compiled_type_node tp)
		{
			make_compiled_object_operator(compiler_string_consts.eq_name,tp,SemanticTree.basic_function_type.objeq);
		}

		private void make_reference_object_noteq_operator(compiled_type_node tp)
		{
			make_compiled_object_operator(compiler_string_consts.noteq_name,tp,SemanticTree.basic_function_type.objnoteq);
		}

		public void init_reference_type(compiled_type_node ctn)
		{
			make_reference_object_assign_operator(ctn);
			make_reference_object_eq_operator(ctn);
			make_reference_object_noteq_operator(ctn);
		}

		//No v drugom smisle reference.
		private void make_object_operator(ref_type_node ctn,SemanticTree.basic_function_type bas_ft,
			string name,type_node ret_type,SemanticTree.parameter_type first_parameter_type)
		{
			parameterArrayList pars=new parameterArrayList();
			basic_function_node bfn=new basic_function_node(bas_ft,pars,ret_type);
			bfn.is_overload=true;
			basic_parameter to=new basic_parameter(compiler_string_consts.left_param_name,ctn,
				first_parameter_type,bfn);
			basic_parameter from=new basic_parameter(compiler_string_consts.right_param_name,ctn,
				SemanticTree.parameter_type.value,bfn);
			pars.Add(to);
			pars.Add(from);
			ctn.add_additional_name(name,new SymbolInfo(bfn));
		}

		private void make_object_operator(ref_type_node ctn,SemanticTree.basic_function_type bas_ft,string name,
			type_node ret_type)
		{
			make_object_operator(ctn,bas_ft,name,ret_type,SemanticTree.parameter_type.value);
		}

		private void make_assign_operator(ref_type_node ctn)
		{
			make_object_operator(ctn,SemanticTree.basic_function_type.objassign,compiler_string_consts.assign_name,
				ctn,SemanticTree.parameter_type.var);
		}

		private void make_equivalence_operator(ref_type_node ctn)
		{
			make_object_operator(ctn,SemanticTree.basic_function_type.objeq,compiler_string_consts.eq_name,_bool_type);
		}

		private void make_not_equivalence_operator(ref_type_node ctn)
		{
			make_object_operator(ctn,SemanticTree.basic_function_type.objnoteq,compiler_string_consts.noteq_name,_bool_type);
		}

		public void init_reference_type(ref_type_node ctn)
		{
			make_assign_operator(ctn);
			make_equivalence_operator(ctn);
			make_not_equivalence_operator(ctn);
		}
		//End: No v drugom smisle reference.

		public void make_empty_operator(string name,compiled_type_node ctn)
		{
			parameterArrayList pars=new parameterArrayList();
			empty_function_node efn=new empty_function_node(pars,ctn);
			efn.is_overload=true;
			basic_parameter par=new basic_parameter(compiler_string_consts.unary_param_name,ctn,
				SemanticTree.parameter_type.value,null);
			pars.Add(par);
			ctn.add_additional_name(name,new SymbolInfo(efn));
		}

		private basic_function_node create_oti_method(SemanticTree.basic_function_type bft,type_node type)
		{
			parameterArrayList pal=new parameterArrayList();
			basic_function_node bfn=new basic_function_node(bft,pal,type);
			common_parameter cp=new common_parameter(compiler_string_consts.unary_param_name,type,
				SemanticTree.parameter_type.var,null);
			pal.Add(cp);
			bfn.is_overload=true;
			return bfn;
		}

		public int int_to_int(constant_node cn)
		{
#if (DEBUG)
			if (cn.semantic_node_type!=semantic_node_type.int_const_node)
			{
				throw new CompilerInternalError("Error in static type conversion");
			}
#endif
			int_const_node icn=(int_const_node)cn;
			return icn.const_value;
		}

		public int char_to_int(constant_node cn)
		{
#if (DEBUG)
			if (cn.semantic_node_type!=semantic_node_type.char_const_node)
			{
				throw new CompilerInternalError("Error in static type conversion");
			}
#endif
			char_const_node icn=(char_const_node)cn;
			return ((int)icn.const_value);
		}

		private void mark_int_as_ordinal()
		{
			ordinal_type_interface oti=new ordinal_type_interface();
			oti.inc_method=create_oti_method(SemanticTree.basic_function_type.iinc,_integer_type);
			oti.dec_method=create_oti_method(SemanticTree.basic_function_type.idec,_integer_type);
			
			SymbolInfo si=_integer_type.find_in_additional_names(compiler_string_consts.greq_name);
			basic_function_node bfn=(basic_function_node)si.sym_info;
			
			oti.greater_eq_method=bfn;

			si=_integer_type.find_in_additional_names(compiler_string_consts.smeq_name);
			bfn=(basic_function_node)si.sym_info;

			oti.lower_eq_method=bfn;

			constant_node cn_max=new int_const_node(int.MinValue,_integer_type);
			constant_node cn_min=new int_const_node(int.MinValue,_integer_type);

			oti.upper_value=cn_max;
			oti.lower_value=cn_min;

			parameterArrayList pal=new parameterArrayList();
			empty_function_node efn=new empty_function_node(pal,_integer_type);
			common_parameter cp=new common_parameter(compiler_string_consts.unary_param_name,_integer_type,
				SemanticTree.parameter_type.value,null);
			
			oti.value_to_int=efn;
			oti.ordinal_type_to_int=new ordinal_type_to_int(int_to_int);
			_integer_type.add_internal_interface(oti);
		}

		private void mark_char_as_ordinal()
		{
			ordinal_type_interface oti=new ordinal_type_interface();
			oti.inc_method=create_oti_method(SemanticTree.basic_function_type.cinc,_char_type);
			oti.dec_method=create_oti_method(SemanticTree.basic_function_type.cdec,_char_type);
			
			SymbolInfo si=_char_type.find_in_additional_names(compiler_string_consts.greq_name);
			basic_function_node bfn=(basic_function_node)si.sym_info;
			
			oti.greater_eq_method=bfn;

			si=_char_type.find_in_additional_names(compiler_string_consts.smeq_name);
			bfn=(basic_function_node)si.sym_info;

			oti.lower_eq_method=bfn;

			constant_node cn_max=new int_const_node(char.MaxValue,_char_type);
			constant_node cn_min=new int_const_node(char.MinValue,_char_type);

			oti.upper_value=cn_max;
			oti.lower_value=cn_min;

			parameterArrayList pal=new parameterArrayList();
			bfn=new basic_function_node(SemanticTree.basic_function_type.chartoi,pal,_integer_type);
			common_parameter cp=new common_parameter(compiler_string_consts.unary_param_name,_char_type,
				SemanticTree.parameter_type.value,null);
			
			oti.value_to_int=bfn;
			oti.ordinal_type_to_int=new ordinal_type_to_int(char_to_int);
			_char_type.add_internal_interface(oti);
		}

		//Спросить у Вани. Мой NetHelper не поддерживает такие операциию
		private void NetInitialize()
		{
			/*
			NetHelper.AddType(typeof(int), _integer_type);
			NetHelper.AddType(typeof(bool), _bool_type);
			NetHelper.AddType(typeof(double), _real_type);
			NetHelper.AddType(typeof(char), _char_type);
			NetHelper.AddType(typeof(string), _string_type);
			*/
		}

		private void initialize_types()
		{
			_integer_type=compiled_type_node.get_type_node(typeof(int));
			_bool_type=compiled_type_node.get_type_node(typeof(bool));
			_real_type=compiled_type_node.get_type_node(typeof(double));
			_char_type=compiled_type_node.get_type_node(typeof(char));
			_string_type=compiled_type_node.get_type_node(typeof(string));

			_pointer_type=compiled_type_node.get_type_node(Type.GetType("System.Void*"));
			NetInitialize();

			//Преобразования типов.
			make_type_conversion(_integer_type,_real_type,type_compare.less_type,SemanticTree.basic_function_type.itod);

			//Операции для типа integer.
			//Присваивание для integer.
			make_assign_operator(_integer_type,SemanticTree.basic_function_type.iassign);

			//Унарные операции.
			make_unary_operator(compiler_string_consts.minus_name,_integer_type,SemanticTree.basic_function_type.iunmin);
			make_unary_operator(compiler_string_consts.not_name,_integer_type,SemanticTree.basic_function_type.inot);
			make_empty_operator(compiler_string_consts.plus_name,_integer_type);
			
			//Арифметические операции.
			_int_add=make_binary_operator(compiler_string_consts.plus_name,_integer_type,SemanticTree.basic_function_type.iadd);
			_int_sub=make_binary_operator(compiler_string_consts.minus_name,_integer_type,SemanticTree.basic_function_type.isub);
			make_binary_operator(compiler_string_consts.mul_name,_integer_type,SemanticTree.basic_function_type.imul);
			make_binary_operator(compiler_string_consts.idiv_name,_integer_type,SemanticTree.basic_function_type.idiv);
			make_binary_operator(compiler_string_consts.mod_name,_integer_type,SemanticTree.basic_function_type.imod);
			//Операция / для integer.
			make_common_binary_operation(compiler_string_consts.div_name,_integer_type,_real_type,_real_type,
				SemanticTree.basic_function_type.ddiv,_real_type);

			//Опрерации сравнения.
			make_binary_operator(compiler_string_consts.gr_name,_integer_type,SemanticTree.basic_function_type.igr,_bool_type);
			make_binary_operator(compiler_string_consts.greq_name,_integer_type,SemanticTree.basic_function_type.igreq,_bool_type);
			make_binary_operator(compiler_string_consts.sm_name,_integer_type,SemanticTree.basic_function_type.ism,_bool_type);
			make_binary_operator(compiler_string_consts.smeq_name,_integer_type,SemanticTree.basic_function_type.ismeq,_bool_type);
			make_binary_operator(compiler_string_consts.eq_name,_integer_type,SemanticTree.basic_function_type.ieq,_bool_type);
			make_binary_operator(compiler_string_consts.noteq_name,_integer_type,SemanticTree.basic_function_type.inoteq,_bool_type);

			//Логические опреции.
			make_binary_operator(compiler_string_consts.and_name,_integer_type,SemanticTree.basic_function_type.iand);
			make_binary_operator(compiler_string_consts.or_name,_integer_type,SemanticTree.basic_function_type.ior);
			make_binary_operator(compiler_string_consts.xor_name,_integer_type,SemanticTree.basic_function_type.ixor);
			make_binary_operator(compiler_string_consts.shl_name,_integer_type,SemanticTree.basic_function_type.ishl);
			make_binary_operator(compiler_string_consts.shr_name,_integer_type,SemanticTree.basic_function_type.ishr);

			//real type.
			//Assign.
			make_assign_operator(_real_type,SemanticTree.basic_function_type.dassign);

			//Унарные операции.
			make_unary_operator(compiler_string_consts.minus_name,_real_type,SemanticTree.basic_function_type.dunmin);
			make_empty_operator(compiler_string_consts.plus_name,_real_type);

			//Арифметические операции.
			make_binary_operator(compiler_string_consts.plus_name,_real_type,SemanticTree.basic_function_type.dadd);
			make_binary_operator(compiler_string_consts.minus_name,_real_type,SemanticTree.basic_function_type.dsub);
			make_binary_operator(compiler_string_consts.mul_name,_real_type,SemanticTree.basic_function_type.dmul);
			make_binary_operator(compiler_string_consts.div_name,_real_type,SemanticTree.basic_function_type.ddiv);

			//Опрерации сравнения.
			make_binary_operator(compiler_string_consts.gr_name,_real_type,SemanticTree.basic_function_type.dgr,_bool_type);
			make_binary_operator(compiler_string_consts.greq_name,_real_type,SemanticTree.basic_function_type.dgreq,_bool_type);
			make_binary_operator(compiler_string_consts.sm_name,_real_type,SemanticTree.basic_function_type.dsm,_bool_type);
			make_binary_operator(compiler_string_consts.smeq_name,_real_type,SemanticTree.basic_function_type.dsmeq,_bool_type);
			make_binary_operator(compiler_string_consts.eq_name,_real_type,SemanticTree.basic_function_type.deq,_bool_type);
			make_binary_operator(compiler_string_consts.noteq_name,_real_type,SemanticTree.basic_function_type.dnoteq,_bool_type);

			//char type.
			//Assign.
			make_assign_operator(_char_type,SemanticTree.basic_function_type.charassign);

			//Опрерации сравнения.
			make_binary_operator(compiler_string_consts.gr_name,_char_type,SemanticTree.basic_function_type.chargr,_bool_type);
			make_binary_operator(compiler_string_consts.greq_name,_char_type,SemanticTree.basic_function_type.chargreq,_bool_type);
			make_binary_operator(compiler_string_consts.sm_name,_char_type,SemanticTree.basic_function_type.charsm,_bool_type);
			make_binary_operator(compiler_string_consts.smeq_name,_char_type,SemanticTree.basic_function_type.charsmeq,_bool_type);
			make_binary_operator(compiler_string_consts.eq_name,_char_type,SemanticTree.basic_function_type.chareq,_bool_type);
			make_binary_operator(compiler_string_consts.noteq_name,_char_type,SemanticTree.basic_function_type.charnoteq,_bool_type);

			//boolean type.
			//Assign.
			make_assign_operator(_bool_type,SemanticTree.basic_function_type.boolassign);

			//Логические операции.
			//Унарные операции.
			make_unary_operator(compiler_string_consts.not_name,_bool_type,SemanticTree.basic_function_type.bnot);

			//Логическме операции.
			make_binary_operator(compiler_string_consts.and_name,_bool_type,SemanticTree.basic_function_type.band);
			make_binary_operator(compiler_string_consts.or_name,_bool_type,SemanticTree.basic_function_type.bor);
			make_binary_operator(compiler_string_consts.xor_name,_bool_type,SemanticTree.basic_function_type.bxor);
			make_unary_operator(compiler_string_consts.not_name,_bool_type,SemanticTree.basic_function_type.boolnot);

			//Опрерации сравнения.
			make_binary_operator(compiler_string_consts.gr_name,_bool_type,SemanticTree.basic_function_type.boolgr);
			make_binary_operator(compiler_string_consts.greq_name,_bool_type,SemanticTree.basic_function_type.boolgreq);
			make_binary_operator(compiler_string_consts.sm_name,_bool_type,SemanticTree.basic_function_type.boolsm);
			make_binary_operator(compiler_string_consts.smeq_name,_bool_type,SemanticTree.basic_function_type.boolsmeq);
			make_binary_operator(compiler_string_consts.eq_name,_bool_type,SemanticTree.basic_function_type.booleq);
			make_binary_operator(compiler_string_consts.noteq_name,_bool_type,SemanticTree.basic_function_type.boolnoteq);

			mark_int_as_ordinal();
			mark_char_as_ordinal();
		}

		private void init_constants(SymbolTable.Scope sc)
		{
			_true_constant=new bool_const_node(true,_bool_type);
			_false_constant=new bool_const_node(false,_bool_type);

			_true_constant_definition=new constant_definition_node(compiler_string_consts.true_const_name,_true_constant);
			_false_constant_definition=new constant_definition_node(compiler_string_consts.false_const_name,_false_constant);

			sc.AddSymbol(compiler_string_consts.true_const_name,new SymbolInfo(_true_constant_definition));
			sc.AddSymbol(compiler_string_consts.false_const_name,new SymbolInfo(_false_constant_definition));
		}

		private void init_temp_methods(SymbolTable.Scope sc)
		{
			//TODO: Сделано по быстрому. Переделать.
			Type tp=typeof(Console);
			compiled_function_node cfn;
			System.Type[] arr=new System.Type[1];
			System.Reflection.MethodInfo mi;
			
			arr[0]=typeof(int);
			mi=tp.GetMethod("WriteLine",arr);
			cfn=new compiled_function_node(mi);
			cfn.parameters.Clear();
			cfn.parameters.Add(new common_parameter("val",_integer_type,SemanticTree.parameter_type.value,null));
			sc.AddSymbol("writeln",new SymbolInfo(cfn));

			arr[0]=typeof(double);
			mi=tp.GetMethod("WriteLine",arr);
			cfn=new compiled_function_node(mi);
			cfn.parameters.Clear();
			cfn.parameters.Add(new common_parameter("val",_real_type,SemanticTree.parameter_type.value,null));
			sc.AddSymbol("writeln",new SymbolInfo(cfn));

			arr[0]=typeof(char);
			mi=tp.GetMethod("WriteLine",arr);
			cfn=new compiled_function_node(mi);
			cfn.parameters.Clear();
			cfn.parameters.Add(new common_parameter("val",_char_type,SemanticTree.parameter_type.value,null));
			sc.AddSymbol("writeln",new SymbolInfo(cfn));

			arr[0]=typeof(bool);
			mi=tp.GetMethod("WriteLine",arr);
			cfn=new compiled_function_node(mi);
			cfn.parameters.Clear();
			cfn.parameters.Add(new common_parameter("val",_bool_type,SemanticTree.parameter_type.value,null));
			sc.AddSymbol("writeln",new SymbolInfo(cfn));

			arr[0]=typeof(string);
			mi=tp.GetMethod("WriteLine",arr);
			cfn=new compiled_function_node(mi);
			cfn.parameters.Clear();
			cfn.parameters.Add(new common_parameter("val",_string_type,SemanticTree.parameter_type.value,null));
			sc.AddSymbol("writeln",new SymbolInfo(cfn));

			mi=tp.GetMethod("ReadLine",new System.Type[0]);
			cfn=new compiled_function_node(mi);
			cfn.parameters.Clear();
			cfn.return_value_type=_string_type;
			sc.AddSymbol("readline",new SymbolInfo(cfn));

			make_assign_operator(_string_type,SemanticTree.basic_function_type.objassign);

			tp=typeof(int);
			arr[0]=typeof(string);
			mi=tp.GetMethod("Parse",arr);
			cfn=new compiled_function_node(mi);
			cfn.parameters.Clear();
			cfn.parameters.Add(new common_parameter("val",_string_type,SemanticTree.parameter_type.value,null));
			cfn.return_value_type=_integer_type;
			sc.AddSymbol("parseint",new SymbolInfo(cfn));

			tp=typeof(double);
			arr[0]=typeof(string);
			mi=tp.GetMethod("Parse",arr);
			cfn=new compiled_function_node(mi);
			cfn.parameters.Clear();
			cfn.parameters.Add(new common_parameter("val",_string_type,SemanticTree.parameter_type.value,null));
			cfn.return_value_type=_real_type;
			sc.AddSymbol("parsereal",new SymbolInfo(cfn));

			tp=typeof(bool);
			arr[0]=typeof(string);
			mi=tp.GetMethod("Parse",arr);
			cfn=new compiled_function_node(mi);
			cfn.parameters.Clear();
			cfn.parameters.Add(new common_parameter("val",_string_type,SemanticTree.parameter_type.value,null));
			cfn.return_value_type=_bool_type;
			sc.AddSymbol("parsebool",new SymbolInfo(cfn));

			tp=typeof(char);
			arr[0]=typeof(string);
			mi=tp.GetMethod("Parse",arr);
			cfn=new compiled_function_node(mi);
			cfn.parameters.Clear();
			cfn.parameters.Add(new common_parameter("val",_string_type,SemanticTree.parameter_type.value,null));
			cfn.return_value_type=_char_type;
			sc.AddSymbol("parsechar",new SymbolInfo(cfn));
			common_namespace_function_node cnfn = new common_namespace_function_node("New",null);
			cnfn.parameters.Clear();
			cnfn.parameters.Add(new common_parameter("ptr",_pointer_type,SemanticTree.parameter_type.value,null));
			sc.AddSymbol("new",new SymbolInfo(cnfn));
			
			cnfn = new common_namespace_function_node("Dispose",null);
			cnfn.parameters.Clear();
			cnfn.parameters.Add(new common_parameter("ptr",_pointer_type,SemanticTree.parameter_type.value,null));
			sc.AddSymbol("dispose",new SymbolInfo(cnfn));
		}

		private void make_types()
		{
			/*
			if (_integer_type!=null)
			{
				return;
			}
			*/
			initialize_types();
		}

		private void init_procedures(convertion_data_and_alghoritms conv,SymbolTable.Scope susc)
		{
			pseudo_function break_procedure=new pseudo_function(compiler_string_consts.break_procedure_name,
				new pseudo_function_algorithm(conv.syntax_tree_visitor.make_break_node));

			susc.AddSymbol(compiler_string_consts.break_procedure_name,new SymbolInfo(break_procedure));

			pseudo_function continue_procedure=new pseudo_function(compiler_string_consts.continue_procedure_name,
				new pseudo_function_algorithm(conv.syntax_tree_visitor.make_continue_node));

			susc.AddSymbol(compiler_string_consts.continue_procedure_name,new SymbolInfo(continue_procedure));
		}

		private void make_system_unit(convertion_data_and_alghoritms conv)
		{
			_system_unit=new unit_node();
			_system_unit.scope=conv.symbol_table.CreateUnitInterfaceScope(new SymbolTable.Scope[0]);

			SymbolTable.Scope susc=_system_unit.scope;
			//Добавляем типы.
			susc.AddSymbol(compiler_string_consts.integer_type_name,new SymbolInfo(_integer_type));
			susc.AddSymbol(compiler_string_consts.real_type_name,new SymbolInfo(_real_type));
			susc.AddSymbol(compiler_string_consts.char_type_name,new SymbolInfo(_char_type));
			susc.AddSymbol(compiler_string_consts.bool_type_name,new SymbolInfo(_bool_type));
			susc.AddSymbol(compiler_string_consts.string_type_name,new SymbolInfo(_string_type));

			susc.AddSymbol(compiler_string_consts.pointer_type_name,new SymbolInfo(_pointer_type));
			init_constants(susc);
			init_procedures(conv,susc);
			init_temp_methods(susc);
		}

		private void make_object_operator(common_type_node ctn,SemanticTree.basic_function_type bas_ft,
			string name,type_node ret_type,SemanticTree.parameter_type first_parameter_type)
		{
			parameterArrayList pars=new parameterArrayList();
			basic_function_node bfn=new basic_function_node(bas_ft,pars,ret_type);
			bfn.is_overload=true;
			basic_parameter to=new basic_parameter(compiler_string_consts.left_param_name,ctn,
				first_parameter_type,bfn);
			basic_parameter from=new basic_parameter(compiler_string_consts.right_param_name,ctn,
				SemanticTree.parameter_type.value,bfn);
			pars.Add(to);
			pars.Add(from);
			ctn.Scope.AddSymbol(name,new SymbolInfo(bfn));
		}

		private void make_object_operator(common_type_node ctn,SemanticTree.basic_function_type bas_ft,string name,
			type_node ret_type)
		{
			make_object_operator(ctn,bas_ft,name,ret_type,SemanticTree.parameter_type.value);
		}

		private void make_assign_operator(common_type_node ctn)
		{
			make_object_operator(ctn,SemanticTree.basic_function_type.objassign,compiler_string_consts.assign_name,
				ctn,SemanticTree.parameter_type.var);
		}

		private void make_equivalence_operator(common_type_node ctn)
		{
			make_object_operator(ctn,SemanticTree.basic_function_type.objeq,compiler_string_consts.eq_name,_bool_type);
		}

		private void make_not_equivalence_operator(common_type_node ctn)
		{
			make_object_operator(ctn,SemanticTree.basic_function_type.objnoteq,compiler_string_consts.noteq_name,_bool_type);
		}

		public void init_reference_type(common_type_node ctn)
		{
			make_assign_operator(ctn);
			make_equivalence_operator(ctn);
			make_not_equivalence_operator(ctn);
		}

		public bool is_initialized
		{
			get
			{
				return (_integer_type!=null);
			}
		}

		public void initialize(convertion_data_and_alghoritms conv)
		{
			if (is_initialized)
			{
				return;
			}
			make_types();
			make_system_unit(conv);
		}

		public system_lib_initializer()
		{
			compiled_type_node.set_system_lib_initializer(this);
			ref_type_node.set_system_lib_initializer(this);
		}


	}

}