//(ssyy) Добавляет +, +=, -, -=
public void AddOperatorsToDelegate(common_type_node ctn, location loc)
{
//+
common_method_node cmn_add = new common_method_node(compiler_string_consts.plus_name, ctn, loc, ctn, SemanticTree.polymorphic_state.ps_static,
SemanticTree.field_access_level.fal_public, ctn.scope);
cmn_add.compile_time_executor = delegate_add_compile_time_executor;
ctn.scope.AddSymbol(cmn_add.name, new SymbolInfo(cmn_add));
common_parameter cp1 = new common_parameter(compiler_string_consts.left_param_name, ctn, SemanticTree.parameter_type.value,
cmn_add, concrete_parameter_type.cpt_none, null, loc);
common_parameter cp2 = new common_parameter(compiler_string_consts.right_param_name, ctn, SemanticTree.parameter_type.value,
cmn_add, concrete_parameter_type.cpt_none, null, loc);
cmn_add.parameters.AddElement(cp1);
cmn_add.parameters.AddElement(cp2);
//+=
common_method_node cmn_add_assign = new common_method_node(compiler_string_consts.plusassign_name, ctn, loc, ctn, SemanticTree.polymorphic_state.ps_static,
SemanticTree.field_access_level.fal_public, ctn.scope);
cmn_add_assign.compile_time_executor = delegate_add_assign_compile_time_executor;
ctn.scope.AddSymbol(cmn_add_assign.name, new SymbolInfo(cmn_add_assign));
common_parameter cp3 = new common_parameter(compiler_string_consts.left_param_name, ctn, SemanticTree.parameter_type.value,
cmn_add_assign, concrete_parameter_type.cpt_none, null, loc);
common_parameter cp4 = new common_parameter(compiler_string_consts.right_param_name, ctn, SemanticTree.parameter_type.value,
cmn_add_assign, concrete_parameter_type.cpt_none, null, loc);
cmn_add_assign.parameters.AddElement(cp3);
cmn_add_assign.parameters.AddElement(cp4);
//-
common_method_node cmn_sub = new common_method_node(compiler_string_consts.minus_name, ctn, loc, ctn, SemanticTree.polymorphic_state.ps_static,
SemanticTree.field_access_level.fal_public, ctn.scope);
cmn_sub.compile_time_executor = delegate_sub_compile_time_executor;
ctn.scope.AddSymbol(cmn_sub.name, new SymbolInfo(cmn_sub));
common_parameter cp12 = new common_parameter(compiler_string_consts.left_param_name, ctn, SemanticTree.parameter_type.value,
cmn_sub, concrete_parameter_type.cpt_none, null, loc);
common_parameter cp22 = new common_parameter(compiler_string_consts.right_param_name, ctn, SemanticTree.parameter_type.value,
cmn_sub, concrete_parameter_type.cpt_none, null, loc);
cmn_sub.parameters.AddElement(cp12);
cmn_sub.parameters.AddElement(cp22);
//-=
common_method_node cmn_sub_assign = new common_method_node(compiler_string_consts.minusassign_name, ctn, loc, ctn, SemanticTree.polymorphic_state.ps_static,
SemanticTree.field_access_level.fal_public, ctn.scope);
cmn_sub_assign.compile_time_executor = delegate_sub_assign_compile_time_executor;
ctn.scope.AddSymbol(cmn_sub_assign.name, new SymbolInfo(cmn_sub_assign));
common_parameter cp32 = new common_parameter(compiler_string_consts.left_param_name, ctn, SemanticTree.parameter_type.value,
cmn_sub_assign, concrete_parameter_type.cpt_none, null, loc);
common_parameter cp42 = new common_parameter(compiler_string_consts.right_param_name, ctn, SemanticTree.parameter_type.value,
cmn_sub_assign, concrete_parameter_type.cpt_none, null, loc);
cmn_sub_assign.parameters.AddElement(cp32);
cmn_sub_assign.parameters.AddElement(cp42);
}
/*public static void RestoreStandartNames()
{
_bool_type.SetName(compiler_string_consts.bool_type_name);
_byte_type.SetName(compiler_string_consts.byte_type_name);
_sbyte_type.SetName(compiler_string_consts.sbyte_type_name);
_short_type.SetName(compiler_string_consts.short_type_name);
_ushort_type.SetName(compiler_string_consts.ushort_type_name);
_integer_type.SetName(compiler_string_consts.integer_type_name); ;
_uint_type.SetName(compiler_string_consts.uint_type_name);
_int64_type.SetName(compiler_string_consts.long_type_name);
_uint64_type.SetName(compiler_string_consts.ulong_type_name);
_double_type.SetName(compiler_string_consts.real_type_name);
_float_type.SetName(compiler_string_consts.float_type_name);
_char_type.SetName(compiler_string_consts.char_type_name);
_string_type.SetName(compiler_string_consts.string_type_name);
_object_type.SetName(compiler_string_consts.object_type_name);
_exception_base_type.SetName(compiler_string_consts.base_exception_class_name);
_array_base_type.SetName(compiler_string_consts.base_array_type_name);
_delegate_base_type.SetName(compiler_string_consts.base_delegate_type_name);
_enum_base_type.SetName(compiler_string_consts.base_enum_class_name);
_pointer_type.SetName(compiler_string_consts.pointer_type_name);
_void_type.SetName(compiler_string_consts.void_class_name);
}*/
private static void make_methods()
{
_empty_method = new basic_function_node(SemanticTree.basic_function_type.none, null, true);
basic_parameter bp = new basic_parameter(compiler_string_consts.unary_param_name, null,
SemanticTree.parameter_type.value, _empty_method);
_empty_method.parameters.AddElement(bp);
_empty_method.compile_time_executor = delegated_empty_method;
//(ssyy) Убрать подмену параметров?!
Type arr_type = typeof(System.Array);
System.Reflection.MethodInfo resize_func_mi = arr_type.GetMethod("Resize");
_resize_func = compiled_function_node.get_compiled_method(resize_func_mi);
_resize_func.parameters.clear();
common_parameter par0 = new common_parameter("Array", _object_type, SemanticTree.parameter_type.value, null,
concrete_parameter_type.cpt_none, null, null);
common_parameter par1 = new common_parameter("Length", _integer_type, SemanticTree.parameter_type.value, null,
concrete_parameter_type.cpt_none, null, null);
_resize_func.parameters.AddElement(par0);
_resize_func.parameters.AddElement(par1);
resize_func.compile_time_executor = set_length_compile_time_executor;
}
public void AddParameter(common_parameter vdn)
{
ParamInfo vi = new ParamInfo();
ht[vdn] = vi;
}
//TODO: Если одного из акцессоров нет?
public override void visit(SyntaxTree.simple_property _simple_property)
{
if (_simple_property.accessors == null)
AddError(get_location(_simple_property), "PROPERTYACCESSOR_{0}_OR_{1}_EXPECTED", compiler_string_consts.PascalReadAccessorName, compiler_string_consts.PascalWriteAccessorName);
if (_simple_property.property_type == null)
AddError(get_location(_simple_property.property_name), "TYPE_NAME_EXPECTED");
common_property_node pn = context.add_property(_simple_property.property_name.name,
get_location(_simple_property.property_name));
assign_doc_info(pn, _simple_property);
//pn.polymorphic_state=SemanticTree.polymorphic_state.ps_common;
//pn.loc=get_location(_simple_property.property_name);
if (_simple_property.attr == SyntaxTree.definition_attribute.Static)
pn.polymorphic_state = SemanticTree.polymorphic_state.ps_static;
parameter_list pal_big = new parameter_list();
//TODO: Спросить у Саши как получить тип параметра - var,const и т.д.
if (_simple_property.parameter_list != null)
{
foreach (SyntaxTree.property_parameter pp in _simple_property.parameter_list.parameters)
{
parameter_list pal_small = new parameter_list();
foreach (SyntaxTree.ident id in pp.names.idents)
{
common_parameter cp = new common_parameter(id.name, SemanticTree.parameter_type.value, null,
concrete_parameter_type.cpt_none, get_location(id));
pal_small.AddElement(cp);
}
type_node tn = convert_strong(pp.type);
foreach (parameter pr in pal_small)
{
pr.type = tn;
}
pal_big.AddRange(pal_small);
}
}
pn.parameters.AddRange(pal_big);
pn.internal_property_type = convert_strong(_simple_property.property_type);
if (_simple_property.accessors != null)
{
convertion_data_and_alghoritms.check_node_parser_error(_simple_property.accessors);
SymbolInfo si = null;
//definition_node dn = null;
if (_simple_property.accessors.read_accessor != null)
{
convertion_data_and_alghoritms.check_node_parser_error(_simple_property.accessors.read_accessor);
if (_simple_property.accessors.read_accessor.accessor_name == null)
{
if (!context.converted_type.IsInterface)
{
AddError(get_location(_simple_property.accessors.read_accessor), "ACCESSOR_NAME_EXPECTED");
}
pn.internal_get_function = GenerateGetSetMethodForInterfaceProperty(pn, get_location(_simple_property.accessors.read_accessor), true);
}
else
{
convertion_data_and_alghoritms.check_node_parser_error(_simple_property.accessors.read_accessor.accessor_name);
si = context.converted_type.find_in_type(_simple_property.accessors.read_accessor.accessor_name.name, context.CurrentScope);
location loc1 = get_location(_simple_property.accessors.read_accessor.accessor_name);
if (si == null)
{
AddError(new UndefinedNameReference(_simple_property.accessors.read_accessor.accessor_name.name, loc1));
}
//dn = check_name_node_type(_simple_property.accessors.read_accessor.accessor_name.name,
// si, loc1, general_node_type.function_node, general_node_type.variable_node);
function_node read_accessor = si.sym_info as function_node;
if (read_accessor != null)
{
bool good_func = true;
bool one_func = si.Next == null;
while (si != null)
{
good_func = true;
if (read_accessor.parameters.Count != pn.parameters.Count)
{
good_func = false;
if (one_func)
{
AddError(new PropertyAndReadAccessorParamsCountConvergence(read_accessor, pn, loc1));
}
}
//TODO: Сверять типы параметров - var, const и т.д.
else
{
for (int i1 = 0; good_func && i1 < read_accessor.parameters.Count; i1++)
{
if (read_accessor.parameters[i1].parameter_type != pn.parameters[i1].parameter_type ||
read_accessor.parameters[i1].type != pn.parameters[i1].type)
{
good_func = false;
if (one_func)
{
AddError(loc1, "PROPERTY_{0}_AND_READ_ACCESSOR_{1}_PARAMS_TYPE_CONVERGENCE", pn.name, read_accessor.name);
}
}
}
if (read_accessor.return_value_type == null)
{
good_func = false;
if (one_func)
{
AddError(loc1, "PROPERTY_READ_ACCESSOR_CAN_NOT_BE_PROCEDURE");
}
}
if (read_accessor.return_value_type != pn.property_type)
{
good_func = false;
if (one_func)
{
AddError(loc1, "PROPERTY_{0}_AND_READ_ACCESSOR_{1}_RETURN_VALUE_TYPE_CONVERGENCE", pn.name, read_accessor.name);
}
}
if (read_accessor is common_method_node && (read_accessor as common_method_node).is_constructor)
{
AddError(loc1, "ACCESSOR_CAN_BE_FIELD_OR_METHOD_ONLY");
}
}
if (good_func)
{
break;
}
si = si.Next;
if (si != null)
{
read_accessor = si.sym_info as function_node;
}
}
if (!good_func)
{
AddError(loc1, "NO_OVERLOAD_FUNCTION_{0}_USEFUL_FOR_ACCESSOR", read_accessor.name);
}
read_accessor = GenerateGetMethod(pn,read_accessor as common_method_node,pn.loc);
}
else
{
class_field cfield = si.sym_info as class_field;
if (cfield == null)
{
AddError(loc1, "ACCESSOR_CAN_BE_FIELD_OR_METHOD_ONLY");
}
if (_simple_property.parameter_list != null)
{
AddError(loc1, "INDEX_PROPERTY_ACCESSOR_CAN_NOT_BE_VARIABLE");
}
if (cfield.type != pn.internal_property_type)
{
AddError(loc1, "PROPERTY_TYPE_MISMATCH_ACCESSOR_FIELD_TYPE");
}
if (pn.polymorphic_state == SemanticTree.polymorphic_state.ps_static && cfield.polymorphic_state != SemanticTree.polymorphic_state.ps_static)
AddError(get_location(_simple_property.accessors.read_accessor.accessor_name), "ACCESSOR_{0}_MUST_BE_STATIC", cfield.name);
if (pn.polymorphic_state != SemanticTree.polymorphic_state.ps_static && cfield.polymorphic_state == SemanticTree.polymorphic_state.ps_static)
AddError(get_location(_simple_property.accessors.read_accessor.accessor_name), "ACCESSOR_{0}_CANNOT_BE_STATIC", cfield.name);
read_accessor = GenerateGetMethodForField(pn, compiler_string_consts.GetGetAccessorName(pn.name), cfield, loc1);
}
//Вот здесь уже можем добавить акцессор для чтения.
pn.internal_get_function = read_accessor;
}
if (pn.internal_get_function != null && pn.polymorphic_state == SemanticTree.polymorphic_state.ps_static && pn.internal_get_function.polymorphic_state != SemanticTree.polymorphic_state.ps_static)
AddError(get_location(_simple_property.accessors.read_accessor.accessor_name), "ACCESSOR_{0}_MUST_BE_STATIC", pn.internal_get_function.name);
if (pn.internal_get_function != null && pn.polymorphic_state != SemanticTree.polymorphic_state.ps_static && pn.internal_get_function.polymorphic_state == SemanticTree.polymorphic_state.ps_static)
AddError(get_location(_simple_property.accessors.read_accessor.accessor_name), "ACCESSOR_{0}_CANNOT_BE_STATIC", pn.internal_get_function.name);
}
if (_simple_property.accessors.write_accessor != null)
{
convertion_data_and_alghoritms.check_node_parser_error(_simple_property.accessors.write_accessor);
if (_simple_property.accessors.write_accessor.accessor_name == null)
{
if (!context.converted_type.IsInterface)
{
AddError(get_location(_simple_property.accessors.write_accessor), "ACCESSOR_NAME_EXPECTED");
}
pn.internal_set_function = GenerateGetSetMethodForInterfaceProperty(pn, get_location(_simple_property.accessors.write_accessor), false);
}
else
{
convertion_data_and_alghoritms.check_node_parser_error(_simple_property.accessors.write_accessor.accessor_name);
si = context.converted_type.find_in_type(_simple_property.accessors.write_accessor.accessor_name.name, context.CurrentScope);
location loc2 = get_location(_simple_property.accessors.write_accessor.accessor_name);
if (si == null)
{
AddError( new UndefinedNameReference(_simple_property.accessors.write_accessor.accessor_name.name, loc2));
}
//dn = check_name_node_type(_simple_property.accessors.write_accessor.accessor_name.name,
// si, loc2, general_node_type.function_node, general_node_type.variable_node);
function_node write_accessor = si.sym_info as function_node;
if (write_accessor != null)
{
bool good_func = true;
bool one_func = si.Next == null;
while (si != null)
{
good_func = true;
if (write_accessor.parameters.Count != pn.parameters.Count + 1)
{
good_func = false;
if (one_func)
{
AddError( new PropertyAndWriteAccessorParamsCountConvergence(write_accessor, pn, loc2));
}
}
else
{
//TODO: Сверять типы параметров - var, const и т.д.
for (int i2 = 0; good_func && i2 < pn.parameters.Count; i2++)
{
if (write_accessor.parameters[i2].parameter_type != pn.parameters[i2].parameter_type ||
write_accessor.parameters[i2].type != pn.parameters[i2].type)
{
good_func = false;
if (one_func)
{
AddError(loc2, "PROPERTY_{0}_AND_WRITE_ACCESSOR_{1}_PARAMS_TYPE_CONVERGENCE", pn.name ,write_accessor.name);
}
}
}
if (write_accessor.parameters[write_accessor.parameters.Count - 1].type != pn.property_type ||
write_accessor.parameters[write_accessor.parameters.Count - 1].parameter_type != PascalABCCompiler.SemanticTree.parameter_type.value)
{
good_func = false;
if (one_func)
{
AddError(loc2, "PROPERTY_{0}_AND_WRITE_ACCESSOR_LAST_PARAMETER_TYPE_CONVERGENCE", pn.name);
}
}
if (write_accessor.return_value_type != null)
{
good_func = false;
if (one_func)
{
AddError(loc2, "PROPERTY_WRITE_ACCESSOR_CAN_NOT_BE_FUNCTION");
}
}
}
if (good_func)
{
break;
}
si = si.Next;
if (si != null)
{
write_accessor = si.sym_info as function_node;
}
}
if (!good_func)
{
AddError(loc2, "NO_OVERLOAD_FUNCTION_{0}_USEFUL_FOR_ACCESSOR", write_accessor.name);
}
if (write_accessor is common_method_node && (write_accessor as common_method_node).is_constructor)
{
AddError(loc2, "ACCESSOR_CAN_BE_FIELD_OR_METHOD_ONLY");
}
write_accessor = GenerateSetMethod(pn, write_accessor as common_method_node, pn.loc);
}
else
{
class_field cfield = si.sym_info as class_field;
if (cfield == null)
{
AddError(loc2, "ACCESSOR_CAN_BE_FIELD_OR_METHOD_ONLY");
}
if (_simple_property.parameter_list != null)
{
AddError(loc2, "INDEX_PROPERTY_ACCESSOR_CAN_NOT_BE_VARIABLE");
}
if (cfield.type != pn.internal_property_type)
{
AddError(loc2, "PROPERTY_TYPE_MISMATCH_ACCESSOR_FIELD_TYPE");
}
if (pn.polymorphic_state == SemanticTree.polymorphic_state.ps_static && cfield.polymorphic_state != SemanticTree.polymorphic_state.ps_static)
AddError(get_location(_simple_property.accessors.write_accessor.accessor_name), "ACCESSOR_{0}_MUST_BE_STATIC", cfield.name);
if (pn.polymorphic_state != SemanticTree.polymorphic_state.ps_static && cfield.polymorphic_state == SemanticTree.polymorphic_state.ps_static)
AddError(get_location(_simple_property.accessors.write_accessor.accessor_name), "ACCESSOR_{0}_CANNOT_BE_STATIC", cfield.name);
write_accessor = GenerateSetMethodForField(pn, compiler_string_consts.GetSetAccessorName(pn.name), cfield, loc2);
}
//Вот здесь уже можем добавить акцессор для чтения.
pn.internal_set_function = write_accessor;
}
if (pn.internal_set_function != null && pn.polymorphic_state == SemanticTree.polymorphic_state.ps_static && pn.internal_set_function.polymorphic_state != SemanticTree.polymorphic_state.ps_static)
AddError(get_location(_simple_property.accessors.write_accessor.accessor_name), "ACCESSOR_{0}_MUST_BE_STATIC", pn.internal_set_function.name);
if (pn.internal_set_function != null && pn.polymorphic_state != SemanticTree.polymorphic_state.ps_static && pn.internal_set_function.polymorphic_state == SemanticTree.polymorphic_state.ps_static)
AddError(get_location(_simple_property.accessors.write_accessor.accessor_name), "ACCESSOR_{0}_CANNOT_BE_STATIC", pn.internal_set_function.name);
}
}
make_attributes_for_declaration(_simple_property,pn);
//TODO: Можно сделать множество свойств по умолчанию.
if (_simple_property.array_default != null)
{
if (pn.parameters.Count == 0)
{
AddError(pn.loc, "DEFAULT_PROPERTY_MUST_BE_INDEXED");
}
if (context.converted_type.default_property_node != null)
{
AddError(pn.loc, "DUPLICATE_DEFAULT_PROPERTY_IN_CLASS");
}
context.converted_type.default_property = pn;
}
}
internal function_node GenerateSetMethodForField(common_property_node cpn, string AcessorName, class_field cf, location loc)
{
SymbolInfo exist_si = context.find_only_in_namespace(AcessorName);
if (exist_si != null && exist_si.sym_info.general_node_type != general_node_type.function_node)
{
AddError(loc, "CAN_NOT_GENERATE_ACCESSOR_{0}", AcessorName);
}
while (exist_si != null)
{
function_node ff = (function_node)(exist_si.sym_info);
if (ff.parameters.Count == 1 && ff.parameters[0].type == cf.type)
{
AddError(loc, "CAN_NOT_GENERATE_ACCESSOR_{0}", AcessorName);
}
exist_si = exist_si.Next;
}
common_method_node cmn = new common_method_node(
AcessorName, loc, cf.cont_type,
cf.polymorphic_state, context.get_field_access_level(), null);
cpn.common_comprehensive_type.methods.AddElement(cmn);
common_parameter cp = new common_parameter(
compiler_string_consts.value, cf.type, SemanticTree.parameter_type.value,
cmn, concrete_parameter_type.cpt_none, null, loc);
cmn.parameters.AddElement(cp);
cmn.is_overload = true;
common_parameter_reference cpr = new common_parameter_reference(cp, 0, loc);
expression_node var_ref;
if (cf.polymorphic_state == SemanticTree.polymorphic_state.ps_common)
{
var_ref = new class_field_reference(cf, new this_node(cf.type, loc), loc);
}
else
{
var_ref = new static_class_field_reference(cf, loc);
}
cmn.function_code = find_operator(compiler_string_consts.assign_name, var_ref, cpr, loc);
cf.cont_type.scope.AddSymbol(AcessorName, new SymbolInfo(cmn));
return cmn;
}
private void visit_procedure_header(SyntaxTree.procedure_header _procedure_header)
{
if (_procedure_header.name != null && _procedure_header.name.meth_name is SyntaxTree.operator_name_ident &&
!SyntaxTree.OperatorServices.IsAssigmentOperator((_procedure_header.name.meth_name as SyntaxTree.operator_name_ident).operator_type))
{
AddError(new OverloadOperatorCanNotBeProcedure(get_location(_procedure_header)));
}
if (_procedure_header is SyntaxTree.constructor &&
(_procedure_header.template_args != null || (_procedure_header.name != null && _procedure_header.name.meth_name != null && _procedure_header.name.meth_name is SyntaxTree.template_type_name)))
{
AddError(get_location(_procedure_header), "CONSTRUCTOR_CAN_NOT_BE_GENERIC");
}
current_function_header = _procedure_header;
hard_node_test_and_visit(_procedure_header.name);
current_function_header = null;
if (context.converted_template_type != null)
{
return;
}
if (_procedure_header.template_args != null)
{
visit_generic_params(context.top_function, _procedure_header.template_args.idents);
}
weak_node_test_and_visit(_procedure_header.parameters);
if (_procedure_header.name.class_name != null)
with_class_name = true;
if (_procedure_header.class_keyword && !has_static_attr(_procedure_header.proc_attributes.proc_attributes))
{
SyntaxTree.procedure_attribute pa = new SyntaxTree.procedure_attribute(PascalABCCompiler.SyntaxTree.proc_attribute.attr_static);
pa.source_context = _procedure_header.source_context;
_procedure_header.proc_attributes.proc_attributes.Add(pa);
}
weak_node_test_and_visit(_procedure_header.proc_attributes);
with_class_name = false;
CheckOverrideOrReintroduceExpectedWarning(get_location(_procedure_header));
if (context.top_function != null && context.top_function is common_namespace_function_node && (context.top_function as common_namespace_function_node).ConnectedToType != null && !context.top_function.IsOperator)
{
concrete_parameter_type cpt = concrete_parameter_type.cpt_none;
SemanticTree.parameter_type pt = PascalABCCompiler.SemanticTree.parameter_type.value;
if ((context.top_function as common_namespace_function_node).ConnectedToType.is_value_type)
{
cpt = concrete_parameter_type.cpt_var;
pt = PascalABCCompiler.SemanticTree.parameter_type.var;
}
type_node cur_tn = (context.top_function as common_namespace_function_node).ConnectedToType;
type_node self_type = cur_tn;
if (context.top_function.generic_params != null && self_type.is_generic_type_definition)
{
self_type = self_type.get_instance(context.top_function.get_generic_params_list());
}
if (!has_extensionmethod_attr(_procedure_header.proc_attributes.proc_attributes))
{
common_parameter cp = new common_parameter(compiler_string_consts.self_word, self_type, pt,
context.top_function, cpt, null, null);
context.top_function.parameters.AddElementFirst(cp);
context.top_function.scope.AddSymbol(compiler_string_consts.self_word, new SymbolInfo(cp));
}
}
if (_procedure_header is SyntaxTree.constructor)
{
common_method_node cmnode = context.top_function as common_method_node;
if (cmnode != null)
{
cmnode.is_constructor = true;
cmnode.return_value_type = context.converted_type;
}
else if (context.top_function is common_namespace_function_node && (context.top_function as common_namespace_function_node).ConnectedToType != null)
AddError(get_location(_procedure_header), "EXTENSION_CONSTRUCTOR_NOT_ALLOWED");
else
if (context.converted_compiled_type != null)
AddError(get_location(_procedure_header), "EXTENSION_CONSTRUCTOR_NOT_ALLOWED");
}
bool unique = context.close_function_params(body_exists);
if (context.converted_type != null && context.converted_type.IsInterface)
{
if (body_exists)
{
AddError(new InterfaceFunctionWithBody(get_location(_procedure_header)));
}
common_method_node cmnode = context.top_function as common_method_node;
context.set_virtual_abstract(cmnode);
}
if (context.converted_type != null)
{
common_method_node cmnode = context.top_function as common_method_node;
if (cmnode != null && cmnode.polymorphic_state == SemanticTree.polymorphic_state.ps_virtual_abstract && body_exists)
{
AddError(new AbstractMethodWithBody(get_location(_procedure_header)));
}
}
if (_procedure_header.where_defs != null)
{
if (unique)
{
visit_where_list(_procedure_header.where_defs);
}
else
{
AddError(get_location(_procedure_header.where_defs), "WHERE_SECTION_MUST_BE_ONLY_IN_FIRST_DECLARATION");
}
}
assign_doc_info(context.top_function,_procedure_header);
if (_procedure_header.attributes != null)
{
make_attributes_for_declaration(_procedure_header, context.top_function);
}
/*if (_procedure_header.name != null && context.converted_compiled_type != null && context.top_function is common_namespace_function_node)
{
if (context.FindMethodToOverride(context.top_function as common_namespace_function_node) != null)
AddError(new CanNotDeclareExtensionMethodAsOverrided(get_location(_procedure_header)));
}*/
if (context.converted_type != null && has_dll_import_attribute(context.top_function))
AddError(get_dll_import_attribute(context.top_function).location, "DLLIMPORT_ATTRIBUTE_CANNOT_BE_APPLIED_TO_METHOD");
if (!body_exists)
{
if (_procedure_header.name.class_name != null && context.converted_explicit_interface_type != null)
{
AddError(get_location(_procedure_header), "EXPLICIT_IMPLEMENTATION_EXPECTED");
}
if ((context.top_function.semantic_node_type == semantic_node_type.common_method_node)
|| ((context.func_stack_size_is_one()) && (_is_interface_part)))
{
context.leave_block();
if (_procedure_header.name.class_name != null && context.converted_compiled_type != null)
context.converted_compiled_type = null;
}
}
body_exists = false;
}
//\ssyy
//ssyy
public void generate_inherited_from_base_and_interface_function(common_type_node ctype, function_node func)
{
common_method_node gen_func = context.create_function(func.name, null) as common_method_node;
gen_func.polymorphic_state = SemanticTree.polymorphic_state.ps_common;
gen_func.newslot_awaited = true;
gen_func.is_final = true;
gen_func.is_overload = true;
gen_func.field_access_level = SemanticTree.field_access_level.fal_public;
gen_func.return_value_type = func.return_value_type;
//gen_func.return_variable = func.retu
foreach (parameter par in func.parameters)
{
concrete_parameter_type cpt =
(par.parameter_type == SemanticTree.parameter_type.value) ?
concrete_parameter_type.cpt_const :
concrete_parameter_type.cpt_var;
common_parameter c_p = new common_parameter(par.name,
par.parameter_type, gen_func, cpt, null);
c_p.type = par.type;
c_p.set_param_is_params(par.is_params);
c_p.inital_value = par.inital_value;
gen_func.parameters.AddElement(c_p);
}
local_variable lv = new local_variable(compiler_string_consts.self_word, gen_func.cont_type, gen_func, null);
gen_func.scope.AddSymbol(compiler_string_consts.self_word, new SymbolInfo(lv));
gen_func.self_variable = lv;
base_function_call bfc;
this_node tn = null;
common_method_node commn = func as common_method_node;
if (commn != null)
{
tn = new this_node(commn.comperehensive_type as type_node, null);
bfc = new common_method_call(commn, tn, null);
}
else
{
compiled_function_node compn = func as compiled_function_node;
tn = new this_node(compn.comperehensive_type as type_node, null);
bfc = new compiled_function_call(compn, tn, null);
}
foreach (parameter p in gen_func.parameters)
{
bfc.parameters.AddElement(
create_variable_reference(p, null));
}
//Это запретит чистку стека
bfc.last_result_function_call = true;
statements_list snlist = new statements_list(null);
snlist.statements.AddElement(bfc);
snlist.statements.AddElement(new empty_statement(null));
gen_func.function_code = snlist;
context.pop_top_function();
//context.leave_block();
}
public common_parameter_reference(common_parameter par,int static_depth,location loc) :
base(par.type,loc)
{
_par=par;
this.static_depth=static_depth;
}
public SymbolInfo(common_parameter value)
{
//_name_information_type=name_information_type.nit_common_parameter;
_sym_info=value;
_access_level=access_level.al_public;
_symbol_kind=symbol_kind.sk_none;
}
public common_event add_event_definition(string name, location loc, type_node tn, SemanticTree.polymorphic_state ps, bool is_abstract)
{
class_field cf = new class_field(name + "$", tn, converted_type, ps, _fal, loc);
common_event ce = new common_event(name, tn, converted_type, null, null, null, _fal, ps, loc);
//add
common_method_node add_meth = new common_method_node(compiler_string_consts.GetAddHandler(name), null, this.converted_type,
ps, SemanticTree.field_access_level.fal_public, null);
common_parameter cp = new common_parameter("value", tn, SemanticTree.parameter_type.value, add_meth, concrete_parameter_type.cpt_none, null, null);
add_meth.parameters.AddElement(cp);
expression_node fld_ref = null;
if (!cf.IsStatic) fld_ref = new class_field_reference(cf, new this_node(converted_type, null), null);
else fld_ref = new static_class_field_reference(cf, 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) });
if (!is_abstract)
{
add_meth.function_code = new statements_list(null);
(add_meth.function_code as statements_list).statements.AddElement(en);
}
converted_type.scope.AddSymbol(add_meth.name, new SymbolInfo(add_meth));
//remove
common_method_node remove_meth = new common_method_node(compiler_string_consts.GetRemoveHandler(name), null, this.converted_type,
ps, SemanticTree.field_access_level.fal_public, null);
cp = new common_parameter("value", tn, SemanticTree.parameter_type.value, add_meth, concrete_parameter_type.cpt_none, null, null);
remove_meth.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) });
if (!is_abstract)
{
remove_meth.function_code = new statements_list(null);
(remove_meth.function_code as statements_list).statements.AddElement(en);
}
converted_type.scope.AddSymbol(remove_meth.name, new SymbolInfo(remove_meth));
this.converted_type.methods.AddElement(add_meth);
this.converted_type.methods.AddElement(remove_meth);
ce.set_add_method(add_meth);
ce.set_remove_method(remove_meth);
ce.field = cf;
this.converted_type.events.AddElement(ce);
if (!is_abstract)
this.converted_type.fields.AddElement(cf);
converted_type.scope.AddSymbol(name, new SymbolInfo(ce));
return ce;
}
private void add_equal_operator_if_need()
{
SymbolInfo si = _ctn.find_in_type(compiler_string_consts.eq_name);
if (si.sym_info is common_method_node)
return;
SymbolTable.ClassMethodScope scope = convertion_data_and_alghoritms.symbol_table.CreateClassMethodScope(_cmn.scope,_ctn.scope);
common_method_node cmn = new common_method_node(compiler_string_consts.GetNETOperName(compiler_string_consts.eq_name),SystemLibrary.SystemLibrary.bool_type,null,_ctn,
SemanticTree.polymorphic_state.ps_static,SemanticTree.field_access_level.fal_public,scope);
cmn.IsOperator = true;
common_parameter prm1 = new common_parameter("a",_ctn,SemanticTree.parameter_type.value,cmn,concrete_parameter_type.cpt_none,null,null);
common_parameter prm2 = new common_parameter("b",_ctn,SemanticTree.parameter_type.value,cmn,concrete_parameter_type.cpt_none,null,null);
cmn.parameters.AddElement(prm1);
cmn.parameters.AddElement(prm2);
statements_list body = new statements_list(null);
foreach (class_field cf in _ctn.fields)
{
expression_node left = new class_field_reference(cf,new common_parameter_reference(prm1,0,null),null);
expression_node right = new class_field_reference(cf,new common_parameter_reference(prm2,0,null),null);
expression_node cond = SystemLibrary.SystemLibrary.syn_visitor.find_operator(compiler_string_consts.eq_name,
left,right,null);
basic_function_call bfc = new basic_function_call(SystemLibrary.SystemLibrary.bool_not as basic_function_node,null);
bfc.parameters.AddElement(cond);
if_node if_stmt = new if_node(bfc,new return_node(new bool_const_node(false,null),null),null,null);
body.statements.AddElement(if_stmt);
}
body.statements.AddElement(new return_node(new bool_const_node(true,null),null));
cmn.function_code = body;
cmn.is_overload = true;
_ctn.methods.AddElement(cmn);
_ctn.Scope.AddSymbol(compiler_string_consts.eq_name,new SymbolInfo(cmn));
}
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;
}
public common_parameter_reference(common_parameter par, int static_depth, location loc) :
base(par.type, loc)
{
_par = par;
this.static_depth = static_depth;
}
private type_node create_array_type(ordinal_type_interface oti_indexer, type_node element_type,common_namespace_node _cmn, location loc)
{
int arr_length = oti_indexer.ordinal_type_to_int(oti_indexer.upper_value) -
oti_indexer.ordinal_type_to_int(oti_indexer.lower_value) + 1;
if (arr_length <= 0)
{
throw new SimpleSemanticError(loc, "NEGATIVE_ARRAY_LENGTH_({0})_NOT_ALLOWED", arr_length);
}
simple_array sa = new simple_array(element_type, arr_length);
//sa.length = arr_length;
//sa.element_type = element_type;
SymbolTable.Scope top_scope = null;
if (_cmn != null)
{
top_scope = _cmn.scope;
}
string name = get_pascal_array_name();
//if (_cmn.namespace_name != null)
// name = _cmn.namespace_name + name;
common_type_node ctn = new common_type_node(null, name, SemanticTree.type_access_level.tal_public,
_cmn, convertion_data_and_alghoritms.symbol_table.CreateClassScope(top_scope, null), loc);
ctn.SetBaseType(SystemLibrary.SystemLibrary.object_type);
//DarkStar Add
//loc не нужно мне это! и некому не нужно!
//loc = null;
//ctn.internal_is_value = true;
class_constant_definition cdn1 = new class_constant_definition(compiler_string_consts.lower_array_const_name,
oti_indexer.lower_value, loc, ctn, SemanticTree.field_access_level.fal_public);
ctn.scope.AddSymbol(cdn1.name, new SymbolInfo(cdn1));
class_constant_definition cdn2 = new class_constant_definition(compiler_string_consts.upper_array_const_name,
oti_indexer.upper_value, loc, ctn, SemanticTree.field_access_level.fal_public);
ctn.scope.AddSymbol(cdn2.name, new SymbolInfo(cdn2));
class_field int_arr = new class_field(compiler_string_consts.internal_array_name, sa, ctn,
SemanticTree.polymorphic_state.ps_common, SemanticTree.field_access_level.fal_public,loc);
ctn.scope.AddSymbol(int_arr.name, new SymbolInfo(int_arr));
ctn.fields.AddElement(int_arr);
SystemLibrary.SystemLibrary.init_reference_type(ctn);
ctn.const_defs.AddElement(cdn1);
ctn.const_defs.AddElement(cdn2);
common_method_node get_func = new common_method_node(compiler_string_consts.get_val_pascal_array_name,
element_type, /*loc*/new location(0xFFFFFF, 0, 0xFFFFFF, 0, loc.doc), ctn, SemanticTree.polymorphic_state.ps_common, SemanticTree.field_access_level.fal_private,
convertion_data_and_alghoritms.symbol_table.CreateScope(ctn.scope));
common_parameter get_param = new common_parameter(compiler_string_consts.unary_param_name,
oti_indexer.lower_value.type, SemanticTree.parameter_type.value, get_func, concrete_parameter_type.cpt_none,
null, loc);
get_func.parameters.AddElement(get_param);
common_parameter_reference cpr = new common_parameter_reference(get_param, 0, loc);
expression_node en1 = convertion_data_and_alghoritms.create_simple_function_call(oti_indexer.value_to_int,
loc, cpr);
expression_node en2 = new int_const_node(oti_indexer.ordinal_type_to_int(oti_indexer.lower_value), loc);
expression_node sub_expr = convertion_data_and_alghoritms.create_simple_function_call(
SystemLibrary.SystemLibrary.int_sub, loc, en1, en2);
this_node thisnode = new this_node(ctn, loc);
class_field_reference cfr1 = new class_field_reference(int_arr, thisnode, loc);
expression_node index_expr = new simple_array_indexing(cfr1, sub_expr, element_type, loc);
statement_node sn = new return_node(index_expr, /*loc*/new location(0xFFFFFF, 0, 0xFFFFFF, 0, loc.doc));
get_func.function_code = sn;
common_method_node set_func = new common_method_node(compiler_string_consts.set_val_pascal_array_name,
null, /*loc*/new location(0xFFFFFF, 0, 0xFFFFFF, 0, loc.doc), ctn, SemanticTree.polymorphic_state.ps_common, SemanticTree.field_access_level.fal_private,
convertion_data_and_alghoritms.symbol_table.CreateScope(ctn.scope));
common_parameter set_ind = new common_parameter(compiler_string_consts.left_param_name,
oti_indexer.lower_value.type, SemanticTree.parameter_type.value, set_func, concrete_parameter_type.cpt_none,
null, loc);
set_func.parameters.AddElement(set_ind);
common_parameter set_val = new common_parameter(compiler_string_consts.right_param_name,
element_type, SemanticTree.parameter_type.value, set_func, concrete_parameter_type.cpt_none, null, loc);
set_func.parameters.AddElement(set_val);
common_parameter_reference cpr2 = new common_parameter_reference(set_ind, 0, loc);
expression_node en3 = convertion_data_and_alghoritms.create_simple_function_call(oti_indexer.value_to_int,
loc, cpr2);
expression_node en4 = new int_const_node(oti_indexer.ordinal_type_to_int(oti_indexer.lower_value), loc);
expression_node sub_expr2 = convertion_data_and_alghoritms.create_simple_function_call(
SystemLibrary.SystemLibrary.int_sub, loc, en3, en4);
class_field_reference cfr2 = new class_field_reference(int_arr, thisnode, loc);
expression_node index_expr2 = new simple_array_indexing(cfr2, sub_expr2, element_type,loc);
SymbolInfo si = element_type.find_in_type(compiler_string_consts.assign_name);
if (si == null)
{
throw new NotSupportedError(loc);
throw new CompilerInternalError("Varable of this type can not be assigned");
}
if (si.sym_info.general_node_type != general_node_type.function_node)
{
throw new CompilerInternalError("Invalid assign operator");
}
expression_node val_ref = new common_parameter_reference(set_val, 0, loc);
function_node assign = (function_node)si.sym_info;
statement_node assign_call = convertion_data_and_alghoritms.create_simple_function_call(assign,
/*loc*/new location(0xFFFFFF, 0, 0xFFFFFF, 0, loc.doc), index_expr2, val_ref);
set_func.function_code = assign_call;
ctn.methods.AddElement(get_func);
ctn.methods.AddElement(set_func);
common_property_node cpn = new common_property_node(compiler_string_consts.index_property_pascal_array_name,
ctn, element_type, get_func, set_func, loc, SemanticTree.field_access_level.fal_public, SemanticTree.polymorphic_state.ps_common);
common_parameter prop_cp = new common_parameter(compiler_string_consts.unary_param_name, oti_indexer.lower_value.type,
SemanticTree.parameter_type.value, null, concrete_parameter_type.cpt_none, null, loc);
cpn.parameters.AddElement(prop_cp);
ctn.properties.AddElement(cpn);
ctn.default_property = cpn;
if (_cmn != null)
{
_cmn.types.AddElement(ctn);
}
bounded_array_interface bai = new bounded_array_interface(oti_indexer, element_type, cpn, oti_indexer.lower_value.type, int_arr);
ctn.add_internal_interface(bai);
ctn.type_special_kind = SemanticTree.type_special_kind.array_wrapper;
if (element_type.type_special_kind != SemanticTree.type_special_kind.array_wrapper)
{
ctn.ImplementingInterfaces.Add(compiled_type_node.get_type_node(NetHelper.NetHelper.FindType(compiler_string_consts.IEnumerableInterfaceName)));
common_method_node en_cmn = new common_method_node(compiler_string_consts.GetEnumeratorMethodName, compiled_type_node.get_type_node(NetHelper.NetHelper.FindType(compiler_string_consts.IEnumeratorInterfaceName)), null, ctn, SemanticTree.polymorphic_state.ps_virtual, SemanticTree.field_access_level.fal_public, null);
compiled_function_node en_fnc = NetHelper.NetHelper.FindName(NetHelper.NetHelper.FindType(compiler_string_consts.IEnumerableInterfaceName), compiler_string_consts.GetEnumeratorMethodName).sym_info as compiled_function_node;
statements_list sl = new statements_list(null);
sl.statements.AddElement(new return_node(
new compiled_function_call(en_fnc, new class_field_reference(int_arr, new this_node(ctn, null), null), null), null));
en_cmn.function_code = sl;
en_cmn.newslot_awaited = true;
ctn.methods.AddElement(en_cmn);
if (!element_type.IsPointer)
{
List<type_node> generic_args = new List<type_node>();
generic_args.Add(element_type);
type_node en_tn = compiled_type_node.get_type_node(NetHelper.NetHelper.FindType(compiler_string_consts.IGenericEnumerableInterfaceName)).get_instance(generic_args);
ctn.ImplementingInterfaces.Add(en_tn);
en_cmn = new common_method_node(compiler_string_consts.GetEnumeratorMethodName, compiled_type_node.get_type_node(NetHelper.NetHelper.FindType(compiler_string_consts.IGenericEnumeratorInterfaceName)).get_instance(generic_args), null, ctn, SemanticTree.polymorphic_state.ps_virtual, SemanticTree.field_access_level.fal_public, null);
//en_fnc = en_tn.find_in_type("GetEnumerator").sym_info as function_node;//NetHelper.NetHelper.FindName(NetHelper.NetHelper.FindType(compiler_string_consts.IGenericEnumerableInterfaceName), compiler_string_consts.GetEnumeratorMethodName).sym_info as compiled_function_node;
SymbolInfo en_si = en_tn.find_in_type("GetEnumerator");
if (en_si.Next != null && (en_si.Next.sym_info as function_node).return_value_type.is_generic_type_instance)
en_si = en_si.Next;
function_node en_fnc_inst = en_si.sym_info as function_node; ;//.get_instance(generic_args, true, loc);
sl = new statements_list(null);
if (en_fnc_inst is compiled_function_node)
sl.statements.AddElement(new return_node(
new compiled_function_call(en_fnc_inst as compiled_function_node, new class_field_reference(int_arr, new this_node(ctn, null), null), null), null));
else
sl.statements.AddElement(new return_node(
new common_method_call(en_fnc_inst as common_method_node, new class_field_reference(int_arr, new this_node(ctn, null), null), null), null));
en_cmn.function_code = sl;
en_cmn.newslot_awaited = true;
ctn.methods.AddElement(en_cmn);
}
}
//= operation
SymbolTable.ClassMethodScope scope = convertion_data_and_alghoritms.symbol_table.CreateClassMethodScope(_cmn.scope,ctn.scope);
common_method_node cmn_eq = new common_method_node(compiler_string_consts.GetNETOperName(compiler_string_consts.eq_name),SystemLibrary.SystemLibrary.bool_type,null,ctn,
SemanticTree.polymorphic_state.ps_static,SemanticTree.field_access_level.fal_public,scope);
cmn_eq.IsOperator = true;
common_parameter prm1 = new common_parameter("a",ctn,SemanticTree.parameter_type.value,cmn_eq,concrete_parameter_type.cpt_none,null,null);
common_parameter prm2 = new common_parameter("b",ctn,SemanticTree.parameter_type.value,cmn_eq,concrete_parameter_type.cpt_none,null,null);
cmn_eq.parameters.AddElement(prm1);
cmn_eq.parameters.AddElement(prm2);
statements_list body = new statements_list(null);
local_variable vdn = new local_variable("$i",SystemLibrary.SystemLibrary.integer_type,cmn_eq,null);//this.convertion_data_and_alghoritms.syntax_tree_visitor.context.create_for_temp_variable(SystemLibrary.SystemLibrary.integer_type, null);
cmn_eq.var_definition_nodes_list.AddElement(vdn);
expression_node var_ref = new local_variable_reference(vdn,0,null);//this.convertion_data_and_alghoritms.syntax_tree_visitor.create_variable_reference(vdn,null);
basic_function_call cond = new basic_function_call(SystemLibrary.SystemLibrary.int_sm as basic_function_node,null);
cond.parameters.AddElement(var_ref);
cond.parameters.AddElement(new int_const_node(arr_length,null));
while_node while_stmt = new while_node(cond,null);
statements_list while_body = new statements_list(null);
while_stmt.body = while_body;
simple_array_indexing left_sar = new simple_array_indexing(new class_field_reference(int_arr, new common_parameter_reference(prm1,0,null), null),var_ref,element_type,null);
simple_array_indexing right_sar = new simple_array_indexing(new class_field_reference(int_arr, new common_parameter_reference(prm2,0,null), null),var_ref,element_type,null);
expression_node cond2 = SystemLibrary.SystemLibrary.syn_visitor.find_operator(compiler_string_consts.noteq_name,
left_sar,right_sar,null);
if_node if_stmt = new if_node(cond2,new return_node(new bool_const_node(false,null),null),null,null);
while_body.statements.AddElement(if_stmt);
while_body.statements.AddElement(new basic_function_call(SystemLibrary.SystemLibrary.int_assign as basic_function_node,null
,var_ref,new basic_function_call(SystemLibrary.SystemLibrary.int_add as basic_function_node,null,var_ref,new int_const_node(1,null))));
body.statements.AddElement(while_stmt);
body.statements.AddElement(new return_node(new bool_const_node(true,null),null));
cmn_eq.function_code = body;
cmn_eq.is_overload = true;
ctn.methods.AddElement(cmn_eq);
ctn.Scope.AddSymbol(compiler_string_consts.eq_name,new SymbolInfo(cmn_eq));
//<> operation
scope = convertion_data_and_alghoritms.symbol_table.CreateClassMethodScope(_cmn.scope,ctn.scope);
common_method_node cmn_noteq = new common_method_node(compiler_string_consts.GetNETOperName(compiler_string_consts.noteq_name),SystemLibrary.SystemLibrary.bool_type,null,ctn,
SemanticTree.polymorphic_state.ps_static,SemanticTree.field_access_level.fal_public,scope);
cmn_noteq.IsOperator = true;
prm1 = new common_parameter("a",ctn,SemanticTree.parameter_type.value,cmn_noteq,concrete_parameter_type.cpt_none,null,null);
prm2 = new common_parameter("b",ctn,SemanticTree.parameter_type.value,cmn_noteq,concrete_parameter_type.cpt_none,null,null);
cmn_noteq.parameters.AddElement(prm1);
cmn_noteq.parameters.AddElement(prm2);
body = new statements_list(null);
vdn = new local_variable("$i",SystemLibrary.SystemLibrary.integer_type,cmn_noteq,null);//this.convertion_data_and_alghoritms.syntax_tree_visitor.context.create_for_temp_variable(SystemLibrary.SystemLibrary.integer_type, null);
cmn_noteq.var_definition_nodes_list.AddElement(vdn);
var_ref = new local_variable_reference(vdn,0,null);//this.convertion_data_and_alghoritms.syntax_tree_visitor.create_variable_reference(vdn,null);
cond = new basic_function_call(SystemLibrary.SystemLibrary.int_sm as basic_function_node,null);
cond.parameters.AddElement(var_ref);
cond.parameters.AddElement(new int_const_node(arr_length,null));
while_stmt = new while_node(cond,null);
while_body = new statements_list(null);
while_stmt.body = while_body;
left_sar = new simple_array_indexing(new class_field_reference(int_arr, new common_parameter_reference(prm1,0,null), null),var_ref,element_type,null);
right_sar = new simple_array_indexing(new class_field_reference(int_arr, new common_parameter_reference(prm2,0,null), null),var_ref,element_type,null);
cond2 = SystemLibrary.SystemLibrary.syn_visitor.find_operator(compiler_string_consts.noteq_name,
left_sar,right_sar,null);
if_stmt = new if_node(cond2,new return_node(new bool_const_node(true,null),null),null,null);
while_body.statements.AddElement(if_stmt);
while_body.statements.AddElement(new basic_function_call(SystemLibrary.SystemLibrary.int_assign as basic_function_node,null
,var_ref,new basic_function_call(SystemLibrary.SystemLibrary.int_add as basic_function_node,null,var_ref,new int_const_node(1,null))));
body.statements.AddElement(while_stmt);
body.statements.AddElement(new return_node(new bool_const_node(false,null),null));
cmn_noteq.function_code = body;
cmn_noteq.is_overload = true;
ctn.methods.AddElement(cmn_noteq);
ctn.Scope.AddSymbol(compiler_string_consts.noteq_name,new SymbolInfo(cmn_noteq));
//Equals
/*scope = convertion_data_and_alghoritms.symbol_table.CreateClassMethodScope(_cmn.scope,ctn.scope);
common_method_node cmn_equals = new common_method_node("Equals",SystemLibrary.SystemLibrary.bool_type,null,ctn,
SemanticTree.polymorphic_state.ps_virtual,SemanticTree.field_access_level.fal_public,scope);
prm1 = new common_parameter("a",SystemLibrary.SystemLibrary.object_type,SemanticTree.parameter_type.value,cmn_equals,concrete_parameter_type.cpt_none,null,null);
cmn_equals.parameters.AddElement(prm1);
body = new statements_list(null);
vdn = new local_variable("$i",ctn,cmn_equals,null);//this.convertion_data_and_alghoritms.syntax_tree_visitor.context.create_for_temp_variable(SystemLibrary.SystemLibrary.integer_type, null);
cmn_equals.var_definition_nodes_list.AddElement(vdn);
var_ref = new local_variable_reference(vdn,0,null);//this.convertion_data_and_alghoritms.syntax_tree_visitor.create_variable_reference(vdn,null);
as_node _as = new as_node(new common_parameter_reference(prm1,0,null),ctn,null);
base_function_call ass_bfc = new basic_function_call(SystemLibrary.SystemLibrary.object_type.find(compiler_string_consts.assign_name).sym_info as basic_function_node,null);
ass_bfc.parameters.AddElement(var_ref);
ass_bfc.parameters.AddElement(_as);
body.statements.AddElement(ass_bfc);
common_static_method_call csmc = new common_static_method_call(ctn.find_in_type(compiler_string_consts.eq_name).sym_info as common_method_node,null);
csmc.parameters.AddElement(new this_node(ctn,null));
csmc.parameters.AddElement(var_ref);
body.statements.AddElement(new return_node(csmc,null));
ctn.methods.AddElement(cmn_equals);
ctn.Scope.AddSymbol("Equals",new SymbolInfo(cmn_equals));*/
return ctn;
}
private common_type_node convert_function_type(SyntaxTree.formal_parameters syn_parametres, SyntaxTree.type_definition return_type,
location loc, string type_name, common_type_node del_type)
{
//TODO: Добавить аттрибуты функции. Или не надо?
//TODO: Сообщать о том что class keyword и of object игнорируется.
parameter_list parameters = new parameter_list();
bool params_met=false;
if (syn_parametres != null)
{
parameter_list temp_params = new parameter_list();
foreach (SyntaxTree.typed_parameters tpars in syn_parametres.params_list)
{
temp_params.clear();
SemanticTree.parameter_type pt = SemanticTree.parameter_type.value;
concrete_parameter_type cpt = concrete_parameter_type.cpt_none;
switch (tpars.param_kind)
{
//TODO: Params parameter.
case SyntaxTree.parametr_kind.var_parametr:
{
pt = SemanticTree.parameter_type.var;
cpt = concrete_parameter_type.cpt_var;
break;
}
case PascalABCCompiler.SyntaxTree.parametr_kind.const_parametr:
{
pt = SemanticTree.parameter_type.value;
cpt = concrete_parameter_type.cpt_const;
break;
}
case PascalABCCompiler.SyntaxTree.parametr_kind.out_parametr:
{
pt = SemanticTree.parameter_type.var;
cpt = concrete_parameter_type.cpt_var;
break;
}
}
foreach (SyntaxTree.ident id in tpars.idents.idents)
{
common_parameter cp = new common_parameter(id.name, pt, null, cpt, get_location(id));
parameters.AddElement(cp);
if (tpars.param_kind == SyntaxTree.parametr_kind.params_parametr)
{
cp.intrenal_is_params = true;
}
temp_params.AddElement(cp);
}
if (tpars.param_kind == SyntaxTree.parametr_kind.params_parametr)
{
if (tpars.idents.idents.Count > 1)
{
AddError(get_location(tpars.idents.idents[1]), "ONLY_ONE_PARAMS_PARAMETER_ALLOWED");
}
}
SyntaxTree.array_type arr = tpars.vars_type as SyntaxTree.array_type;
if (tpars.vars_type is SyntaxTree.class_definition || /*tpars.vars_type is SyntaxTree.enum_type_definition ||*/
(arr != null && arr.indexers != null && arr.indexers.indexers.Count > 0 && arr.indexers.indexers[0] != null))
{
AddError(get_location(tpars.vars_type), "STRUCT_TYPE_DEFINITION_IN_FORMAL_PARAM");
}
type_node tp = convert_strong(tpars.vars_type);
/*if (depended_from_generic_parameter(tp)) // SSM 25/07/13 - закомментировал и пока всё работает
{
AddError(new DelegateCanNotUseComprehensiveGenericParameter(get_location(tpars.vars_type)));
}*/
if (tpars.param_kind == SyntaxTree.parametr_kind.params_parametr)
{
internal_interface ii = tp.get_internal_interface(internal_interface_kind.unsized_array_interface);
if (ii == null)
{
AddError(get_location(tpars.vars_type), "ONLY_UNSIZED_ARRAY_PARAMS_PARAMETER_ALLOWED");
}
}
foreach (common_parameter ccp in temp_params)
{
ccp.type = tp;
}
if (params_met)
{
AddError(get_location(tpars), "ONLY_LAST_PARAMETER_CAN_BE_PARAMS");
}
if (tpars.param_kind == PascalABCCompiler.SyntaxTree.parametr_kind.params_parametr)
{
params_met = true;
// if (default_value_met)
// {
// AddError(new FunctionWithParamsParameterCanNotHaveDefaultParameters(get_location(tp)));
// }
}
}
}
type_node ret_val_type = null;
if (return_type != null)
{
ret_val_type = convert_strong(return_type);
/*if (depended_from_generic_parameter(ret_val_type)) // SSM 25/07/13 - закомментировал и пока всё работает
{
AddError(new DelegateCanNotUseComprehensiveGenericParameter(get_location(return_type)));
}*/
}
common_type_node del;
if (del_type == null)
{
del = convertion_data_and_alghoritms.type_constructor.create_delegate(type_name,
ret_val_type, parameters, context.converted_namespace, loc);
}
else
{
del = del_type;
convertion_data_and_alghoritms.type_constructor.init_delegate(del, ret_val_type, parameters, loc);
}
context.converted_namespace.types.AddElement(del);
return del;
}
/// <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 override void visit(SyntaxTree.function_header _function_header)
{
current_function_header = _function_header;
hard_node_test_and_visit(_function_header.name);
current_function_header = null;
if (context.converted_template_type != null)
{
return;
}
if (_function_header.template_args != null)
{
visit_generic_params(context.top_function, _function_header.template_args.idents);
}
SymbolInfo si = context.create_special_names();
weak_node_test_and_visit(_function_header.parameters);
type_node tn = null;
if (_function_header.return_type == null)
{
if (context.top_function.IsOperator)
AddError(get_location(_function_header), "FUNCTION_NEED_RETURN_TYPE");
}
if (_function_header.return_type != null)
{
check_parameter_on_complex_type(_function_header.return_type);
tn = convert_strong(_function_header.return_type);
check_for_type_allowed(tn,get_location(_function_header.return_type));
if (_function_header.return_type is function_header || _function_header.return_type is procedure_header)
check_delegate_on_generic_parameters(tn as common_type_node, get_location(_function_header.return_type));
}
//(ssyy) moved up, так как при проверке аттрибута override надо знать тип возвращаемого значения
context.top_function.return_value_type = tn;
assign_doc_info(context.top_function,_function_header);
if (_function_header.attributes != null)
{
make_attributes_for_declaration(_function_header, context.top_function);
}
if (context.converted_type != null && has_dll_import_attribute(context.top_function))
AddError(get_dll_import_attribute(context.top_function).location, "DLLIMPORT_ATTRIBUTE_CANNOT_BE_APPLIED_TO_METHOD");
if (_function_header.name.class_name != null)
with_class_name = true;
if (_function_header.class_keyword && !has_static_attr(_function_header.proc_attributes.proc_attributes))
{
SyntaxTree.procedure_attribute pa = new SyntaxTree.procedure_attribute(PascalABCCompiler.SyntaxTree.proc_attribute.attr_static);
pa.source_context = _function_header.source_context;
_function_header.proc_attributes.proc_attributes.Add(pa);
}
weak_node_test_and_visit(_function_header.proc_attributes);
if (context.top_function.IsOperator)
{
//if (cmmn == null)
//{
// throw new OverloadOperatorMustBeStaticFunction(get_location(_function_header), context.top_function);
//}
if (context.top_function is common_method_node)
{
common_method_node cmmn = context.top_function as common_method_node;
if (cmmn.polymorphic_state != SemanticTree.polymorphic_state.ps_static)
{
AddError(get_location(_function_header), "OVERLOADED_OPERATOR_MUST_BE_STATIC_FUNCTION");
}
if ((cmmn.name == compiler_string_consts.implicit_operator_name || cmmn.name == compiler_string_consts.explicit_operator_name))
{
if (!convertion_data_and_alghoritms.eq_type_nodes(tn, cmmn.comperehensive_type as type_node) && !convertion_data_and_alghoritms.eq_type_nodes(cmmn.comperehensive_type as type_node, cmmn.parameters[0].type))
{
AddError(get_location(_function_header.return_type), "RETURN_VALUE_SHOULD_HAVE_TYPE_{0}", (cmmn.comperehensive_type as type_node).PrintableName);
}
else if (convertion_data_and_alghoritms.eq_type_nodes(tn, cmmn.parameters[0].type))
{
AddError(get_location(_function_header), "CIRCURAL_TYPE_CONVERSION_DEFINITION");
}
}
else
{
int expected_params = 2;
if (cmmn.name == "not")
expected_params = 1;
if ((cmmn.name == "+" || cmmn.name == "-"))
{
if (cmmn.parameters.Count != 2 && cmmn.parameters.Count != 1)
AddError(new SimpleSemanticError(cmmn.loc, "OPERATORS_SHOULD_HAVE_1_OR_2_PARAMETERS"));
}
else if (cmmn.parameters.Count != expected_params)
{
if (expected_params==1)
AddError(new SimpleSemanticError(cmmn.loc, "OPERATOR_SHOULD_HAVE_1_PARAMETER"));
else AddError(new SimpleSemanticError(cmmn.loc, "OPERATOR_SHOULD_HAVE_2_PARAMETERS"));
}
bool has_types = false;
foreach (parameter p in cmmn.parameters)
{
type_node ptn = p.type;
if (ptn.is_generic_type_instance)
ptn = ptn.original_generic;
if (ptn == cmmn.cont_type)
has_types = true;
}
if (!has_types)
AddError(new SimpleSemanticError(cmmn.loc, "LEAST_ONE_PARAMETER_TYPE_SHOULD_EQ_DECLARING_TYPE_{0}",cmmn.cont_type.name));
}
}
else if (context.top_function is common_namespace_function_node)
{
common_namespace_function_node cnfn = context.top_function as common_namespace_function_node;
if ((cnfn.name == compiler_string_consts.implicit_operator_name || cnfn.name == compiler_string_consts.explicit_operator_name))
{
if (cnfn.parameters.Count != 1)
AddError(new SimpleSemanticError(cnfn.loc,"EXTENSION_METHODS_MUST_HAVE_LEAST_ONE_PARAMETER"));
if (cnfn.ConnectedToType == null)
AddError(new SimpleSemanticError(cnfn.loc, "OPERATOR_SHOULD_BE_EXTENSION_METHOD"));
if (!convertion_data_and_alghoritms.eq_type_nodes(tn, cnfn.ConnectedToType) && !convertion_data_and_alghoritms.eq_type_nodes(cnfn.ConnectedToType as type_node, cnfn.parameters[0].type))
{
AddError(get_location(_function_header.return_type), "RETURN_VALUE_SHOULD_HAVE_TYPE_{0}", (cnfn.ConnectedToType as type_node).PrintableName);
}
else if (convertion_data_and_alghoritms.eq_type_nodes(tn, cnfn.parameters[0].type))
{
AddError(get_location(_function_header), "CIRCURAL_TYPE_CONVERSION_DEFINITION");
}
}
else
{
int expected_params = 2;
if (cnfn.name == "not")
expected_params = 1;
if (cnfn.name == "+" || cnfn.name == "-")
{
if (cnfn.parameters.Count != 2 && cnfn.parameters.Count != 1)
AddError(new SimpleSemanticError(cnfn.loc, "OPERATORS_SHOULD_HAVE_1_OR_2_PARAMETERS"));
}
else if (cnfn.parameters.Count != expected_params)
{
if (expected_params == 1)
AddError(new SimpleSemanticError(cnfn.loc, "OPERATOR_SHOULD_HAVE_1_PARAMETER"));
else AddError(new SimpleSemanticError(cnfn.loc, "OPERATOR_SHOULD_HAVE_2_PARAMETERS"));
}
bool has_types = false;
foreach (parameter p in cnfn.parameters)
{
type_node ptn = p.type;
if (ptn.is_generic_type_instance)
ptn = ptn.original_generic;
if (cnfn.ConnectedToType != null && (ptn == cnfn.ConnectedToType || ptn == cnfn.ConnectedToType.original_generic))
has_types = true;
}
if (cnfn.ConnectedToType == null)
AddError(new SimpleSemanticError(cnfn.loc, "OPERATOR_SHOULD_BE_EXTENSION_METHOD"));
if (!has_types)
AddError(new SimpleSemanticError(cnfn.loc, "LEAST_ONE_PARAMETER_TYPE_SHOULD_EQ_DECLARING_TYPE_{0}",cnfn.ConnectedToType.name));
}
}
}
with_class_name = false;
if (context.top_function != null && context.top_function is common_namespace_function_node && (context.top_function as common_namespace_function_node).ConnectedToType != null && !context.top_function.IsOperator)
{
concrete_parameter_type cpt = concrete_parameter_type.cpt_none;
SemanticTree.parameter_type pt = PascalABCCompiler.SemanticTree.parameter_type.value;
if ((context.top_function as common_namespace_function_node).ConnectedToType.is_value_type)
{
cpt = concrete_parameter_type.cpt_var;
pt = PascalABCCompiler.SemanticTree.parameter_type.var;
}
type_node cur_tn = (context.top_function as common_namespace_function_node).ConnectedToType;
/*if (cur_tn.is_generic_type_definition && cur_tn is compiled_type_node)
{
List<type_node> instance_params = new List<type_node>();
compiled_type_node cur_ctn = cur_tn as compiled_type_node;
for (int i = 0; i < cur_ctn.instance_params.Count; i++)
{
instance_params.Add(find_type(cur_ctn.instance_params[i].name, null));
}
cur_tn = cur_tn.get_instance(instance_params);
}*/
type_node self_type = cur_tn;
if (context.top_function.generic_params != null && self_type.is_generic_type_definition)
{
self_type = self_type.get_instance(context.top_function.get_generic_params_list());
}
if (!has_extensionmethod_attr(_function_header.proc_attributes.proc_attributes))
{
common_parameter cp = new common_parameter(compiler_string_consts.self_word, self_type, pt,
context.top_function, cpt, null, null);
context.top_function.parameters.AddElementFirst(cp);
context.top_function.scope.AddSymbol(compiler_string_consts.self_word, new SymbolInfo(cp));
}
}
CheckOverrideOrReintroduceExpectedWarning(get_location(_function_header));
common_type_node common_converted_type_tmp = context.converted_type;
compiled_type_node compiled_converted_type_tmp = context.converted_compiled_type;
common_namespace_function_node cnfn2 = context.top_function as common_namespace_function_node;
if (cnfn2 != null && cnfn2.ConnectedToType != null)
{
if (cnfn2.ConnectedToType is compiled_type_node)
context.converted_compiled_type = cnfn2.ConnectedToType as compiled_type_node;
else if (cnfn2.ConnectedToType is common_type_node)
context.converted_type = cnfn2.ConnectedToType as common_type_node;
}
bool unique = context.close_function_params(body_exists);
context.converted_type = common_converted_type_tmp;
context.converted_compiled_type = compiled_converted_type_tmp;
if (context.top_function.return_value_type == null)
AddError(get_location(_function_header), "FUNCTION_NEED_RETURN_TYPE");
if (_function_header.where_defs != null)
{
if (unique)
{
visit_where_list(_function_header.where_defs);
}
else
{
AddError(get_location(_function_header.where_defs), "WHERE_SECTION_MUST_BE_ONLY_IN_FIRST_DECLARATION");
}
}
if (context.converted_type != null && context.converted_type.IsInterface)
{
if (body_exists)
{
AddError(new InterfaceFunctionWithBody(get_location(_function_header)));
}
common_method_node cmnode = context.top_function as common_method_node;
context.set_virtual_abstract(cmnode);
}
convertion_data_and_alghoritms.create_function_return_variable(context.top_function, si);
/*if (_function_header.name != null && context.converted_compiled_type != null && context.top_function is common_namespace_function_node)
{
if (context.FindMethodToOverride(context.top_function as common_namespace_function_node) != null)
AddError(new CanNotDeclareExtensionMethodAsOverrided(get_location(_function_header)));
}*/
//TODO: Разобрать подробнее.
if (!body_exists)
{
if (_function_header.name.class_name != null && context.converted_explicit_interface_type != null)
{
AddError(get_location(_function_header), "EXPLICIT_IMPLEMENTATION_EXPECTED");
}
if ((context.top_function.semantic_node_type == semantic_node_type.common_method_node)
|| ((context.func_stack_size_is_one()) && (_is_interface_part)))
{
context.leave_block();
}
}
body_exists = false;
}
protected parameter_list make_parameters(parameter_list orig_pl, common_function_node fn)
{
parameter_list pl = new parameter_list();
//TODO: разобраться с concrete_parameter_type
foreach (parameter p in orig_pl)
{
common_parameter cp = new common_parameter(
p.name, generic_convertions.determine_type(p.type, _instance_params, false),
p.parameter_type,
fn, concrete_parameter_type.cpt_none, p.inital_value, null);
cp.intrenal_is_params = p.is_params;
cp.is_special_name = p.is_special_name;
cp.is_ret_value = p.is_ret_value;
cp.default_value = p.default_value;
pl.AddElement(cp);
}
return pl;
}
//ssyy
public void generate_inherit_constructors()
{
common_type_node _ctn = context.converted_type;
if (_ctn == null)
{
throw new CompilerInternalError("Can generate inherited constructors only in class.");
}
if (_ctn.has_user_defined_constructor)
{
//Пользователь определил хотя бы один конструктор, никакие конструкторы не наследуем.
return;
}
//Получили список процедур предка, имеющих имя Create
SymbolInfo si = _ctn.base_type.find_in_type(compiler_string_consts.default_constructor_name, _ctn.base_type.Scope);
delete_inherited_constructors(ref si, _ctn.base_type);
while (si != null)
{
function_node fn = si.sym_info as function_node;
compiled_constructor_node pconstr = fn as compiled_constructor_node;
common_method_node mconstr = fn as common_method_node;
//Если это конструктор...
if (pconstr != null ||
mconstr != null && mconstr.is_constructor)
{
//Генерируем унаследованный конструктор
location loc = null;
SemanticTree.polymorphic_state ps;
if (mconstr != null)
{
loc = mconstr.loc;
ps = mconstr.polymorphic_state;
}
else //значит (pconstr != null)
{
ps = pconstr.polymorphic_state;
}
if (pconstr != null)
context.set_field_access_level(pconstr.field_access_level);
else
context.set_field_access_level(mconstr.field_access_level);
common_method_node gen_constr = context.create_function(compiler_string_consts.default_constructor_name, loc) as common_method_node;
gen_constr.polymorphic_state = ps;
gen_constr.is_overload = true;
gen_constr.is_constructor = true;
gen_constr.field_access_level = fn.field_access_level;
gen_constr.return_value_type = _ctn;
foreach (parameter par in fn.parameters)
{
//(ssyy) Интересно, зачем это.
concrete_parameter_type cpt =
(par.parameter_type == SemanticTree.parameter_type.var) ?
concrete_parameter_type.cpt_var :
concrete_parameter_type.cpt_none;
common_parameter c_p = new common_parameter(par.name,
par.parameter_type, gen_constr, cpt, null);
c_p.type = par.type;
c_p.set_param_is_params(par.is_params);
c_p.inital_value = par.inital_value;
gen_constr.parameters.AddElement(c_p);
c_p.default_value = par.default_value;
}
base_function_call bfc;
if (mconstr != null)
{
common_constructor_call c1 = new common_constructor_call(mconstr, null);
c1._new_obj_awaited = false;
bfc = c1;
}
else
{
compiled_constructor_call c2 = new compiled_constructor_call(pconstr, null);
c2._new_obj_awaited = false;
bfc = c2;
}
foreach (parameter p in gen_constr.parameters)
{
bfc.parameters.AddElement(
create_variable_reference(p, null));
}
statements_list snlist = new statements_list(null);
snlist.statements.AddElement(bfc);
snlist.statements.AddElement(new empty_statement(null));
gen_constr.function_code = snlist;
context.leave_block();
if (fn.parameters.Count == 0 || fn.parameters[0].default_value != null)
{
_ctn.has_default_constructor = true;
}
}
si = si.Next;
}
}
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);
}
}
public void lambda_header_visit(SymbolInfo si, SyntaxTree.function_header _function_header, type_node tn1)
{
type_node tn = null;
if (_function_header.return_type == null)
{
if (context.top_function.IsOperator)
AddError(get_location(_function_header), "FUNCTION_NEED_RETURN_TYPE");
}
if (_function_header.return_type != null)
{
check_parameter_on_complex_type(_function_header.return_type);
if (tn1 != null)
tn = tn1;
else
tn = convert_strong(_function_header.return_type);
//if (tn == SystemLibrary.SystemLibrary.void_type)
// AddError(new VoidNotValid(get_location(_function_header.return_type)));
check_for_type_allowed(tn, get_location(_function_header.return_type));
}
//(ssyy) moved up, так как при проверке аттрибута override надо знать тип возвращаемого значения
context.top_function.return_value_type = tn;
assign_doc_info(context.top_function, _function_header);
if (_function_header.attributes != null)
{
make_attributes_for_declaration(_function_header, context.top_function);
}
if (context.converted_type != null && has_dll_import_attribute(context.top_function))
AddError(get_dll_import_attribute(context.top_function).location, "DLLIMPORT_ATTRIBUTE_CANNOT_BE_APPLIED_TO_METHOD");
if (_function_header.name.class_name != null)
with_class_name = true;
if (_function_header.class_keyword && !has_static_attr(_function_header.proc_attributes.proc_attributes))
{
SyntaxTree.procedure_attribute pa = new SyntaxTree.procedure_attribute(PascalABCCompiler.SyntaxTree.proc_attribute.attr_static);
pa.source_context = _function_header.source_context;
_function_header.proc_attributes.proc_attributes.Add(pa);
}
weak_node_test_and_visit(_function_header.proc_attributes);
if (context.top_function.IsOperator)
{
common_method_node cmmn = context.top_function as common_method_node;
//if (cmmn == null)
//{
// throw new OverloadOperatorMustBeStaticFunction(get_location(_function_header), context.top_function);
//}
if (cmmn != null && cmmn.polymorphic_state != SemanticTree.polymorphic_state.ps_static)
{
AddError(get_location(_function_header), "OVERLOADED_OPERATOR_MUST_BE_STATIC_FUNCTION");
}
if (cmmn != null && (cmmn.name == compiler_string_consts.implicit_operator_name || cmmn.name == compiler_string_consts.explicit_operator_name))
if (!convertion_data_and_alghoritms.eq_type_nodes(tn, cmmn.comperehensive_type as type_node) && !convertion_data_and_alghoritms.eq_type_nodes(cmmn.comperehensive_type as type_node, cmmn.parameters[0].type))
{
AddError(get_location(_function_header.return_type), "RETURN_VALUE_SHOULD_HAVE_TYPE_{0}", (cmmn.comperehensive_type as type_node).PrintableName);
}
else if (convertion_data_and_alghoritms.eq_type_nodes(tn, cmmn.parameters[0].type))
{
AddError(get_location(_function_header), "CIRCURAL_TYPE_CONVERSION_DEFINITION");
}
}
with_class_name = false;
if (context.top_function != null && context.top_function is common_namespace_function_node && (context.top_function as common_namespace_function_node).ConnectedToType != null && !context.top_function.IsOperator)
{
concrete_parameter_type cpt = concrete_parameter_type.cpt_none;
SemanticTree.parameter_type pt = PascalABCCompiler.SemanticTree.parameter_type.value;
if ((context.top_function as common_namespace_function_node).ConnectedToType.is_value_type)
{
cpt = concrete_parameter_type.cpt_var;
pt = PascalABCCompiler.SemanticTree.parameter_type.var;
}
common_parameter cp = new common_parameter(compiler_string_consts.self_word, (context.top_function as common_namespace_function_node).ConnectedToType, pt,
context.top_function, cpt, null, null);
context.top_function.parameters.AddElementFirst(cp);
context.top_function.scope.AddSymbol(compiler_string_consts.self_word, new SymbolInfo(cp));
}
CheckOverrideOrReintroduceExpectedWarning(get_location(_function_header));
bool unique = context.close_function_params(body_exists);
if (context.top_function.return_value_type == null)
AddError(get_location(_function_header), "FUNCTION_NEED_RETURN_TYPE");
if (_function_header.where_defs != null)
{
if (unique)
{
visit_where_list(_function_header.where_defs);
}
else
{
AddError(get_location(_function_header.where_defs), "WHERE_SECTION_MUST_BE_ONLY_IN_FIRST_DECLARATION");
}
}
convertion_data_and_alghoritms.create_function_return_variable(context.top_function, si);
/*if (_function_header.name != null && context.converted_compiled_type != null && context.top_function is common_namespace_function_node)
{
if (context.FindMethodToOverride(context.top_function as common_namespace_function_node) != null)
AddError(new CanNotDeclareExtensionMethodAsOverrided(get_location(_function_header)));
}*/
//TODO: Разобрать подробнее.
if (!body_exists)
{
if ((context.top_function.semantic_node_type == semantic_node_type.common_method_node)
|| ((context.func_stack_size_is_one()) && (_is_interface_part)))
{
context.leave_block();
}
}
body_exists = false;
}
private common_parameter GetParameter()
{
int offset = (int)br.BaseStream.Position - start_pos;
br.ReadByte();
string s = br.ReadString();
type_node tn = GetTypeReference();
concrete_parameter_type cpt = (concrete_parameter_type)br.ReadByte();
SemanticTree.parameter_type pt = SemanticTree.parameter_type.value;
switch (cpt)
{
case concrete_parameter_type.cpt_const: pt = SemanticTree.parameter_type.value; break;
case concrete_parameter_type.cpt_var: pt = SemanticTree.parameter_type.var; break;
case concrete_parameter_type.cpt_none: pt = SemanticTree.parameter_type.value; break;
}
common_parameter p = new common_parameter(s, pt, null, cpt, null);
p.type = tn;
if (br.ReadBoolean()) p.set_used_as_unlocal();
p.intrenal_is_params = br.ReadBoolean();
if (br.ReadByte() == 1)
{
p.default_value = CreateExpressionWithOffset();
}
p.attributes.AddRange(GetAttributes());
//members[offset] = p;
AddMember(p, offset);
return p;
}
private function_node GenerateSetMethod(common_property_node cpn, common_method_node accessor, location loc)
{
common_method_node cmn = new common_method_node(
"set_" + cpn.name, loc, cpn.common_comprehensive_type,
cpn.polymorphic_state, cpn.field_access_level, null);
cpn.common_comprehensive_type.methods.AddElement(cmn);
//cmn.return_value_type = cpn.property_type;
cmn.is_overload = true;
foreach (common_parameter cp in accessor.parameters)
{
common_parameter new_cp = new common_parameter(cp.name, cp.type, cp.parameter_type, cp.common_function, cp.concrete_parameter_type, cp.default_value, loc);
cmn.parameters.AddElement(new_cp);
}
expression_node meth_call;
if (cpn.polymorphic_state == SemanticTree.polymorphic_state.ps_common)
{
meth_call = new common_method_call(accessor, new this_node(cpn.common_comprehensive_type, loc), loc);
foreach (common_parameter cp in cmn.parameters)
{
(meth_call as common_method_call).parameters.AddElement(new common_parameter_reference(cp, 0, loc));
}
}
else
{
meth_call = new common_static_method_call(accessor, loc);
foreach (common_parameter cp in cmn.parameters)
{
(meth_call as common_static_method_call).parameters.AddElement(new common_parameter_reference(cp, 0, loc));
}
}
cmn.function_code = meth_call;
cpn.common_comprehensive_type.scope.AddSymbol("set_" + cpn.name, new SymbolInfo(cmn));
return cmn;
}
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);
}
private function_node GenerateGetSetMethodForInterfaceProperty(common_property_node pn, location loc, bool get_meth)
{
string AcessorName = (get_meth) ?
compiler_string_consts.GetGetAccessorName(pn.name) :
compiler_string_consts.GetSetAccessorName(pn.name);
SymbolInfo exist_si = context.find_only_in_namespace(AcessorName);
if (exist_si != null && exist_si.sym_info.general_node_type != general_node_type.function_node)
{
AddError(loc, "CAN_NOT_GENERATE_ACCESSOR_{0}", AcessorName);
}
common_method_node cmn = new common_method_node(
AcessorName, loc, pn.common_comprehensive_type,
pn.polymorphic_state, context.get_field_access_level(), null);
cmn.is_overload = true;
foreach (common_parameter cp in pn.parameters)
{
common_parameter accp = new common_parameter(cp.name, cp.parameter_type, cmn, cp.concrete_parameter_type, cp.loc);
accp.type = cp.type;
accp.inital_value = cp.inital_value;
accp.intrenal_is_params = cp.intrenal_is_params;
accp.is_ret_value = cp.is_ret_value;
cmn.parameters.AddElement(accp);
}
if (get_meth)
{
cmn.return_value_type = pn.internal_property_type;
}
else
{
//foreach (common_parameter par in cmn.parameters)
//{
// if (par.name ==
//}
common_parameter accp = new common_parameter(compiler_string_consts.value_in_accessor_name,
SemanticTree.parameter_type.value, cmn, concrete_parameter_type.cpt_none, null);
accp.type = pn.internal_property_type;
cmn.parameters.AddElement(accp);
}
while (exist_si != null)
{
if (convertion_data_and_alghoritms.function_eq_params(cmn, (function_node)(exist_si.sym_info)))
{
AddError(loc, "CAN_NOT_GENERATE_ACCESSOR_{0}", cmn.name);
}
exist_si = exist_si.Next;
}
pn.common_comprehensive_type.methods.AddElement(cmn);
pn.common_comprehensive_type.scope.AddSymbol(AcessorName, new SymbolInfo(cmn));
return cmn;
}
public common_parameter add_parameter(string name,SemanticTree.parameter_type pt,
concrete_parameter_type cpt,location loc)
{
check_name_free(name,loc);
#if (DEBUG)
if (converting_block()!=block_type.function_block)
{
throw new CompilerInternalError("Parameters can be defined with functions only");
}
#endif
common_function_node top_func = _func_stack.top();
common_parameter cp=new common_parameter(name,pt,top_func,cpt,loc);
top_func.parameters.AddElement(cp);
top_func.scope.AddSymbol(name,new SymbolInfo(cp));
var_defs.Add(cp);
return cp;
}
//сохранение параметра
private void VisitParameter(common_parameter p)
{
SavePosition(p);
bw.Write((byte)p.semantic_node_type);
bw.Write(p.name);
WriteTypeReference(p.type);
bw.Write((byte)p.concrete_parameter_type);
bw.Write(p.is_used_as_unlocal);
bw.Write(p.is_params);
if (CanWriteObject(p.default_value))
{
SaveExpressionAndOffset(p.default_value);
bw.Write(0);
//VisitExpression((expression_node)var.inital_value);
}
SaveOffsetForAttribute(p);
bw.Write(0);//attributes;
}
public void make_constructor()
{
#if (DEBUG)
if (converting_block()!=block_type.function_block)
{
throw new CompilerInternalError("Create constructor call without function");
}
if (_func_stack.top().node_location_kind!=SemanticTree.node_location_kind.in_class_location)
{
throw new CompilerInternalError("Create constructor applied to non class method");
}
#endif
common_function_node top_func=_func_stack.top();
top_func.return_value_type=_ctn;
common_method_node top_method=(common_method_node)top_func;
common_method_node cmn=new common_method_node(top_func.name,_ctn,top_method.loc,_ctn,
SemanticTree.polymorphic_state.ps_static,_fal,top_func.scope);
cmn.is_constructor=true;
cmn.is_overload=top_function.is_overload;
//parameter_list pl = new parameter_list();
foreach (common_parameter pr in top_method.parameters)
{
common_parameter new_par = new common_parameter(pr.name, pr.type, pr.parameter_type, cmn, pr.concrete_parameter_type,
pr.default_value, pr.loc);
cmn.parameters.AddElement(new_par);
}
//cmn.parameters.AddRange(top_method.parameters);
statements_list stl=new statements_list(top_func.loc);
cmn.function_code=stl;
this_node thn=new this_node(_ctn,top_func.loc);
common_method_call csmc=new common_method_call(top_method,thn,top_func.loc);
foreach(common_parameter cp in cmn.parameters)
{
common_parameter_reference cpr=new common_parameter_reference(cp,0,top_func.loc);
csmc.parametres.AddElement(cpr);
}
stl.statements.AddElement(csmc);
_ctn.methods.AddElement(cmn);
top_method.pascal_associated_constructor=cmn;
}
public ParamInfo GetParameter(common_parameter vdn)
{
return (ParamInfo)ht[vdn];
}
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);
}
