private void VisitAssignment(base_function_call en) { for (int i = 1; i < en.parameters.Count; i++) { VisitExpression(en.parameters[i]); } expression_node p = en.parameters[0]; switch (p.semantic_node_type) { case semantic_node_type.local_variable_reference: IncreaseNumAssVar((local_variable_reference)p); break; case semantic_node_type.local_block_variable_reference: IncreaseNumAssVar((local_block_variable_reference)p); break; case semantic_node_type.namespace_variable_reference: IncreaseNumAssVar((namespace_variable_reference)p); break; case semantic_node_type.class_field_reference: VisitExpression((p as class_field_reference).obj); IncreaseNumAssField((class_field_reference)p); break; case semantic_node_type.static_class_field_reference: IncreaseNumAssField((static_class_field_reference)p); break; case semantic_node_type.common_parameter_reference: IncreaseNumAssParam((common_parameter_reference)p); break; case semantic_node_type.deref_node: CheckAssign(((dereference_node)p).deref_expr); break; case semantic_node_type.simple_array_indexing: VisitSimpleArrayIndexing((simple_array_indexing)p); break; } }
public expression_node visit(SyntaxTree.expression expr) { expr.visit(syntax_tree_visitor); /*addressed_expression ad = ret_semantic as addressed_expression; * if (ad != null && ad.is_addressed) * { * if (convertion_data_and_alghoritms.check_for_constant(ad)) * ad.is_addressed = false; * }*/ //Надеюсь, это сильно не скажется на производительности, хотя в другом случае этот же код просто будет разбросан по всем метдам syntax_tree_visitor-а. base_function_call bfc = ret_semantic as base_function_call; if (bfc != null) { if (bfc.simple_function_node.compile_time_executor != null) { expression_node ex = bfc.simple_function_node.compile_time_executor(bfc.location, bfc.parameters.ToArray()); if (ex != null) { return(ex); } } } return(ret_semantic as expression_node); }
private void VisitAssignment(base_function_call en) { for (int i = 1; i < en.parameters.Count; i++) VisitExpression(en.parameters[i]); expression_node p = en.parameters[0]; switch (p.semantic_node_type) { case semantic_node_type.local_variable_reference: IncreaseNumAssVar((local_variable_reference)p); break; case semantic_node_type.local_block_variable_reference: IncreaseNumAssVar((local_block_variable_reference)p); break; case semantic_node_type.namespace_variable_reference: IncreaseNumAssVar((namespace_variable_reference)p); break; case semantic_node_type.class_field_reference: VisitExpression((p as class_field_reference).obj); IncreaseNumAssField((class_field_reference)p); break; case semantic_node_type.static_class_field_reference: IncreaseNumAssField((static_class_field_reference)p); break; case semantic_node_type.common_parameter_reference: IncreaseNumAssParam((common_parameter_reference)p); break; case semantic_node_type.deref_node: CheckAssign(((dereference_node)p).deref_expr); break; case semantic_node_type.simple_array_indexing: VisitSimpleArrayIndexing((simple_array_indexing)p); break; } }
internal expression_node CreateDelegateCall(base_function_call fn_call) { common_type_node del = CreateDelegate(fn_call.simple_function_node); common_constructor_call deleg_costructor_call = new common_constructor_call(del.methods[0], fn_call.location); deleg_costructor_call.parameters.AddElement((base_function_call)fn_call); return deleg_costructor_call; }
/// <summary> /// Обрабатывает случай, когда левая часть присваивания свойство. /// </summary> /// <returns>True - обработка прошла, иначе False.</returns> private bool ProcessAssignToPropertyIfPossible(assign _assign, addressed_expression to, location loc, expression_node from) { //проверка на обращение к полю записи возвращенной из функции с целью присваивания //нужно чтобы пользователь не мог менять временный обьект if (to.semantic_node_type == semantic_node_type.static_property_reference || to.semantic_node_type == semantic_node_type.non_static_property_reference) { property_node pn; if (to.semantic_node_type == semantic_node_type.static_property_reference) { pn = (to as static_property_reference).property; } else { pn = (to as non_static_property_reference).property; } var ot = MapCompositeAssignmentOperatorToSameBinaryOperator(_assign); var oper_ass_in_prop = ot != Operators.Undefined; if (_assign.operator_type == Operators.Assignment || oper_ass_in_prop) { if (oper_ass_in_prop) { if (pn.get_function == null) { AddError(loc, "THIS_PROPERTY_{0}_CAN_NOT_BE_READED", pn.name); } base_function_call prop_expr; if (to.semantic_node_type == semantic_node_type.non_static_property_reference) { prop_expr = create_not_static_method_call(pn.get_function, (to as non_static_property_reference).expression, loc, false); prop_expr.parameters.AddRange((to as non_static_property_reference).fact_parametres); } else { prop_expr = create_static_method_call(pn.get_function, loc, pn.comprehensive_type, false); prop_expr.parameters.AddRange((to as static_property_reference).fact_parametres); } from = find_operator(ot, prop_expr, from, loc); } if (to.semantic_node_type == semantic_node_type.static_property_reference) { static_property_reference spr = (static_property_reference)to; if (spr.property.set_function == null) { AddError(loc, "THIS_PROPERTY_{0}_CAN_NOT_BE_WRITED", spr.property.name); } check_property_params(spr, loc); function_node set_func = spr.property.set_function; from = convertion_data_and_alghoritms.convert_type(from, spr.property.property_type); spr.fact_parametres.AddElement(from); base_function_call bfc = create_static_method_call(set_func, loc, spr.property.comprehensive_type, true); bfc.parameters.AddRange(spr.fact_parametres); return_value((statement_node)bfc); } else if (to.semantic_node_type == semantic_node_type.non_static_property_reference) { non_static_property_reference nspr = (non_static_property_reference)to; check_property_params(nspr, loc); from = convertion_data_and_alghoritms.convert_type(from, nspr.property.property_type); nspr.fact_parametres.AddElement(from); //Обработка s[i]:='c' if (SystemUnitAssigned) { if (nspr.property.comprehensive_type == SystemLibrary.SystemLibrary.string_type) { if (nspr.property == SystemLibrary.SystemLibrary.string_type.default_property_node) { if (SystemLibInitializer.StringDefaultPropertySetProcedure != null) { expressions_list exl = new expressions_list(); exl.AddElement(nspr.expression); exl.AddElement(nspr.fact_parametres[0]); exl.AddElement(from); function_node fn = convertion_data_and_alghoritms.select_function(exl, SystemLibInitializer.StringDefaultPropertySetProcedure .SymbolInfo, loc); expression_node ret = convertion_data_and_alghoritms.create_simple_function_call(fn, loc, exl.ToArray()); return_value((statement_node)ret); return(true); } } } } if (nspr.property.set_function == null) { AddError(loc, "THIS_PROPERTY_{0}_CAN_NOT_BE_WRITED", nspr.property.name); } function_node set_func = nspr.property.set_function; base_function_call bfc = create_not_static_method_call(set_func, nspr.expression, loc, true); bfc.parameters.AddRange(nspr.fact_parametres); return_value((statement_node)bfc); } return(true); } } return(false); }
/// <summary> /// Автовыведение типов в yield'ax. /// </summary> private void ProcessAssigntToAutoType(addressed_expression to, ref expression_node from) { var sequence = to.type as compiled_generic_instance_type_node; // SSM 26.06.16 - правка в связи с автовыведением типов в yieldах if (to.type is auto_type) { try_convert_typed_expression_to_function_call(ref from); if (to is class_field_reference) { var cfr = to as class_field_reference; if (from is typed_expression) // SSM 22.12.18 syntax_tree_visitor.cs 16066 - взял оттуда { base_function_call bfc = ((from as typed_expression).type as delegated_methods).proper_methods[0]; /*if (bfc.function.is_generic_function && _var_def_statement.vars_type == null) * { * AddError(inital_value.location, "CAN_NOT_DEDUCE_TYPE_{0}", null); * } * foreach (parameter p in bfc.simple_function_node.parameters) * { * if (p.type.is_generic_parameter) * AddError(inital_value.location, "USE_ANONYMOUS_FUNCTION_TYPE_WITH_GENERICS"); * } */ common_type_node del = convertion_data_and_alghoritms.type_constructor.create_delegate(context.get_delegate_type_name(), bfc.simple_function_node.return_value_type, bfc.simple_function_node.parameters, context.converted_namespace, null); context.converted_namespace.types.AddElement(del); //- сомневаюсь - контекст уже поменялся! //tn = del; from = convertion_data_and_alghoritms.explicit_convert_type(from, del); from.type = del; } cfr.field.type = from.type; cfr.type = from.type; // Это неверно работает когда yieldится процедура #1439 // SSM 1.11.18 попытка правки возвращения процедуры в yield //if (from.type.semantic_node_type == semantic_node_type.delegated_method) //cfr.type.semantic_node_type = semantic_node_type.delegated_method; cfr.field.inital_value = context.GetInitalValueForVariable(cfr.field, cfr.field.inital_value); } else if (to is local_block_variable_reference) { var lvr = to as local_block_variable_reference; lvr.var.type = from.type; lvr.type = from.type; lvr.var.inital_value = context.GetInitalValueForVariable(lvr.var, lvr.var.inital_value); } else { AddError(to.location, "Не могу вывести тип при наличии yield: " + to.type.full_name); } //to.type = from.type; // и без всякого real_type! } else if (sequence?.instance_params[0] is ienumerable_auto_type) { type_node elem_type = null; try_convert_typed_expression_to_function_call(ref from); bool bb; // здесь bb не нужно. Оно нужно в foreach var b = FindIEnumerableElementType(from.type, ref elem_type, out bb); if (!b) { AddError(from.location, "CAN_NOT_EXECUTE_FOREACH_BY_EXPR_OF_TYPE_{0}", from.type.full_name); } var IEnumType = new template_type_reference(new named_type_reference("System.Collections.Generic.IEnumerable"), new template_param_list(new semantic_type_node(elem_type))); if (to is class_field_reference) { var cfr = to as class_field_reference; cfr.field.type = convert_strong(IEnumType); cfr.type = cfr.field.type; } else if (to is local_block_variable_reference) { var lvr = to as local_block_variable_reference; lvr.var.type = convert_strong(IEnumType); // замена типа у описания переменной lvr.type = lvr.var.type; // замена типа у переменной } } }
private base_function_call get_function_call_copy(base_function_call bfc) { return bfc.copy(); }
private simple_array_indexing make_unmanaged_shortstring_getter(base_function_call cfc) { return new simple_array_indexing(cfc.parameters[0], cfc.parameters[1], SystemLibrary.SystemLibrary.char_type, cfc.location); }