//(ssyy) Добавляет +, +=, -, -= public void AddOperatorsToDelegate(common_type_node ctn, location loc) { //+ common_method_node cmn_add = new common_method_node(compiler_string_consts.plus_name, ctn, loc, ctn, SemanticTree.polymorphic_state.ps_static, SemanticTree.field_access_level.fal_public, ctn.scope); cmn_add.compile_time_executor = delegate_add_compile_time_executor; ctn.scope.AddSymbol(cmn_add.name, new SymbolInfo(cmn_add)); common_parameter cp1 = new common_parameter(compiler_string_consts.left_param_name, ctn, SemanticTree.parameter_type.value, cmn_add, concrete_parameter_type.cpt_none, null, loc); common_parameter cp2 = new common_parameter(compiler_string_consts.right_param_name, ctn, SemanticTree.parameter_type.value, cmn_add, concrete_parameter_type.cpt_none, null, loc); cmn_add.parameters.AddElement(cp1); cmn_add.parameters.AddElement(cp2); //+= common_method_node cmn_add_assign = new common_method_node(compiler_string_consts.plusassign_name, ctn, loc, ctn, SemanticTree.polymorphic_state.ps_static, SemanticTree.field_access_level.fal_public, ctn.scope); cmn_add_assign.compile_time_executor = delegate_add_assign_compile_time_executor; ctn.scope.AddSymbol(cmn_add_assign.name, new SymbolInfo(cmn_add_assign)); common_parameter cp3 = new common_parameter(compiler_string_consts.left_param_name, ctn, SemanticTree.parameter_type.value, cmn_add_assign, concrete_parameter_type.cpt_none, null, loc); common_parameter cp4 = new common_parameter(compiler_string_consts.right_param_name, ctn, SemanticTree.parameter_type.value, cmn_add_assign, concrete_parameter_type.cpt_none, null, loc); cmn_add_assign.parameters.AddElement(cp3); cmn_add_assign.parameters.AddElement(cp4); //- common_method_node cmn_sub = new common_method_node(compiler_string_consts.minus_name, ctn, loc, ctn, SemanticTree.polymorphic_state.ps_static, SemanticTree.field_access_level.fal_public, ctn.scope); cmn_sub.compile_time_executor = delegate_sub_compile_time_executor; ctn.scope.AddSymbol(cmn_sub.name, new SymbolInfo(cmn_sub)); common_parameter cp12 = new common_parameter(compiler_string_consts.left_param_name, ctn, SemanticTree.parameter_type.value, cmn_sub, concrete_parameter_type.cpt_none, null, loc); common_parameter cp22 = new common_parameter(compiler_string_consts.right_param_name, ctn, SemanticTree.parameter_type.value, cmn_sub, concrete_parameter_type.cpt_none, null, loc); cmn_sub.parameters.AddElement(cp12); cmn_sub.parameters.AddElement(cp22); //-= common_method_node cmn_sub_assign = new common_method_node(compiler_string_consts.minusassign_name, ctn, loc, ctn, SemanticTree.polymorphic_state.ps_static, SemanticTree.field_access_level.fal_public, ctn.scope); cmn_sub_assign.compile_time_executor = delegate_sub_assign_compile_time_executor; ctn.scope.AddSymbol(cmn_sub_assign.name, new SymbolInfo(cmn_sub_assign)); common_parameter cp32 = new common_parameter(compiler_string_consts.left_param_name, ctn, SemanticTree.parameter_type.value, cmn_sub_assign, concrete_parameter_type.cpt_none, null, loc); common_parameter cp42 = new common_parameter(compiler_string_consts.right_param_name, ctn, SemanticTree.parameter_type.value, cmn_sub_assign, concrete_parameter_type.cpt_none, null, loc); cmn_sub_assign.parameters.AddElement(cp32); cmn_sub_assign.parameters.AddElement(cp42); }
/*public static void RestoreStandartNames() { _bool_type.SetName(compiler_string_consts.bool_type_name); _byte_type.SetName(compiler_string_consts.byte_type_name); _sbyte_type.SetName(compiler_string_consts.sbyte_type_name); _short_type.SetName(compiler_string_consts.short_type_name); _ushort_type.SetName(compiler_string_consts.ushort_type_name); _integer_type.SetName(compiler_string_consts.integer_type_name); ; _uint_type.SetName(compiler_string_consts.uint_type_name); _int64_type.SetName(compiler_string_consts.long_type_name); _uint64_type.SetName(compiler_string_consts.ulong_type_name); _double_type.SetName(compiler_string_consts.real_type_name); _float_type.SetName(compiler_string_consts.float_type_name); _char_type.SetName(compiler_string_consts.char_type_name); _string_type.SetName(compiler_string_consts.string_type_name); _object_type.SetName(compiler_string_consts.object_type_name); _exception_base_type.SetName(compiler_string_consts.base_exception_class_name); _array_base_type.SetName(compiler_string_consts.base_array_type_name); _delegate_base_type.SetName(compiler_string_consts.base_delegate_type_name); _enum_base_type.SetName(compiler_string_consts.base_enum_class_name); _pointer_type.SetName(compiler_string_consts.pointer_type_name); _void_type.SetName(compiler_string_consts.void_class_name); }*/ private static void make_methods() { _empty_method = new basic_function_node(SemanticTree.basic_function_type.none, null, true); basic_parameter bp = new basic_parameter(compiler_string_consts.unary_param_name, null, SemanticTree.parameter_type.value, _empty_method); _empty_method.parameters.AddElement(bp); _empty_method.compile_time_executor = delegated_empty_method; //(ssyy) Убрать подмену параметров?! Type arr_type = typeof(System.Array); System.Reflection.MethodInfo resize_func_mi = arr_type.GetMethod("Resize"); _resize_func = compiled_function_node.get_compiled_method(resize_func_mi); _resize_func.parameters.clear(); common_parameter par0 = new common_parameter("Array", _object_type, SemanticTree.parameter_type.value, null, concrete_parameter_type.cpt_none, null, null); common_parameter par1 = new common_parameter("Length", _integer_type, SemanticTree.parameter_type.value, null, concrete_parameter_type.cpt_none, null, null); _resize_func.parameters.AddElement(par0); _resize_func.parameters.AddElement(par1); resize_func.compile_time_executor = set_length_compile_time_executor; }
public void AddParameter(common_parameter vdn) { ParamInfo vi = new ParamInfo(); ht[vdn] = vi; }
//TODO: Если одного из акцессоров нет? public override void visit(SyntaxTree.simple_property _simple_property) { if (_simple_property.accessors == null) AddError(get_location(_simple_property), "PROPERTYACCESSOR_{0}_OR_{1}_EXPECTED", compiler_string_consts.PascalReadAccessorName, compiler_string_consts.PascalWriteAccessorName); if (_simple_property.property_type == null) AddError(get_location(_simple_property.property_name), "TYPE_NAME_EXPECTED"); common_property_node pn = context.add_property(_simple_property.property_name.name, get_location(_simple_property.property_name)); assign_doc_info(pn, _simple_property); //pn.polymorphic_state=SemanticTree.polymorphic_state.ps_common; //pn.loc=get_location(_simple_property.property_name); if (_simple_property.attr == SyntaxTree.definition_attribute.Static) pn.polymorphic_state = SemanticTree.polymorphic_state.ps_static; parameter_list pal_big = new parameter_list(); //TODO: Спросить у Саши как получить тип параметра - var,const и т.д. if (_simple_property.parameter_list != null) { foreach (SyntaxTree.property_parameter pp in _simple_property.parameter_list.parameters) { parameter_list pal_small = new parameter_list(); foreach (SyntaxTree.ident id in pp.names.idents) { common_parameter cp = new common_parameter(id.name, SemanticTree.parameter_type.value, null, concrete_parameter_type.cpt_none, get_location(id)); pal_small.AddElement(cp); } type_node tn = convert_strong(pp.type); foreach (parameter pr in pal_small) { pr.type = tn; } pal_big.AddRange(pal_small); } } pn.parameters.AddRange(pal_big); pn.internal_property_type = convert_strong(_simple_property.property_type); if (_simple_property.accessors != null) { convertion_data_and_alghoritms.check_node_parser_error(_simple_property.accessors); SymbolInfo si = null; //definition_node dn = null; if (_simple_property.accessors.read_accessor != null) { convertion_data_and_alghoritms.check_node_parser_error(_simple_property.accessors.read_accessor); if (_simple_property.accessors.read_accessor.accessor_name == null) { if (!context.converted_type.IsInterface) { AddError(get_location(_simple_property.accessors.read_accessor), "ACCESSOR_NAME_EXPECTED"); } pn.internal_get_function = GenerateGetSetMethodForInterfaceProperty(pn, get_location(_simple_property.accessors.read_accessor), true); } else { convertion_data_and_alghoritms.check_node_parser_error(_simple_property.accessors.read_accessor.accessor_name); si = context.converted_type.find_in_type(_simple_property.accessors.read_accessor.accessor_name.name, context.CurrentScope); location loc1 = get_location(_simple_property.accessors.read_accessor.accessor_name); if (si == null) { AddError(new UndefinedNameReference(_simple_property.accessors.read_accessor.accessor_name.name, loc1)); } //dn = check_name_node_type(_simple_property.accessors.read_accessor.accessor_name.name, // si, loc1, general_node_type.function_node, general_node_type.variable_node); function_node read_accessor = si.sym_info as function_node; if (read_accessor != null) { bool good_func = true; bool one_func = si.Next == null; while (si != null) { good_func = true; if (read_accessor.parameters.Count != pn.parameters.Count) { good_func = false; if (one_func) { AddError(new PropertyAndReadAccessorParamsCountConvergence(read_accessor, pn, loc1)); } } //TODO: Сверять типы параметров - var, const и т.д. else { for (int i1 = 0; good_func && i1 < read_accessor.parameters.Count; i1++) { if (read_accessor.parameters[i1].parameter_type != pn.parameters[i1].parameter_type || read_accessor.parameters[i1].type != pn.parameters[i1].type) { good_func = false; if (one_func) { AddError(loc1, "PROPERTY_{0}_AND_READ_ACCESSOR_{1}_PARAMS_TYPE_CONVERGENCE", pn.name, read_accessor.name); } } } if (read_accessor.return_value_type == null) { good_func = false; if (one_func) { AddError(loc1, "PROPERTY_READ_ACCESSOR_CAN_NOT_BE_PROCEDURE"); } } if (read_accessor.return_value_type != pn.property_type) { good_func = false; if (one_func) { AddError(loc1, "PROPERTY_{0}_AND_READ_ACCESSOR_{1}_RETURN_VALUE_TYPE_CONVERGENCE", pn.name, read_accessor.name); } } if (read_accessor is common_method_node && (read_accessor as common_method_node).is_constructor) { AddError(loc1, "ACCESSOR_CAN_BE_FIELD_OR_METHOD_ONLY"); } } if (good_func) { break; } si = si.Next; if (si != null) { read_accessor = si.sym_info as function_node; } } if (!good_func) { AddError(loc1, "NO_OVERLOAD_FUNCTION_{0}_USEFUL_FOR_ACCESSOR", read_accessor.name); } read_accessor = GenerateGetMethod(pn,read_accessor as common_method_node,pn.loc); } else { class_field cfield = si.sym_info as class_field; if (cfield == null) { AddError(loc1, "ACCESSOR_CAN_BE_FIELD_OR_METHOD_ONLY"); } if (_simple_property.parameter_list != null) { AddError(loc1, "INDEX_PROPERTY_ACCESSOR_CAN_NOT_BE_VARIABLE"); } if (cfield.type != pn.internal_property_type) { AddError(loc1, "PROPERTY_TYPE_MISMATCH_ACCESSOR_FIELD_TYPE"); } if (pn.polymorphic_state == SemanticTree.polymorphic_state.ps_static && cfield.polymorphic_state != SemanticTree.polymorphic_state.ps_static) AddError(get_location(_simple_property.accessors.read_accessor.accessor_name), "ACCESSOR_{0}_MUST_BE_STATIC", cfield.name); if (pn.polymorphic_state != SemanticTree.polymorphic_state.ps_static && cfield.polymorphic_state == SemanticTree.polymorphic_state.ps_static) AddError(get_location(_simple_property.accessors.read_accessor.accessor_name), "ACCESSOR_{0}_CANNOT_BE_STATIC", cfield.name); read_accessor = GenerateGetMethodForField(pn, compiler_string_consts.GetGetAccessorName(pn.name), cfield, loc1); } //Вот здесь уже можем добавить акцессор для чтения. pn.internal_get_function = read_accessor; } if (pn.internal_get_function != null && pn.polymorphic_state == SemanticTree.polymorphic_state.ps_static && pn.internal_get_function.polymorphic_state != SemanticTree.polymorphic_state.ps_static) AddError(get_location(_simple_property.accessors.read_accessor.accessor_name), "ACCESSOR_{0}_MUST_BE_STATIC", pn.internal_get_function.name); if (pn.internal_get_function != null && pn.polymorphic_state != SemanticTree.polymorphic_state.ps_static && pn.internal_get_function.polymorphic_state == SemanticTree.polymorphic_state.ps_static) AddError(get_location(_simple_property.accessors.read_accessor.accessor_name), "ACCESSOR_{0}_CANNOT_BE_STATIC", pn.internal_get_function.name); } if (_simple_property.accessors.write_accessor != null) { convertion_data_and_alghoritms.check_node_parser_error(_simple_property.accessors.write_accessor); if (_simple_property.accessors.write_accessor.accessor_name == null) { if (!context.converted_type.IsInterface) { AddError(get_location(_simple_property.accessors.write_accessor), "ACCESSOR_NAME_EXPECTED"); } pn.internal_set_function = GenerateGetSetMethodForInterfaceProperty(pn, get_location(_simple_property.accessors.write_accessor), false); } else { convertion_data_and_alghoritms.check_node_parser_error(_simple_property.accessors.write_accessor.accessor_name); si = context.converted_type.find_in_type(_simple_property.accessors.write_accessor.accessor_name.name, context.CurrentScope); location loc2 = get_location(_simple_property.accessors.write_accessor.accessor_name); if (si == null) { AddError( new UndefinedNameReference(_simple_property.accessors.write_accessor.accessor_name.name, loc2)); } //dn = check_name_node_type(_simple_property.accessors.write_accessor.accessor_name.name, // si, loc2, general_node_type.function_node, general_node_type.variable_node); function_node write_accessor = si.sym_info as function_node; if (write_accessor != null) { bool good_func = true; bool one_func = si.Next == null; while (si != null) { good_func = true; if (write_accessor.parameters.Count != pn.parameters.Count + 1) { good_func = false; if (one_func) { AddError( new PropertyAndWriteAccessorParamsCountConvergence(write_accessor, pn, loc2)); } } else { //TODO: Сверять типы параметров - var, const и т.д. for (int i2 = 0; good_func && i2 < pn.parameters.Count; i2++) { if (write_accessor.parameters[i2].parameter_type != pn.parameters[i2].parameter_type || write_accessor.parameters[i2].type != pn.parameters[i2].type) { good_func = false; if (one_func) { AddError(loc2, "PROPERTY_{0}_AND_WRITE_ACCESSOR_{1}_PARAMS_TYPE_CONVERGENCE", pn.name ,write_accessor.name); } } } if (write_accessor.parameters[write_accessor.parameters.Count - 1].type != pn.property_type || write_accessor.parameters[write_accessor.parameters.Count - 1].parameter_type != PascalABCCompiler.SemanticTree.parameter_type.value) { good_func = false; if (one_func) { AddError(loc2, "PROPERTY_{0}_AND_WRITE_ACCESSOR_LAST_PARAMETER_TYPE_CONVERGENCE", pn.name); } } if (write_accessor.return_value_type != null) { good_func = false; if (one_func) { AddError(loc2, "PROPERTY_WRITE_ACCESSOR_CAN_NOT_BE_FUNCTION"); } } } if (good_func) { break; } si = si.Next; if (si != null) { write_accessor = si.sym_info as function_node; } } if (!good_func) { AddError(loc2, "NO_OVERLOAD_FUNCTION_{0}_USEFUL_FOR_ACCESSOR", write_accessor.name); } if (write_accessor is common_method_node && (write_accessor as common_method_node).is_constructor) { AddError(loc2, "ACCESSOR_CAN_BE_FIELD_OR_METHOD_ONLY"); } write_accessor = GenerateSetMethod(pn, write_accessor as common_method_node, pn.loc); } else { class_field cfield = si.sym_info as class_field; if (cfield == null) { AddError(loc2, "ACCESSOR_CAN_BE_FIELD_OR_METHOD_ONLY"); } if (_simple_property.parameter_list != null) { AddError(loc2, "INDEX_PROPERTY_ACCESSOR_CAN_NOT_BE_VARIABLE"); } if (cfield.type != pn.internal_property_type) { AddError(loc2, "PROPERTY_TYPE_MISMATCH_ACCESSOR_FIELD_TYPE"); } if (pn.polymorphic_state == SemanticTree.polymorphic_state.ps_static && cfield.polymorphic_state != SemanticTree.polymorphic_state.ps_static) AddError(get_location(_simple_property.accessors.write_accessor.accessor_name), "ACCESSOR_{0}_MUST_BE_STATIC", cfield.name); if (pn.polymorphic_state != SemanticTree.polymorphic_state.ps_static && cfield.polymorphic_state == SemanticTree.polymorphic_state.ps_static) AddError(get_location(_simple_property.accessors.write_accessor.accessor_name), "ACCESSOR_{0}_CANNOT_BE_STATIC", cfield.name); write_accessor = GenerateSetMethodForField(pn, compiler_string_consts.GetSetAccessorName(pn.name), cfield, loc2); } //Вот здесь уже можем добавить акцессор для чтения. pn.internal_set_function = write_accessor; } if (pn.internal_set_function != null && pn.polymorphic_state == SemanticTree.polymorphic_state.ps_static && pn.internal_set_function.polymorphic_state != SemanticTree.polymorphic_state.ps_static) AddError(get_location(_simple_property.accessors.write_accessor.accessor_name), "ACCESSOR_{0}_MUST_BE_STATIC", pn.internal_set_function.name); if (pn.internal_set_function != null && pn.polymorphic_state != SemanticTree.polymorphic_state.ps_static && pn.internal_set_function.polymorphic_state == SemanticTree.polymorphic_state.ps_static) AddError(get_location(_simple_property.accessors.write_accessor.accessor_name), "ACCESSOR_{0}_CANNOT_BE_STATIC", pn.internal_set_function.name); } } make_attributes_for_declaration(_simple_property,pn); //TODO: Можно сделать множество свойств по умолчанию. if (_simple_property.array_default != null) { if (pn.parameters.Count == 0) { AddError(pn.loc, "DEFAULT_PROPERTY_MUST_BE_INDEXED"); } if (context.converted_type.default_property_node != null) { AddError(pn.loc, "DUPLICATE_DEFAULT_PROPERTY_IN_CLASS"); } context.converted_type.default_property = pn; } }
internal function_node GenerateSetMethodForField(common_property_node cpn, string AcessorName, class_field cf, location loc) { SymbolInfo exist_si = context.find_only_in_namespace(AcessorName); if (exist_si != null && exist_si.sym_info.general_node_type != general_node_type.function_node) { AddError(loc, "CAN_NOT_GENERATE_ACCESSOR_{0}", AcessorName); } while (exist_si != null) { function_node ff = (function_node)(exist_si.sym_info); if (ff.parameters.Count == 1 && ff.parameters[0].type == cf.type) { AddError(loc, "CAN_NOT_GENERATE_ACCESSOR_{0}", AcessorName); } exist_si = exist_si.Next; } common_method_node cmn = new common_method_node( AcessorName, loc, cf.cont_type, cf.polymorphic_state, context.get_field_access_level(), null); cpn.common_comprehensive_type.methods.AddElement(cmn); common_parameter cp = new common_parameter( compiler_string_consts.value, cf.type, SemanticTree.parameter_type.value, cmn, concrete_parameter_type.cpt_none, null, loc); cmn.parameters.AddElement(cp); cmn.is_overload = true; common_parameter_reference cpr = new common_parameter_reference(cp, 0, loc); expression_node var_ref; if (cf.polymorphic_state == SemanticTree.polymorphic_state.ps_common) { var_ref = new class_field_reference(cf, new this_node(cf.type, loc), loc); } else { var_ref = new static_class_field_reference(cf, loc); } cmn.function_code = find_operator(compiler_string_consts.assign_name, var_ref, cpr, loc); cf.cont_type.scope.AddSymbol(AcessorName, new SymbolInfo(cmn)); return cmn; }
private void visit_procedure_header(SyntaxTree.procedure_header _procedure_header) { if (_procedure_header.name != null && _procedure_header.name.meth_name is SyntaxTree.operator_name_ident && !SyntaxTree.OperatorServices.IsAssigmentOperator((_procedure_header.name.meth_name as SyntaxTree.operator_name_ident).operator_type)) { AddError(new OverloadOperatorCanNotBeProcedure(get_location(_procedure_header))); } if (_procedure_header is SyntaxTree.constructor && (_procedure_header.template_args != null || (_procedure_header.name != null && _procedure_header.name.meth_name != null && _procedure_header.name.meth_name is SyntaxTree.template_type_name))) { AddError(get_location(_procedure_header), "CONSTRUCTOR_CAN_NOT_BE_GENERIC"); } current_function_header = _procedure_header; hard_node_test_and_visit(_procedure_header.name); current_function_header = null; if (context.converted_template_type != null) { return; } if (_procedure_header.template_args != null) { visit_generic_params(context.top_function, _procedure_header.template_args.idents); } weak_node_test_and_visit(_procedure_header.parameters); if (_procedure_header.name.class_name != null) with_class_name = true; if (_procedure_header.class_keyword && !has_static_attr(_procedure_header.proc_attributes.proc_attributes)) { SyntaxTree.procedure_attribute pa = new SyntaxTree.procedure_attribute(PascalABCCompiler.SyntaxTree.proc_attribute.attr_static); pa.source_context = _procedure_header.source_context; _procedure_header.proc_attributes.proc_attributes.Add(pa); } weak_node_test_and_visit(_procedure_header.proc_attributes); with_class_name = false; CheckOverrideOrReintroduceExpectedWarning(get_location(_procedure_header)); if (context.top_function != null && context.top_function is common_namespace_function_node && (context.top_function as common_namespace_function_node).ConnectedToType != null && !context.top_function.IsOperator) { concrete_parameter_type cpt = concrete_parameter_type.cpt_none; SemanticTree.parameter_type pt = PascalABCCompiler.SemanticTree.parameter_type.value; if ((context.top_function as common_namespace_function_node).ConnectedToType.is_value_type) { cpt = concrete_parameter_type.cpt_var; pt = PascalABCCompiler.SemanticTree.parameter_type.var; } type_node cur_tn = (context.top_function as common_namespace_function_node).ConnectedToType; type_node self_type = cur_tn; if (context.top_function.generic_params != null && self_type.is_generic_type_definition) { self_type = self_type.get_instance(context.top_function.get_generic_params_list()); } if (!has_extensionmethod_attr(_procedure_header.proc_attributes.proc_attributes)) { common_parameter cp = new common_parameter(compiler_string_consts.self_word, self_type, pt, context.top_function, cpt, null, null); context.top_function.parameters.AddElementFirst(cp); context.top_function.scope.AddSymbol(compiler_string_consts.self_word, new SymbolInfo(cp)); } } if (_procedure_header is SyntaxTree.constructor) { common_method_node cmnode = context.top_function as common_method_node; if (cmnode != null) { cmnode.is_constructor = true; cmnode.return_value_type = context.converted_type; } else if (context.top_function is common_namespace_function_node && (context.top_function as common_namespace_function_node).ConnectedToType != null) AddError(get_location(_procedure_header), "EXTENSION_CONSTRUCTOR_NOT_ALLOWED"); else if (context.converted_compiled_type != null) AddError(get_location(_procedure_header), "EXTENSION_CONSTRUCTOR_NOT_ALLOWED"); } bool unique = context.close_function_params(body_exists); if (context.converted_type != null && context.converted_type.IsInterface) { if (body_exists) { AddError(new InterfaceFunctionWithBody(get_location(_procedure_header))); } common_method_node cmnode = context.top_function as common_method_node; context.set_virtual_abstract(cmnode); } if (context.converted_type != null) { common_method_node cmnode = context.top_function as common_method_node; if (cmnode != null && cmnode.polymorphic_state == SemanticTree.polymorphic_state.ps_virtual_abstract && body_exists) { AddError(new AbstractMethodWithBody(get_location(_procedure_header))); } } if (_procedure_header.where_defs != null) { if (unique) { visit_where_list(_procedure_header.where_defs); } else { AddError(get_location(_procedure_header.where_defs), "WHERE_SECTION_MUST_BE_ONLY_IN_FIRST_DECLARATION"); } } assign_doc_info(context.top_function,_procedure_header); if (_procedure_header.attributes != null) { make_attributes_for_declaration(_procedure_header, context.top_function); } /*if (_procedure_header.name != null && context.converted_compiled_type != null && context.top_function is common_namespace_function_node) { if (context.FindMethodToOverride(context.top_function as common_namespace_function_node) != null) AddError(new CanNotDeclareExtensionMethodAsOverrided(get_location(_procedure_header))); }*/ if (context.converted_type != null && has_dll_import_attribute(context.top_function)) AddError(get_dll_import_attribute(context.top_function).location, "DLLIMPORT_ATTRIBUTE_CANNOT_BE_APPLIED_TO_METHOD"); if (!body_exists) { if (_procedure_header.name.class_name != null && context.converted_explicit_interface_type != null) { AddError(get_location(_procedure_header), "EXPLICIT_IMPLEMENTATION_EXPECTED"); } if ((context.top_function.semantic_node_type == semantic_node_type.common_method_node) || ((context.func_stack_size_is_one()) && (_is_interface_part))) { context.leave_block(); if (_procedure_header.name.class_name != null && context.converted_compiled_type != null) context.converted_compiled_type = null; } } body_exists = false; }
//\ssyy //ssyy public void generate_inherited_from_base_and_interface_function(common_type_node ctype, function_node func) { common_method_node gen_func = context.create_function(func.name, null) as common_method_node; gen_func.polymorphic_state = SemanticTree.polymorphic_state.ps_common; gen_func.newslot_awaited = true; gen_func.is_final = true; gen_func.is_overload = true; gen_func.field_access_level = SemanticTree.field_access_level.fal_public; gen_func.return_value_type = func.return_value_type; //gen_func.return_variable = func.retu foreach (parameter par in func.parameters) { concrete_parameter_type cpt = (par.parameter_type == SemanticTree.parameter_type.value) ? concrete_parameter_type.cpt_const : concrete_parameter_type.cpt_var; common_parameter c_p = new common_parameter(par.name, par.parameter_type, gen_func, cpt, null); c_p.type = par.type; c_p.set_param_is_params(par.is_params); c_p.inital_value = par.inital_value; gen_func.parameters.AddElement(c_p); } local_variable lv = new local_variable(compiler_string_consts.self_word, gen_func.cont_type, gen_func, null); gen_func.scope.AddSymbol(compiler_string_consts.self_word, new SymbolInfo(lv)); gen_func.self_variable = lv; base_function_call bfc; this_node tn = null; common_method_node commn = func as common_method_node; if (commn != null) { tn = new this_node(commn.comperehensive_type as type_node, null); bfc = new common_method_call(commn, tn, null); } else { compiled_function_node compn = func as compiled_function_node; tn = new this_node(compn.comperehensive_type as type_node, null); bfc = new compiled_function_call(compn, tn, null); } foreach (parameter p in gen_func.parameters) { bfc.parameters.AddElement( create_variable_reference(p, null)); } //Это запретит чистку стека bfc.last_result_function_call = true; statements_list snlist = new statements_list(null); snlist.statements.AddElement(bfc); snlist.statements.AddElement(new empty_statement(null)); gen_func.function_code = snlist; context.pop_top_function(); //context.leave_block(); }
public common_parameter_reference(common_parameter par,int static_depth,location loc) : base(par.type,loc) { _par=par; this.static_depth=static_depth; }
public SymbolInfo(common_parameter value) { //_name_information_type=name_information_type.nit_common_parameter; _sym_info=value; _access_level=access_level.al_public; _symbol_kind=symbol_kind.sk_none; }
public common_event add_event_definition(string name, location loc, type_node tn, SemanticTree.polymorphic_state ps, bool is_abstract) { class_field cf = new class_field(name + "$", tn, converted_type, ps, _fal, loc); common_event ce = new common_event(name, tn, converted_type, null, null, null, _fal, ps, loc); //add common_method_node add_meth = new common_method_node(compiler_string_consts.GetAddHandler(name), null, this.converted_type, ps, SemanticTree.field_access_level.fal_public, null); common_parameter cp = new common_parameter("value", tn, SemanticTree.parameter_type.value, add_meth, concrete_parameter_type.cpt_none, null, null); add_meth.parameters.AddElement(cp); expression_node fld_ref = null; if (!cf.IsStatic) fld_ref = new class_field_reference(cf, new this_node(converted_type, null), null); else fld_ref = new static_class_field_reference(cf, null); expression_node en = this.syntax_tree_visitor.convertion_data_and_alghoritms.type_constructor.delegate_add_assign_compile_time_executor (null, new expression_node[2] { fld_ref, new common_parameter_reference(cp, 0, null) }); if (!is_abstract) { add_meth.function_code = new statements_list(null); (add_meth.function_code as statements_list).statements.AddElement(en); } converted_type.scope.AddSymbol(add_meth.name, new SymbolInfo(add_meth)); //remove common_method_node remove_meth = new common_method_node(compiler_string_consts.GetRemoveHandler(name), null, this.converted_type, ps, SemanticTree.field_access_level.fal_public, null); cp = new common_parameter("value", tn, SemanticTree.parameter_type.value, add_meth, concrete_parameter_type.cpt_none, null, null); remove_meth.parameters.AddElement(cp); en = this.syntax_tree_visitor.convertion_data_and_alghoritms.type_constructor.delegate_sub_assign_compile_time_executor (null, new expression_node[2] { fld_ref, new common_parameter_reference(cp, 0, null) }); if (!is_abstract) { remove_meth.function_code = new statements_list(null); (remove_meth.function_code as statements_list).statements.AddElement(en); } converted_type.scope.AddSymbol(remove_meth.name, new SymbolInfo(remove_meth)); this.converted_type.methods.AddElement(add_meth); this.converted_type.methods.AddElement(remove_meth); ce.set_add_method(add_meth); ce.set_remove_method(remove_meth); ce.field = cf; this.converted_type.events.AddElement(ce); if (!is_abstract) this.converted_type.fields.AddElement(cf); converted_type.scope.AddSymbol(name, new SymbolInfo(ce)); return ce; }
private void add_equal_operator_if_need() { SymbolInfo si = _ctn.find_in_type(compiler_string_consts.eq_name); if (si.sym_info is common_method_node) return; SymbolTable.ClassMethodScope scope = convertion_data_and_alghoritms.symbol_table.CreateClassMethodScope(_cmn.scope,_ctn.scope); common_method_node cmn = 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.IsOperator = true; common_parameter prm1 = new common_parameter("a",_ctn,SemanticTree.parameter_type.value,cmn,concrete_parameter_type.cpt_none,null,null); common_parameter prm2 = new common_parameter("b",_ctn,SemanticTree.parameter_type.value,cmn,concrete_parameter_type.cpt_none,null,null); cmn.parameters.AddElement(prm1); cmn.parameters.AddElement(prm2); statements_list body = new statements_list(null); foreach (class_field cf in _ctn.fields) { expression_node left = new class_field_reference(cf,new common_parameter_reference(prm1,0,null),null); expression_node right = new class_field_reference(cf,new common_parameter_reference(prm2,0,null),null); expression_node cond = SystemLibrary.SystemLibrary.syn_visitor.find_operator(compiler_string_consts.eq_name, left,right,null); basic_function_call bfc = new basic_function_call(SystemLibrary.SystemLibrary.bool_not as basic_function_node,null); bfc.parameters.AddElement(cond); if_node if_stmt = new if_node(bfc,new return_node(new bool_const_node(false,null),null),null,null); body.statements.AddElement(if_stmt); } body.statements.AddElement(new return_node(new bool_const_node(true,null),null)); cmn.function_code = body; cmn.is_overload = true; _ctn.methods.AddElement(cmn); _ctn.Scope.AddSymbol(compiler_string_consts.eq_name,new SymbolInfo(cmn)); }
public common_namespace_event add_namespace_event(string name, location loc, type_node tn) { namespace_variable nv = new namespace_variable(name + "$", tn, converted_namespace, loc); common_namespace_event cne = new common_namespace_event(name, tn, converted_namespace, null, null, null, loc); common_namespace_function_node add_func = new common_namespace_function_node(compiler_string_consts.GetAddHandler(name), null, this.converted_namespace, null); common_parameter cp = new common_parameter("value", tn, SemanticTree.parameter_type.value, add_func, concrete_parameter_type.cpt_none, null, null); add_func.parameters.AddElement(cp); expression_node fld_ref = null; fld_ref = new namespace_variable_reference(nv, null); expression_node en = this.syntax_tree_visitor.convertion_data_and_alghoritms.type_constructor.delegate_add_assign_compile_time_executor (null, new expression_node[2] { fld_ref, new common_parameter_reference(cp, 0, null) }); //en = this.syntax_tree_visitor.convertion_data_and_alghoritms.create_simple_function_call(tn.find_in_type(compiler_string_consts.assign_name).sym_info as function_node,null, // fld_ref,en); add_func.function_code = new statements_list(null); (add_func.function_code as statements_list).statements.AddElement(en); //remove common_namespace_function_node remove_func = new common_namespace_function_node(compiler_string_consts.GetRemoveHandler(name), null, this.converted_namespace, null); cp = new common_parameter("value", tn, SemanticTree.parameter_type.value, add_func, concrete_parameter_type.cpt_none, null, null); remove_func.parameters.AddElement(cp); en = this.syntax_tree_visitor.convertion_data_and_alghoritms.type_constructor.delegate_sub_assign_compile_time_executor (null, new expression_node[2] { fld_ref, new common_parameter_reference(cp, 0, null) }); //en = this.syntax_tree_visitor.convertion_data_and_alghoritms.create_simple_function_call(tn.find_in_type(compiler_string_consts.assign_name).sym_info as function_node,null, // fld_ref,en); remove_func.function_code = new statements_list(null); (remove_func.function_code as statements_list).statements.AddElement(en); this.converted_namespace.functions.AddElement(add_func); this.converted_namespace.functions.AddElement(remove_func); cne.set_add_function(add_func); cne.set_remove_function(remove_func); cne.field = nv; this.converted_namespace.events.AddElement(cne); this.converted_namespace.variables.AddElement(nv); CurrentScope.AddSymbol(name, new SymbolInfo(cne)); return cne; }
public common_parameter_reference(common_parameter par, int static_depth, location loc) : base(par.type, loc) { _par = par; this.static_depth = static_depth; }
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; }
private common_type_node convert_function_type(SyntaxTree.formal_parameters syn_parametres, SyntaxTree.type_definition return_type, location loc, string type_name, common_type_node del_type) { //TODO: Добавить аттрибуты функции. Или не надо? //TODO: Сообщать о том что class keyword и of object игнорируется. parameter_list parameters = new parameter_list(); bool params_met=false; if (syn_parametres != null) { parameter_list temp_params = new parameter_list(); foreach (SyntaxTree.typed_parameters tpars in syn_parametres.params_list) { temp_params.clear(); SemanticTree.parameter_type pt = SemanticTree.parameter_type.value; concrete_parameter_type cpt = concrete_parameter_type.cpt_none; switch (tpars.param_kind) { //TODO: Params parameter. case SyntaxTree.parametr_kind.var_parametr: { pt = SemanticTree.parameter_type.var; cpt = concrete_parameter_type.cpt_var; break; } case PascalABCCompiler.SyntaxTree.parametr_kind.const_parametr: { pt = SemanticTree.parameter_type.value; cpt = concrete_parameter_type.cpt_const; break; } case PascalABCCompiler.SyntaxTree.parametr_kind.out_parametr: { pt = SemanticTree.parameter_type.var; cpt = concrete_parameter_type.cpt_var; break; } } foreach (SyntaxTree.ident id in tpars.idents.idents) { common_parameter cp = new common_parameter(id.name, pt, null, cpt, get_location(id)); parameters.AddElement(cp); if (tpars.param_kind == SyntaxTree.parametr_kind.params_parametr) { cp.intrenal_is_params = true; } temp_params.AddElement(cp); } if (tpars.param_kind == SyntaxTree.parametr_kind.params_parametr) { if (tpars.idents.idents.Count > 1) { AddError(get_location(tpars.idents.idents[1]), "ONLY_ONE_PARAMS_PARAMETER_ALLOWED"); } } SyntaxTree.array_type arr = tpars.vars_type as SyntaxTree.array_type; if (tpars.vars_type is SyntaxTree.class_definition || /*tpars.vars_type is SyntaxTree.enum_type_definition ||*/ (arr != null && arr.indexers != null && arr.indexers.indexers.Count > 0 && arr.indexers.indexers[0] != null)) { AddError(get_location(tpars.vars_type), "STRUCT_TYPE_DEFINITION_IN_FORMAL_PARAM"); } type_node tp = convert_strong(tpars.vars_type); /*if (depended_from_generic_parameter(tp)) // SSM 25/07/13 - закомментировал и пока всё работает { AddError(new DelegateCanNotUseComprehensiveGenericParameter(get_location(tpars.vars_type))); }*/ if (tpars.param_kind == SyntaxTree.parametr_kind.params_parametr) { internal_interface ii = tp.get_internal_interface(internal_interface_kind.unsized_array_interface); if (ii == null) { AddError(get_location(tpars.vars_type), "ONLY_UNSIZED_ARRAY_PARAMS_PARAMETER_ALLOWED"); } } foreach (common_parameter ccp in temp_params) { ccp.type = tp; } if (params_met) { AddError(get_location(tpars), "ONLY_LAST_PARAMETER_CAN_BE_PARAMS"); } if (tpars.param_kind == PascalABCCompiler.SyntaxTree.parametr_kind.params_parametr) { params_met = true; // if (default_value_met) // { // AddError(new FunctionWithParamsParameterCanNotHaveDefaultParameters(get_location(tp))); // } } } } type_node ret_val_type = null; if (return_type != null) { ret_val_type = convert_strong(return_type); /*if (depended_from_generic_parameter(ret_val_type)) // SSM 25/07/13 - закомментировал и пока всё работает { AddError(new DelegateCanNotUseComprehensiveGenericParameter(get_location(return_type))); }*/ } common_type_node del; if (del_type == null) { del = convertion_data_and_alghoritms.type_constructor.create_delegate(type_name, ret_val_type, parameters, context.converted_namespace, loc); } else { del = del_type; convertion_data_and_alghoritms.type_constructor.init_delegate(del, ret_val_type, parameters, loc); } context.converted_namespace.types.AddElement(del); return del; }
/// <summary> /// Временный узел, который используется при выведении типов параметров /// </summary> /// <param name="def"></param> /// <param name="visitor"></param> /// <returns></returns> public static typed_expression GetTempFunctionNodeForTypeInference(SyntaxTree.function_lambda_definition def, syntax_tree_visitor visitor) { var res = new common_namespace_function_node(def.lambda_name, null, null, null); if (def.return_type != null) res.return_value_type = visitor.convert_strong(def.return_type); else res.return_value_type = null; res.parameters.clear(); if (def.formal_parameters != null && def.formal_parameters.params_list.Count != 0) { for (int i = 0; i < def.formal_parameters.params_list.Count; i++) for (int j = 0; j < def.formal_parameters.params_list[i].idents.idents.Count; j++) { var new_param = new common_parameter(null, SemanticTree.parameter_type.value, res, concrete_parameter_type.cpt_none, null); new_param.type = visitor.convert_strong(def.formal_parameters.params_list[i].vars_type); res.parameters.AddElement(new_param); } } var hhh = new delegated_methods(); hhh.proper_methods.AddElement(new common_namespace_function_call(res, null)); return new typed_expression(hhh, null); }
public override void visit(SyntaxTree.function_header _function_header) { current_function_header = _function_header; hard_node_test_and_visit(_function_header.name); current_function_header = null; if (context.converted_template_type != null) { return; } if (_function_header.template_args != null) { visit_generic_params(context.top_function, _function_header.template_args.idents); } SymbolInfo si = context.create_special_names(); weak_node_test_and_visit(_function_header.parameters); type_node tn = null; if (_function_header.return_type == null) { if (context.top_function.IsOperator) AddError(get_location(_function_header), "FUNCTION_NEED_RETURN_TYPE"); } if (_function_header.return_type != null) { check_parameter_on_complex_type(_function_header.return_type); tn = convert_strong(_function_header.return_type); check_for_type_allowed(tn,get_location(_function_header.return_type)); if (_function_header.return_type is function_header || _function_header.return_type is procedure_header) check_delegate_on_generic_parameters(tn as common_type_node, get_location(_function_header.return_type)); } //(ssyy) moved up, так как при проверке аттрибута override надо знать тип возвращаемого значения context.top_function.return_value_type = tn; assign_doc_info(context.top_function,_function_header); if (_function_header.attributes != null) { make_attributes_for_declaration(_function_header, context.top_function); } if (context.converted_type != null && has_dll_import_attribute(context.top_function)) AddError(get_dll_import_attribute(context.top_function).location, "DLLIMPORT_ATTRIBUTE_CANNOT_BE_APPLIED_TO_METHOD"); if (_function_header.name.class_name != null) with_class_name = true; if (_function_header.class_keyword && !has_static_attr(_function_header.proc_attributes.proc_attributes)) { SyntaxTree.procedure_attribute pa = new SyntaxTree.procedure_attribute(PascalABCCompiler.SyntaxTree.proc_attribute.attr_static); pa.source_context = _function_header.source_context; _function_header.proc_attributes.proc_attributes.Add(pa); } weak_node_test_and_visit(_function_header.proc_attributes); if (context.top_function.IsOperator) { //if (cmmn == null) //{ // throw new OverloadOperatorMustBeStaticFunction(get_location(_function_header), context.top_function); //} if (context.top_function is common_method_node) { common_method_node cmmn = context.top_function as common_method_node; if (cmmn.polymorphic_state != SemanticTree.polymorphic_state.ps_static) { AddError(get_location(_function_header), "OVERLOADED_OPERATOR_MUST_BE_STATIC_FUNCTION"); } if ((cmmn.name == compiler_string_consts.implicit_operator_name || cmmn.name == compiler_string_consts.explicit_operator_name)) { if (!convertion_data_and_alghoritms.eq_type_nodes(tn, cmmn.comperehensive_type as type_node) && !convertion_data_and_alghoritms.eq_type_nodes(cmmn.comperehensive_type as type_node, cmmn.parameters[0].type)) { AddError(get_location(_function_header.return_type), "RETURN_VALUE_SHOULD_HAVE_TYPE_{0}", (cmmn.comperehensive_type as type_node).PrintableName); } else if (convertion_data_and_alghoritms.eq_type_nodes(tn, cmmn.parameters[0].type)) { AddError(get_location(_function_header), "CIRCURAL_TYPE_CONVERSION_DEFINITION"); } } else { int expected_params = 2; if (cmmn.name == "not") expected_params = 1; if ((cmmn.name == "+" || cmmn.name == "-")) { if (cmmn.parameters.Count != 2 && cmmn.parameters.Count != 1) AddError(new SimpleSemanticError(cmmn.loc, "OPERATORS_SHOULD_HAVE_1_OR_2_PARAMETERS")); } else if (cmmn.parameters.Count != expected_params) { if (expected_params==1) AddError(new SimpleSemanticError(cmmn.loc, "OPERATOR_SHOULD_HAVE_1_PARAMETER")); else AddError(new SimpleSemanticError(cmmn.loc, "OPERATOR_SHOULD_HAVE_2_PARAMETERS")); } bool has_types = false; foreach (parameter p in cmmn.parameters) { type_node ptn = p.type; if (ptn.is_generic_type_instance) ptn = ptn.original_generic; if (ptn == cmmn.cont_type) has_types = true; } if (!has_types) AddError(new SimpleSemanticError(cmmn.loc, "LEAST_ONE_PARAMETER_TYPE_SHOULD_EQ_DECLARING_TYPE_{0}",cmmn.cont_type.name)); } } else if (context.top_function is common_namespace_function_node) { common_namespace_function_node cnfn = context.top_function as common_namespace_function_node; if ((cnfn.name == compiler_string_consts.implicit_operator_name || cnfn.name == compiler_string_consts.explicit_operator_name)) { if (cnfn.parameters.Count != 1) AddError(new SimpleSemanticError(cnfn.loc,"EXTENSION_METHODS_MUST_HAVE_LEAST_ONE_PARAMETER")); if (cnfn.ConnectedToType == null) AddError(new SimpleSemanticError(cnfn.loc, "OPERATOR_SHOULD_BE_EXTENSION_METHOD")); if (!convertion_data_and_alghoritms.eq_type_nodes(tn, cnfn.ConnectedToType) && !convertion_data_and_alghoritms.eq_type_nodes(cnfn.ConnectedToType as type_node, cnfn.parameters[0].type)) { AddError(get_location(_function_header.return_type), "RETURN_VALUE_SHOULD_HAVE_TYPE_{0}", (cnfn.ConnectedToType as type_node).PrintableName); } else if (convertion_data_and_alghoritms.eq_type_nodes(tn, cnfn.parameters[0].type)) { AddError(get_location(_function_header), "CIRCURAL_TYPE_CONVERSION_DEFINITION"); } } else { int expected_params = 2; if (cnfn.name == "not") expected_params = 1; if (cnfn.name == "+" || cnfn.name == "-") { if (cnfn.parameters.Count != 2 && cnfn.parameters.Count != 1) AddError(new SimpleSemanticError(cnfn.loc, "OPERATORS_SHOULD_HAVE_1_OR_2_PARAMETERS")); } else if (cnfn.parameters.Count != expected_params) { if (expected_params == 1) AddError(new SimpleSemanticError(cnfn.loc, "OPERATOR_SHOULD_HAVE_1_PARAMETER")); else AddError(new SimpleSemanticError(cnfn.loc, "OPERATOR_SHOULD_HAVE_2_PARAMETERS")); } bool has_types = false; foreach (parameter p in cnfn.parameters) { type_node ptn = p.type; if (ptn.is_generic_type_instance) ptn = ptn.original_generic; if (cnfn.ConnectedToType != null && (ptn == cnfn.ConnectedToType || ptn == cnfn.ConnectedToType.original_generic)) has_types = true; } if (cnfn.ConnectedToType == null) AddError(new SimpleSemanticError(cnfn.loc, "OPERATOR_SHOULD_BE_EXTENSION_METHOD")); if (!has_types) AddError(new SimpleSemanticError(cnfn.loc, "LEAST_ONE_PARAMETER_TYPE_SHOULD_EQ_DECLARING_TYPE_{0}",cnfn.ConnectedToType.name)); } } } with_class_name = false; if (context.top_function != null && context.top_function is common_namespace_function_node && (context.top_function as common_namespace_function_node).ConnectedToType != null && !context.top_function.IsOperator) { concrete_parameter_type cpt = concrete_parameter_type.cpt_none; SemanticTree.parameter_type pt = PascalABCCompiler.SemanticTree.parameter_type.value; if ((context.top_function as common_namespace_function_node).ConnectedToType.is_value_type) { cpt = concrete_parameter_type.cpt_var; pt = PascalABCCompiler.SemanticTree.parameter_type.var; } type_node cur_tn = (context.top_function as common_namespace_function_node).ConnectedToType; /*if (cur_tn.is_generic_type_definition && cur_tn is compiled_type_node) { List<type_node> instance_params = new List<type_node>(); compiled_type_node cur_ctn = cur_tn as compiled_type_node; for (int i = 0; i < cur_ctn.instance_params.Count; i++) { instance_params.Add(find_type(cur_ctn.instance_params[i].name, null)); } cur_tn = cur_tn.get_instance(instance_params); }*/ type_node self_type = cur_tn; if (context.top_function.generic_params != null && self_type.is_generic_type_definition) { self_type = self_type.get_instance(context.top_function.get_generic_params_list()); } if (!has_extensionmethod_attr(_function_header.proc_attributes.proc_attributes)) { common_parameter cp = new common_parameter(compiler_string_consts.self_word, self_type, pt, context.top_function, cpt, null, null); context.top_function.parameters.AddElementFirst(cp); context.top_function.scope.AddSymbol(compiler_string_consts.self_word, new SymbolInfo(cp)); } } CheckOverrideOrReintroduceExpectedWarning(get_location(_function_header)); common_type_node common_converted_type_tmp = context.converted_type; compiled_type_node compiled_converted_type_tmp = context.converted_compiled_type; common_namespace_function_node cnfn2 = context.top_function as common_namespace_function_node; if (cnfn2 != null && cnfn2.ConnectedToType != null) { if (cnfn2.ConnectedToType is compiled_type_node) context.converted_compiled_type = cnfn2.ConnectedToType as compiled_type_node; else if (cnfn2.ConnectedToType is common_type_node) context.converted_type = cnfn2.ConnectedToType as common_type_node; } bool unique = context.close_function_params(body_exists); context.converted_type = common_converted_type_tmp; context.converted_compiled_type = compiled_converted_type_tmp; if (context.top_function.return_value_type == null) AddError(get_location(_function_header), "FUNCTION_NEED_RETURN_TYPE"); if (_function_header.where_defs != null) { if (unique) { visit_where_list(_function_header.where_defs); } else { AddError(get_location(_function_header.where_defs), "WHERE_SECTION_MUST_BE_ONLY_IN_FIRST_DECLARATION"); } } if (context.converted_type != null && context.converted_type.IsInterface) { if (body_exists) { AddError(new InterfaceFunctionWithBody(get_location(_function_header))); } common_method_node cmnode = context.top_function as common_method_node; context.set_virtual_abstract(cmnode); } convertion_data_and_alghoritms.create_function_return_variable(context.top_function, si); /*if (_function_header.name != null && context.converted_compiled_type != null && context.top_function is common_namespace_function_node) { if (context.FindMethodToOverride(context.top_function as common_namespace_function_node) != null) AddError(new CanNotDeclareExtensionMethodAsOverrided(get_location(_function_header))); }*/ //TODO: Разобрать подробнее. if (!body_exists) { if (_function_header.name.class_name != null && context.converted_explicit_interface_type != null) { AddError(get_location(_function_header), "EXPLICIT_IMPLEMENTATION_EXPECTED"); } if ((context.top_function.semantic_node_type == semantic_node_type.common_method_node) || ((context.func_stack_size_is_one()) && (_is_interface_part))) { context.leave_block(); } } body_exists = false; }
protected parameter_list make_parameters(parameter_list orig_pl, common_function_node fn) { parameter_list pl = new parameter_list(); //TODO: разобраться с concrete_parameter_type foreach (parameter p in orig_pl) { common_parameter cp = new common_parameter( p.name, generic_convertions.determine_type(p.type, _instance_params, false), p.parameter_type, fn, concrete_parameter_type.cpt_none, p.inital_value, null); cp.intrenal_is_params = p.is_params; cp.is_special_name = p.is_special_name; cp.is_ret_value = p.is_ret_value; cp.default_value = p.default_value; pl.AddElement(cp); } return pl; }
//ssyy public void generate_inherit_constructors() { common_type_node _ctn = context.converted_type; if (_ctn == null) { throw new CompilerInternalError("Can generate inherited constructors only in class."); } if (_ctn.has_user_defined_constructor) { //Пользователь определил хотя бы один конструктор, никакие конструкторы не наследуем. return; } //Получили список процедур предка, имеющих имя Create SymbolInfo si = _ctn.base_type.find_in_type(compiler_string_consts.default_constructor_name, _ctn.base_type.Scope); delete_inherited_constructors(ref si, _ctn.base_type); while (si != null) { function_node fn = si.sym_info as function_node; 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) { //Генерируем унаследованный конструктор location loc = null; SemanticTree.polymorphic_state ps; if (mconstr != null) { loc = mconstr.loc; ps = mconstr.polymorphic_state; } else //значит (pconstr != null) { ps = pconstr.polymorphic_state; } if (pconstr != null) context.set_field_access_level(pconstr.field_access_level); else context.set_field_access_level(mconstr.field_access_level); common_method_node gen_constr = context.create_function(compiler_string_consts.default_constructor_name, loc) as common_method_node; gen_constr.polymorphic_state = ps; gen_constr.is_overload = true; gen_constr.is_constructor = true; gen_constr.field_access_level = fn.field_access_level; gen_constr.return_value_type = _ctn; foreach (parameter par in fn.parameters) { //(ssyy) Интересно, зачем это. concrete_parameter_type cpt = (par.parameter_type == SemanticTree.parameter_type.var) ? concrete_parameter_type.cpt_var : concrete_parameter_type.cpt_none; common_parameter c_p = new common_parameter(par.name, par.parameter_type, gen_constr, cpt, null); c_p.type = par.type; c_p.set_param_is_params(par.is_params); c_p.inital_value = par.inital_value; gen_constr.parameters.AddElement(c_p); c_p.default_value = par.default_value; } base_function_call bfc; if (mconstr != null) { common_constructor_call c1 = new common_constructor_call(mconstr, null); c1._new_obj_awaited = false; bfc = c1; } else { compiled_constructor_call c2 = new compiled_constructor_call(pconstr, null); c2._new_obj_awaited = false; bfc = c2; } foreach (parameter p in gen_constr.parameters) { bfc.parameters.AddElement( create_variable_reference(p, null)); } statements_list snlist = new statements_list(null); snlist.statements.AddElement(bfc); snlist.statements.AddElement(new empty_statement(null)); gen_constr.function_code = snlist; context.leave_block(); if (fn.parameters.Count == 0 || fn.parameters[0].default_value != null) { _ctn.has_default_constructor = true; } } si = si.Next; } }
public generic_namespace_function_instance_node(common_namespace_function_node original_generic_function, List<type_node> instance_parameters) : base( generic_convertions.MakePseudoInstanceName(original_generic_function.name, instance_parameters, false), null, original_generic_function.namespace_node, null) { _original_function = original_generic_function; _instance_params = instance_parameters; this.field_access_level = original_generic_function.field_access_level; this.is_final = original_generic_function.is_final; this.is_overload = true; this.polymorphic_state = original_generic_function.polymorphic_state; this.return_value_type = generic_convertions.determine_type(original_generic_function.return_value_type, instance_parameters, true); foreach (parameter par in original_generic_function.parameters) { common_parameter cpar = new common_parameter(par.name, generic_convertions.determine_type(par.type, _instance_params, true), par.parameter_type, this, (par.parameter_type == SemanticTree.parameter_type.var) ? concrete_parameter_type.cpt_var : concrete_parameter_type.cpt_none, par.default_value, null); cpar.inital_value = par.inital_value; cpar.default_value = par.default_value; cpar.intrenal_is_params = par.is_params; cpar.is_ret_value = par.is_ret_value; cpar.is_special_name = par.is_special_name; parameters.AddElement(cpar); } }
public void lambda_header_visit(SymbolInfo si, SyntaxTree.function_header _function_header, type_node tn1) { type_node tn = null; if (_function_header.return_type == null) { if (context.top_function.IsOperator) AddError(get_location(_function_header), "FUNCTION_NEED_RETURN_TYPE"); } if (_function_header.return_type != null) { check_parameter_on_complex_type(_function_header.return_type); if (tn1 != null) tn = tn1; else tn = convert_strong(_function_header.return_type); //if (tn == SystemLibrary.SystemLibrary.void_type) // AddError(new VoidNotValid(get_location(_function_header.return_type))); check_for_type_allowed(tn, get_location(_function_header.return_type)); } //(ssyy) moved up, так как при проверке аттрибута override надо знать тип возвращаемого значения context.top_function.return_value_type = tn; assign_doc_info(context.top_function, _function_header); if (_function_header.attributes != null) { make_attributes_for_declaration(_function_header, context.top_function); } if (context.converted_type != null && has_dll_import_attribute(context.top_function)) AddError(get_dll_import_attribute(context.top_function).location, "DLLIMPORT_ATTRIBUTE_CANNOT_BE_APPLIED_TO_METHOD"); if (_function_header.name.class_name != null) with_class_name = true; if (_function_header.class_keyword && !has_static_attr(_function_header.proc_attributes.proc_attributes)) { SyntaxTree.procedure_attribute pa = new SyntaxTree.procedure_attribute(PascalABCCompiler.SyntaxTree.proc_attribute.attr_static); pa.source_context = _function_header.source_context; _function_header.proc_attributes.proc_attributes.Add(pa); } weak_node_test_and_visit(_function_header.proc_attributes); if (context.top_function.IsOperator) { common_method_node cmmn = context.top_function as common_method_node; //if (cmmn == null) //{ // throw new OverloadOperatorMustBeStaticFunction(get_location(_function_header), context.top_function); //} if (cmmn != null && cmmn.polymorphic_state != SemanticTree.polymorphic_state.ps_static) { AddError(get_location(_function_header), "OVERLOADED_OPERATOR_MUST_BE_STATIC_FUNCTION"); } if (cmmn != null && (cmmn.name == compiler_string_consts.implicit_operator_name || cmmn.name == compiler_string_consts.explicit_operator_name)) if (!convertion_data_and_alghoritms.eq_type_nodes(tn, cmmn.comperehensive_type as type_node) && !convertion_data_and_alghoritms.eq_type_nodes(cmmn.comperehensive_type as type_node, cmmn.parameters[0].type)) { AddError(get_location(_function_header.return_type), "RETURN_VALUE_SHOULD_HAVE_TYPE_{0}", (cmmn.comperehensive_type as type_node).PrintableName); } else if (convertion_data_and_alghoritms.eq_type_nodes(tn, cmmn.parameters[0].type)) { AddError(get_location(_function_header), "CIRCURAL_TYPE_CONVERSION_DEFINITION"); } } with_class_name = false; if (context.top_function != null && context.top_function is common_namespace_function_node && (context.top_function as common_namespace_function_node).ConnectedToType != null && !context.top_function.IsOperator) { concrete_parameter_type cpt = concrete_parameter_type.cpt_none; SemanticTree.parameter_type pt = PascalABCCompiler.SemanticTree.parameter_type.value; if ((context.top_function as common_namespace_function_node).ConnectedToType.is_value_type) { cpt = concrete_parameter_type.cpt_var; pt = PascalABCCompiler.SemanticTree.parameter_type.var; } common_parameter cp = new common_parameter(compiler_string_consts.self_word, (context.top_function as common_namespace_function_node).ConnectedToType, pt, context.top_function, cpt, null, null); context.top_function.parameters.AddElementFirst(cp); context.top_function.scope.AddSymbol(compiler_string_consts.self_word, new SymbolInfo(cp)); } CheckOverrideOrReintroduceExpectedWarning(get_location(_function_header)); bool unique = context.close_function_params(body_exists); if (context.top_function.return_value_type == null) AddError(get_location(_function_header), "FUNCTION_NEED_RETURN_TYPE"); if (_function_header.where_defs != null) { if (unique) { visit_where_list(_function_header.where_defs); } else { AddError(get_location(_function_header.where_defs), "WHERE_SECTION_MUST_BE_ONLY_IN_FIRST_DECLARATION"); } } convertion_data_and_alghoritms.create_function_return_variable(context.top_function, si); /*if (_function_header.name != null && context.converted_compiled_type != null && context.top_function is common_namespace_function_node) { if (context.FindMethodToOverride(context.top_function as common_namespace_function_node) != null) AddError(new CanNotDeclareExtensionMethodAsOverrided(get_location(_function_header))); }*/ //TODO: Разобрать подробнее. if (!body_exists) { if ((context.top_function.semantic_node_type == semantic_node_type.common_method_node) || ((context.func_stack_size_is_one()) && (_is_interface_part))) { context.leave_block(); } } body_exists = false; }
private common_parameter GetParameter() { int offset = (int)br.BaseStream.Position - start_pos; br.ReadByte(); string s = br.ReadString(); type_node tn = GetTypeReference(); concrete_parameter_type cpt = (concrete_parameter_type)br.ReadByte(); SemanticTree.parameter_type pt = SemanticTree.parameter_type.value; switch (cpt) { case concrete_parameter_type.cpt_const: pt = SemanticTree.parameter_type.value; break; case concrete_parameter_type.cpt_var: pt = SemanticTree.parameter_type.var; break; case concrete_parameter_type.cpt_none: pt = SemanticTree.parameter_type.value; break; } common_parameter p = new common_parameter(s, pt, null, cpt, null); p.type = tn; if (br.ReadBoolean()) p.set_used_as_unlocal(); p.intrenal_is_params = br.ReadBoolean(); if (br.ReadByte() == 1) { p.default_value = CreateExpressionWithOffset(); } p.attributes.AddRange(GetAttributes()); //members[offset] = p; AddMember(p, offset); return p; }
private function_node GenerateSetMethod(common_property_node cpn, common_method_node accessor, location loc) { common_method_node cmn = new common_method_node( "set_" + cpn.name, loc, cpn.common_comprehensive_type, cpn.polymorphic_state, cpn.field_access_level, null); cpn.common_comprehensive_type.methods.AddElement(cmn); //cmn.return_value_type = cpn.property_type; cmn.is_overload = true; foreach (common_parameter cp in accessor.parameters) { common_parameter new_cp = new common_parameter(cp.name, cp.type, cp.parameter_type, cp.common_function, cp.concrete_parameter_type, cp.default_value, loc); cmn.parameters.AddElement(new_cp); } expression_node meth_call; if (cpn.polymorphic_state == SemanticTree.polymorphic_state.ps_common) { meth_call = new common_method_call(accessor, new this_node(cpn.common_comprehensive_type, loc), loc); foreach (common_parameter cp in cmn.parameters) { (meth_call as common_method_call).parameters.AddElement(new common_parameter_reference(cp, 0, loc)); } } else { meth_call = new common_static_method_call(accessor, loc); foreach (common_parameter cp in cmn.parameters) { (meth_call as common_static_method_call).parameters.AddElement(new common_parameter_reference(cp, 0, loc)); } } cmn.function_code = meth_call; cpn.common_comprehensive_type.scope.AddSymbol("set_" + cpn.name, new SymbolInfo(cmn)); return cmn; }
private void add_delegate_operator(string name, compile_time_executor executor) { common_namespace_function_node cnfn = new common_namespace_function_node(name, this, null, null, null); cnfn.ConnectedToType = this; cnfn.compile_time_executor = executor; add_name(name, new SymbolInfo(cnfn)); common_parameter cp1 = new common_parameter(compiler_string_consts.left_param_name, this, SemanticTree.parameter_type.value, cnfn, concrete_parameter_type.cpt_none, null, null); common_parameter cp2 = new common_parameter(compiler_string_consts.right_param_name, this, SemanticTree.parameter_type.value, cnfn, concrete_parameter_type.cpt_none, null, null); cnfn.parameters.AddElement(cp1); cnfn.parameters.AddElement(cp2); }
private function_node GenerateGetSetMethodForInterfaceProperty(common_property_node pn, location loc, bool get_meth) { string AcessorName = (get_meth) ? compiler_string_consts.GetGetAccessorName(pn.name) : compiler_string_consts.GetSetAccessorName(pn.name); SymbolInfo exist_si = context.find_only_in_namespace(AcessorName); if (exist_si != null && exist_si.sym_info.general_node_type != general_node_type.function_node) { AddError(loc, "CAN_NOT_GENERATE_ACCESSOR_{0}", AcessorName); } common_method_node cmn = new common_method_node( AcessorName, loc, pn.common_comprehensive_type, pn.polymorphic_state, context.get_field_access_level(), null); cmn.is_overload = true; foreach (common_parameter cp in pn.parameters) { common_parameter accp = new common_parameter(cp.name, cp.parameter_type, cmn, cp.concrete_parameter_type, cp.loc); accp.type = cp.type; accp.inital_value = cp.inital_value; accp.intrenal_is_params = cp.intrenal_is_params; accp.is_ret_value = cp.is_ret_value; cmn.parameters.AddElement(accp); } if (get_meth) { cmn.return_value_type = pn.internal_property_type; } else { //foreach (common_parameter par in cmn.parameters) //{ // if (par.name == //} common_parameter accp = new common_parameter(compiler_string_consts.value_in_accessor_name, SemanticTree.parameter_type.value, cmn, concrete_parameter_type.cpt_none, null); accp.type = pn.internal_property_type; cmn.parameters.AddElement(accp); } while (exist_si != null) { if (convertion_data_and_alghoritms.function_eq_params(cmn, (function_node)(exist_si.sym_info))) { AddError(loc, "CAN_NOT_GENERATE_ACCESSOR_{0}", cmn.name); } exist_si = exist_si.Next; } pn.common_comprehensive_type.methods.AddElement(cmn); pn.common_comprehensive_type.scope.AddSymbol(AcessorName, new SymbolInfo(cmn)); return cmn; }
public common_parameter add_parameter(string name,SemanticTree.parameter_type pt, concrete_parameter_type cpt,location loc) { check_name_free(name,loc); #if (DEBUG) if (converting_block()!=block_type.function_block) { throw new CompilerInternalError("Parameters can be defined with functions only"); } #endif common_function_node top_func = _func_stack.top(); common_parameter cp=new common_parameter(name,pt,top_func,cpt,loc); top_func.parameters.AddElement(cp); top_func.scope.AddSymbol(name,new SymbolInfo(cp)); var_defs.Add(cp); return cp; }
//сохранение параметра private void VisitParameter(common_parameter p) { SavePosition(p); bw.Write((byte)p.semantic_node_type); bw.Write(p.name); WriteTypeReference(p.type); bw.Write((byte)p.concrete_parameter_type); bw.Write(p.is_used_as_unlocal); bw.Write(p.is_params); if (CanWriteObject(p.default_value)) { SaveExpressionAndOffset(p.default_value); bw.Write(0); //VisitExpression((expression_node)var.inital_value); } SaveOffsetForAttribute(p); bw.Write(0);//attributes; }
public void make_constructor() { #if (DEBUG) if (converting_block()!=block_type.function_block) { throw new CompilerInternalError("Create constructor call without function"); } if (_func_stack.top().node_location_kind!=SemanticTree.node_location_kind.in_class_location) { throw new CompilerInternalError("Create constructor applied to non class method"); } #endif common_function_node top_func=_func_stack.top(); top_func.return_value_type=_ctn; common_method_node top_method=(common_method_node)top_func; common_method_node cmn=new common_method_node(top_func.name,_ctn,top_method.loc,_ctn, SemanticTree.polymorphic_state.ps_static,_fal,top_func.scope); cmn.is_constructor=true; cmn.is_overload=top_function.is_overload; //parameter_list pl = new parameter_list(); foreach (common_parameter pr in top_method.parameters) { common_parameter new_par = new common_parameter(pr.name, pr.type, pr.parameter_type, cmn, pr.concrete_parameter_type, pr.default_value, pr.loc); cmn.parameters.AddElement(new_par); } //cmn.parameters.AddRange(top_method.parameters); statements_list stl=new statements_list(top_func.loc); cmn.function_code=stl; this_node thn=new this_node(_ctn,top_func.loc); common_method_call csmc=new common_method_call(top_method,thn,top_func.loc); foreach(common_parameter cp in cmn.parameters) { common_parameter_reference cpr=new common_parameter_reference(cp,0,top_func.loc); csmc.parametres.AddElement(cpr); } stl.statements.AddElement(csmc); _ctn.methods.AddElement(cmn); top_method.pascal_associated_constructor=cmn; }
public ParamInfo GetParameter(common_parameter vdn) { return (ParamInfo)ht[vdn]; }
public void init_delegate(common_type_node ctn, type_node return_value_type, parameter_list parameters, location loc) { common_method_node constructor=new common_method_node(compiler_string_consts.default_constructor_name,null,loc,ctn,SemanticTree.polymorphic_state.ps_common, SemanticTree.field_access_level.fal_public, convertion_data_and_alghoritms.symbol_table.CreateScope(ctn.scope)); constructor.is_constructor = true; constructor.return_value_type = ctn; constructor.function_code=new runtime_statement(SemanticTree.runtime_statement_type.ctor_delegate,loc); common_method_node invoke=new common_method_node(compiler_string_consts.invoke_method_name, return_value_type,loc,ctn,SemanticTree.polymorphic_state.ps_virtual, SemanticTree.field_access_level.fal_public, convertion_data_and_alghoritms.symbol_table.CreateScope(ctn.scope)); ctn.add_name(compiler_string_consts.invoke_method_name,new SymbolInfo(invoke)); for (int i=0; i<parameters.Count; i++) { if (parameters[i] is compiled_parameter) { parameters[i] = new common_parameter(parameters[i].name,parameters[i].type,parameters[i].parameter_type,invoke,concrete_parameter_type.cpt_none,null,null); } } invoke.parameters.AddRange(parameters); invoke.function_code = new runtime_statement(SemanticTree.runtime_statement_type.invoke_delegate, loc); common_method_node begin_invoke = new common_method_node(compiler_string_consts.begin_invoke_method_name, begin_invoke_result_type, loc, ctn, SemanticTree.polymorphic_state.ps_virtual, SemanticTree.field_access_level.fal_public, convertion_data_and_alghoritms.symbol_table.CreateScope(ctn.scope)); ctn.add_name(compiler_string_consts.begin_invoke_method_name,new SymbolInfo(begin_invoke)); parameter_list begin_invoke_params=new parameter_list(); begin_invoke_params.AddRange(parameters); common_parameter cp=new common_parameter(compiler_string_consts.callback_string,begin_invoke_parameter_type, SemanticTree.parameter_type.value,begin_invoke,concrete_parameter_type.cpt_none, null,loc); begin_invoke_params.AddElement(cp); cp = new common_parameter(compiler_string_consts.object_in_par_string, SystemLibrary.SystemLibrary.object_type, SemanticTree.parameter_type.value,begin_invoke, concrete_parameter_type.cpt_none, null, loc); begin_invoke_params.AddElement(cp); begin_invoke.parameters.AddRange(begin_invoke_params); begin_invoke.function_code = new runtime_statement(SemanticTree.runtime_statement_type.begin_invoke_delegate, loc); common_method_node end_invoke = new common_method_node(compiler_string_consts.end_invoke_method_name, return_value_type, loc, ctn, SemanticTree.polymorphic_state.ps_virtual, SemanticTree.field_access_level.fal_public, convertion_data_and_alghoritms.symbol_table.CreateScope(ctn.scope)); ctn.add_name(compiler_string_consts.end_invoke_method_name,new SymbolInfo(end_invoke)); cp = new common_parameter(compiler_string_consts.result_string, begin_invoke_result_type, SemanticTree.parameter_type.value, end_invoke, concrete_parameter_type.cpt_none, null, loc); end_invoke.parameters.AddElement(cp); end_invoke.function_code = new runtime_statement(SemanticTree.runtime_statement_type.end_invoke_delegate, loc); ctn.methods.AddElement(constructor); ctn.methods.AddElement(invoke); ctn.methods.AddElement(begin_invoke); ctn.methods.AddElement(end_invoke); SystemLibrary.SystemLibrary.init_reference_type(ctn); delegate_internal_interface dii = new delegate_internal_interface(return_value_type, invoke, constructor); dii.parameters.AddRange(parameters); ctn.add_internal_interface(dii); AddOperatorsToDelegate(ctn, loc); }