private void CollectInfoNamespaces(common_namespace_node cnn) { if (!cnn.from_pcu) { if (cnn.is_main) foreach (var_definition_node vdn2 in cnn.variables) { if (vdn2 is namespace_variable) { namespace_variable vdn = vdn2 as namespace_variable; VarInfo vi = helper.GetVariable(vdn); if (vi.num_use == 0 && !vdn.is_special_name) warns.Add(new UnusedVariable(vdn.name, vdn.loc)); if (vi.num_ass > 0 && vi.act_num_use == 0) warns.Add(new AssignWithoutUsing(vdn.name, vi.last_ass_loc)); //if (vi.num_ass == 0 && vi.act_num_use > 0) helper.AddRealWarning(vdn, warns); } else if (vdn2 is local_block_variable) { local_block_variable vdn = vdn2 as local_block_variable; VarInfo vi = helper.GetVariable(vdn); if (vi.num_use == 0 && !vdn.is_special_name) warns.Add(new UnusedVariable(vdn.name, vdn.loc)); if (vi.num_ass > 0 && vi.act_num_use == 0) warns.Add(new AssignWithoutUsing(vdn.name, vi.last_ass_loc)); } } foreach (common_type_node ctn in cnn.types) CollectInfoFields(ctn); } }
private void VisitCommonNamespaceHeader(common_namespace_node cnn) { if (!cnn.from_pcu) { foreach (namespace_variable vdn in cnn.variables) helper.AddVariable(vdn); } }
/// <summary> /// Клонирует пространство имен. /// </summary> /// <returns>Копия пространства иен.</returns> public common_namespace_node clone() { common_namespace_node cnn = new common_namespace_node(this._comprehensive_namespace, this._cont_unit, this._name, this._scope, this._loc); cnn.merge_with_namespace(this); return(cnn); }
public common_namespace_event(string name, type_node del_type, common_namespace_node cont_namespace, common_namespace_function_node add_function, common_namespace_function_node remove_function, common_namespace_function_node raise_function, location loc) { this._name = name; this.del_type = del_type; this._add_function = add_function; this._remove_function = remove_function; this._raise_function = raise_function; this._cont_namespace = cont_namespace; this._loc = loc; }
/// <summary> /// Добавляет к текущему пространству имен указанное пространство имен. /// </summary> /// <param name="merge_with">Пространство имен для добавления.</param> public void merge_with_namespace(common_namespace_node merge_with) { _types.AddRange(merge_with._types); //ssyy _templates.AddRange(merge_with._templates); _type_synonyms.AddRange(merge_with._type_synonyms); //\ssyy _variables.AddRange(merge_with._variables); _functions.AddRange(merge_with._functions); _constants.AddRange(merge_with._constants); _namespaces.AddRange(merge_with._namespaces); }
public template_class(SyntaxTree.type_declaration type_decl, string name, common_namespace_node cnn, /*common_type_node ctn,location loc,*/ document doc, using_namespace_list unl) { _cnn = cnn; _type_decl = type_decl; _name = name; _doc = doc; //(ssyy) using - список, по-видимому, можно только копировать, т.к. Николай его периодически чистит. _unl = new using_namespace_list(); foreach (using_namespace un in unl) { _unl.AddElement(un); } }
private void VisitCommonNamespaceNode(common_namespace_node cnn) { if (!cnn.from_pcu) { foreach (common_type_node ctn in cnn.types) VisitCommonTypeHeader(ctn); foreach (common_type_node ctn in cnn.types) VisitCommonType(ctn); foreach (common_namespace_function_node cnfn in cnn.functions) { VisitCommonNamespaceFunctionNode(cnfn); } } }
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(); }
//TODO: Исправить этот метод, так чтобы он работал только с корневыми или со всеми пространствами имен. /// <summary> /// Просматривает список модулей, и объединяет одни и те-же пространства имен разных модулей. /// </summary> /// <param name="units">Список модулей.</param> /// <returns>Список пространств имен.</returns> private static common_namespace_node[] get_units_namespaces(common_unit_node_list units) { /*System.Collections.Generic.Dictionary<string, common_namespace_node> namespaces = new System.Collections.Generic.Dictionary<string, common_namespace_node>( SystemLibrary.SystemLibrary.string_comparer); foreach (common_unit_node un in units) { foreach (common_namespace_node cnn in un.namespaces) { string full_name = cnn.namespace_full_name; common_namespace_node new_namespace; if (!(namespaces.TryGetValue(full_name,out new_namespace))) { new_namespace = cnn.clone(); namespaces[full_name] = new_namespace; } else { new_namespace.merge_with_namespace(cnn); } } } common_namespace_node[] ret = new common_namespace_node[namespaces.Count]; namespaces.Values.CopyTo(ret, 0); return ret;*/ System.Collections.Hashtable ht = new System.Collections.Hashtable(); System.Collections.ArrayList al = new System.Collections.ArrayList(); common_namespace_node main_cnn = null; foreach (common_unit_node un in units) { foreach (common_namespace_node cnn in un.namespaces) { //if (cnn.namespace_full_name != "") //{ if (ht[cnn.namespace_name] == null) { al.Add(cnn); ht[cnn.namespace_name] = cnn; } //else // throw new Errors.CompilerInternalError("MergeNamespaces", new Errors.LocatedError("Dupblicate nammespace name: "+cnn.namespace_name)); //} //else main_cnn = cnn; } } int num = 0; if (main_cnn != null) num++; common_namespace_node[] namespaces_to_ret = new common_namespace_node[al.Count + num]; if (main_cnn != null) namespaces_to_ret[0] = main_cnn; al.CopyTo(namespaces_to_ret, num); return namespaces_to_ret; /*System.Collections.Hashtable ht = new System.Collections.Hashtable(); System.Collections.ArrayList al = new System.Collections.ArrayList(); foreach (common_unit_node un in units) { foreach (common_namespace_node cnn in un.namespaces) if (ht[cnn.namespace_name] == null) { al.Add(cnn); ht[cnn.namespace_name] = cnn; } } common_namespace_node[] namespaces_to_ret = new common_namespace_node[al.Count]; al.CopyTo(namespaces_to_ret); return namespaces_to_ret;*/ }
//\ssyy private string GetSynonimName(common_namespace_node cnn, compiled_type_node ctn) { for (int i = 0; i < cnn.type_synonyms.Count; i++) { if (cnn.type_synonyms[i].original_type == ctn) return cnn.type_synonyms[i].name; } return ctn.name; }
public wrapped_common_type_node(PCUReader pr, type_node base_type, string name, SemanticTree.type_access_level type_access_level, common_namespace_node comprehensive_namespace, SymbolTable.ClassScope cs, location loc,int offset): base(base_type, name, type_access_level, comprehensive_namespace,cs,loc) { this.pr = pr; this.offset = offset; }
public template_class(SyntaxTree.type_declaration type_decl, string name,common_namespace_node cnn,/*common_type_node ctn,location loc,*/document doc,using_namespace_list unl) { _cnn = cnn; _type_decl = type_decl; _name = name; _doc = doc; //(ssyy) using - список, по-видимому, можно только копировать, т.к. Николай его периодически чистит. _unl = new using_namespace_list(); foreach (using_namespace un in unl) { _unl.AddElement(un); } }
//TODO: Исправить этот метод, так чтобы он работал только с корневыми или со всеми пространствами имен. /// <summary> /// Просматривает список модулей, и объединяет одни и те-же пространства имен разных модулей. /// </summary> /// <param name="units">Список модулей.</param> /// <returns>Список пространств имен.</returns> private static common_namespace_node[] get_units_namespaces(common_unit_node_list units) { /*System.Collections.Generic.Dictionary<string, common_namespace_node> namespaces = * new System.Collections.Generic.Dictionary<string, common_namespace_node>( * SystemLibrary.SystemLibrary.string_comparer); * * foreach (common_unit_node un in units) * { * foreach (common_namespace_node cnn in un.namespaces) * { * string full_name = cnn.namespace_full_name; * common_namespace_node new_namespace; * if (!(namespaces.TryGetValue(full_name,out new_namespace))) * { * new_namespace = cnn.clone(); * namespaces[full_name] = new_namespace; * } * else * { * new_namespace.merge_with_namespace(cnn); * } * } * } * common_namespace_node[] ret = new common_namespace_node[namespaces.Count]; * namespaces.Values.CopyTo(ret, 0); * return ret;*/ System.Collections.Hashtable ht = new System.Collections.Hashtable(); System.Collections.ArrayList al = new System.Collections.ArrayList(); common_namespace_node main_cnn = null; foreach (common_unit_node un in units) { foreach (common_namespace_node cnn in un.namespaces) { //if (cnn.namespace_full_name != "") //{ if (ht[cnn.namespace_name] == null) { al.Add(cnn); ht[cnn.namespace_name] = cnn; } //else // throw new Errors.CompilerInternalError("MergeNamespaces", new Errors.LocatedError("Dupblicate nammespace name: "+cnn.namespace_name)); //} //else main_cnn = cnn; } } int num = 0; if (main_cnn != null) { num++; } common_namespace_node[] namespaces_to_ret = new common_namespace_node[al.Count + num]; if (main_cnn != null) { namespaces_to_ret[0] = main_cnn; } al.CopyTo(namespaces_to_ret, num); return(namespaces_to_ret); /*System.Collections.Hashtable ht = new System.Collections.Hashtable(); * System.Collections.ArrayList al = new System.Collections.ArrayList(); * foreach (common_unit_node un in units) * { * foreach (common_namespace_node cnn in un.namespaces) * if (ht[cnn.namespace_name] == null) * { * al.Add(cnn); * ht[cnn.namespace_name] = cnn; * } * } * common_namespace_node[] namespaces_to_ret = new common_namespace_node[al.Count]; * al.CopyTo(namespaces_to_ret); * return namespaces_to_ret;*/ }
public void leave_interface_part() { _cmn = null; }
/// <summary> /// Конструктор класса. /// </summary> /// <param name="name">Имя константы.</param> /// <param name="cn">Значени константы.</param> /// <param name="loc">Расположение определения константы.</param> /// <param name="comprehensive_namespace">Пространство имен в котором определена константа.</param> public namespace_constant_definition(string name, constant_node cn, location loc, common_namespace_node comprehensive_namespace) : base(name, cn, loc) { _comprehensive_namespace = comprehensive_namespace; }
public common_type_node(string name, SemanticTree.type_access_level type_access_level, common_namespace_node comprehensive_namespace, SymbolTable.ClassScope cs, location loc) { _name = name; _type_access_level = type_access_level; _comprehensive_namespace = comprehensive_namespace; defined_in_scope = (comprehensive_namespace == null)?null:comprehensive_namespace.scope; //_ref_type = new ref_type_node(this); _scope = cs; _loc = loc; }
public common_namespace_node create_namespace(common_namespace_node comprehensive_namespace,string namespace_name, common_unit_node cont_unit,SymbolTable.Scope _scope,location loc) { SymbolTable.Scope scope; if (comprehensive_namespace == null) { //scope = convertion_data_and_alghoritms.symbol_table.CreateScope(cont_unit.scope); scope = _scope; } else { scope = convertion_data_and_alghoritms.symbol_table.CreateScope(comprehensive_namespace.scope); } _cmn = new common_namespace_node(comprehensive_namespace, cont_unit, namespace_name, scope, loc); cont_unit.namespaces.AddElement(_cmn); _cmn.scope.AddSymbol(namespace_name,new SymbolInfo(_cmn)); return _cmn; }
private static void init_temp_methods_and_consts(common_namespace_node system_namespace,SymbolTable.Scope where_add, initialization_properties initialization_properties,location system_unit_location) { //SymbolTable.Scope sc = system_namespace.scope; SymbolTable.Scope sc = where_add; namespace_constant_definition _true_constant_definition = new namespace_constant_definition( PascalABCCompiler.TreeConverter.compiler_string_consts.true_const_name, SystemLibrary.true_constant, system_unit_location, system_namespace); system_namespace.constants.AddElement(_true_constant_definition); namespace_constant_definition _false_constant_definition = new namespace_constant_definition( PascalABCCompiler.TreeConverter.compiler_string_consts.false_const_name, SystemLibrary.false_constant, system_unit_location, system_namespace); system_namespace.constants.AddElement(_false_constant_definition); sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.true_const_name, new PascalABCCompiler.TreeConverter.SymbolInfo(_true_constant_definition)); sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.false_const_name, new PascalABCCompiler.TreeConverter.SymbolInfo(_false_constant_definition)); //TODO: Сделано по быстрому. Переделать. Можно просто один раз сериализовать модуль system и не инициализировать его всякий раз подобным образом. Неплохо-бы использовать NetHelper.GetMethod. Type tp = typeof(Console); compiled_function_node cfn; System.Type[] arr = new System.Type[1]; System.Reflection.MethodInfo mi; //TODO: Сделать узел или базовый метод создания и удаления объекта. common_namespace_function_node cnfn = new common_namespace_function_node(TreeConverter.compiler_string_consts.new_procedure_name, null, null, system_namespace, null); cnfn.parameters.AddElement(new common_parameter("ptr", SystemLibrary.pointer_type, SemanticTree.parameter_type.value, cnfn, concrete_parameter_type.cpt_var, null, null)); cnfn.SpecialFunctionKind = SemanticTree.SpecialFunctionKind.New; _NewProcedure = new PascalABCCompiler.TreeConverter.SymbolInfo(cnfn); _NewProcedure.symbol_kind = PascalABCCompiler.TreeConverter.symbol_kind.sk_overload_function; _NewProcedure.access_level = PascalABCCompiler.TreeConverter.access_level.al_public; _NewProcedureDecl = cnfn; sc.AddSymbol(TreeConverter.compiler_string_consts.new_procedure_name, _NewProcedure); cnfn = new common_namespace_function_node(TreeConverter.compiler_string_consts.dispose_procedure_name, null, null, system_namespace, null); cnfn.parameters.AddElement(new common_parameter("ptr", SystemLibrary.pointer_type, SemanticTree.parameter_type.value, cnfn, concrete_parameter_type.cpt_var, null, null)); _DisposeProcedure = new PascalABCCompiler.TreeConverter.SymbolInfo(cnfn); _DisposeProcedure.symbol_kind = PascalABCCompiler.TreeConverter.symbol_kind.sk_overload_function; _DisposeProcedure.access_level = PascalABCCompiler.TreeConverter.access_level.al_public; _DisposeProcedureDecl = cnfn; cnfn.SpecialFunctionKind = SemanticTree.SpecialFunctionKind.Dispose; sc.AddSymbol(TreeConverter.compiler_string_consts.dispose_procedure_name, _DisposeProcedure); cnfn = new common_namespace_function_node(TreeConverter.compiler_string_consts.new_array_procedure_name, compiled_type_node.get_type_node(typeof(Array)), null, system_namespace, null); cnfn.parameters.AddElement(new common_parameter("t", compiled_type_node.get_type_node(typeof(Type)), SemanticTree.parameter_type.value, cnfn, concrete_parameter_type.cpt_none, null, null)); cnfn.parameters.AddElement(new common_parameter("n", SystemLibrary.integer_type, SemanticTree.parameter_type.value, cnfn, concrete_parameter_type.cpt_none, null, null)); cnfn.SpecialFunctionKind = SemanticTree.SpecialFunctionKind.NewArray; _NewArrayProcedure = new PascalABCCompiler.TreeConverter.SymbolInfo(cnfn); _NewArrayProcedureDecl = cnfn; //sc.AddSymbol(TreeConverter.compiler_string_consts.new_procedure_name, _NewProcedure); basic_function_node break_procedure = new basic_function_node(SemanticTree.basic_function_type.none, null, true); break_procedure.compile_time_executor = initialization_properties.break_executor; sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.break_procedure_name, new PascalABCCompiler.TreeConverter.SymbolInfo(break_procedure)); basic_function_node continue_procedure = new basic_function_node(SemanticTree.basic_function_type.none, null, true); continue_procedure.compile_time_executor = initialization_properties.continue_executor; sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.continue_procedure_name, new PascalABCCompiler.TreeConverter.SymbolInfo(continue_procedure)); basic_function_node exit_procedure = new basic_function_node(SemanticTree.basic_function_type.none, null, true); exit_procedure.compile_time_executor = initialization_properties.exit_executor; sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.exit_procedure_name, new PascalABCCompiler.TreeConverter.SymbolInfo(exit_procedure)); sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.set_length_procedure_name, new PascalABCCompiler.TreeConverter.SymbolInfo(SystemLibrary.resize_func, PascalABCCompiler.TreeConverter.access_level.al_public, PascalABCCompiler.TreeConverter.symbol_kind.sk_overload_function)); }
public procedure_definition_info(common_namespace_node _nspace, SyntaxTree.procedure_definition _proc) { nspace = _nspace; proc = _proc; }
public SymbolInfo(common_namespace_node value) { //_name_information_type=name_information_type.nit_common_namespace; _sym_info=value; _access_level=access_level.al_public; _symbol_kind=symbol_kind.sk_none; }
/// <summary> /// Конструктор класса. /// </summary> /// <param name="name">Имя константы.</param> /// <param name="cn">Значени константы.</param> /// <param name="loc">Расположение определения константы.</param> /// <param name="comprehensive_namespace">Пространство имен в котором определена константа.</param> public namespace_constant_definition(string name, constant_node cn, location loc, common_namespace_node comprehensive_namespace) : base(name,cn,loc) { _comprehensive_namespace = comprehensive_namespace; }
public static common_unit_node make_system_unit(SymbolTable.TreeConverterSymbolTable symbol_table, initialization_properties initialization_properties) { //TODO: В качестве location везде в этом методе следует указывать location system_unit-а. Имя файла мы знаем, а место - там где написано, что integer и прочие типы описаны как бы в модуле system. location system_unit_location = null; SymbolTable.UnitInterfaceScope main_scope = symbol_table.CreateUnitInterfaceScope(new SymbolTable.Scope[0]); SymbolTable.UnitImplementationScope impl_scope = symbol_table.CreateUnitImplementationScope(main_scope, new SymbolTable.Scope[0]); common_unit_node _system_unit = new common_unit_node(main_scope,impl_scope,null,null); common_namespace_node cnn = new common_namespace_node(null, _system_unit, PascalABCCompiler.TreeConverter.compiler_string_consts.system_unit_name, symbol_table.CreateScope(main_scope),system_unit_location); main_scope.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.system_unit_name, new PascalABCCompiler.TreeConverter.SymbolInfo(cnn)); //SymbolTable.Scope sc = cnn.scope; SymbolTable.Scope sc = main_scope; //Добавляем типы. sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.byte_type_name, new PascalABCCompiler.TreeConverter.SymbolInfo(SystemLibrary.byte_type)); //sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.decimal_type_name, new PascalABCCompiler.TreeConverter.SymbolInfo(SystemLibrary.decimal_type)); sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.sbyte_type_name, new PascalABCCompiler.TreeConverter.SymbolInfo(SystemLibrary.sbyte_type)); sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.short_type_name, new PascalABCCompiler.TreeConverter.SymbolInfo(SystemLibrary.short_type)); sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.ushort_type_name, new PascalABCCompiler.TreeConverter.SymbolInfo(SystemLibrary.ushort_type)); sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.integer_type_name, new PascalABCCompiler.TreeConverter.SymbolInfo(SystemLibrary.integer_type)); sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.uint_type_name, new PascalABCCompiler.TreeConverter.SymbolInfo(SystemLibrary.uint_type)); sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.long_type_name, new PascalABCCompiler.TreeConverter.SymbolInfo(SystemLibrary.int64_type)); sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.ulong_type_name, new PascalABCCompiler.TreeConverter.SymbolInfo(SystemLibrary.uint64_type)); sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.float_type_name, new PascalABCCompiler.TreeConverter.SymbolInfo(SystemLibrary.float_type)); sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.real_type_name, new PascalABCCompiler.TreeConverter.SymbolInfo(SystemLibrary.double_type)); sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.char_type_name, new PascalABCCompiler.TreeConverter.SymbolInfo(SystemLibrary.char_type)); sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.bool_type_name, new PascalABCCompiler.TreeConverter.SymbolInfo(SystemLibrary.bool_type)); sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.string_type_name, new PascalABCCompiler.TreeConverter.SymbolInfo(SystemLibrary.string_type)); //sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.object_type_name, new PascalABCCompiler.TreeConverter.SymbolInfo(SystemLibrary.object_type)); sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.pointer_type_name, new PascalABCCompiler.TreeConverter.SymbolInfo(SystemLibrary.pointer_type)); //sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.base_exception_class_name, new PascalABCCompiler.TreeConverter.SymbolInfo(SystemLibrary.exception_base_type)); sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.base_array_type_name, new PascalABCCompiler.TreeConverter.SymbolInfo(SystemLibrary.array_base_type)); sc.AddSymbol(PascalABCCompiler.TreeConverter.compiler_string_consts.base_delegate_type_name, new PascalABCCompiler.TreeConverter.SymbolInfo(SystemLibrary.delegate_base_type)); //TODO: Переделать. Пусть таблица символов создается одна. Как статическая. compiled_type_node comp_byte_type = ((compiled_type_node)SystemLibrary.byte_type); compiled_type_node comp_sbyte_type = ((compiled_type_node)SystemLibrary.sbyte_type); compiled_type_node comp_short_type = ((compiled_type_node)SystemLibrary.short_type); compiled_type_node comp_ushort_type = ((compiled_type_node)SystemLibrary.ushort_type); compiled_type_node comp_integer_type = ((compiled_type_node)SystemLibrary.integer_type); compiled_type_node comp_uint_type = ((compiled_type_node)SystemLibrary.uint_type); compiled_type_node comp_long_type = ((compiled_type_node)SystemLibrary.int64_type); compiled_type_node comp_ulong_type = ((compiled_type_node)SystemLibrary.uint64_type); compiled_type_node comp_float_type = ((compiled_type_node)SystemLibrary.float_type); compiled_type_node comp_real_type = ((compiled_type_node)SystemLibrary.double_type); compiled_type_node comp_char_type=((compiled_type_node)SystemLibrary.char_type); compiled_type_node comp_bool_type = ((compiled_type_node)SystemLibrary.bool_type); compiled_type_node comp_string_type=((compiled_type_node)SystemLibrary.string_type); compiled_type_node comp_object_type=((compiled_type_node)SystemLibrary.object_type); compiled_type_node comp_pointer_type=((compiled_type_node)SystemLibrary.pointer_type); compiled_type_node comp_exception_type=((compiled_type_node)SystemLibrary.exception_base_type); compiled_type_node comp_array_type = ((compiled_type_node)SystemLibrary.array_base_type); compiled_type_node comp_delegate_type = ((compiled_type_node)SystemLibrary.delegate_base_type); comp_byte_type.scope = new PascalABCCompiler.NetHelper.NetTypeScope(comp_byte_type.compiled_type, symbol_table); comp_sbyte_type.scope = new PascalABCCompiler.NetHelper.NetTypeScope(comp_sbyte_type.compiled_type, symbol_table); comp_short_type.scope = new PascalABCCompiler.NetHelper.NetTypeScope(comp_short_type.compiled_type, symbol_table); comp_ushort_type.scope = new PascalABCCompiler.NetHelper.NetTypeScope(comp_ushort_type.compiled_type, symbol_table); comp_integer_type.scope = new PascalABCCompiler.NetHelper.NetTypeScope(comp_integer_type.compiled_type, symbol_table); comp_uint_type.scope = new PascalABCCompiler.NetHelper.NetTypeScope(comp_uint_type.compiled_type, symbol_table); comp_long_type.scope = new PascalABCCompiler.NetHelper.NetTypeScope(comp_long_type.compiled_type, symbol_table); comp_ulong_type.scope = new PascalABCCompiler.NetHelper.NetTypeScope(comp_ulong_type.compiled_type, symbol_table); comp_real_type.scope = new PascalABCCompiler.NetHelper.NetTypeScope(comp_real_type.compiled_type, symbol_table); comp_char_type.scope = new PascalABCCompiler.NetHelper.NetTypeScope(comp_char_type.compiled_type, symbol_table); comp_bool_type.scope = new PascalABCCompiler.NetHelper.NetTypeScope(comp_bool_type.compiled_type, symbol_table); comp_string_type.scope = new PascalABCCompiler.NetHelper.NetTypeScope(comp_string_type.compiled_type, symbol_table); comp_object_type.scope = new PascalABCCompiler.NetHelper.NetTypeScope(comp_object_type.compiled_type, symbol_table); comp_pointer_type.scope = new PascalABCCompiler.NetHelper.NetTypeScope(comp_pointer_type.compiled_type, symbol_table); comp_exception_type.scope = new PascalABCCompiler.NetHelper.NetTypeScope(comp_exception_type.compiled_type, symbol_table); comp_array_type.scope = new PascalABCCompiler.NetHelper.NetTypeScope(comp_array_type.compiled_type, symbol_table); comp_delegate_type.scope = new PascalABCCompiler.NetHelper.NetTypeScope(comp_delegate_type.compiled_type, symbol_table); init_temp_methods_and_consts(cnn,sc, initialization_properties,system_unit_location); return _system_unit; }
public common_type_node(type_node base_type,string name,SemanticTree.type_access_level type_access_level, common_namespace_node comprehensive_namespace, SymbolTable.ClassScope cs, location loc) { _name=name; _type_access_level=type_access_level; _comprehensive_namespace=comprehensive_namespace; //_ref_type = new ref_type_node(this); _scope = cs; _loc = loc; this.SetBaseType(base_type); }
public generic_instance_type_node(type_node original_generic_type, List<type_node> param_types, type_node base_type, string name, SemanticTree.type_access_level type_access_level, common_namespace_node comprehensive_namespace, location loc) : base(base_type, name, type_access_level, comprehensive_namespace, null, loc) { _original_generic = original_generic_type; _instance_params = param_types; }
public common_generic_instance_type_node(common_type_node generic_definition, List<type_node> param_types, type_node base_type, string name, SemanticTree.type_access_level type_access_level, common_namespace_node comprehensive_namespace, location loc) : base(generic_definition, param_types, base_type, name, type_access_level, comprehensive_namespace, loc) { }
public void leave_block() { switch (converting_block()) { case block_type.function_block: { common_function_node top_func = _func_stack.top(); location loc; if (top_func.function_code == null) { loc = top_func.loc; } else if ((top_func.function_code as statements_list) != null) { statements_list stl = (statements_list)top_func.function_code; if (stl.statements.Count > 0) { loc = stl.statements[stl.statements.Count - 1].location; } else { loc = top_func.loc; } } else { loc = top_func.function_code.location; } if (top_func.function_code != null) { if (top_func.return_variable != null) { //TODO: Обратить внимание на преобразования типов. Можно сделать метод, который если тело функции не statement создает список statement-ов и добавляет в него существующий statement. statements_list stl = (statements_list)top_func.function_code; local_variable_reference lvr = new local_variable_reference(top_func.return_variable, 0, loc); stl.statements.AddElement(new return_node(lvr, loc)); } else if ((top_func.return_value_type != null) && (_ctn != null)) { //TODO: Обратить внимание на преобразования типов. Можно сделать метод, который если тело функции не statement создает список statement-ов и добавляет в него существующий statement. statements_list stl = (statements_list)top_func.function_code; this_node thn = new this_node(_ctn, loc); stl.statements.AddElement(new return_node(thn, loc)); } } check_predefinition_defined(); _func_stack.pop(); break; } case block_type.type_block: { //TODO: Может и сюда вставить check_predefinition_defined, несмотря на то, что в данный момент он ничего не делает. _cmn.types.AddElement(_ctn); _ctn=null; break; } case block_type.namespace_block: { check_predefinition_defined(); _cmn=null; break; } } }
/// <summary> /// Клонирует пространство имен. /// </summary> /// <returns>Копия пространства иен.</returns> public common_namespace_node clone() { common_namespace_node cnn = new common_namespace_node(this._comprehensive_namespace, this._cont_unit, this._name, this._scope, this._loc); cnn.merge_with_namespace(this); return cnn; }
/// <summary> /// Конструктор узла. /// </summary> /// <param name="name">Имя функции.</param> /// <param name="ret_type">Тип возвращааемого знчения функции.</param> /// <param name="loc">Расположение функции.</param> /// <param name="nsp">Пространство имен, в котором определена функция.</param> /// <param name="scope">Пространство имен функции.</param> public common_namespace_function_node(string name, type_node ret_type, location loc, common_namespace_node nsp, SymbolTable.Scope scope) : base(name,ret_type,loc,scope) { _namespace=nsp; }
public namespace_variable(string name, type_node type, common_namespace_node cont_namespace, location loc) : base(name, type) { _cont_namespace = cont_namespace; _loc = loc; }
//процедура сохранения модуля на диск public void SaveSemanticTree(CompilationUnit Unit, string TargetFileName, bool IncludeDebugInfo) { pcu_file.IncludeDebugInfo = IncludeDebugInfo; pcu_file.UseRtlDll = compiler.CompilerOptions.UseDllForSystemUnits; unit = Unit; cun = (common_unit_node)unit.SemanticTree; this.FileName = TargetFileName; string program_folder=System.IO.Path.GetDirectoryName(System.IO.Path.GetFullPath(TargetFileName)); name = System.IO.Path.GetFileName(TargetFileName); //name = name.Substring(0,name.LastIndexOf('.'))+".pcu"; //FileStream fs = new FileStream(name,FileMode.Create,FileAccess.ReadWrite); ChangeState(this, PCUReaderWriterState.BeginSaveTree, TargetFileName); pcu_file.compiler_directives = cun.compiler_directives; if (Path.GetDirectoryName(TargetFileName).ToLower() == Path.GetDirectoryName(Unit.SyntaxTree.file_name).ToLower()) pcu_file.SourceFileName = Path.GetFileName(Unit.SyntaxTree.file_name); else pcu_file.SourceFileName = Unit.SyntaxTree.file_name; ms = new MemoryStream(); bw = new BinaryWriter(ms); //if (Unit.InterfaceUsedUnits.Count > 0) Console.WriteLine("{0} {1}",name,Unit.InterfaceUsedUnits[0].namespaces[0].namespace_name); cur_cnn = cun.namespaces[0]; //(ssyy) формируем список нешаблонных классов cur_cnn.MakeNonTemplateTypesList(); GetUsedUnits();//заполняем список полключаемых модулей GetCountOfMembers();//заполняем список имен интерфейсных сущностей WriteUnit();//пишем имя interface_namespace cur_cnn = cun.namespaces[1]; //(ssyy) формируем список нешаблонных классов cur_cnn.MakeNonTemplateTypesList(); GetCountOfImplementationMembers();//(ssyy) заполняем список имен сущностей реализации WriteUnit();//пишем имя implementation_namespace SaveOffsetForAttribute(cun.namespaces[0]); bw.Write(0);//attributes; cur_cnn = cun.namespaces[0]; //bw.Write((byte)0); //bw.Write((byte)0); //ssyy VisitTemplateClasses();//сериализуем шаблонные классы //\ssyy VisitTypeDefinitions();//сериализуем описания типов интерфейсной части //ssyy pcu_file.interface_synonyms_offset = (int)bw.BaseStream.Position; VisitTypeSynonyms(); //\ssyy cur_cnn = cun.namespaces[1]; is_interface = false; //ssyy VisitLabelDeclarations(cur_cnn.labels); //сериализуем метки type_entity_index = 0; VisitTemplateClasses();//сериализуем шаблонные классы //\ssyy VisitTypeDefinitions();//сериализуем описания типов имплемент. части //ssyy pcu_file.implementation_synonyms_offset = (int)bw.BaseStream.Position; VisitTypeSynonyms(); //\ssyy cur_cnn = cun.namespaces[0]; is_interface = true; foreach (common_type_node ctn in cur_cnn.non_template_types) { VisitTypeMemberDefinition(ctn); } cur_cnn = cun.namespaces[1]; is_interface = false; foreach (common_type_node ctn in cur_cnn.non_template_types) { VisitTypeMemberDefinition(ctn); } cur_cnn = cun.namespaces[0]; is_interface = true; VisitConstantDefinitions();//сериализуем константы VisitVariableDefinitions();//сериализуем переменные VisitFunctionDefinitions();//сериализуем функции VisitRefTypeDefinitions(); VisitEventDefinitions(); cur_cnn = cun.namespaces[1]; is_interface = false; entity_index = 0; //имплементационная часть VisitConstantDefinitions(); VisitVariableDefinitions(); VisitFunctionDefinitions(); VisitRefTypeDefinitions(); VisitEventDefinitions(); cur_cnn = cun.namespaces[0]; //сериализуем тела функций foreach (common_namespace_function_node cnfn in cur_cnn.functions) { VisitFunctionImplementation(cnfn); } //сериализуем тела методов и конструкторов типа foreach (common_type_node ctn in cur_cnn.non_template_types) { VisitTypeImplementation(ctn); } cur_cnn = cun.namespaces[1]; //имплементационная часть foreach (common_namespace_function_node cnfn in cur_cnn.functions) VisitFunctionImplementation(cnfn); foreach (common_type_node ctn in cur_cnn.non_template_types) { VisitTypeImplementation(ctn); } WriteVariablePositions(); WriteConstantPositions(); AddAttributes(); WriteInitExpressions(); //сохранение интерфейсной и имплементац. частей модуля if (ext_offsets.Count != 0) { List<definition_node> dnl = new List<definition_node>(ext_offsets.Keys); foreach (definition_node wdn in dnl) { if (wdn is wrapped_definition_node) AddOffsetForMembers(wdn, (wdn as wrapped_definition_node).offset); else if (wdn is wrapped_common_type_node) AddOffsetForMembers(wdn, (wdn as wrapped_common_type_node).offset); else if (PCUReader.AllReadOrWritedDefinitionNodesOffsets.ContainsKey(wdn)) AddOffsetForMembers(wdn, PCUReader.AllReadOrWritedDefinitionNodesOffsets[wdn]); } //ssyy 01.07.2007 //CloseWriter(); //\ssyy } //если нет импортирумых сущностей, смещение которых неизвестно else //if (ext_offsets.Count == 0) { //CloseWriter(); /*FileStream fs = new FileStream(TargetFileName, FileMode.Create, FileAccess.ReadWrite); BinaryWriter fbw = new BinaryWriter(fs); WritePCUHeader(fbw); //пишем заголовок PCU byte[] buf = new byte[bw.BaseStream.Length]; bw.Seek(0, SeekOrigin.Begin); bw.BaseStream.Read(buf, 0, buf.Length); fbw.Write(buf); bw.Close(); ms.Close(); fbw.Close(); fs.Close();*/ //если существовал pcu, который использовался reader-ом и была циклическая связь //if (pcu_reader != null) pcu_reader.OpenUnit(); } }
private void AddNamespaces() { cun.unit_name=br.ReadString(); common_namespace_node cnn = new common_namespace_node(null, cun, cun.unit_name, cun.scope, ReadDebugInfo()); cun.namespaces.AddElement(cnn); cun.add_unit_name_to_namespace(); cnn = new common_namespace_node(cnn, cun, br.ReadString(), cun.implementation_scope, ReadDebugInfo()); cun.namespaces.AddElement(cnn); var attributes = GetAttributes(); cun.attributes.AddRange(attributes); cun.namespaces[0].attributes.AddRange(attributes); }
//получения индекса модуля в списке подключ. модулей private int GetUnitToken(common_namespace_node ns) { int tok = 0; if (!used_units.TryGetValue(ns,out tok)) { return used_units[(ns.cont_unit as common_unit_node).namespaces[0]]; } return tok; }
public namespace_variable(string name,type_node type,common_namespace_node cont_namespace,location loc) : base(name,type) { _cont_namespace=cont_namespace; _loc = loc; }
private List<SemanticTree.ICommonTypeNode> ReadGenericParams(common_namespace_node cur_nn) { if (SemanticRules.RuntimeInitVariablesOfGenericParameters) { if (!SystemLibrary.SystemLibInitializer.NeedsToRestore.Contains( SystemLibrary.SystemLibInitializer.RuntimeInitializeFunction)) { SystemLibrary.SystemLibInitializer.NeedsToRestore.Add( SystemLibrary.SystemLibInitializer.RuntimeInitializeFunction); } } //common_namespace_node cur_nn = (is_interface) ? cun.namespaces[0] : cun.namespaces[1]; int param_count = br.ReadInt32(); List<SemanticTree.ICommonTypeNode> type_params = new List<PascalABCCompiler.SemanticTree.ICommonTypeNode>(param_count); for (int i = 0; i < param_count; i++) { string par_name = br.ReadString(); common_type_node par = new common_type_node( par_name, SemanticTree.type_access_level.tal_public, cur_nn, SystemLibrary.SystemLibrary.syn_visitor.convertion_data_and_alghoritms.symbol_table.CreateInterfaceScope(null, SystemLibrary.SystemLibrary.object_type.Scope, null), null); SystemLibrary.SystemLibrary.init_reference_type(par); par.SetBaseType(SystemLibrary.SystemLibrary.object_type); type_params.Add(par); } return type_params; }
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(); TypedFiles.Clear(); ShortStringTypes.Clear(); TypedSets.Clear(); _compiled_tn = null; _explicit_interface_type = null; _ctt = null; allow_inherited_ctor_call = false; _types_predefined.Clear(); _block_stack.Clear(); member_decls.Clear(); possible_incorrect_instances.Clear(); skip_check_where_sections = false; LambdaHelper.Reset(); //lroman// SavedContext = null; SavedContextStack.Clear(); compiled_tc_cache.Clear(); extension_method = false; _last_created_function = null; in_parameters_block = false; is_order_independed_method_description = false; }