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