public static void add_default_ctor(common_type_node param) { common_method_node cnode = new common_method_node( compiler_string_consts.default_constructor_name, param, null, param, SemanticTree.polymorphic_state.ps_common, SemanticTree.field_access_level.fal_public, null); cnode.is_constructor = true; param.methods.AddElement(cnode); param.add_name(compiler_string_consts.default_constructor_name, new SymbolInfo(cnode)); param.has_default_constructor = true; }
public common_event(string name, type_node del_type, common_type_node cont_type, common_method_node add_method, common_method_node remove_method, common_method_node raise_method, SemanticTree.field_access_level fal, SemanticTree.polymorphic_state ps, location loc) { this._name = name; this.del_type = del_type; this._add_method = add_method; this._remove_method = remove_method; this._raise_method = raise_method; this._field_access_level = fal; this._polymorphic_state = ps; this._cont_type = cont_type; this._loc = loc; }
public void reset() { _cmn = null; _ctn = null; _func_stack.clear(); var_defs.Clear(); _main_procedure = null; _last_created_function = null; _cycles_stack.clear(); _num_of_for_cycles = 0; _fal = SemanticTree.field_access_level.fal_private; rec_num = 1; var_defs_stack.Clear(); type_stack.Clear(); clear_special_local_vars(); _scope_stack.Clear(); }
private void VisitCommonTypeHeader(common_type_node ctn) { if (ctn.base_type != null && ctn.base_type is common_type_node) VisitCommonTypeHeader(ctn.base_type as common_type_node); foreach (class_field fld in ctn.fields) helper.AddField(fld); }
private void VisitTypeImplementation(common_type_node type) { foreach (common_method_node meth in type.methods) VisitMethodImplementation(meth); }
//сохранение свойств private void VisitPropertyDefinitions(common_type_node ctn) { int offset = GetMemberOffset(ctn); bw.Write(ctn.properties.Count); for (int i=0; i<ctn.properties.Count; i++) VisitPropertyDefinition(ctn.properties[i],offset); }
//сохранение полей private void VisitFieldDefinitions(common_type_node ctn) { bw.Write(ctn.fields.Count); int offset = GetMemberOffset(ctn); for (int i=0; i<ctn.fields.Count; i++) VisitFieldDefinition(ctn.fields[i],offset); }
private void VisitTypeDefinition(common_type_node type) { int offset = 0; if (is_interface == true) offset = SavePositionAndConstPool(type); else offset = SavePositionAndImplementationPool(type); bw.Write((byte)type.semantic_node_type); bw.Write(is_interface); bw.Write(type_entity_index++); if (is_interface == true) bw.Write(GetNameIndex(type)); else bw.Write(type.name); /*if (type.base_type != null) WriteTypeReference(type.base_type); else*/ //Пишем, является ли данный класс интерфейсом if (type.IsInterface) { bw.Write((byte)1); } else { bw.Write((byte)0); } //Пишем, является ли данный класс делегатом if (type.IsDelegate) { bw.Write((byte)1); } else { bw.Write((byte)0); } //Является ли тип описанием дженерика if (type.is_generic_type_definition) { bw.Write((byte)1); //Число типов-параметров bw.Write(type.generic_params.Count); //Имена параметров foreach (common_type_node par in type.generic_params) { bw.Write(par.name); } } else { bw.Write((byte)0); } int base_class_off = (int)bw.BaseStream.Position; bw.Seek(GetSizeOfReference(type.base_type), SeekOrigin.Current); //(ssyy) На кой чёрт это надо? //WriteTypeReference(SystemLibrary.SystemLibrary.object_type); //WriteTypeReference(type.base_type); bw.Write(type.internal_is_value); //Пишем поддерживаемые интерфейсы //eto nepravilno!!! a vdrug bazovye interfejsy eshe ne projdeny. //WriteImplementingInterfaces(type); int interface_impl_off = (int)bw.BaseStream.Position; int seek_off = sizeof(int); for (int k=0; k<type.ImplementingInterfaces.Count; k++) seek_off += GetSizeOfReference(type.ImplementingInterfaces[k] as TreeRealization.type_node); bw.Seek(seek_off, SeekOrigin.Current); bw.Write((byte)type.type_access_level); bw.Write((byte)type.type_special_kind); bw.Write(type.IsSealed); bw.Write(type.IsAbstract); bw.Write(type.IsPartial); if (type.type_special_kind == SemanticTree.type_special_kind.diap_type) { ordinal_type_interface oti = type.get_internal_interface(internal_interface_kind.ordinal_interface) as ordinal_type_interface; VisitExpression(oti.lower_value); VisitExpression(oti.upper_value); } if (type.is_generic_type_definition) { //Ограничители параметров WriteTypeParamsEliminations(type.generic_params); } if(CanWriteObject(type.element_type)) WriteTypeReference(type.element_type); bw.Write(GetUnitReference(type.comprehensive_namespace)); SaveOffsetForAttribute(type); bw.Write(0);//attributes; if (type.default_property != null) bw.Write((byte)1); else bw.Write((byte)0); int def_prop_off = (int)bw.BaseStream.Position; if (type.default_property != null) bw.Write(0);//default_property WriteDebugInfo(type.loc); //заполнение списка имен членов этого класса int num = type.const_defs.Count + type.fields.Count + type.properties.Count + type.methods.Count+type.events.Count; NameRef[] names = new NameRef[num]; int pos = (int)bw.BaseStream.Position; int int_size = System.Runtime.InteropServices.Marshal.SizeOf(typeof(int)); int size = int_size; int i=0,j=0; for (i=j; i<type.const_defs.Count+j; i++) { names[i] = new NameRef(type.const_defs[i - j].name, i); name_pool[type.const_defs[i - j]] = names[i]; size += names[i].Size; } j=i; for (i=j; i<type.fields.Count+j; i++) { names[i] = new NameRef(type.fields[i - j].name, i, convert_field_access_level(type.fields[i - j].field_access_level), type.fields[i - j].semantic_node_type); name_pool[type.fields[i - j]] = names[i]; size += names[i].Size; } j=i; for (i=j; i<type.properties.Count+j; i++) { names[i] = new NameRef(type.properties[i - j].name, i, convert_field_access_level(type.properties[i - j].field_access_level), type.properties[i - j].semantic_node_type); name_pool[type.properties[i - j]] = names[i]; size += names[i].Size; } j=i; for (i=j; i<type.methods.Count+j; i++) { names[i] = new NameRef(type.methods[i - j].name, i, convert_field_access_level(type.methods[i - j].field_access_level), type.methods[i - j].semantic_node_type); name_pool[type.methods[i - j]] = names[i]; if (type.methods[i - j].is_overload) names[i].symbol_kind = symbol_kind.sk_overload_function; names[i].virtual_slot = type.methods[i - j].newslot_awaited || type.methods[i - j].polymorphic_state == SemanticTree.polymorphic_state.ps_virtual || type.methods[i - j].polymorphic_state == SemanticTree.polymorphic_state.ps_virtual_abstract || type.methods[i - j].is_constructor; size += names[i].Size; } j=i; for (i=j; i<type.events.Count+j; i++) { names[i] = new NameRef(type.events[i - j].name, i, convert_field_access_level(type.events[i - j].field_access_level), type.events[i - j].semantic_node_type); name_pool[type.events[i - j]] = names[i]; size += names[i].Size; } bw.BaseStream.Seek(size,SeekOrigin.Current); /*VisitConstantInTypeDefinitions(type); VisitFieldDefinitions(type); VisitMethodDefinitions(type); VisitPropertyDefinitions(type); int tmp = (int)bw.BaseStream.Position; if (type.default_property != null) { bw.Seek(def_prop_off, SeekOrigin.Begin); bw.Write(GetMemberOffset(type.default_property)); bw.Seek(tmp, SeekOrigin.Begin); } bw.BaseStream.Seek(pos,SeekOrigin.Begin); bw.Write(names.Length); for (i=0; i<names.Length; i++) { bw.Write(names[i].name); bw.Write(names[i].offset); } bw.BaseStream.Seek(tmp,SeekOrigin.Begin);*/ ClassInfo ci = new ClassInfo(pos, def_prop_off, base_class_off, interface_impl_off,names); class_info[type] = ci; }
//(ssyy) Сохранение параметров generic-типов private void WriteGenericParameter(common_type_node type) { if (type.generic_type_container != null) { bw.Write((byte)TypeKind.GenericParameterOfType); //Пишем ссылку на generic-тип, содержащий данный параметр WriteTypeReference(type.generic_type_container as type_node); } else { common_method_node cnode = type.generic_function_container as common_method_node; if (cnode != null) { bw.Write((byte)TypeKind.GenericParameterOfMethod); WriteMethodReference(cnode); } else { common_namespace_function_node cnfn = type.generic_function_container as common_namespace_function_node; bw.Write((byte)TypeKind.GenericParameterOfFunction); WriteFunctionReference(cnfn); } } bw.Write(type.generic_param_index); }
public bool SameTypeAutoClasses(List<string> names, List<type_node> types, common_type_node t) { if (t.properties.Count() != names.Count()) return false; var tnames = t.properties.Select(tt => tt.name); return types.SequenceEqual(t.fields.Select(tt => tt.type)) && names.SequenceEqual(tnames, StringComparer.OrdinalIgnoreCase); //return true; }
//\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(); }
private record_constant ConvertRecordConst(common_type_node ctn, record_constant constant) { location loc = constant.location; if (!ctn.is_value_type) AddError(loc, "RECORD_CONST_NOT_ALLOWED_{0}", ctn.name); if (ctn.fields.Count != constant.record_const_definition_list.Count) AddError(loc, "INVALID_RECORD_CONST_FIELD_COUNT"); constant.SetType(ctn); constant.field_values.Clear(); bool tmp = this.is_typed_const_def; this.is_typed_const_def = true; for (int i = 0; i < ctn.fields.Count; i++) { class_field cf = ctn.fields[i]; if (cf.name.ToLower() != constant.record_const_definition_list[i].name.name.ToLower()) AddError(get_location(constant.record_const_definition_list[i].name), "FIELD_NAME_SHOULD_BE_EQUAL_RECORD_FIELD_NAME", cf.name); constant.field_values.Add(convert_strong_to_constant_node(constant.record_const_definition_list[i].val, cf.type)); } this.is_typed_const_def = tmp; return constant; }
private record_initializer ConvertRecordInitializer(common_type_node ctn, record_initializer constant) { location loc = constant.location; if (!ctn.is_value_type) AddError(loc, "RECORD_CONST_NOT_ALLOWED_{0}", ctn.name); if (ctn.fields.Count != constant.record_const_definition_list.Count) AddError(loc, "INVALID_RECORD_CONST_FIELD_COUNT"); constant.type = ctn; constant.field_values.Clear(); for (int i = 0; i < ctn.fields.Count; i++) { class_field cf = ctn.fields[i]; if (cf.name.ToLower() != constant.record_const_definition_list[i].name.name.ToLower()) AddError(get_location(constant.record_const_definition_list[i].name), "FIELD_NAME_SHOULD_BE_EQUAL_RECORD_FIELD_NAME", cf.name); expression_node en = convert_strong_to_constant_or_function_call_for_varinit(convert_strong(constant.record_const_definition_list[i].val),cf.type); en.type = cf.type; constant.field_values.Add(en); } return constant; }
private void check_delegate_on_generic_parameters(common_type_node ctn, location loc) { if (ctn == null) return; foreach (common_method_node cmn in ctn.methods) { if (cmn.name == "Invoke") { foreach (common_parameter prm in cmn.parameters) { if (is_instance_of_generic_parameter(prm.type)) AddError(loc, "ANONYMOUS_FUNCTION_TYPE_WITH_GENERICS"); } if (cmn.return_value_type != null && is_instance_of_generic_parameter(cmn.return_value_type)) AddError(loc, "ANONYMOUS_FUNCTION_TYPE_WITH_GENERICS"); } } }
//Добавляет ограничители для параметра шаблона private void add_generic_eliminations(common_type_node param, List<SyntaxTree.type_definition> specificators) { Hashtable used_interfs = new Hashtable(); for (int i = 0; i < specificators.Count; ++i) { SyntaxTree.declaration_specificator ds = specificators[i] as SyntaxTree.declaration_specificator; if (ds != null) { switch (ds.specificator) { case SyntaxTree.DeclarationSpecificator.WhereDefClass: if (i == 0) { param.is_class = true; } else { AddError(get_location(specificators[i]), "CLASS_OR_RECORD_SPECIFICATOR_MUST_BE_FIRST"); } break; case SyntaxTree.DeclarationSpecificator.WhereDefValueType: if (i == 0) { param.internal_is_value = true; } else { AddError(get_location(specificators[i]), "CLASS_OR_RECORD_SPECIFICATOR_MUST_BE_FIRST"); } break; case SyntaxTree.DeclarationSpecificator.WhereDefConstructor: if (i == specificators.Count - 1) { generic_parameter_eliminations.add_default_ctor(param); //common_method_node cnode = new common_method_node( // compiler_string_consts.default_constructor_name, param, null, // param, SemanticTree.polymorphic_state.ps_common, // SemanticTree.field_access_level.fal_public, null); //cnode.is_constructor = true; //param.methods.AddElement(cnode); //param.add_name(compiler_string_consts.default_constructor_name, new SymbolInfo(cnode)); } else { AddError(get_location(specificators[i]), "CONSTRUCTOR_SPECIFICATOR_MUST_BE_LAST"); } break; } } else { SyntaxTree.named_type_reference ntr = specificators[i] as SyntaxTree.named_type_reference; if (ntr == null) { AddError(get_location(specificators[i]), "SPECIFICATOR_MUST_BE_TYPE_REFERENCE"); } else { type_node spec_type = ret.visit(ntr); if (spec_type is ref_type_node || spec_type == SystemLibrary.SystemLibrary.void_type || spec_type == SystemLibrary.SystemLibrary.pointer_type) ErrorsList.Add(new SimpleSemanticError(get_location(specificators[i]), "INAVLID_TYPE")); if (spec_type.IsInterface) { if (used_interfs[spec_type] != null) { AddError(get_location(specificators[i]), "INTERFACE_{0}_ALREADY_ADDED_TO_IMPLEMENTING_LIST", spec_type.PrintableName); } else { used_interfs.Add(spec_type, spec_type); } //Добавляем интерфейс type_table.AddInterface(param, spec_type, get_location(specificators[i])); } else { if (i != 0) { AddError(get_location(specificators[i]), "PARENT_SPECIFICATOR_MUST_BE_FIRST"); } else { //Тип-предок if (spec_type == SystemLibrary.SystemLibrary.object_type) { AddError(get_location(specificators[i]), "OBJECT_CAN_NOT_BE_USED_AS_PARENT_SPECIFICATOR"); } if (spec_type == SystemLibrary.SystemLibrary.enum_base_type) { AddError(get_location(specificators[i]), "ENUM_CAN_NOT_BE_USED_AS_PARENT_SPECIFICATOR"); } check_cycle_inheritance(param, spec_type); param.SetBaseType(spec_type); } } } } } InitInterfaceScope(param); }
//получение ссылки на тип, описанный в другом модуле private int GetExtTypeReference(common_type_node ctn) { ImportedEntity ie = null; if (ext_members.TryGetValue(ctn, out ie)) { return ie.index * ie.GetSize(); } ie = new ImportedEntity(); ie.flag = ImportKind.Common; ie.num_unit = GetUnitToken(ctn.comprehensive_namespace); ie.offset = GetExternalOffset(ctn); int offset = imp_entitles.Count*ie.GetSize(); ie.index = imp_entitles.Count; imp_entitles.Add(ie); ext_members[ctn] = ie; return offset; }
//(ssyy) Сохранение инстанции шаблонного класса private void WriteTemplateInstance(common_type_node cnode) { bw.Write((byte)TypeKind.TemplateInstance); //Записать ссылку на шаблонный класс WriteTemplateClassReference(cnode.original_template); WriteTypeList(cnode.original_template.GetParamsList(cnode)); }
private void VisitAndAddInterfaces(common_type_node t, List<SyntaxTree.named_type_reference> types, int start, Hashtable used_interfaces) { for (int i = start; i < types.Count; i++) { type_node interf = ret.visit(types[i]); location loc = get_location(types[i]); if (used_interfaces[interf] != null) { AddError(loc, "INTERFACE_{0}_ALREADY_ADDED_TO_IMPLEMENTING_LIST", interf.PrintableName); } used_interfaces.Add(interf, interf); type_table.AddInterface(t, interf, loc); } }
private void WriteImplementingInterfaces(common_type_node type) { bw.Write(type.ImplementingInterfaces.Count); foreach (type_node interf in type.ImplementingInterfaces) { WriteTypeReference(interf); } }
private void InitInterfaceScope(common_type_node ctn) { List<SymbolTable.Scope> interf_scopes = new List<SymbolTable.Scope>(ctn.ImplementingInterfaces.Count); foreach (type_node tnode in ctn.ImplementingInterfaces) { interf_scopes.Add(tnode.Scope); } (ctn.Scope as SymbolTable.InterfaceScope).TopInterfaceScopeArray = interf_scopes.ToArray(); }
private void VisitTypeMemberDefinition(common_type_node ctn) { VisitConstantInTypeDefinitions(ctn); VisitFieldDefinitions(ctn); VisitMethodDefinitions(ctn); VisitPropertyDefinitions(ctn); VisitEventDefinitions(ctn); int tmp = (int)bw.BaseStream.Position; ClassInfo ci = class_info[ctn]; int def_prop_off = ci.def_prop_off; int pos = ci.names_pos; int base_class_off = ci.base_class_off; NameRef[] names = ci.names; if (ctn.base_type != null) { bw.Seek(base_class_off, SeekOrigin.Begin); WriteTypeReference(ctn.base_type); bw.Seek(tmp, SeekOrigin.Begin); } bw.Seek(ci.interf_impl_off, SeekOrigin.Begin); WriteImplementingInterfaces(ctn); bw.Seek(tmp, SeekOrigin.Begin); if (ctn.default_property != null) { bw.Seek(def_prop_off, SeekOrigin.Begin); bw.Write(GetMemberOffset(ctn.default_property)); bw.Seek(tmp, SeekOrigin.Begin); } bw.BaseStream.Seek(pos, SeekOrigin.Begin); bw.Write(names.Length); for (int i = 0; i < names.Length; i++) { bw.Write(names[i].name); bw.Write(names[i].offset); bw.Write((byte)names[i].access_level); bw.Write((byte)names[i].symbol_kind); bw.Write((byte)names[i].semantic_node_type); bw.Write(names[i].virtual_slot); } bw.BaseStream.Seek(tmp, SeekOrigin.Begin); }
private void CheckConstantRecordNotBeContainsMethods(common_type_node ctn, location loc) { if (ctn.is_value) { if (ctn.methods.Count > 0) { for (int i=0; i<ctn.methods.Count; i++) if (ctn.methods[i].loc != null) AddError(loc, "CONSTANT_RECORD_CAN_NOT_CONTAINS_METHODS"); } //if (!(ctn.methods.Count == 2 && ctn.methods[0] is common_method_node && (ctn.methods[0] as common_method_node).is_constructor && ctn.methods[0].loc == null // && ctn.methods[1] is common_method_node && ctn.methods[1].loc == null)) // throw new ConstantRecordCanNotContainsMethods(loc); if (ctn.base_type is common_type_node) CheckConstantRecordNotBeContainsMethods(ctn.base_type as common_type_node, loc); } else { if (IsBoundedArray(ctn) && ctn.element_type is common_type_node) CheckConstantRecordNotBeContainsMethods(ctn.element_type as common_type_node, loc); } }
//сохранение классовых констант private void VisitConstantInTypeDefinitions(common_type_node ctn) { int offset = GetMemberOffset(ctn); bw.Write(ctn.const_defs.Count); for (int i=0; i<ctn.const_defs.Count; i++) VisitConstantInTypeDefinition(ctn.const_defs[i],offset); }
private common_type_node convert_function_type(SyntaxTree.function_header func_header, location loc, string type_name, common_type_node del_type) { return convert_function_type(func_header.parameters, func_header.return_type, loc, type_name, del_type); }
private void VisitEventDefinitions(common_type_node ctn) { int offset = GetMemberOffset(ctn); bw.Write(ctn.events.Count); for (int i=0; i<ctn.events.Count; i++) VisitEventDefinition(ctn.events[i],offset); }
private common_type_node convert_function_type(SyntaxTree.procedure_header proc_header, location loc, string type_name, common_type_node del_type) { return convert_function_type(proc_header.parameters, null, loc, type_name, del_type); }
private void VisitCommonType(common_type_node ctn) { foreach (common_method_node cmn in ctn.methods) { VisitMethod(cmn); } }
public List<type_node> GetParamsList(common_type_node template_instance) { /*string key = instance_name; int num = 0; if (instance_name[instance_name.Length - 1] != '>') { int i = instance_name.Length - 1; while (instance_name[i] != '$') { i--; } string snum = instance_name.Substring(i + 1); num = Convert.ToInt32(snum); key = instance_name.Substring(0, i); } List<List<type_node>> founded = _instances[key]; return founded[num];*/ List<type_node> i_params; if (_instance_params.TryGetValue(template_instance, out i_params)) { return i_params; } else { return null; } }
private void CollectInfoFields(common_type_node ctn) { if (!ctn.comprehensive_namespace.from_pcu) foreach (class_field fld in ctn.fields) { FldInfo fi = helper.GetField(fld); // if (fi.num_use == 0 && !ctn.name.Contains("$") && fld.field_access_level == SemanticTree.field_access_level.fal_private) warns.Add(new UnusedField(fld.name, fld.loc)); } }
/// <summary> /// Конструктор узла. /// </summary> /// <param name="name">Имя функции.</param> /// <param name="ret_type"></param> /// <param name="loc">Расположение имени метода в программе.</param> /// <param name="cont_type">Тип, который содержит этот метод.</param> /// <param name="polymorphic_state">Обычный, виртуальный или статический метод.</param> /// <param name="field_access_level">Уровень доступа к методу.</param> /// <param name="scope">Пространство имен функции.</param> public common_method_node(string name,type_node ret_type, location loc, common_type_node cont_type, SemanticTree.polymorphic_state polymorphic_state, SemanticTree.field_access_level field_access_level, SymbolTable.Scope scope) : base(name,ret_type,loc,scope) { _cont_type=cont_type; _field_access_level = field_access_level; _polymorphic_state = polymorphic_state; }