/* private static void mark_byte_as_ordinal() { basic_function_node inc_value_method = create_inc_value_method(SemanticTree.basic_function_type.binc, _byte_type); basic_function_node dec_value_method = create_dec_value_method(SemanticTree.basic_function_type.bdec, _byte_type); basic_function_node inc_method = create_inc_method(SemanticTree.basic_function_type.binc, _byte_type); basic_function_node dec_method = create_dec_method(SemanticTree.basic_function_type.bdec, _byte_type); SymbolInfo si = _byte_type.find_in_type(compiler_string_consts.greq_name); basic_function_node greq = (basic_function_node)si.sym_info; si = _byte_type.find(compiler_string_consts.smeq_name); basic_function_node loeq = (basic_function_node)si.sym_info; constant_node cn_max = new byte_const_node(byte.MaxValue, null); constant_node cn_min = new byte_const_node(byte.MinValue, null); basic_function_node i2i_method = create_emty_function(byte_type); ordinal_type_to_int ordinal_type_to_int = byte_to_int; ordinal_type_interface oti = new ordinal_type_interface(inc_method, dec_method, inc_value_method, dec_value_method, internal_inc_value, internal_dec_value, loeq, greq, cn_min, cn_max, i2i_method, ordinal_type_to_int); _byte_type.add_internal_interface(oti); } */ private static void mark_type_as_ordinal(type_node type, SemanticTree.basic_function_type inc,SemanticTree.basic_function_type dec, SemanticTree.basic_function_type vinc, SemanticTree.basic_function_type vdec, constant_node lower_value, constant_node upper_value, function_node t2i,ordinal_type_to_int t2i_comp) { basic_function_node inc_value = create_oti_method(inc, type, SemanticTree.parameter_type.value); basic_function_node dec_value = create_oti_method(dec, type, SemanticTree.parameter_type.value); basic_function_node inc_var = create_oti_method(vinc, type, SemanticTree.parameter_type.var); basic_function_node dec_var = create_oti_method(vdec, type, SemanticTree.parameter_type.var); SymbolInfo si = type.find_in_type(compiler_string_consts.greq_name); basic_function_node greq = (basic_function_node)si.sym_info; si = type.find(compiler_string_consts.smeq_name); basic_function_node loeq = (basic_function_node)si.sym_info; si = type.find(compiler_string_consts.sm_name); basic_function_node lo = (basic_function_node)si.sym_info; si = type.find(compiler_string_consts.gr_name); basic_function_node gr = (basic_function_node)si.sym_info; ordinal_type_interface oti = new ordinal_type_interface(inc_value, dec_value, inc_var, dec_var, loeq, greq, lo, gr, lower_value, upper_value, t2i, t2i_comp); type.add_internal_interface(oti); }
private void dot_node_as_type_ident(type_node tn, SyntaxTree.ident id_right, motivation mot) { SymbolInfo si_right = tn.find_in_type(id_right.name, context.CurrentScope); if (si_right == null) { AddError(new MemberIsNotDeclaredInType(id_right, get_location(id_right), tn)); } switch (mot) { case motivation.address_reciving: { return_addressed_value(create_addressed_with_type_expression(tn, id_right, si_right)); return; } case motivation.expression_evaluation: { return_value(create_static_expression(tn, id_right, si_right)); return; } case motivation.semantic_node_reciving: { if (si_right.sym_info.general_node_type == general_node_type.type_node) return_semantic_value(si_right.sym_info as type_node); else return_semantic_value(create_static_expression(tn, id_right, si_right)); return; } } throw new CompilerInternalError("Invalid motivation"); }
public static bool type_has_default_ctor(type_node tn, bool find_protected_ctors) { SymbolInfo si = tn.find_in_type(compiler_string_consts.default_constructor_name, tn.Scope); while (si != null) { function_node fn = si.sym_info as function_node; if (find_protected_ctors || fn.field_access_level == PascalABCCompiler.SemanticTree.field_access_level.fal_public) { compiled_constructor_node pconstr = fn as compiled_constructor_node; common_method_node mconstr = fn as common_method_node; if ((pconstr != null || mconstr != null && mconstr.is_constructor) && (fn.parameters.Count == 0 || fn.parameters[0].default_value != null) ) { //Нашли конструктор по умолчанию у предка return true; } } si = si.Next; } return false; }
private base_function_call create_constructor_call(type_node tn, expressions_list exprs, location loc, Tuple<bool, List<SyntaxTree.expression>> lambdas_info = null) { if (tn.IsInterface) { AddError(loc, "INTERFACE_{0}_CONSTRUCTOR_CALL", tn.name); } if (tn.IsAbstract) { AddError(loc, "ABSTRACT_CONSTRUCTOR_{0}_CALL", tn.name); } SymbolInfo si = tn.find_in_type(TreeConverter.compiler_string_consts.default_constructor_name, context.CurrentScope); //tn.Scope); delete_inherited_constructors(ref si, tn); if (si == null) AddError(loc, "CONSTRUCTOR_NOT_FOUND"); function_node fnn = null; try { #region Если встретились лямбды в фактических параметрах, то выбираем нужную функцию из перегруженных, выводим типы, отмечаем флаг в лямбдах, говорящий о том, что мы их реально обходим //lroman// if (lambdas_info != null && lambdas_info.Item1) { LambdaHelper.processingLambdaParametersForTypeInference++; var syntax_nodes_parameters = lambdas_info.Item2; // SSM 21.05.14 - попытка обработать перегруженные функции с параметрами-лямбдами с различными возвращаемыми значениями function_node_list spf = null; try { function_node fn = convertion_data_and_alghoritms.select_function(exprs, si, loc, syntax_nodes_parameters); int exprCounter = 0; foreach (SyntaxTree.expression en in syntax_nodes_parameters) { if (!(en is SyntaxTree.function_lambda_definition)) { exprCounter++; continue; } else { var enLambda = (SyntaxTree.function_lambda_definition)en; LambdaHelper.InferTypesFromVarStmt(fn.parameters[exprCounter].type, enLambda, this); enLambda.lambda_visit_mode = LambdaVisitMode.VisitForAdvancedMethodCallProcessing; exprs[exprCounter] = convert_strong(en); enLambda.lambda_visit_mode = LambdaVisitMode.VisitForInitialMethodCallProcessing; exprCounter++; } } } catch (SeveralFunctionsCanBeCalled sf) { spf = sf.set_of_possible_functions; // Возможны несколько перегруженных версий - надо выводить дальше в надежде что какие-то уйдут и останется одна } Exception lastmultex = null; if (spf != null) // пытаемся инстанцировать одну за другой и ошибки гасим try { // exprs - глобальная, поэтому надо копировать int spfnum = -1; // spfnum - первый номер правильно инстанцированной. Пока -1. Если потом встретился второй, то тоже ошибка int GoodVersionsCount = 0; int GoodVersionsCountWithSameResType = 0; for (int i = 0; i < spf.Count; i++) { function_node fn = spf[i]; try { int exprCounter = 0; expressions_list exprs1 = new expressions_list(); exprs1.AddRange(exprs); // сделали копию foreach (SyntaxTree.expression en in syntax_nodes_parameters) { if (!(en is SyntaxTree.function_lambda_definition)) { exprCounter++; continue; } else { var fld = en as SyntaxTree.function_lambda_definition; var lambdaName = fld.lambda_name; //lroman Сохранять имя необходимо var fl = fld.lambda_visit_mode; // запомнили типы параметров лямбды - SSM object[] realparamstype = new object[fld.formal_parameters.params_list.Count]; // здесь хранятся выведенные типы лямбд или null если типы явно заданы for (var k = 0; k < fld.formal_parameters.params_list.Count; k++) { var laminftypeK = fld.formal_parameters.params_list[k].vars_type as SyntaxTree.lambda_inferred_type; if (laminftypeK == null) realparamstype[k] = null; else realparamstype[k] = laminftypeK.real_type; } // запоминаем реальный тип возвращаемого значения если он не указан явно (это должен быть any_type или null если он указан явно) - он может измениться при следующем вызове, поэтому мы его восстановим var restype = fld.return_type as SyntaxTree.lambda_inferred_type; object realrestype = null; if (restype != null) realrestype = restype.real_type; LambdaHelper.InferTypesFromVarStmt(fn.parameters[exprCounter].type, fld, this); fld.lambda_visit_mode = LambdaVisitMode.VisitForAdvancedMethodCallProcessing; //lroman fld.lambda_name = LambdaHelper.GetAuxiliaryLambdaName(lambdaName); // поправляю имя. Думаю, назад возвращать не надо. ПРОВЕРИТЬ! //contextChanger.SaveContextAndUpToNearestDefSect(); try { exprs1[exprCounter] = convert_strong(en); type_node resexprtype = fld.RealSemTypeOfResExpr as type_node; type_node resformaltype = fld.RealSemTypeOfResult as type_node; var bbb = resexprtype == resformaltype; // только в одном случае должно быть true - эту версию и надо выбирать. Если в нескольких, то неоднозначность if (bbb) { GoodVersionsCountWithSameResType += 1; spfnum = i; // здесь запоминаем индекс потому что он точно подойдет. Тогда ниже он запоминаться не будет. } /*var tt = fn.parameters[exprCounter].type as compiled_type_node; if (tt != null && tt.compiled_type.FullName.ToLower().StartsWith("system.func")) { resformaltype = tt.instance_params[tt.instance_params.Count - 1]; // Последний параметр в записи Func<T,T1,...TN> - тип возвращаемого значения var bbb = resexprtype == resformaltype; // только в одном случае должно быть true - эту версию и надо выбирать. Если в нескольких, то неоднозначность if (bbb) { GoodVersionsCountWithSameResType += 1; spfnum = i; // здесь запоминаем индекс потому что он точно подойдет. Тогда ниже он запоминаться не будет. } }*/ } catch { throw; } finally { LambdaHelper.RemoveLambdaInfoFromCompilationContext(context, en as function_lambda_definition); // восстанавливаем сохраненный тип возвращаемого значения if (restype != null) restype.real_type = realrestype; // восстанавливаем сохраненные типы параметров лямбды, которые не были заданы явно for (var k = 0; k < fld.formal_parameters.params_list.Count; k++) { var laminftypeK = fld.formal_parameters.params_list[k].vars_type as SyntaxTree.lambda_inferred_type; if (laminftypeK != null) laminftypeK.real_type = realparamstype[k]; } fld.lambda_name = lambdaName; //lroman Восстанавливаем имена fld.lambda_visit_mode = fl; } //contextChanger.RestoreCurrentContext(); exprCounter++; } } /*if (spfnum >= 0) // два удачных инстанцирования - плохо. Может, одно - с более близким типом возвращаемого значения, тогда это плохо - надо доделать, но пока так { spfnum = -2; break; }*/ if (GoodVersionsCountWithSameResType == 0) spfnum = i; // здесь запоминаем индекс только если нет подошедших, совпадающих по типу возвращаемого значения GoodVersionsCount += 1; for (int j = 0; j < exprs.Count; j++) // копируем назад если всё хорошо exprs[j] = exprs1[j]; } catch (Exception e) { // если сюда попали, значит, не вывели типы в лямбде и надо эту инстанцию пропускать //contextChanger.RestoreCurrentContext(); lastmultex = e; } } if (GoodVersionsCount > 1 && GoodVersionsCountWithSameResType != 1) // подошло много, но не было ровно одной с совпадающим типом возвращаемого значения throw new SeveralFunctionsCanBeCalled(loc, spf); if (GoodVersionsCount == 0) // было много, но ни одна не подошла из-за лямбд { throw lastmultex; //throw new NoFunctionWithSameArguments(subloc2, false); } var kk = 0; foreach (SyntaxTree.expression en in syntax_nodes_parameters) //lroman окончательно подставить типы в лямбды { if (!(en is SyntaxTree.function_lambda_definition)) { kk++; continue; } else { LambdaHelper.InferTypesFromVarStmt(spf[spfnum].parameters[kk].type, en as SyntaxTree.function_lambda_definition, this); exprs[kk] = convert_strong(en); kk++; } } } // SSM 21.05.14 end LambdaHelper.processingLambdaParametersForTypeInference--; fnn = convertion_data_and_alghoritms.select_function(exprs, si, loc); } //lroman// #endregion else { fnn = convertion_data_and_alghoritms.select_function(exprs, si, loc); } } catch (NoFunctionWithSameParametresNum e) { e.is_constructor = true; throw; } return create_static_method_call_with_params(fnn, loc, tn, false, exprs); }
private type_node create_array_type(ordinal_type_interface oti_indexer, type_node element_type,common_namespace_node _cmn, location loc) { int arr_length = oti_indexer.ordinal_type_to_int(oti_indexer.upper_value) - oti_indexer.ordinal_type_to_int(oti_indexer.lower_value) + 1; if (arr_length <= 0) { throw new SimpleSemanticError(loc, "NEGATIVE_ARRAY_LENGTH_({0})_NOT_ALLOWED", arr_length); } simple_array sa = new simple_array(element_type, arr_length); //sa.length = arr_length; //sa.element_type = element_type; SymbolTable.Scope top_scope = null; if (_cmn != null) { top_scope = _cmn.scope; } string name = get_pascal_array_name(); //if (_cmn.namespace_name != null) // name = _cmn.namespace_name + name; common_type_node ctn = new common_type_node(null, name, SemanticTree.type_access_level.tal_public, _cmn, convertion_data_and_alghoritms.symbol_table.CreateClassScope(top_scope, null), loc); ctn.SetBaseType(SystemLibrary.SystemLibrary.object_type); //DarkStar Add //loc не нужно мне это! и некому не нужно! //loc = null; //ctn.internal_is_value = true; class_constant_definition cdn1 = new class_constant_definition(compiler_string_consts.lower_array_const_name, oti_indexer.lower_value, loc, ctn, SemanticTree.field_access_level.fal_public); ctn.scope.AddSymbol(cdn1.name, new SymbolInfo(cdn1)); class_constant_definition cdn2 = new class_constant_definition(compiler_string_consts.upper_array_const_name, oti_indexer.upper_value, loc, ctn, SemanticTree.field_access_level.fal_public); ctn.scope.AddSymbol(cdn2.name, new SymbolInfo(cdn2)); class_field int_arr = new class_field(compiler_string_consts.internal_array_name, sa, ctn, SemanticTree.polymorphic_state.ps_common, SemanticTree.field_access_level.fal_public,loc); ctn.scope.AddSymbol(int_arr.name, new SymbolInfo(int_arr)); ctn.fields.AddElement(int_arr); SystemLibrary.SystemLibrary.init_reference_type(ctn); ctn.const_defs.AddElement(cdn1); ctn.const_defs.AddElement(cdn2); common_method_node get_func = new common_method_node(compiler_string_consts.get_val_pascal_array_name, element_type, /*loc*/new location(0xFFFFFF, 0, 0xFFFFFF, 0, loc.doc), ctn, SemanticTree.polymorphic_state.ps_common, SemanticTree.field_access_level.fal_private, convertion_data_and_alghoritms.symbol_table.CreateScope(ctn.scope)); common_parameter get_param = new common_parameter(compiler_string_consts.unary_param_name, oti_indexer.lower_value.type, SemanticTree.parameter_type.value, get_func, concrete_parameter_type.cpt_none, null, loc); get_func.parameters.AddElement(get_param); common_parameter_reference cpr = new common_parameter_reference(get_param, 0, loc); expression_node en1 = convertion_data_and_alghoritms.create_simple_function_call(oti_indexer.value_to_int, loc, cpr); expression_node en2 = new int_const_node(oti_indexer.ordinal_type_to_int(oti_indexer.lower_value), loc); expression_node sub_expr = convertion_data_and_alghoritms.create_simple_function_call( SystemLibrary.SystemLibrary.int_sub, loc, en1, en2); this_node thisnode = new this_node(ctn, loc); class_field_reference cfr1 = new class_field_reference(int_arr, thisnode, loc); expression_node index_expr = new simple_array_indexing(cfr1, sub_expr, element_type, loc); statement_node sn = new return_node(index_expr, /*loc*/new location(0xFFFFFF, 0, 0xFFFFFF, 0, loc.doc)); get_func.function_code = sn; common_method_node set_func = new common_method_node(compiler_string_consts.set_val_pascal_array_name, null, /*loc*/new location(0xFFFFFF, 0, 0xFFFFFF, 0, loc.doc), ctn, SemanticTree.polymorphic_state.ps_common, SemanticTree.field_access_level.fal_private, convertion_data_and_alghoritms.symbol_table.CreateScope(ctn.scope)); common_parameter set_ind = new common_parameter(compiler_string_consts.left_param_name, oti_indexer.lower_value.type, SemanticTree.parameter_type.value, set_func, concrete_parameter_type.cpt_none, null, loc); set_func.parameters.AddElement(set_ind); common_parameter set_val = new common_parameter(compiler_string_consts.right_param_name, element_type, SemanticTree.parameter_type.value, set_func, concrete_parameter_type.cpt_none, null, loc); set_func.parameters.AddElement(set_val); common_parameter_reference cpr2 = new common_parameter_reference(set_ind, 0, loc); expression_node en3 = convertion_data_and_alghoritms.create_simple_function_call(oti_indexer.value_to_int, loc, cpr2); expression_node en4 = new int_const_node(oti_indexer.ordinal_type_to_int(oti_indexer.lower_value), loc); expression_node sub_expr2 = convertion_data_and_alghoritms.create_simple_function_call( SystemLibrary.SystemLibrary.int_sub, loc, en3, en4); class_field_reference cfr2 = new class_field_reference(int_arr, thisnode, loc); expression_node index_expr2 = new simple_array_indexing(cfr2, sub_expr2, element_type,loc); SymbolInfo si = element_type.find_in_type(compiler_string_consts.assign_name); if (si == null) { throw new NotSupportedError(loc); throw new CompilerInternalError("Varable of this type can not be assigned"); } if (si.sym_info.general_node_type != general_node_type.function_node) { throw new CompilerInternalError("Invalid assign operator"); } expression_node val_ref = new common_parameter_reference(set_val, 0, loc); function_node assign = (function_node)si.sym_info; statement_node assign_call = convertion_data_and_alghoritms.create_simple_function_call(assign, /*loc*/new location(0xFFFFFF, 0, 0xFFFFFF, 0, loc.doc), index_expr2, val_ref); set_func.function_code = assign_call; ctn.methods.AddElement(get_func); ctn.methods.AddElement(set_func); common_property_node cpn = new common_property_node(compiler_string_consts.index_property_pascal_array_name, ctn, element_type, get_func, set_func, loc, SemanticTree.field_access_level.fal_public, SemanticTree.polymorphic_state.ps_common); common_parameter prop_cp = new common_parameter(compiler_string_consts.unary_param_name, oti_indexer.lower_value.type, SemanticTree.parameter_type.value, null, concrete_parameter_type.cpt_none, null, loc); cpn.parameters.AddElement(prop_cp); ctn.properties.AddElement(cpn); ctn.default_property = cpn; if (_cmn != null) { _cmn.types.AddElement(ctn); } bounded_array_interface bai = new bounded_array_interface(oti_indexer, element_type, cpn, oti_indexer.lower_value.type, int_arr); ctn.add_internal_interface(bai); ctn.type_special_kind = SemanticTree.type_special_kind.array_wrapper; if (element_type.type_special_kind != SemanticTree.type_special_kind.array_wrapper) { ctn.ImplementingInterfaces.Add(compiled_type_node.get_type_node(NetHelper.NetHelper.FindType(compiler_string_consts.IEnumerableInterfaceName))); common_method_node en_cmn = new common_method_node(compiler_string_consts.GetEnumeratorMethodName, compiled_type_node.get_type_node(NetHelper.NetHelper.FindType(compiler_string_consts.IEnumeratorInterfaceName)), null, ctn, SemanticTree.polymorphic_state.ps_virtual, SemanticTree.field_access_level.fal_public, null); compiled_function_node en_fnc = NetHelper.NetHelper.FindName(NetHelper.NetHelper.FindType(compiler_string_consts.IEnumerableInterfaceName), compiler_string_consts.GetEnumeratorMethodName).sym_info as compiled_function_node; statements_list sl = new statements_list(null); sl.statements.AddElement(new return_node( new compiled_function_call(en_fnc, new class_field_reference(int_arr, new this_node(ctn, null), null), null), null)); en_cmn.function_code = sl; en_cmn.newslot_awaited = true; ctn.methods.AddElement(en_cmn); if (!element_type.IsPointer) { List<type_node> generic_args = new List<type_node>(); generic_args.Add(element_type); type_node en_tn = compiled_type_node.get_type_node(NetHelper.NetHelper.FindType(compiler_string_consts.IGenericEnumerableInterfaceName)).get_instance(generic_args); ctn.ImplementingInterfaces.Add(en_tn); en_cmn = new common_method_node(compiler_string_consts.GetEnumeratorMethodName, compiled_type_node.get_type_node(NetHelper.NetHelper.FindType(compiler_string_consts.IGenericEnumeratorInterfaceName)).get_instance(generic_args), null, ctn, SemanticTree.polymorphic_state.ps_virtual, SemanticTree.field_access_level.fal_public, null); //en_fnc = en_tn.find_in_type("GetEnumerator").sym_info as function_node;//NetHelper.NetHelper.FindName(NetHelper.NetHelper.FindType(compiler_string_consts.IGenericEnumerableInterfaceName), compiler_string_consts.GetEnumeratorMethodName).sym_info as compiled_function_node; SymbolInfo en_si = en_tn.find_in_type("GetEnumerator"); if (en_si.Next != null && (en_si.Next.sym_info as function_node).return_value_type.is_generic_type_instance) en_si = en_si.Next; function_node en_fnc_inst = en_si.sym_info as function_node; ;//.get_instance(generic_args, true, loc); sl = new statements_list(null); if (en_fnc_inst is compiled_function_node) sl.statements.AddElement(new return_node( new compiled_function_call(en_fnc_inst as compiled_function_node, new class_field_reference(int_arr, new this_node(ctn, null), null), null), null)); else sl.statements.AddElement(new return_node( new common_method_call(en_fnc_inst as common_method_node, new class_field_reference(int_arr, new this_node(ctn, null), null), null), null)); en_cmn.function_code = sl; en_cmn.newslot_awaited = true; ctn.methods.AddElement(en_cmn); } } //= operation SymbolTable.ClassMethodScope scope = convertion_data_and_alghoritms.symbol_table.CreateClassMethodScope(_cmn.scope,ctn.scope); common_method_node cmn_eq = new common_method_node(compiler_string_consts.GetNETOperName(compiler_string_consts.eq_name),SystemLibrary.SystemLibrary.bool_type,null,ctn, SemanticTree.polymorphic_state.ps_static,SemanticTree.field_access_level.fal_public,scope); cmn_eq.IsOperator = true; common_parameter prm1 = new common_parameter("a",ctn,SemanticTree.parameter_type.value,cmn_eq,concrete_parameter_type.cpt_none,null,null); common_parameter prm2 = new common_parameter("b",ctn,SemanticTree.parameter_type.value,cmn_eq,concrete_parameter_type.cpt_none,null,null); cmn_eq.parameters.AddElement(prm1); cmn_eq.parameters.AddElement(prm2); statements_list body = new statements_list(null); local_variable vdn = new local_variable("$i",SystemLibrary.SystemLibrary.integer_type,cmn_eq,null);//this.convertion_data_and_alghoritms.syntax_tree_visitor.context.create_for_temp_variable(SystemLibrary.SystemLibrary.integer_type, null); cmn_eq.var_definition_nodes_list.AddElement(vdn); expression_node var_ref = new local_variable_reference(vdn,0,null);//this.convertion_data_and_alghoritms.syntax_tree_visitor.create_variable_reference(vdn,null); basic_function_call cond = new basic_function_call(SystemLibrary.SystemLibrary.int_sm as basic_function_node,null); cond.parameters.AddElement(var_ref); cond.parameters.AddElement(new int_const_node(arr_length,null)); while_node while_stmt = new while_node(cond,null); statements_list while_body = new statements_list(null); while_stmt.body = while_body; simple_array_indexing left_sar = new simple_array_indexing(new class_field_reference(int_arr, new common_parameter_reference(prm1,0,null), null),var_ref,element_type,null); simple_array_indexing right_sar = new simple_array_indexing(new class_field_reference(int_arr, new common_parameter_reference(prm2,0,null), null),var_ref,element_type,null); expression_node cond2 = SystemLibrary.SystemLibrary.syn_visitor.find_operator(compiler_string_consts.noteq_name, left_sar,right_sar,null); if_node if_stmt = new if_node(cond2,new return_node(new bool_const_node(false,null),null),null,null); while_body.statements.AddElement(if_stmt); while_body.statements.AddElement(new basic_function_call(SystemLibrary.SystemLibrary.int_assign as basic_function_node,null ,var_ref,new basic_function_call(SystemLibrary.SystemLibrary.int_add as basic_function_node,null,var_ref,new int_const_node(1,null)))); body.statements.AddElement(while_stmt); body.statements.AddElement(new return_node(new bool_const_node(true,null),null)); cmn_eq.function_code = body; cmn_eq.is_overload = true; ctn.methods.AddElement(cmn_eq); ctn.Scope.AddSymbol(compiler_string_consts.eq_name,new SymbolInfo(cmn_eq)); //<> operation scope = convertion_data_and_alghoritms.symbol_table.CreateClassMethodScope(_cmn.scope,ctn.scope); common_method_node cmn_noteq = new common_method_node(compiler_string_consts.GetNETOperName(compiler_string_consts.noteq_name),SystemLibrary.SystemLibrary.bool_type,null,ctn, SemanticTree.polymorphic_state.ps_static,SemanticTree.field_access_level.fal_public,scope); cmn_noteq.IsOperator = true; prm1 = new common_parameter("a",ctn,SemanticTree.parameter_type.value,cmn_noteq,concrete_parameter_type.cpt_none,null,null); prm2 = new common_parameter("b",ctn,SemanticTree.parameter_type.value,cmn_noteq,concrete_parameter_type.cpt_none,null,null); cmn_noteq.parameters.AddElement(prm1); cmn_noteq.parameters.AddElement(prm2); body = new statements_list(null); vdn = new local_variable("$i",SystemLibrary.SystemLibrary.integer_type,cmn_noteq,null);//this.convertion_data_and_alghoritms.syntax_tree_visitor.context.create_for_temp_variable(SystemLibrary.SystemLibrary.integer_type, null); cmn_noteq.var_definition_nodes_list.AddElement(vdn); var_ref = new local_variable_reference(vdn,0,null);//this.convertion_data_and_alghoritms.syntax_tree_visitor.create_variable_reference(vdn,null); cond = new basic_function_call(SystemLibrary.SystemLibrary.int_sm as basic_function_node,null); cond.parameters.AddElement(var_ref); cond.parameters.AddElement(new int_const_node(arr_length,null)); while_stmt = new while_node(cond,null); while_body = new statements_list(null); while_stmt.body = while_body; left_sar = new simple_array_indexing(new class_field_reference(int_arr, new common_parameter_reference(prm1,0,null), null),var_ref,element_type,null); right_sar = new simple_array_indexing(new class_field_reference(int_arr, new common_parameter_reference(prm2,0,null), null),var_ref,element_type,null); cond2 = SystemLibrary.SystemLibrary.syn_visitor.find_operator(compiler_string_consts.noteq_name, left_sar,right_sar,null); if_stmt = new if_node(cond2,new return_node(new bool_const_node(true,null),null),null,null); while_body.statements.AddElement(if_stmt); while_body.statements.AddElement(new basic_function_call(SystemLibrary.SystemLibrary.int_assign as basic_function_node,null ,var_ref,new basic_function_call(SystemLibrary.SystemLibrary.int_add as basic_function_node,null,var_ref,new int_const_node(1,null)))); body.statements.AddElement(while_stmt); body.statements.AddElement(new return_node(new bool_const_node(false,null),null)); cmn_noteq.function_code = body; cmn_noteq.is_overload = true; ctn.methods.AddElement(cmn_noteq); ctn.Scope.AddSymbol(compiler_string_consts.noteq_name,new SymbolInfo(cmn_noteq)); //Equals /*scope = convertion_data_and_alghoritms.symbol_table.CreateClassMethodScope(_cmn.scope,ctn.scope); common_method_node cmn_equals = new common_method_node("Equals",SystemLibrary.SystemLibrary.bool_type,null,ctn, SemanticTree.polymorphic_state.ps_virtual,SemanticTree.field_access_level.fal_public,scope); prm1 = new common_parameter("a",SystemLibrary.SystemLibrary.object_type,SemanticTree.parameter_type.value,cmn_equals,concrete_parameter_type.cpt_none,null,null); cmn_equals.parameters.AddElement(prm1); body = new statements_list(null); vdn = new local_variable("$i",ctn,cmn_equals,null);//this.convertion_data_and_alghoritms.syntax_tree_visitor.context.create_for_temp_variable(SystemLibrary.SystemLibrary.integer_type, null); cmn_equals.var_definition_nodes_list.AddElement(vdn); var_ref = new local_variable_reference(vdn,0,null);//this.convertion_data_and_alghoritms.syntax_tree_visitor.create_variable_reference(vdn,null); as_node _as = new as_node(new common_parameter_reference(prm1,0,null),ctn,null); base_function_call ass_bfc = new basic_function_call(SystemLibrary.SystemLibrary.object_type.find(compiler_string_consts.assign_name).sym_info as basic_function_node,null); ass_bfc.parameters.AddElement(var_ref); ass_bfc.parameters.AddElement(_as); body.statements.AddElement(ass_bfc); common_static_method_call csmc = new common_static_method_call(ctn.find_in_type(compiler_string_consts.eq_name).sym_info as common_method_node,null); csmc.parameters.AddElement(new this_node(ctn,null)); csmc.parameters.AddElement(var_ref); body.statements.AddElement(new return_node(csmc,null)); ctn.methods.AddElement(cmn_equals); ctn.Scope.AddSymbol("Equals",new SymbolInfo(cmn_equals));*/ return ctn; }