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 static common_type_node AddTypeToSetTypeList(common_type_node tctn)
{
if (instance.TypedSets.ContainsKey(tctn.element_type)) return instance.TypedSets[tctn.element_type];
instance.TypedSets.Add(tctn.element_type,tctn);
tctn.add_name(compiler_string_consts.assign_name,new SymbolInfo(SystemLibrary.SystemLibrary.make_assign_operator(tctn,PascalABCCompiler.SemanticTree.basic_function_type.objassign)));
tctn.scope.AddSymbol(compiler_string_consts.plus_name, SystemLibrary.SystemLibInitializer.SetUnionProcedure.SymbolInfo);
tctn.scope.AddSymbol(compiler_string_consts.mul_name, SystemLibrary.SystemLibInitializer.SetIntersectProcedure.SymbolInfo);
tctn.scope.AddSymbol(compiler_string_consts.in_name, SystemLibrary.SystemLibInitializer.InSetProcedure.SymbolInfo);
tctn.scope.AddSymbol(compiler_string_consts.minus_name, SystemLibrary.SystemLibInitializer.SetSubtractProcedure.SymbolInfo);
tctn.scope.AddSymbol(compiler_string_consts.eq_name, SystemLibrary.SystemLibInitializer.CompareSetEquals.SymbolInfo);
tctn.scope.AddSymbol(compiler_string_consts.noteq_name, SystemLibrary.SystemLibInitializer.CompareSetInEquals.SymbolInfo);
tctn.scope.AddSymbol(compiler_string_consts.sm_name, SystemLibrary.SystemLibInitializer.CompareSetLess.SymbolInfo);
tctn.scope.AddSymbol(compiler_string_consts.smeq_name, SystemLibrary.SystemLibInitializer.CompareSetLessEqual.SymbolInfo);
tctn.scope.AddSymbol(compiler_string_consts.gr_name, SystemLibrary.SystemLibInitializer.CompareSetGreater.SymbolInfo);
tctn.scope.AddSymbol(compiler_string_consts.greq_name, SystemLibrary.SystemLibInitializer.CompareSetGreaterEqual.SymbolInfo);
tctn.scope.AddSymbol(compiler_string_consts.plusassign_name,new SymbolInfo(make_set_plus_assign(tctn)));
tctn.scope.AddSymbol(compiler_string_consts.minusassign_name,new SymbolInfo(make_set_minus_assign(tctn)));
tctn.scope.AddSymbol(compiler_string_consts.multassign_name,new SymbolInfo(make_set_mult_assign(tctn)));
return tctn;
}
public common_type_node create_set_type(type_node elem_type, location def_loc)
{
//if (elem_type == PascalABCCompiler.SystemLibrary.SystemLibrary.byte_type)
// elem_type = PascalABCCompiler.SystemLibrary.SystemLibrary.integer_type;
if (TypedSets.ContainsKey(elem_type))
return TypedSets[elem_type];
string name = compiler_string_consts.GetSetTypeName(elem_type.name);
/*common_type_node sctn = SystemLibrary.SystemLibInitializer.TypedSetType.sym_info as common_type_node;
sctn.type_special_kind = SemanticTree.type_special_kind.set_type;
if (sctn.scope.Find(compiler_string_consts.assign_name) == null)
sctn.scope.AddSymbol(compiler_string_consts.assign_name, sctn.scope.Find(compiler_string_consts.AssignSetName));
return sctn;*/
type_node base_type = SystemLibrary.SystemLibInitializer.TypedSetType.sym_info as type_node;
//check_name_free(name, def_loc);
SymbolTable.ClassScope scope = convertion_data_and_alghoritms.symbol_table.CreateClassScope(_cmn.scope, null);
common_type_node tctn = new common_type_node(name, SemanticTree.type_access_level.tal_public, _cmn,
scope, def_loc);
set_field_access_level(SemanticTree.field_access_level.fal_public);
_cmn.scope.AddSymbol(name, new SymbolInfo(tctn));
tctn.type_special_kind = SemanticTree.type_special_kind.set_type;
//tctn.add_intersection_node(type_intersection_node);
tctn.element_type = elem_type;
tctn.internal_is_value = base_type.is_value;
tctn.is_class = base_type.is_class;
tctn.SetBaseType(base_type);
tctn.add_name(compiler_string_consts.assign_name,new SymbolInfo(SystemLibrary.SystemLibrary.make_assign_operator(tctn,PascalABCCompiler.SemanticTree.basic_function_type.objassign)));
//tctn.add_name(compiler_string_consts.assign_name,SystemLibrary.SystemLibInitializer.AssignSetProcedure.SymbolInfo);
/*foreach (type_node tn in TypedSets.Keys)
{
type_compare tc = type_table.compare_types(elem_type,tn);
if (tc != type_compare.non_comparable_type)
{
tctn.add_name(compiler_string_consts.assign_name,new SymbolInfo(SystemLibrary.SystemLibrary.make_assign_operator(TypedSets[tn],PascalABCCompiler.SemanticTree.basic_function_type.objassign)));
TypedSets[tn].add_name(compiler_string_consts.assign_name,new SymbolInfo(SystemLibrary.SystemLibrary.make_assign_operator(tctn,PascalABCCompiler.SemanticTree.basic_function_type.objassign)));
}
}*/
tctn.ImplementingInterfaces.Add(compiled_type_node.get_type_node(NetHelper.NetHelper.FindType(compiler_string_consts.IEnumerableInterfaceName)));
//tctn.scope.AddSymbol(compiler_string_consts.and_name,SystemLibrary.)
//_ctn = tctn;
//if (tctn.scope.Find(compiler_string_consts.assign_name) != tctn.scope.Find(compiler_string_consts.AssignSetName))
// tctn.scope.AddSymbol(compiler_string_consts.assign_name, tctn.scope.Find(compiler_string_consts.AssignSetName));
tctn.scope.AddSymbol(compiler_string_consts.plus_name, SystemLibrary.SystemLibInitializer.SetUnionProcedure.SymbolInfo);
tctn.scope.AddSymbol(compiler_string_consts.mul_name, SystemLibrary.SystemLibInitializer.SetIntersectProcedure.SymbolInfo);
tctn.scope.AddSymbol(compiler_string_consts.in_name, SystemLibrary.SystemLibInitializer.InSetProcedure.SymbolInfo);
tctn.scope.AddSymbol(compiler_string_consts.minus_name, SystemLibrary.SystemLibInitializer.SetSubtractProcedure.SymbolInfo);
tctn.scope.AddSymbol(compiler_string_consts.eq_name, SystemLibrary.SystemLibInitializer.CompareSetEquals.SymbolInfo);
tctn.scope.AddSymbol(compiler_string_consts.noteq_name, SystemLibrary.SystemLibInitializer.CompareSetInEquals.SymbolInfo);
tctn.scope.AddSymbol(compiler_string_consts.sm_name, SystemLibrary.SystemLibInitializer.CompareSetLess.SymbolInfo);
tctn.scope.AddSymbol(compiler_string_consts.smeq_name, SystemLibrary.SystemLibInitializer.CompareSetLessEqual.SymbolInfo);
tctn.scope.AddSymbol(compiler_string_consts.gr_name, SystemLibrary.SystemLibInitializer.CompareSetGreater.SymbolInfo);
tctn.scope.AddSymbol(compiler_string_consts.greq_name, SystemLibrary.SystemLibInitializer.CompareSetGreaterEqual.SymbolInfo);
tctn.scope.AddSymbol(compiler_string_consts.plusassign_name,new SymbolInfo(make_set_plus_assign(tctn)));
tctn.scope.AddSymbol(compiler_string_consts.minusassign_name,new SymbolInfo(make_set_minus_assign(tctn)));
tctn.scope.AddSymbol(compiler_string_consts.multassign_name,new SymbolInfo(make_set_mult_assign(tctn)));
//SystemLibrary.SystemLibrary.init_reference_type(tctn);
converted_namespace.types.AddElement(tctn);
TypedSets.Add(elem_type, tctn);
return tctn;
}
private void AddTypeCheckToStaticConstructor(common_type_node generic_def)
{
statements_list stl = new statements_list(null);
GenericParameterAbilities gpa;
foreach (common_type_node param in generic_def.generic_params)
{
if (syntax_tree_visitor.generic_param_abilities.TryGetValue(param, out gpa))
{
if (gpa.useful_for_pointers)
{
stl.statements.AddElement(CreateTypeCheckCall(SystemLibrary.SystemLibInitializer.CheckCanUsePointerOnTypeProcedure.sym_info, param));
}
if (gpa.useful_for_binary_files)
{
stl.statements.AddElement(CreateTypeCheckCall(SystemLibrary.SystemLibInitializer.CheckCanUseTypeForBinaryFilesProcedure.sym_info, param));
}
if (gpa.useful_for_typed_files)
{
stl.statements.AddElement(CreateTypeCheckCall(SystemLibrary.SystemLibInitializer.CheckCanUseTypeForTypedFilesProcedure.sym_info, param));
}
}
if (SemanticRules.RuntimeInitVariablesOfGenericParameters)
{
basic_function_call bfc = new basic_function_call(
SystemLibrary.SystemLibrary.byte_assign as basic_function_node, null);
bfc.parameters.AddElement(new static_class_field_reference(param.runtime_initialization_marker, null));
base_function_call dcall = null;
if (SystemLibrary.SystemLibInitializer.RuntimeDetermineTypeFunction.sym_info is common_namespace_function_node)
dcall = new common_namespace_function_call(
SystemLibrary.SystemLibInitializer.RuntimeDetermineTypeFunction.sym_info as common_namespace_function_node, null);
else
dcall = new compiled_static_method_call(
SystemLibrary.SystemLibInitializer.RuntimeDetermineTypeFunction.sym_info as compiled_function_node, null);
dcall.parameters.AddElement(new typeof_operator(param, null));
bfc.parameters.AddElement(dcall);
stl.statements.AddElement(bfc);
}
}
if (stl.statements.Count == 0) return;
string stat_ctor_name = compiler_string_consts.static_ctor_prefix + compiler_string_consts.default_constructor_name;
SymbolInfo si = generic_def.scope.FindOnlyInScope(stat_ctor_name);
common_method_node stat_ctor;
if (si == null)
{
stat_ctor = new common_method_node(stat_ctor_name, null, null, generic_def,
SemanticTree.polymorphic_state.ps_static, SemanticTree.field_access_level.fal_public, null);
stat_ctor.is_constructor = true;
generic_def.add_name(stat_ctor_name, new SymbolInfo(stat_ctor));
generic_def.methods.AddElement(stat_ctor);
}
else
{
stat_ctor = si.sym_info as common_method_node;
}
if (stat_ctor.function_code != null)
{
stl.statements.AddElement(stat_ctor.function_code);
}
else
{
stl.statements.AddElement(new return_node(null, null));
}
stat_ctor.function_code = stl;
}
public void init_delegate(common_type_node ctn, type_node return_value_type, parameter_list parameters,
location loc)
{
common_method_node constructor=new common_method_node(compiler_string_consts.default_constructor_name,null,loc,ctn,SemanticTree.polymorphic_state.ps_common,
SemanticTree.field_access_level.fal_public,
convertion_data_and_alghoritms.symbol_table.CreateScope(ctn.scope));
constructor.is_constructor = true;
constructor.return_value_type = ctn;
constructor.function_code=new runtime_statement(SemanticTree.runtime_statement_type.ctor_delegate,loc);
common_method_node invoke=new common_method_node(compiler_string_consts.invoke_method_name,
return_value_type,loc,ctn,SemanticTree.polymorphic_state.ps_virtual,
SemanticTree.field_access_level.fal_public,
convertion_data_and_alghoritms.symbol_table.CreateScope(ctn.scope));
ctn.add_name(compiler_string_consts.invoke_method_name,new SymbolInfo(invoke));
for (int i=0; i<parameters.Count; i++)
{
if (parameters[i] is compiled_parameter)
{
parameters[i] = new common_parameter(parameters[i].name,parameters[i].type,parameters[i].parameter_type,invoke,concrete_parameter_type.cpt_none,null,null);
}
}
invoke.parameters.AddRange(parameters);
invoke.function_code = new runtime_statement(SemanticTree.runtime_statement_type.invoke_delegate, loc);
common_method_node begin_invoke = new common_method_node(compiler_string_consts.begin_invoke_method_name,
begin_invoke_result_type, loc, ctn, SemanticTree.polymorphic_state.ps_virtual, SemanticTree.field_access_level.fal_public,
convertion_data_and_alghoritms.symbol_table.CreateScope(ctn.scope));
ctn.add_name(compiler_string_consts.begin_invoke_method_name,new SymbolInfo(begin_invoke));
parameter_list begin_invoke_params=new parameter_list();
begin_invoke_params.AddRange(parameters);
common_parameter cp=new common_parameter(compiler_string_consts.callback_string,begin_invoke_parameter_type,
SemanticTree.parameter_type.value,begin_invoke,concrete_parameter_type.cpt_none,
null,loc);
begin_invoke_params.AddElement(cp);
cp = new common_parameter(compiler_string_consts.object_in_par_string, SystemLibrary.SystemLibrary.object_type,
SemanticTree.parameter_type.value,begin_invoke, concrete_parameter_type.cpt_none,
null, loc);
begin_invoke_params.AddElement(cp);
begin_invoke.parameters.AddRange(begin_invoke_params);
begin_invoke.function_code = new runtime_statement(SemanticTree.runtime_statement_type.begin_invoke_delegate, loc);
common_method_node end_invoke = new common_method_node(compiler_string_consts.end_invoke_method_name,
return_value_type, loc, ctn, SemanticTree.polymorphic_state.ps_virtual, SemanticTree.field_access_level.fal_public,
convertion_data_and_alghoritms.symbol_table.CreateScope(ctn.scope));
ctn.add_name(compiler_string_consts.end_invoke_method_name,new SymbolInfo(end_invoke));
cp = new common_parameter(compiler_string_consts.result_string, begin_invoke_result_type,
SemanticTree.parameter_type.value, end_invoke, concrete_parameter_type.cpt_none,
null, loc);
end_invoke.parameters.AddElement(cp);
end_invoke.function_code = new runtime_statement(SemanticTree.runtime_statement_type.end_invoke_delegate, loc);
ctn.methods.AddElement(constructor);
ctn.methods.AddElement(invoke);
ctn.methods.AddElement(begin_invoke);
ctn.methods.AddElement(end_invoke);
SystemLibrary.SystemLibrary.init_reference_type(ctn);
delegate_internal_interface dii = new delegate_internal_interface(return_value_type, invoke, constructor);
dii.parameters.AddRange(parameters);
ctn.add_internal_interface(dii);
AddOperatorsToDelegate(ctn, loc);
}
