public SymbolInfo(class_field value) { //_name_information_type=name_information_type.nit_class_field; _sym_info=value; _access_level=get_class_member_access_level(value); _symbol_kind=symbol_kind.sk_none; }
//добавить внешнюю сущность public static void AddExternalMember(definition_node dn, int offset) { gl_members[dn] = offset; }
//то же самое, но только для членов класса (это лишнее можно объединить) /* private int SavePositionAndConstPoolInType(definition_node dn) { int pos = (int)bw.BaseStream.Position; members[dn] = pos; name_pool[dn].offset = pos; gl_members[dn] = pos; PCUWriter pw = null; if (not_comp_members.TryGetValue(dn,out pw)) pw.AddOffsetForMembers(dn,pos); return pos; }*/ //просто сохраняем смещение сущности private int SavePosition(definition_node dn) { int pos = (int)bw.BaseStream.Position; members[dn] = pos; gl_members[dn] = pos; return pos; }
//получение смещения сущности в модуле private int GetMemberOffset(definition_node dn) { return members[dn]; }
//получение смещения в другом модуле private int GetExternalOffset(definition_node dn) { int off = -1; if (!gl_members.TryGetValue(dn, out off)) { add_not_comp_members(dn, this); ext_offsets[dn] = imp_entitles.Count; } return off; }
private void assign_doc_info(definition_node dn, SyntaxTree.syntax_tree_node stn) { string s = null; if (docs != null && docs.TryGetValue(stn, out s) && !string.IsNullOrEmpty(s)) { dn.documentation = s; } return; }
//отложенное добавление смещения импортирумой сущности в список импорт. сущностей //используется при циклических связях модулей private void AddOffsetForMembers(definition_node dn, int offset) { if (!ext_offsets.ContainsKey(dn)) { return; } int pos = ext_offsets[dn]; //берем индекс в списке имп. сущ. imp_entitles[pos].offset = offset; // сохраняем смещение в другом модуле ext_offsets.Remove(dn); //удаляем сущность из таблицы //if (ext_offsets.Count == 0) //CloseWriter(); // если не разрешенных зависимостей больше нет, записываем модуль на диск }
public definition_node get_member_definition(definition_node instance_member) { return _member_definitions[instance_member] as definition_node; }
public definition_node ConvertMember(definition_node orig_node) { definition_node rez_node = _members[orig_node] as definition_node; if (rez_node == null) { //Преобразуем найденный член класса. SemanticTree.IClassMemberNode orig_member = orig_node as SemanticTree.IClassMemberNode; if (orig_member == null) { //Для basic_function generic_instance_type_node gitn = base_type as generic_instance_type_node; if (gitn == null) return orig_node; else return gitn.ConvertMember(orig_node); } type_node tn = orig_member.comperehensive_type as type_node; if (orig_member.comperehensive_type.is_generic_type_instance) tn = tn.original_generic; if (tn != _original_generic) { if (orig_member.comperehensive_type.is_generic_type_definition) { generic_instance_type_node compr_type = find_instance_type_from(orig_member.comperehensive_type as type_node); if (compr_type == null) { compiled_function_node cfn = orig_node as compiled_function_node; if (cfn == null) { return orig_node; } compiled_type_node cct = orig_member.comperehensive_type as compiled_type_node; type_node inst_type = this; do { inst_type = inst_type.base_type; } while (inst_type.semantic_node_type != semantic_node_type.compiled_type_node || (inst_type != cct && inst_type.original_generic != cct)); MethodInfo[] meths = cct._compiled_type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance); int num = System.Array.IndexOf(meths, cfn.method_info); MethodInfo mi = ((compiled_type_node)inst_type)._compiled_type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance)[num]; return compiled_function_node.get_compiled_method(mi); } else return compr_type.ConvertMember(orig_node); } else if (orig_member.comperehensive_type.is_generic_type_instance) { generic_instance_type_node compr_type = find_instance_type_from(tn); if (compr_type == null) { compiled_function_node cfn = orig_node as compiled_function_node; if (cfn == null) { return orig_node; } compiled_type_node cct = tn as compiled_type_node; type_node inst_type = this; do { inst_type = inst_type.base_type; } while (inst_type.semantic_node_type != semantic_node_type.compiled_type_node || (inst_type != cct && inst_type.original_generic != cct)); MethodInfo[] meths = cct._compiled_type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance); int num = System.Array.IndexOf(meths, cfn.method_info); MethodInfo mi = ((compiled_type_node)inst_type)._compiled_type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance)[num]; return compiled_function_node.get_compiled_method(mi); } else return compr_type.ConvertMember(orig_node); // } else return orig_node; } SemanticTree.ILocated orig_loc = orig_node as SemanticTree.ILocated; location loc = (orig_loc == null) ? null : (orig_loc.Location as location); switch (orig_node.general_node_type) { case general_node_type.constant_definition: constant_definition_node orig_cdn = orig_node as constant_definition_node; rez_node = new class_constant_definition( orig_cdn.name, orig_cdn.const_value, loc, this, orig_member.field_access_level); break; case general_node_type.variable_node: var_definition_node orig_cf = (var_definition_node)(orig_node); rez_node = new class_field(orig_cf.name, generic_convertions.determine_type(orig_cf.type, _instance_params, false), this, orig_member.polymorphic_state, orig_member.field_access_level, loc); break; case general_node_type.property_node: property_node orig_pn = (property_node)(orig_node); rez_node = make_property(orig_pn, loc); break; case general_node_type.function_node: function_node orig_fn = (function_node)(orig_node); rez_node = make_method(orig_fn, loc); break; case general_node_type.event_node: //(ssyy) Не знаю, что тут делать rez_node = orig_node; break; default: throw new CompilerInternalError("Unexpected definition_node."); } AddMember(orig_node, rez_node); } return rez_node; }
public SymbolInfo(type_node value) { _sym_info=value; _access_level=access_level.al_public; _symbol_kind=symbol_kind.sk_none; }
public SymbolInfo(definition_node value, access_level alevel, symbol_kind skind) { _sym_info = value; _access_level = alevel; _symbol_kind = skind; }
public SymbolInfo(common_property_node value) { //_name_information_type=name_information_type.nit_common_property; _sym_info=value; _access_level=get_class_member_access_level(value); _symbol_kind=symbol_kind.sk_none; }
public SymbolInfo(constant_definition_node value) { //_name_information_type=name_information_type.nit_constant_defnition; _sym_info=value; _access_level=access_level.al_public; _symbol_kind=symbol_kind.sk_none; }
public SymbolInfo(basic_parameter value) { //_name_information_type=name_information_type.nit_basic_parameter; _sym_info=value; _access_level=access_level.al_public; _symbol_kind=symbol_kind.sk_none; }
private addressed_expression create_class_static_field_reference(type_node tn, definition_node dn, SyntaxTree.ident id_right) { switch (dn.semantic_node_type) { case semantic_node_type.class_field: { class_field cf = (class_field)dn; if (cf.polymorphic_state != SemanticTree.polymorphic_state.ps_static) { AddError(new CanNotReferenceToNonStaticFieldWithType(cf, get_location(id_right), tn)); } static_class_field_reference scfr = new static_class_field_reference(cf, get_location(id_right)); return scfr; } case semantic_node_type.compiled_variable_definition: { compiled_variable_definition cvd = (compiled_variable_definition)dn; if (cvd.polymorphic_state != SemanticTree.polymorphic_state.ps_static) { AddError(new CanNotReferenceToNonStaticFieldWithType(cvd, get_location(id_right), tn)); } static_compiled_variable_reference scvr = new static_compiled_variable_reference(cvd, get_location(id_right)); return scvr; } } throw new CompilerInternalError("Error in create static class field reference."); }
internal void AddMember(definition_node dn, int offset) { members[offset] = dn; AddReadOrWritedDefinitionNode(dn, offset); }
private addressed_expression create_class_field_reference(expression_node en, definition_node dn, SyntaxTree.ident id_right) { try_convert_typed_expression_to_function_call(ref en); if (dn.semantic_node_type == semantic_node_type.class_field) { class_field cf = (class_field)dn; if (cf.polymorphic_state == SemanticTree.polymorphic_state.ps_static) { AddError(new CanNotReferanceToStaticFieldWithExpression(cf, get_location(id_right), en)); } class_field_reference cfr = new class_field_reference(cf, en, get_location(id_right)); //return_value(cfr); return cfr; } if (dn.semantic_node_type == semantic_node_type.compiled_variable_definition) { compiled_variable_definition cfd = (compiled_variable_definition)dn; if (cfd.polymorphic_state == SemanticTree.polymorphic_state.ps_static) { AddError(new CanNotReferanceToStaticFieldWithExpression(cfd, get_location(id_right), en)); } compiled_variable_reference cfr2 = new compiled_variable_reference(cfd, en, get_location(id_right)); //return_value(cfr2); return cfr2; } #if (DEBUG) throw new CompilerInternalError("Invalid variable kind"); #endif return null; }
internal static void AddReadOrWritedDefinitionNode(definition_node dn, int offset) { if(!AllReadOrWritedDefinitionNodesOffsets.ContainsKey(dn)) AllReadOrWritedDefinitionNodesOffsets.Add(dn, offset); }
private static void add_not_comp_members(definition_node dn, PCUWriter pw) { if (not_comp_members.ContainsKey(dn)) { not_comp_members[dn].Add(pw); } else { List<PCUWriter> l=new List<PCUWriter>(); l.Add(pw); not_comp_members.Add(dn, l); } }
private void check_for_usage_attribute(definition_node dn, AttributeTargets targets, string name, location loc, SemanticTree.attribute_qualifier_kind qualifier) { switch (dn.semantic_node_type) { case semantic_node_type.common_type_node : { common_type_node ctn = dn as common_type_node; if (ctn.IsDelegate) { if ((targets & (AttributeTargets.Delegate)) != (AttributeTargets.Delegate)) AddError(loc, "ATTRIBUTE_{0}_NOT_APPLICABLE_TO_DELEGATE", name); } else if (ctn.IsInterface) { if ((targets & AttributeTargets.Interface) != AttributeTargets.Interface) AddError(loc, "ATTRIBUTE_{0}_NOT_APPLICABLE_TO_INTERFACE", name); } else if (ctn.IsEnum) { if ((targets & (AttributeTargets.Enum)) != (AttributeTargets.Enum)) AddError(loc, "ATTRIBUTE_{0}_NOT_APPLICABLE_TO_ENUM", name); } else if (ctn.is_value_type) { if ((targets & AttributeTargets.Struct) != AttributeTargets.Struct) AddError(loc, "ATTRIBUTE_{0}_NOT_APPLICABLE_TO_STRUCT", name); } else if ((targets & AttributeTargets.Class) != AttributeTargets.Class) AddError(loc, "ATTRIBUTE_{0}_NOT_APPLICABLE_TO_CLASS", name); } break; case semantic_node_type.common_method_node: if ((dn as common_method_node).is_constructor) { if ((targets & AttributeTargets.Constructor) != AttributeTargets.Constructor) AddError(loc, "ATTRIBUTE_{0}_NOT_APPLICABLE_TO_CONSTRUCTOR", name); } else if ((targets & AttributeTargets.Method) != AttributeTargets.Method && qualifier != SemanticTree.attribute_qualifier_kind.return_kind) AddError(loc, "ATTRIBUTE_{0}_NOT_APPLICABLE_TO_METHOD", name); break; case semantic_node_type.common_namespace_function_node: if ((targets & AttributeTargets.Method) != AttributeTargets.Method && qualifier != SemanticTree.attribute_qualifier_kind.return_kind) AddError(loc, "ATTRIBUTE_{0}_NOT_APPLICABLE_TO_METHOD", name); break; case semantic_node_type.class_field: if ((targets & AttributeTargets.Field) != AttributeTargets.Field) AddError(loc, "ATTRIBUTE_{0}_NOT_APPLICABLE_TO_FIELD", name); break; case semantic_node_type.common_property_node: if ((targets & AttributeTargets.Property) != AttributeTargets.Property) AddError(loc, "ATTRIBUTE_{0}_NOT_APPLICABLE_TO_PROPERTY", name); break; case semantic_node_type.common_namespace_event: case semantic_node_type.common_event: if ((targets & AttributeTargets.Event) != AttributeTargets.Event) AddError(loc, "ATTRIBUTE_{0}_NOT_APPLICABLE_TO_EVENT", name); break; case semantic_node_type.common_parameter: if ((targets & AttributeTargets.Parameter) != AttributeTargets.Parameter) AddError(loc, "ATTRIBUTE_{0}_NOT_APPLICABLE_TO_FIELD", name); break; case semantic_node_type.common_unit_node: if ((targets & AttributeTargets.Assembly) != AttributeTargets.Assembly) AddError(loc, "ATTRIBUTE_{0}_NOT_APPLICABLE_TO_ASSEMBLY", name); break; } }
private void SaveOffsetForAttribute(definition_node dn) { if (!attr_dict.ContainsKey(dn)) { attr_dict[dn] = new List<int>(); } attr_dict[dn].Add((int)bw.BaseStream.Position); }
private void make_attributes_for_declaration(SyntaxTree.declaration td, definition_node ctn) { if (td.attributes != null) { Hashtable ht = new Hashtable(); foreach (SyntaxTree.simple_attribute_list sal in td.attributes.attributes) for (int j = 0; j < sal.attributes.Count; j++) { SyntaxTree.attribute attr = sal.attributes[j]; attribute_converted = true; type_node tn = convert_strong(attr.type); bool is_attr = false; type_node tmp = tn; while (tmp.base_type != null && !is_attr) { is_attr = tmp.base_type == SystemLibrary.SystemLibrary.attribute_type; tmp = tmp.base_type; } if (!is_attr) AddError(get_location(attr), "CLASS_{0}_NOT_ATTRIBUTE", tn.name); bool allowMultiple = false; AttributeTargets targets = get_usage_attrs(tn, out allowMultiple); if (ht.Contains(tn) && !allowMultiple) { AddError(get_location(attr), "DUPLICATE_ATTRIBUTE_{0}_APPLICATION", tn.name); } else ht[tn] = tn; SemanticTree.attribute_qualifier_kind qualifier = SemanticTree.attribute_qualifier_kind.none_kind; if (attr.qualifier != null) if (j == 0) { if (string.Compare(attr.qualifier.name, "return", true) == 0) { if (context.top_function == null) AddError(get_location(attr), "ATTRIBUTE_APPLICABLE_ONLY_TO_METHOD"); if (context.top_function.return_value_type == null || context.top_function.return_value_type == SystemLibrary.SystemLibrary.void_type) AddError(get_location(attr), "EXPECTED_RETURN_VALUE_FOR_ATTRIBUTE"); throw new NotSupportedError(get_location(attr.qualifier)); qualifier = SemanticTree.attribute_qualifier_kind.return_kind; } else throw new NotSupportedError(get_location(attr.qualifier)); } else AddError(get_location(attr.qualifier), "ATTRIBUTE_QUALIFIER_MUST_BE_FIRST"); check_for_usage_attribute(ctn, targets, tn.name, get_location(attr), qualifier); attribute_converted = false; SyntaxTree.expression_list cnstr_args = new SyntaxTree.expression_list(); if (attr.arguments != null) { foreach (SyntaxTree.expression e in attr.arguments.expressions) { if (e is SyntaxTree.bin_expr && (e as SyntaxTree.bin_expr).operation_type == SyntaxTree.Operators.Equal && (e as SyntaxTree.bin_expr).left is SyntaxTree.ident) { break; } else { cnstr_args.expressions.Add(e); } } } expressions_list args = new expressions_list(); for (int i = 0; i < cnstr_args.expressions.Count; i++) { constant_node cn = convert_strong_to_constant_node(cnstr_args.expressions[i]); check_for_strong_constant(cn, get_location(cnstr_args.expressions[i])); args.AddElement(cn); } base_function_call bfc = create_constructor_call(tn, args, get_location(attr)); if (ctn is common_type_node && tn == SystemLibrary.SystemLibrary.struct_layout_attribute_type) { if ((System.Runtime.InteropServices.LayoutKind)Convert.ToInt32((args[0] as constant_node).get_object_value()) == System.Runtime.InteropServices.LayoutKind.Explicit) { check_all_fields_have_field_offset_attr(ctn as common_type_node); } } attribute_node attr_node = new attribute_node(bfc.simple_function_node, tn, get_location(td)); foreach (expression_node en in bfc.parameters) { constant_node cn = convert_strong_to_constant_node(en, en.type); check_for_strong_constant(cn, en.location); attr_node.args.Add(cn); } if (attr.arguments != null) { for (int i = cnstr_args.expressions.Count; i < attr.arguments.expressions.Count; i++) { SyntaxTree.expression e = attr.arguments.expressions[i]; if (!(e is SyntaxTree.bin_expr && (e as SyntaxTree.bin_expr).operation_type == SyntaxTree.Operators.Equal && (e as SyntaxTree.bin_expr).left is SyntaxTree.ident)) { AddError(get_location(e), "EXPECTED_ATTRIBUTE_INITIALIZER"); } else { SyntaxTree.ident id = (e as SyntaxTree.bin_expr).left as SyntaxTree.ident; SymbolInfo si = tn.find_in_type(id.name); definition_node dn = context.check_name_node_type(id.name, si, get_location(id), general_node_type.property_node, general_node_type.variable_node); type_node mem_tn = null; if (dn is property_node) { property_node pn = dn as property_node; attr_node.prop_names.Add(pn); if (pn.set_function == null) AddError(new ThisPropertyCanNotBeWrited(pn, get_location(id))); if (pn.set_function.parameters.Count != 1) AddError(get_location(id), "INDEX_PROPERTY_INITIALIZING_NOT_VALID"); mem_tn = pn.set_function.parameters[0].type; } else if (dn is var_definition_node) { attr_node.field_names.Add(dn as var_definition_node); mem_tn = (dn as var_definition_node).type; } else { throw new CompilerInternalError("Bad general node type for attribute initializer"); } //SyntaxTree.assign tmp_ass = new SyntaxTree.assign(id,(e as SyntaxTree.bin_expr).right,SyntaxTree.Operators.Assignment); //tmp_ass.source_context = e.source_context; //basic_function_call tmp_bfc = convert_strong(tmp_ass) as basic_function_call; constant_node cn = convert_strong_to_constant_node((e as SyntaxTree.bin_expr).right, mem_tn); check_for_strong_constant(cn, get_location((e as SyntaxTree.bin_expr).right)); if (dn is property_node) attr_node.prop_initializers.Add(cn); else attr_node.field_initializers.Add(cn); } } } attr_node.qualifier = qualifier; ctn.attributes.AddElement(attr_node); } } }
//получения индекса в таблице интерфейсных имен private int GetNameIndex(definition_node dn) { return name_pool[dn].index; }
internal addressed_expression create_variable_reference(definition_node dn, location lloc) { switch (dn.semantic_node_type) { case semantic_node_type.local_variable: { local_variable lv = (local_variable)dn; if (context.converting_block() == block_type.function_block) { return new local_variable_reference(lv, convertion_data_and_alghoritms.symbol_table.GetRelativeScopeDepth(lv.function.scope, context.top_function.scope), lloc); } else if (context.converting_block() == block_type.namespace_block) { return new local_variable_reference(lv, 0, lloc); } else { throw new CompilerInternalError("Invalid block type"); } } case semantic_node_type.namespace_variable: { namespace_variable nv = (namespace_variable)dn; return new namespace_variable_reference(nv, lloc); } case semantic_node_type.class_field: { class_field cf = (class_field)dn; if (cf.polymorphic_state == SemanticTree.polymorphic_state.ps_static) { return new static_class_field_reference(cf, lloc); } expression_node obj = GetCurrentObjectReference(cf.cont_type.Scope,cf, lloc); //new this_node(context.converted_type, lloc); return new class_field_reference(cf, obj, lloc); } case semantic_node_type.common_parameter: { if (context.in_parameters_block) AddError(new ParameterReferenceInDefaultParameterNotAllowed(lloc)); common_parameter cpar = (common_parameter)dn; return new common_parameter_reference(cpar, convertion_data_and_alghoritms.symbol_table.GetRelativeScopeDepth(cpar.common_function.scope, context.top_function.scope), lloc); } case semantic_node_type.local_block_variable: { return new local_block_variable_reference((local_block_variable)dn, lloc); } case semantic_node_type.compiled_variable_definition: { return new static_compiled_variable_reference((compiled_variable_definition)dn,lloc); } default: throw new NotSupportedError(lloc); } return null; }
//сериализована ли сущность private bool IsDefined(definition_node dn) { return members.ContainsKey(dn); }
void checkPolymorphicState(definition_node dn,location loc) { }
//сохранить смещение сущности в таблицах и в списке интерфейсных имен private int SavePositionAndConstPool(definition_node dn) { int pos = (int)bw.BaseStream.Position; members[dn] = pos; name_pool[dn].offset = pos; if (dn is common_namespace_function_node) if ((dn as common_namespace_function_node).is_overload) name_pool[dn].symbol_kind = symbol_kind.sk_overload_function; gl_members[dn] = pos; List<PCUWriter> pwl = null; //если какой-то модуль ждет смещения от этой сущности, сообщаем ему if (not_comp_members.TryGetValue(dn, out pwl)) foreach(PCUWriter pw in pwl) pw.AddOffsetForMembers(dn, pos); PCUReader.AddReadOrWritedDefinitionNode(dn, pos); return pos; }
internal expression_node GetCurrentObjectReference(SymbolTable.Scope scope, definition_node dn, location loc) { if (WithSection) if (scope != null) if (WithVariables.ContainsKey(scope)) return WithVariables[scope]; else if (WithTypes.Contains(scope)) { switch (dn.semantic_node_type) { case semantic_node_type.class_field : if (!(dn as class_field).IsStatic) AddError(new CanNotReferenceToNonStaticFieldWithType(dn as class_field,loc,null)); break; case semantic_node_type.compiled_variable_definition : if (!(dn as compiled_variable_definition).IsStatic) AddError(new CanNotReferenceToNonStaticFieldWithType(dn as class_field,loc,null)); break; case semantic_node_type.compiled_property_node: case semantic_node_type.common_property_node : if ((dn as property_node).polymorphic_state != SemanticTree.polymorphic_state.ps_static) AddError(new CanNotReferenceToNonStaticPropertyWithType(dn as property_node,loc,null)); break; case semantic_node_type.compiled_function_node: case semantic_node_type.common_method_node: if ((dn as function_node).polymorphic_state != SemanticTree.polymorphic_state.ps_static) AddError(new CanNotReferenceToNonStaticMethodWithType((dn as function_node).name,loc)); break; } } if (context.inStaticArea()) { AddError(new CanNotReferenceToNonStaticFromStatic(dn,loc)); return null; } else return new this_node(context.converted_type, loc); }
//(ssyy) сохраняем смещение сущности (для implementation) private int SavePositionAndImplementationPool(definition_node dn) { int pos = (int)bw.BaseStream.Position; members[dn] = pos; impl_name_pool[dn].offset = pos; gl_members[dn] = pos; return pos; }
public SymbolInfo(namespace_variable value) { //_name_information_type=name_information_type.nit_namespace_variable; _sym_info=value; _access_level=access_level.al_public; _symbol_kind=symbol_kind.sk_none; }