private void add_overloads_for_default_parameter()
{
List<parameter> default_params = new List<parameter>();
foreach (parameter p in top_function.parameters)
{
if (p.default_value != null)
{
default_params.Add(p);
}
}
int num_of_defaults = default_params.Count-1;
if (default_params.Count > 0 && converted_func_stack.size == 1)
while (num_of_defaults >= 0)
{
if (converted_type == null)
{
common_namespace_function_node cnfn = new common_namespace_function_node(top_function.name, top_function.return_value_type, null, converted_namespace, null);
foreach (parameter p in top_function.parameters)
{
if (p.default_value == null)
cnfn.parameters.AddElement(p);
}
for (int i = 0; i < num_of_defaults; i++)
cnfn.parameters.AddElement(default_params[i]);
statements_list sl = new statements_list(null);
common_namespace_function_call cnfc = new common_namespace_function_call(top_function as common_namespace_function_node, null);
foreach (common_parameter p in cnfn.parameters)
{
cnfc.parameters.AddElement(new common_parameter_reference(p, 0, null));
}
for (int i = num_of_defaults; i < default_params.Count; i++)
cnfc.parameters.AddElement(default_params[i].default_value);
if (cnfn.return_value_type != null)
sl.statements.AddElement(new return_node(cnfc, null));
else
sl.statements.AddElement(cnfc);
cnfn.function_code = sl;
converted_namespace.functions.AddElement(cnfn);
}
else
{
common_method_node cmn = top_function as common_method_node;
common_method_node cnfn = new common_method_node(top_function.name, top_function.return_value_type, null, converted_type, top_function.polymorphic_state, top_function.field_access_level, null);
foreach (parameter p in top_function.parameters)
{
if (p.default_value == null)
cnfn.parameters.AddElement(p);
}
for (int i = 0; i < num_of_defaults; i++)
cnfn.parameters.AddElement(default_params[i]);
statements_list sl = new statements_list(null);
common_method_call cnfc = new common_method_call(cmn, (cnfn.polymorphic_state != SemanticTree.polymorphic_state.ps_static) ? new this_node(converted_type, null) : null, null);
foreach (common_parameter p in cnfn.parameters)
{
cnfc.parameters.AddElement(new common_parameter_reference(p, 0, null));
}
for (int i = num_of_defaults; i < default_params.Count; i++)
cnfc.parameters.AddElement(default_params[i].default_value);
if (cnfn.return_value_type != null)
sl.statements.AddElement(new return_node(cnfc, null));
else
sl.statements.AddElement(cnfc);
cnfn.function_code = sl;
cnfn.is_constructor = cmn.is_constructor;
converted_type.methods.AddElement(cnfn);
}
num_of_defaults--;
}
}
private void VisitFunctionDefinition(common_namespace_function_node func)
{
int pos;
if (is_interface == true)
pos = SavePositionAndConstPool(func);
else
pos = SavePositionAndImplementationPool(func);
//Переделать это!
if (cun.main_function == func)
InitializationMethodOffset = pos;
if (cun.finalization_method == func)
FinalizationMethodOffset = pos;
bw.Write((byte)func.semantic_node_type);
int connected_to_type_pos = (int)bw.BaseStream.Position;
bw.Write(0);
if (CanWriteObject(func.ConnectedToType))
WriteTypeReference(func.ConnectedToType);
int cur_pos = (int)bw.BaseStream.Position;
bw.Seek(connected_to_type_pos, SeekOrigin.Begin);
bw.Write(cur_pos);
bw.Seek(cur_pos, SeekOrigin.Begin);
bw.Write(is_interface);
if (is_interface == true)
bw.Write(GetNameIndex(func));
else
bw.Write(func.name);
//Является ли метод описанием дженерика
WriteGenericFunctionInformation(func);
//if (func.is_generic_function)
//{
// bw.Write((byte)1);
// //Число типов-параметров
// bw.Write(func.generic_params.Count);
// //Имена параметров
// foreach (common_type_node par in func.generic_params)
// {
// bw.Write(par.name);
// }
// WriteTypeParamsEliminations(func.generic_params);
//}
//else
//{
// bw.Write((byte)0);
//}
if (func.return_value_type == null) bw.Write((byte)0);
else
{
bw.Write((byte)1);
WriteTypeReference(func.return_value_type);
VisitLocalVariable(func.return_variable);
}
bw.Write(func.parameters.Count);
foreach (common_parameter p in func.parameters)
VisitParameter(p);
bw.Write(GetUnitReference(func.namespace_node));
SaveOffsetForAttribute(func);
bw.Write(0);//attributes;
bw.Write(func.is_forward);
bw.Write(func.is_overload);
bw.Write(func.num_of_default_variables);
bw.Write(func.num_of_for_cycles);
bw.Write(func.var_definition_nodes_list.Count);
foreach (local_variable var in func.var_definition_nodes_list)
if (var != func.return_variable)
VisitLocalVariable(var);
bw.Write(func.constants.Count);
foreach (function_constant_definition cnst in func.constants)
VisitFunctionConstant(cnst);
bw.Write(func.functions_nodes_list.Count);
foreach (common_in_function_function_node nest_func in func.functions_nodes_list)
VisitNestedFunctionDefinition(nest_func);
WriteDebugInfo(func.loc);
SaveCodeReference(func);
bw.Write(0);
}
//(ssyy) Может быть, соединить следующие 2 метода в один?
private void VisitFunctionImplementation(common_namespace_function_node func)
{
foreach (common_in_function_function_node nested in func.functions_nodes_list)
VisitNestedFunctionImplementation(nested);
//(ssyy) метки
VisitLabelDeclarations(func.label_nodes_list);
FixupCode(func);
VisitStatement(func.function_code);
}
public void visit_implementation(SyntaxTree.unit_module _unit_module)
{
if (_unit_module.initialization_part != null)
{
var lambdaSearcher = new LambdaSearcher(_unit_module.initialization_part);
if (lambdaSearcher.CheckIfContainsLambdas())
{
AddError(new LambdasNotAllowedInInitializationPartOfModule(get_location(lambdaSearcher.FoundLambda)));
}
}
if (_unit_module.finalization_part != null)
{
var lambdaSearcher = new LambdaSearcher(_unit_module.finalization_part);
if (lambdaSearcher.CheckIfContainsLambdas())
{
AddError(new LambdasNotAllowedInFinalizationPartOfModule(get_location(lambdaSearcher.FoundLambda)));
}
}
//using_list.AddRange(implementation_using_list);
/*if (_unit_module.implementation_part != null)
{
weak_node_test_and_visit(_unit_module.implementation_part.using_namespaces);
}*/
SymbolTable.Scope[] used_units = build_referenced_units(referenced_units,false);
_compiled_unit.implementation_scope =
convertion_data_and_alghoritms.symbol_table.CreateUnitImplementationScope(_compiled_unit.scope, used_units);
location loc = null;
if (_unit_module.unit_name != null)
{
loc = get_location(_unit_module.unit_name);
}
common_namespace_node cnsn = context.create_namespace(_unit_module.unit_name.idunit_name.name + compiler_string_consts.ImplementationSectionNamespaceName,
_compiled_unit, _compiled_unit.implementation_scope, loc);
//cnsn.scope=_compiled_unit.implementation_scope;
if (_unit_module.implementation_part != null)
{
hard_node_test_and_visit(_unit_module.implementation_part);
}
//weak_node_test_and_visit(_unit_module.initialization_part);
context.enter_code_block_without_bind();
statement_node init_statements = convert_weak(_unit_module.initialization_part);
context.leave_code_block();
common_namespace_function_node initialization_function = null;
if (init_statements != null)
{
context.check_labels(context.converted_namespace.labels);
//(ssyy) Блокируем поставленные метки, чтобы не допустить переход из finalization-секции
//context.block_defined_labels(context.converted_namespace.labels);
initialization_function = new common_namespace_function_node(compiler_string_consts.initialization_function_name,
null, init_statements.location, context.converted_namespace, convertion_data_and_alghoritms.symbol_table.CreateScope(context.converted_namespace.scope));
initialization_function.function_code = init_statements;
cnsn.functions.AddElement(initialization_function);
_compiled_unit.main_function = initialization_function;
context.apply_special_local_vars(_compiled_unit.main_function);
}
context.enter_code_block_without_bind();
statement_node final_statements = convert_weak(_unit_module.finalization_part);
context.leave_code_block();
common_namespace_function_node finalization_function = null;
if (final_statements != null)
{
context.check_labels(context.converted_namespace.labels);
finalization_function = new common_namespace_function_node(compiler_string_consts.finalization_function_name,
null, final_statements.location, context.converted_namespace, convertion_data_and_alghoritms.symbol_table.CreateScope(context.converted_namespace.scope));
finalization_function.function_code = final_statements;
cnsn.functions.AddElement(finalization_function);
_compiled_unit.finalization_method = finalization_function;
context.apply_special_local_vars(_compiled_unit.finalization_method);
}
context.check_all_name_unit_defined(_compiled_unit);
}
//получение ссылки на функцию
private int GetFunctionReference(common_namespace_function_node fn, ref byte is_def)
{
int off = 0;
if (members.TryGetValue(fn, out off)) //если этот тип описан в этом модуле
{
is_def = 1;
return off;//возвращаем его смещение
}
is_def = 0;
ImportedEntity ie = null;
if (ext_members.TryGetValue(fn, out ie))
{
return ie.index * ie.GetSize();
}
ie = new ImportedEntity();
ie.flag = ImportKind.Common;
ie.num_unit = GetUnitToken(fn.namespace_node);
ie.offset = GetExternalOffset(fn);
int offset = imp_entitles.Count*ie.GetSize();
ie.index = imp_entitles.Count;
imp_entitles.Add(ie);
ext_members[fn] = ie;
return offset;
}
private common_namespace_function_call create_common_namespace_function_call(common_namespace_function_node cnfn,
SemanticTree.ILocation loc,params expression_node[] exprs)
{
common_namespace_function_call cnc=new common_namespace_function_call(cnfn,loc_to_loc(loc));
cnc.parameters.AddRange(exprs);
return cnc;
}
public common_function_node create_function(string name,location def_loc)
{
check_function_name(name,def_loc);
common_function_node cfn=null;
switch (converting_block())
{
case block_type.function_block:
{
common_function_node top_func = _func_stack.top();
SymbolTable.Scope scope = convertion_data_and_alghoritms.symbol_table.CreateScope(top_func.scope);
common_in_function_function_node ciffn;
ciffn=new common_in_function_function_node(name,def_loc,top_func,scope);
top_func.functions_nodes_list.AddElement(ciffn);
_last_created_function=new SymbolInfo(ciffn);
top_func.scope.AddSymbol(name,_last_created_function);
cfn=ciffn;
break;
}
case block_type.type_block:
{
common_method_node cmmn;
SymbolTable.Scope scope = convertion_data_and_alghoritms.symbol_table.CreateClassMethodScope(_cmn.scope, _ctn.Scope);
//TODO:сделать static и virtual.
//TODO: interface and implementation scopes.
cmmn=new common_method_node(name,def_loc,_ctn,SemanticTree.polymorphic_state.ps_common,_fal,scope);
_last_created_function=new SymbolInfo(cmmn);
_ctn.Scope.AddSymbol(name,_last_created_function);
_ctn.methods.AddElement(cmmn);
local_variable lv = new local_variable(compiler_string_consts.self_word, _ctn, cmmn, def_loc);
cmmn.scope.AddSymbol(compiler_string_consts.self_word, new SymbolInfo(lv));
cmmn.self_variable = lv;
cmmn.var_definition_nodes_list.AddElement(lv);
cfn=cmmn;
break;
}
case block_type.namespace_block:
{
common_namespace_function_node cnfnn;
SymbolTable.Scope scope = convertion_data_and_alghoritms.symbol_table.CreateScope(_cmn.scope);
cnfnn=new common_namespace_function_node(name,def_loc,_cmn,scope);
_cmn.functions.AddElement(cnfnn);
_last_created_function=new SymbolInfo(cnfnn);
_cmn.scope.AddSymbol(name,_last_created_function);
cfn=cnfnn;
break;
}
}
_func_stack.push(cfn);
return cfn;
}
public void create_main_function(string[] used_stand_modules, Dictionary<string, object> config)
{
add_needed_cctors();
common_namespace_function_node temp = _main_function;
_main_function = new common_namespace_function_node("Main", null, null, (common_namespace_node)_main_function.comprehensive_namespace, null);
location loc = temp.loc;
statements_list sl = new statements_list(loc);
_main_function.function_code = sl;
// if (units[0].MainArgsParameter!=null)
// {
// _main_function.parameters.AddElement(units[0].MainArgsParameter);
// sl.statements.AddElement(units[0].MainArgsAssignExpr);
// }
// if (units[0].IsConsoleApplicationVariableAssignExpr!=null)
// {
// sl.statements.AddElement(units[0].IsConsoleApplicationVariableAssignExpr);
// }
statements_list sl2 = sl;
sl = new statements_list(null);
common_namespace_function_node init_func = new common_namespace_function_node("$_Init_",null,null,(common_namespace_node)_main_function.comprehensive_namespace,null);
((common_namespace_node)_main_function.comprehensive_namespace).functions.AddElement(init_func);
namespace_variable init_var = new namespace_variable("$is_init",SystemLibrary.SystemLibrary.bool_type,(common_namespace_node)_main_function.comprehensive_namespace,null);
((common_namespace_node)_main_function.comprehensive_namespace).variables.AddElement(init_var);
if (SystemLibrary.SystemLibInitializer.ConfigVariable.Found)
{
namespace_variable conf_nv = null;
compiled_variable_definition conf_cf = null;
if (SystemLibrary.SystemLibInitializer.ConfigVariable.sym_info is namespace_variable)
conf_nv = SystemLibrary.SystemLibInitializer.ConfigVariable.sym_info as namespace_variable;
else
conf_cf = SystemLibrary.SystemLibInitializer.ConfigVariable.sym_info as compiled_variable_definition;
foreach (string config_var in config.Keys)
{
var config_value = config[config_var];
compiled_function_call cfc = new compiled_function_call(compiled_function_node.get_compiled_method(NetHelper.NetHelper.AddToDictionaryMethod),
(conf_nv != null) ? (expression_node)new namespace_variable_reference(conf_nv, null) : (expression_node)new static_compiled_variable_reference(conf_cf, null), null);
cfc.parameters.AddElement(new string_const_node(config_var, null));
switch (Type.GetTypeCode(config_value.GetType()))
{
case TypeCode.String:
cfc.parameters.AddElement(new string_const_node((string)config_value, null));
break;
case TypeCode.Int32:
cfc.parameters.AddElement(new int_const_node((int)config_value, null));
break;
case TypeCode.Boolean:
cfc.parameters.AddElement(new bool_const_node((bool)config_value, null));
break;
case TypeCode.Double:
cfc.parameters.AddElement(new double_const_node((double)config_value, null));
break;
default:
throw new NotSupportedException("Config value type is nort supported");
}
sl.statements.AddElement(cfc);
}
}
if (units[0].MainArgsParameter!=null)
{
_main_function.parameters.AddElement(units[0].MainArgsParameter);
sl.statements.AddElementFirst(units[0].MainArgsAssignExpr);
}
if (units[0].IsConsoleApplicationVariableAssignExpr!=null)
{
sl.statements.AddElementFirst(units[0].IsConsoleApplicationVariableAssignExpr);
}
for (int i = 0; i < units.Count; i++)
{
if (units[i].main_function != null)
{
if (units[i].main_function.name != TreeConverter.compiler_string_consts.temp_main_function_name)
{
common_namespace_function_call cnfc = new common_namespace_function_call(units[i].main_function, loc);
sl.statements.AddElement(cnfc);
}
else
{
common_namespace_function_call cnfc = new common_namespace_function_call(units[i].main_function, loc);
sl2.statements.AddElement(cnfc);
}
}
}
//if (units.Count == 1)
for (int i = 0; i < used_stand_modules.Length; i++)
{
Type t = NetHelper.NetHelper.FindRtlType(used_stand_modules[i] + "." + used_stand_modules[i]);
if (t == null)
continue;
compiled_type_node ctn = compiled_type_node.get_type_node(t);
System.Reflection.MethodInfo mi = ctn.compiled_type.GetMethod("__InitModule__");
if (mi == null)
{
continue;
}
compiled_static_method_call csmc = new compiled_static_method_call(compiled_function_node.get_compiled_method(mi), null);
sl.statements.AddElement(csmc);
}
for (int i = units.Count - 1; i >= 0; i--)
{
if (units[i].finalization_method != null)
{
common_namespace_function_call cnfc = new common_namespace_function_call(units[i].finalization_method, loc);
sl2.statements.AddElement(cnfc);
}
}
//if (units.Count == 1)
for (int i = 0; i < used_stand_modules.Length; i++)
{
Type t = NetHelper.NetHelper.FindRtlType(used_stand_modules[i] + "." + used_stand_modules[i]);
if (t == null)
continue;
compiled_type_node ctn = compiled_type_node.get_type_node(t);
System.Reflection.MethodInfo mi = ctn.compiled_type.GetMethod("__FinalizeModule__");
if (mi == null)
continue;
compiled_static_method_call csmc = new compiled_static_method_call(compiled_function_node.get_compiled_method(mi), null);
sl2.statements.AddElement(csmc);
}
sl2 = new statements_list(loc);
basic_function_call bfc = new basic_function_call(SystemLibrary.SystemLibrary.bool_assign as basic_function_node,null);
bfc.parameters.AddElement(new namespace_variable_reference(init_var,null));
bfc.parameters.AddElement(new bool_const_node(true,null));
sl.statements.AddElementFirst(bfc);
bfc = new basic_function_call(SystemLibrary.SystemLibrary.bool_not as basic_function_node,null);
bfc.parameters.AddElement(new namespace_variable_reference(init_var,null));
sl2.statements.AddElement(new if_node(bfc,sl,null,null));
init_func.function_code = sl2;
sl = new statements_list(null);
sl.statements.AddElement(new common_namespace_function_call(init_func,null));
common_namespace_function_node init_variables_func = new common_namespace_function_node("$_InitVariables_", null, null, (common_namespace_node)_main_function.comprehensive_namespace, null);
init_variables_func.function_code = new statements_list(null);
((common_namespace_node)_main_function.comprehensive_namespace).functions.AddElement(init_variables_func);
sl.statements.AddElement(new common_namespace_function_call(init_variables_func,null));
_init_code = sl;
}
public void create_main_function_as_in_module()
{
add_needed_cctors();
statements_list sl = new statements_list(loc);
statements_list intern_sl = new statements_list(loc);
statements_list sl2 = sl;
sl = new statements_list(null);
common_namespace_function_node init_func = new common_namespace_function_node("$_Init_", null, null, common_namespaces[0], null);
common_namespaces[0].functions.AddElement(init_func);
namespace_variable init_var = new namespace_variable("$is_init", SystemLibrary.SystemLibrary.bool_type, common_namespaces[0], null);
common_namespaces[0].variables.AddElement(init_var);
for (int i = 0; i < units.Count; i++)
{
if (units[i].main_function != null)
{
common_namespace_function_call cnfc = new common_namespace_function_call(units[i].main_function, loc);
sl.statements.AddElement(cnfc);
}
}
/*for (int i = units.Count - 1; i >= 0; i--)
{
if (units[i].finalization_method != null)
{
common_namespace_function_call cnfc = new common_namespace_function_call(units[i].finalization_method, loc);
sl.statements.AddElement(cnfc);
}
}*/
sl2 = new statements_list(loc);
basic_function_call bfc = new basic_function_call(SystemLibrary.SystemLibrary.bool_assign as basic_function_node, null);
bfc.parameters.AddElement(new namespace_variable_reference(init_var, null));
bfc.parameters.AddElement(new bool_const_node(true, null));
sl.statements.AddElementFirst(bfc);
bfc = new basic_function_call(SystemLibrary.SystemLibrary.bool_not as basic_function_node, null);
bfc.parameters.AddElement(new namespace_variable_reference(init_var, null));
sl2.statements.AddElement(new if_node(bfc, sl, null, null));
init_func.function_code = sl2;
_init_code = new common_namespace_function_call(init_func, null);
add_initialization_to_cctors();
}
public SymbolInfo(common_namespace_function_node value)
{
//_name_information_type=name_information_type.nit_common_namespace_function;
_sym_info=value;
_access_level=access_level.al_public;
_symbol_kind=get_function_kind(value);
}
/// <summary>
/// Конструктор класса.
/// </summary>
/// <param name="main_function">Главная функция программы.</param>
/// <param name="loc">Расположение программы.</param>
public program_node(common_namespace_function_node main_function,location loc) : base(loc)
{
_main_function=main_function;
}
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 common_unit_node(SymbolTable.UnitInterfaceScope scope,
SymbolTable.UnitImplementationScope implementation_scope,
common_namespace_function_node main_function,
common_namespace_function_node finalization_method)
{
_scope = scope;
_implementation_scope = implementation_scope;
_main_function = main_function;
_finalization_method = finalization_method;
}
//\ssyy
public function_node FindMethodToOverride(common_namespace_function_node cmn)
{
type_node base_class = _compiled_tn;
if (base_class == null)
{
return null;
}
SymbolInfo si = base_class.find_in_type(cmn.name);
function_node fn = null;
while (si != null)
{
if (si.sym_info.general_node_type != general_node_type.function_node)
{
return null;
}
fn = si.sym_info as function_node;
//(ssyy) Сверяем как параметры функций, так и типы возвращаемых значений
if (cmn != fn && convertion_data_and_alghoritms.function_eq_params_and_result(cmn, fn))
{
break;
}
si = si.Next;
}
if (si == null)
{
return null;
}
compiled_function_node cfn_sec = fn as compiled_function_node;
if (cfn_sec != null)
{
if (cfn_sec.polymorphic_state != SemanticTree.polymorphic_state.ps_virtual && cfn_sec.polymorphic_state != SemanticTree.polymorphic_state.ps_virtual_abstract && !cfn_sec.IsFinal)
{
return null;
}
}
return fn;
}
private common_namespace_function_node GetNamespaceFunction(int offset, bool restore_code = true)
{
definition_node dn = null;
if (members.TryGetValue(offset, out dn))
return dn as common_namespace_function_node;
common_namespace_function_node cnfn = null;
int pos = (int)br.BaseStream.Position;
br.BaseStream.Seek(start_pos+offset,SeekOrigin.Begin);
br.ReadByte();
int func_pos = start_pos + br.ReadInt32();
int connected_to_type_pos = (int)br.BaseStream.Position;
br.BaseStream.Seek(func_pos, SeekOrigin.Begin);
string name;
type_node ConnectedToType = null;
/*if (CanReadObject())
ConnectedToType = GetTypeReference();*/
bool is_interface = br.ReadBoolean();
if (is_interface)//пропускаем флаг - интерфейсности
{
name = GetString(br.ReadInt32());
}
else
{
name = br.ReadString();
}
if (is_interface)
{
cnfn = new common_namespace_function_node(name,null,cun.namespaces[0],null);
int_members.Add(cnfn);
}
else
{
cnfn = new common_namespace_function_node(name,null,cun.namespaces[1],null);
impl_members.Add(cnfn);
}
AddMember(cnfn, offset);
ReadGenericFunctionInformation(cnfn);
int cur_pos = (int)br.BaseStream.Position;
br.BaseStream.Seek(connected_to_type_pos, SeekOrigin.Begin);
if (CanReadObject())
ConnectedToType = GetTypeReference();
br.BaseStream.Seek(cur_pos, SeekOrigin.Begin);
if (br.ReadByte() == 1)
{
cnfn.return_value_type = GetTypeReference();
cnfn.return_variable = GetLocalVariable(cnfn);
cnfn.var_definition_nodes_list.AddElement(cnfn.return_variable);
}
//members[offset] = cnfn;
int num_par = br.ReadInt32();
for (int i=0; i<num_par; i++)
cnfn.parameters.AddElement(GetParameter(cnfn));
br.ReadInt32(); //namespace
cnfn.attributes.AddRange(GetAttributes());
cnfn.is_forward = br.ReadBoolean();
cnfn.is_overload = br.ReadBoolean();
cnfn.num_of_default_variables = br.ReadInt32();
cnfn.num_of_for_cycles = br.ReadInt32();
int num_var = br.ReadInt32();
if (cnfn.return_value_type != null) num_var--;
for (int i = 0; i < num_var; i++)
{
local_variable lv = GetLocalVariable(cnfn);
if (lv != cnfn.return_variable)
cnfn.var_definition_nodes_list.AddElement(lv);
}
int num_consts = br.ReadInt32();
for (int i = 0; i < num_consts; i++)
{
cnfn.constants.AddElement(GetFunctionConstant(cnfn));
}
int num_nest_funcs = br.ReadInt32();
for (int i=0; i<num_nest_funcs; i++)
cnfn.functions_nodes_list.AddElement(GetNestedFunction());
//br.ReadInt32();//code;
cnfn.loc = ReadDebugInfo();
cnfn.function_code = (restore_code /*|| cnfn.is_generic_function*/) ? GetCode(br.ReadInt32()) : new wrapped_function_body(this, br.ReadInt32());
cnfn.ConnectedToType = ConnectedToType;
if (cnfn.ConnectedToType != null && cnfn.ConnectedToType.type_special_kind == SemanticTree.type_special_kind.array_kind && cnfn.ConnectedToType.element_type.is_generic_parameter)
cnfn.ConnectedToType.base_type.Scope.AddSymbol(cnfn.name, new SymbolInfo(cnfn));
else if (cnfn.ConnectedToType != null && cnfn.ConnectedToType.is_generic_parameter)
cnfn.ConnectedToType.base_type.Scope.AddSymbol(cnfn.name, new SymbolInfo(cnfn));
else if (cnfn.ConnectedToType is compiled_generic_instance_type_node && cnfn.ConnectedToType.original_generic.Scope != null)
cnfn.ConnectedToType.original_generic.Scope.AddSymbol(cnfn.name, new SymbolInfo(cnfn));
br.BaseStream.Seek(pos,SeekOrigin.Begin);
return cnfn;
}
/// <summary>
/// Конструктор корневого узла dll.
/// </summary>
/// <param name="initialization_function">Метод инициализации dll.</param>
/// <param name="finalization_function">Метод финализации dll.</param>
/// <param name="loc">Расположение заголовка главного unit-а dll.</param>
public dll_node(common_namespace_function_node initialization_function,
common_namespace_function_node finalization_function, location loc) : base(loc)
{
_initialization_function=initialization_function;
_finalization_function=finalization_function;
}
private common_namespace_function_node GetNamespaceFunctionWithImplementation(int offset)
{
int tmp = (int)br.BaseStream.Position;
string name = br.ReadString();
br.ReadInt32();
location loc = ReadDebugInfo();
common_namespace_function_node cnfn = new common_namespace_function_node(name, loc, cun.namespaces[0], null);
if (br.ReadByte() == 1)
cnfn.function_code = CreateStatement();
return cnfn;
}
private void SaveFunction(common_namespace_function_node cfn)
{
if (!string.IsNullOrEmpty(cfn.documentation))
{
if (!cfn.documentation.Trim(' ','\t').StartsWith("<summary>"))
{
xtw.WriteStartElement("member");
xtw.WriteStartAttribute("name");
xtw.WriteString("M:"+(is_assembly?unit_name+"."+unit_name+".":"")+cfn.name+GetGenericFlag(cfn)+GetParameters(cfn));
xtw.WriteEndAttribute();
xtw.WriteStartElement("summary");
xtw.WriteString(cfn.documentation);
xtw.WriteEndElement();
xtw.WriteEndElement();
}
else
{
string doc = string.Concat("<member name=\""+"M:"+(is_assembly?unit_name+"."+unit_name+".":"")+cfn.name+GetGenericFlag(cfn)+GetParameters(cfn)+"\">",cfn.documentation,"</member>");
StringReader sr = new StringReader(doc);
XmlReader xr = XmlTextReader.Create(sr);
xr.Read();
xtw.WriteNode(xr.ReadSubtree(),false);
sr.Close();
xr.Close();
}
}
}
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);
}
/// <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 System.Collections.Generic.List<local_variable> special_local_vars
{
get
{
return _special_local_vars;
}
}
*/
public void apply_special_local_vars(common_namespace_function_node cnfn)
{
foreach (local_variable lv in _special_local_vars)
{
lv.function = cnfn;
cnfn.var_definition_nodes_list.AddElement(lv);
}
clear_special_local_vars();
}
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;
}
//TODO: Слить как нибудь два следующих метода.
public override void visit(SyntaxTree.program_module _program_module)
{
//MikhailoMMX Инициализация OpenMP
OpenMP.InitOpenMP(_program_module.compiler_directives, this, _program_module);
//\MikhailoMMX
//current_document=new document(_program_module.file_name);
string namespace_name = "";
location loc = get_location(_program_module);
if (_program_module.program_name != null)
{
namespace_name = _program_module.program_name.prog_name.name;
loc = get_location(_program_module.program_name.prog_name);
//if (namespace_name.ToLower() != System.IO.Path.GetFileNameWithoutExtension(_program_module.file_name).ToLower())
// throw new ProgramNameMustBeEqualProgramFileName(loc);
}
_compiled_unit = new common_unit_node();
_compiled_unit.compiler_directives = ConvertDirectives(_program_module);
//PrepareDirectives(_compiled_unit.compiler_directives);
//using_list.AddRange(interface_using_list);
//weak_node_test_and_visit(_program_module.using_namespaces);
//weak_node_test_and_visit(_program_module.used_units);
//compiled_main_unit=new unit_node();
//SymbolTable.Scope[] used_units=new SymbolTable.Scope[used_assemblyes.Count+1];
SymbolTable.Scope[] used_units = build_referenced_units(referenced_units,true);
_compiled_unit.scope = convertion_data_and_alghoritms.symbol_table.CreateUnitInterfaceScope(used_units);
common_namespace_node cnsn = context.create_namespace(namespace_name, _compiled_unit, _compiled_unit.scope, loc);
cnsn.is_main = true;
//compiled_program=new program_node();
//compiled_program.units.Add(compiled_main_unit);
reset_for_interface();
UpdateUnitDefinitionItemForUnit(_compiled_unit);
//_program_module.program_block.visit(this);
hard_node_test_and_visit(_program_module.program_block);
context.check_labels(context.converted_namespace.labels);
// frninja 28/04/16 - режем мусорные методы хелперы yield
{
var toRemove = cnsn.functions.Where(m => m.name.StartsWith(YieldHelpers.YieldConsts.YieldHelperMethodPrefix)).ToArray();
foreach (var m in toRemove)
{
cnsn.functions.remove(m);
}
}
// end frninja
//TODO: Доделать.
common_namespace_function_node main_function = new common_namespace_function_node(compiler_string_consts.temp_main_function_name,
null, null, cnsn, null);
main_function.function_code = context.code;
context.apply_special_local_vars(main_function);
cnsn.functions.AddElement(main_function);
context.leave_block();
_compiled_unit.main_function = main_function;
//cnsn.SetNamespaceName(System.IO.Path.GetFileNameWithoutExtension(_program_module.file_name));
}
public void set_raise_function(common_namespace_function_node meth)
{
_raise_function = meth;
}
//сохранение ссылки на функцию
private void WriteFunctionReference(common_namespace_function_node fn)
{
generic_namespace_function_instance_node gi = fn as generic_namespace_function_instance_node;
if (gi != null)
{
WriteGenericNamespaceFunctionReference(gi);
return;
}
byte is_def = 0;
int offset=0;
if (fn.SpecialFunctionKind == SemanticTree.SpecialFunctionKind.None)
offset = GetFunctionReference(fn, ref is_def);
else
is_def = 2;
bw.Write(is_def);
if (fn.SpecialFunctionKind == SemanticTree.SpecialFunctionKind.None)
bw.Write(offset);
else
bw.Write((byte)fn.SpecialFunctionKind);
}
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);
}
}
//сохранение initialization и finalization частей
private int VisitFunctionWithImplementation(common_namespace_function_node func)
{
int pos = SavePosition(func);
bw.Write((byte)func.semantic_node_type);
bw.Write(func.name);
bw.Write(GetUnitReference(func.namespace_node));
WriteDebugInfo(func.loc);
if (func.function_code != null)
{
bw.Write((byte)1);
VisitStatement(func.function_code);
}
else bw.Write((byte)0);
return pos;
}
private common_namespace_function_node CreateInterfaceNamespaceFunction(string name, int offset)
{
definition_node dn = null;
if (members.TryGetValue(offset, out dn))
return dn as common_namespace_function_node;
common_namespace_function_node cnfn = null;
cnfn = new common_namespace_function_node(name,null,cun.namespaces[0],null);
//members[offset] = cnfn;
AddMember(cnfn, offset);
type_node ConnectedToType = null;
br.ReadInt32();
if (CanReadObject())
ConnectedToType = GetTypeReference();
br.ReadBoolean();//пропускаем флаг - интерфейсности
br.ReadInt32();
ReadGenericFunctionInformation(cnfn);
//if (CanReadObject())
//{
// cnfn.generic_params = ReadGenericParams(cun.namespaces[0]);
// foreach (common_type_node par in cnfn.generic_params)
// {
// par.generic_function_container = cnfn;
// ReadTypeParameterEliminations(par);
// }
//}
if (br.ReadByte() == 1)
{
cnfn.return_value_type = GetTypeReference();
cnfn.return_variable = GetLocalVariable(cnfn);
cnfn.var_definition_nodes_list.AddElement(cnfn.return_variable);
}
int num_par = br.ReadInt32();
for (int i=0; i<num_par; i++)
cnfn.parameters.AddElement(GetParameter(cnfn));
br.ReadInt32(); //namespace
cnfn.attributes.AddRange(GetAttributes());
cnfn.is_forward = br.ReadBoolean();
cnfn.is_overload = br.ReadBoolean();
cnfn.num_of_default_variables = br.ReadInt32();
cnfn.num_of_for_cycles = br.ReadInt32();
int num_var = br.ReadInt32();
if (cnfn.return_value_type != null) num_var--;
for (int i = 0; i < num_var; i++)
{
local_variable lv = GetLocalVariable(cnfn);
if (lv != cnfn.return_variable)
cnfn.var_definition_nodes_list.AddElement(lv);
}
int num_consts = br.ReadInt32();
for (int i = 0; i < num_consts; i++)
{
function_constant_definition fcd = GetFunctionConstant(cnfn);
cnfn.constants.AddElement(fcd);
}
int num_nest_funcs = br.ReadInt32();
for (int i=0; i<num_nest_funcs; i++)
cnfn.functions_nodes_list.AddElement(GetNestedFunction());
//br.ReadInt32();//code;
cnfn.loc = ReadDebugInfo();
cnfn.function_code = GetCode(br.ReadInt32());
int_members.Add(cnfn);
cnfn.ConnectedToType = ConnectedToType;
if (cnfn.ConnectedToType != null && cnfn.ConnectedToType.type_special_kind == SemanticTree.type_special_kind.array_kind && cnfn.ConnectedToType.element_type.is_generic_parameter)
cnfn.ConnectedToType.base_type.Scope.AddSymbol(cnfn.name, new SymbolInfo(cnfn));
else if (cnfn.ConnectedToType != null && cnfn.ConnectedToType.is_generic_parameter)
cnfn.ConnectedToType.base_type.Scope.AddSymbol(cnfn.name, new SymbolInfo(cnfn));
else if (cnfn.ConnectedToType is compiled_generic_instance_type_node && cnfn.ConnectedToType.original_generic.Scope != null)
cnfn.ConnectedToType.original_generic.Scope.AddSymbol(cnfn.name, new SymbolInfo(cnfn));
else if (cnfn.ConnectedToType != null && cnfn.ConnectedToType.IsDelegate && cnfn.ConnectedToType.base_type.IsDelegate)
compiled_type_node.get_type_node(typeof(Delegate)).Scope.AddSymbol(cnfn.name, new SymbolInfo(cnfn));
return cnfn;
}
private void VisitCommonNamespaceFunctionNode(common_namespace_function_node cnfn)
{
if (extended_mode)
VisitVariables(cnfn.var_definition_nodes_list);
foreach (var_definition_node vdn in cnfn.var_definition_nodes_list)
helper.AddVariable(vdn);
foreach (common_parameter prm in cnfn.parameters)
helper.AddParameter(prm);
foreach (common_in_function_function_node nested in cnfn.functions_nodes_list)
VisitNestedFunction(nested);
cur_func = cnfn;
VisitStatement(cnfn.function_code);
foreach (var_definition_node vdn2 in cnfn.var_definition_nodes_list)
{
if (vdn2 is local_variable)
{
local_variable vdn = vdn2 as local_variable;
VarInfo vi = helper.GetVariable(vdn);
if (vi.num_use == 0 && !vdn.is_special_name) warns.Add(new UnusedVariable(vdn.name, vdn.loc));
else if (vi.num_ass == 0 && vdn.is_ret_value && !cnfn.name.StartsWith("<>") && cnfn.return_value_type != null && cnfn.return_value_type.type_special_kind != SemanticTree.type_special_kind.record && !cnfn.return_value_type.IsPointer && cnfn.return_value_type.type_special_kind != SemanticTree.type_special_kind.array_wrapper
&& !helper.IsExternal(cnfn)) warns.Add(new UndefinedReturnValue(cnfn.name, cnfn.function_code.location));
if (vi.num_ass > 0 && vi.act_num_use == 0 && !vdn.is_special_name) 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));
else if (vi.num_ass == 0 && vdn.is_ret_value && !cnfn.name.StartsWith("<>") && cnfn.return_value_type != null && cnfn.return_value_type.type_special_kind != SemanticTree.type_special_kind.record && !cnfn.return_value_type.IsPointer && cnfn.return_value_type.type_special_kind != SemanticTree.type_special_kind.array_wrapper
&& !helper.IsExternal(cnfn)) warns.Add(new UndefinedReturnValue(cnfn.name, cnfn.function_code.location));
if (vi.num_ass > 0 && vi.act_num_use == 0 && !vdn.is_special_name) warns.Add(new AssignWithoutUsing(vdn.name, vi.last_ass_loc));
//if (vi.num_ass == 0 && vi.act_num_use > 0) helper.AddRealWarning(vdn, warns);
}
if (vdn2.inital_value != null) VisitExpression(vdn2.inital_value);
}
foreach (common_parameter prm in cnfn.parameters)
{
ParamInfo vi = helper.GetParameter(prm);
if (prm.inital_value != null) VisitExpression(prm.inital_value);
//if (vi.num_use == 0 && !prm.name.Contains("$")) warns.Add(new UnusedParameter(prm.name, prm.loc));
}
foreach (var_definition_node vdn in cnfn.var_definition_nodes_list)
{
VarInfo vi = helper.GetVariable(vdn);
if (vdn.inital_value != null) VisitExpression(vdn.inital_value);
}
}
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;
}