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;
}
private common_method_call create_common_method_call(common_method_node cmn,location loc,expression_node obj,
params expression_node[] exprs)
{
#if (DEBUG)
if (cmn.polymorphic_state==SemanticTree.polymorphic_state.ps_static)
{
throw new CompilerInternalError("Static method can not be called with type");
}
#endif
common_method_call cmc=new common_method_call(cmn,obj,loc);
cmc.virtual_call = !syntax_tree_visitor.inherited_ident_processing;
cmc.parameters.AddRange(exprs);
return cmc;
}
private void AddTypeCheckToStaticConstructor(common_type_node generic_def)
{
statements_list stl = new statements_list(null);
GenericParameterAbilities gpa;
foreach (common_type_node param in generic_def.generic_params)
{
if (syntax_tree_visitor.generic_param_abilities.TryGetValue(param, out gpa))
{
if (gpa.useful_for_pointers)
{
stl.statements.AddElement(CreateTypeCheckCall(SystemLibrary.SystemLibInitializer.CheckCanUsePointerOnTypeProcedure.sym_info, param));
}
if (gpa.useful_for_binary_files)
{
stl.statements.AddElement(CreateTypeCheckCall(SystemLibrary.SystemLibInitializer.CheckCanUseTypeForBinaryFilesProcedure.sym_info, param));
}
if (gpa.useful_for_typed_files)
{
stl.statements.AddElement(CreateTypeCheckCall(SystemLibrary.SystemLibInitializer.CheckCanUseTypeForTypedFilesProcedure.sym_info, param));
}
}
if (SemanticRules.RuntimeInitVariablesOfGenericParameters)
{
basic_function_call bfc = new basic_function_call(
SystemLibrary.SystemLibrary.byte_assign as basic_function_node, null);
bfc.parameters.AddElement(new static_class_field_reference(param.runtime_initialization_marker, null));
base_function_call dcall = null;
if (SystemLibrary.SystemLibInitializer.RuntimeDetermineTypeFunction.sym_info is common_namespace_function_node)
dcall = new common_namespace_function_call(
SystemLibrary.SystemLibInitializer.RuntimeDetermineTypeFunction.sym_info as common_namespace_function_node, null);
else
dcall = new compiled_static_method_call(
SystemLibrary.SystemLibInitializer.RuntimeDetermineTypeFunction.sym_info as compiled_function_node, null);
dcall.parameters.AddElement(new typeof_operator(param, null));
bfc.parameters.AddElement(dcall);
stl.statements.AddElement(bfc);
}
}
if (stl.statements.Count == 0) return;
string stat_ctor_name = compiler_string_consts.static_ctor_prefix + compiler_string_consts.default_constructor_name;
SymbolInfo si = generic_def.scope.FindOnlyInScope(stat_ctor_name);
common_method_node stat_ctor;
if (si == null)
{
stat_ctor = new common_method_node(stat_ctor_name, null, null, generic_def,
SemanticTree.polymorphic_state.ps_static, SemanticTree.field_access_level.fal_public, null);
stat_ctor.is_constructor = true;
generic_def.add_name(stat_ctor_name, new SymbolInfo(stat_ctor));
generic_def.methods.AddElement(stat_ctor);
}
else
{
stat_ctor = si.sym_info as common_method_node;
}
if (stat_ctor.function_code != null)
{
stl.statements.AddElement(stat_ctor.function_code);
}
else
{
stl.statements.AddElement(new return_node(null, null));
}
stat_ctor.function_code = stl;
}
private common_static_method_call create_common_static_method_call(common_method_node cmn,SemanticTree.ILocation loc,
params expression_node[] exprs)
{
#if (DEBUG)
if (cmn.polymorphic_state!=SemanticTree.polymorphic_state.ps_static)
{
throw new CompilerInternalError("Not static method can not be called as static");
}
#endif
common_static_method_call csmc=new common_static_method_call(cmn,loc_to_loc(loc));
csmc.parameters.AddRange(exprs);
return csmc;
}
//ssyy
public void set_virtual_abstract(common_method_node cmn)
{
cmn.overrided_method = null;
cmn.newslot_awaited = true;
cmn.polymorphic_state = SemanticTree.polymorphic_state.ps_virtual_abstract;
}
//сохранение реализации метода
private void VisitMethodImplementation(common_method_node meth)
{
foreach (common_in_function_function_node nested in meth.functions_nodes_list)
VisitNestedFunctionImplementation(nested);
//(ssyy) метки
VisitLabelDeclarations(meth.label_nodes_list);
FixupCode(meth);
//if (meth.function_code == null)
//{
// bw.Write((byte)0);
//}
//else
//{
// bw.Write((byte)1);
if (meth.function_code == null)
{
VisitStatement(new empty_statement(null));
}
else
{
VisitStatement(meth.function_code);
}
//}
}
public common_function_node create_function(string name,location def_loc)
{
check_function_name(name,def_loc);
common_function_node cfn=null;
switch (converting_block())
{
case block_type.function_block:
{
common_function_node top_func = _func_stack.top();
SymbolTable.Scope scope = convertion_data_and_alghoritms.symbol_table.CreateScope(top_func.scope);
common_in_function_function_node ciffn;
ciffn=new common_in_function_function_node(name,def_loc,top_func,scope);
top_func.functions_nodes_list.AddElement(ciffn);
_last_created_function=new SymbolInfo(ciffn);
top_func.scope.AddSymbol(name,_last_created_function);
cfn=ciffn;
break;
}
case block_type.type_block:
{
common_method_node cmmn;
SymbolTable.Scope scope = convertion_data_and_alghoritms.symbol_table.CreateClassMethodScope(_cmn.scope, _ctn.Scope);
//TODO:сделать static и virtual.
//TODO: interface and implementation scopes.
cmmn=new common_method_node(name,def_loc,_ctn,SemanticTree.polymorphic_state.ps_common,_fal,scope);
_last_created_function=new SymbolInfo(cmmn);
_ctn.Scope.AddSymbol(name,_last_created_function);
_ctn.methods.AddElement(cmmn);
local_variable lv = new local_variable(compiler_string_consts.self_word, _ctn, cmmn, def_loc);
cmmn.scope.AddSymbol(compiler_string_consts.self_word, new SymbolInfo(lv));
cmmn.self_variable = lv;
cmmn.var_definition_nodes_list.AddElement(lv);
cfn=cmmn;
break;
}
case block_type.namespace_block:
{
common_namespace_function_node cnfnn;
SymbolTable.Scope scope = convertion_data_and_alghoritms.symbol_table.CreateScope(_cmn.scope);
cnfnn=new common_namespace_function_node(name,def_loc,_cmn,scope);
_cmn.functions.AddElement(cnfnn);
_last_created_function=new SymbolInfo(cnfnn);
_cmn.scope.AddSymbol(name,_last_created_function);
cfn=cnfnn;
break;
}
}
_func_stack.push(cfn);
return cfn;
}
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 SaveMethod(common_method_node cfn)
{
if (!string.IsNullOrEmpty(cfn.documentation))
{
if (!cfn.documentation.Trim(' ','\t').StartsWith("<summary>"))
{
xtw.WriteStartElement("member");
xtw.WriteStartAttribute("name");
if (is_assembly)
{
if (!cfn.is_constructor)
xtw.WriteString("M:"+get_name(cfn.cont_type)+"."+cfn.name+GetGenericFlag(cfn)+GetParameters(cfn));
else
xtw.WriteString("M:"+get_name(cfn.cont_type)+".#ctor"+GetGenericFlag(cfn)+GetParameters(cfn));
}
else
{
if (!cfn.is_constructor)
xtw.WriteString("M:"+cfn.cont_type.name+"."+cfn.name+GetGenericFlag(cfn)+GetParameters(cfn));
else
xtw.WriteString("M:"+cfn.cont_type.name+".#ctor"+GetGenericFlag(cfn)+GetParameters(cfn));
}
xtw.WriteEndAttribute();
xtw.WriteStartElement("summary");
xtw.WriteString(cfn.documentation);
xtw.WriteEndElement();
xtw.WriteEndElement();
}
else
{
string descr = null;
if (is_assembly)
{
if (!cfn.is_constructor)
descr = "M:"+get_name(cfn.cont_type)+"."+cfn.name+GetGenericFlag(cfn)+GetParameters(cfn);
else
descr = "M:"+get_name(cfn.cont_type)+".#ctor"+GetGenericFlag(cfn)+GetParameters(cfn);
}
else
{
if (!cfn.is_constructor)
descr = "M:"+cfn.cont_type.name+"."+cfn.name+GetGenericFlag(cfn)+GetParameters(cfn);
else
descr = "M:"+cfn.cont_type.name+".#ctor"+GetGenericFlag(cfn)+GetParameters(cfn);
}
string doc = string.Concat("<member name=\""+descr+"\">",cfn.documentation,"</member>");
StringReader sr = new StringReader(doc);
XmlReader xr = XmlTextReader.Create(sr);
xr.Read();
xtw.WriteNode(xr.ReadSubtree(),false);
sr.Close();
xr.Close();
}
}
}
public void set_add_method(common_method_node meth)
{
_add_method = meth;
}
public NoMethodInClassWithThisParams(common_method_node cmn, common_type_node ctn, location loc)
: base(loc)
{
_cmn = cmn;
_ctn = ctn;
}
public SymbolInfo(common_method_node value)
{
//_name_information_type=name_information_type.nit_common_method;
_sym_info=value;
_access_level=get_class_member_access_level(value);
_symbol_kind=get_function_kind(value);
}
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 void set_override(common_method_node cmn)
{
cmn.polymorphic_state = SemanticTree.polymorphic_state.ps_virtual;
cmn.overrided_method = FindMethodToOverride(cmn);
if (cmn.overrided_method == null)
AddError(cmn.loc, "NO_METHOD_TO_OVERRIDE");
cmn.SetName(cmn.overrided_method.name);
}
public function_node FindMethodToOverride(common_method_node cmn)
{
type_node base_class = cmn.cont_type.base_type;
if (base_class == null)
{
return null;
}
SymbolInfo si = base_class.find_in_type(cmn.name, CurrentScope);
function_node fn = null;
while (si != null)
{
if (si.sym_info.general_node_type != general_node_type.function_node)
{
return null;
}
fn = si.sym_info as function_node;
//(ssyy) Сверяем как параметры функций, так и типы возвращаемых значений
if (convertion_data_and_alghoritms.function_eq_params_and_result(cmn, fn))
{
break;
}
si = si.Next;
}
if (si == null)
{
return null;
}
common_method_node cmn_sec = fn as common_method_node;
if (cmn_sec != null)
{
if (cmn_sec.polymorphic_state != SemanticTree.polymorphic_state.ps_virtual && cmn_sec.polymorphic_state != SemanticTree.polymorphic_state.ps_virtual_abstract)
{
return null;
}
}
else
{
compiled_function_node cfn_sec = fn as compiled_function_node;
if (cfn_sec != null)
{
if (cfn_sec.polymorphic_state != SemanticTree.polymorphic_state.ps_virtual && cfn_sec.polymorphic_state != SemanticTree.polymorphic_state.ps_virtual_abstract && !cfn_sec.IsFinal)
{
return null;
}
}
else
{
throw new CompilerInternalError("Undefined method type.");
}
}
return fn;
}
public void set_virtual(common_method_node cmn)
{
cmn.overrided_method = null;
cmn.polymorphic_state = SemanticTree.polymorphic_state.ps_virtual;
}
public void set_raise_method(common_method_node meth)
{
_raise_method = meth;
}
public void set_override(common_method_node cmn)
{
cmn.polymorphic_state = SemanticTree.polymorphic_state.ps_virtual;
type_node base_class = cmn.cont_type.base_type;
if (base_class == null)
{
throw new NoMethodToOverride(cmn);
}
SymbolInfo si = base_class.find_in_type(cmn.name);
function_node fn = null;
while (si != null)
{
if (si.sym_info.general_node_type != general_node_type.function_node)
{
throw new NoMethodToOverride(cmn);
}
fn = si.sym_info as function_node;
if (convertion_data_and_alghoritms.function_eq_params(cmn, fn))
{
break;
}
si = si.Next;
}
if (si == null)
{
throw new NoMethodToOverride(cmn);
}
common_method_node cmn_sec = fn as common_method_node;
if (cmn_sec != null)
{
if (cmn_sec.polymorphic_state != SemanticTree.polymorphic_state.ps_virtual)
{
throw new NoMethodToOverride(cmn);
}
}
else
{
compiled_function_node cfn_sec = fn as compiled_function_node;
if (cfn_sec != null)
{
if (cfn_sec.polymorphic_state != SemanticTree.polymorphic_state.ps_virtual)
{
throw new NoMethodToOverride(cmn);
}
}
else
{
throw new CompilerInternalError("Undefined method type.");
}
}
cmn.overrided_method = fn;
cmn.SetName(fn.name);
}
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 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;
}
private void WriteMethodReference(common_method_node meth)
{
if (meth.comperehensive_type.is_generic_parameter)
{
bw.Write(PCUConsts.generic_param_ctor);
WriteGenericParameter(meth.comperehensive_type as common_type_node);
return;
}
generic_method_instance_node gmin = meth as generic_method_instance_node;
if (gmin != null)
{
WriteGenericMethodReference(gmin);
return;
}
generic_instance_type_node gitn = meth.comperehensive_type as generic_instance_type_node;
if (gitn != null)
{
if (gitn is common_generic_instance_type_node)
{
bw.Write(PCUConsts.generic_meth);
WriteGenericTypeInstance(gitn);
WriteMethodReference(gitn.get_member_definition(meth) as common_method_node);
return;
}
if (meth.is_constructor)
{
bw.Write(PCUConsts.generic_ctor);
WriteGenericTypeInstance(gitn);
WriteCompiledConstructor(
gitn.get_member_definition(meth) as compiled_constructor_node
);
return;
}
bw.Write(PCUConsts.generic_meth);
WriteGenericTypeInstance(gitn);
WriteCompiledMethod(
gitn.get_member_definition(meth) as compiled_function_node
);
return;
}
common_type_node ctnode = meth.comperehensive_type as common_type_node;
if (ctnode != null && ctnode.original_template != null)
{
bw.Write(PCUConsts.template_meth); //т.е. пишем на место is_def
WriteTemplateInstance(ctnode);
bw.Write(ctnode.methods.IndexOf(meth));
return;
}
//generic_namespace_function_instance_node gnfin = meth as generic_namespace_function_instance_node;
//if (gnfin != null)
//{
// WriteGenericNamespaceFunctionReference(gnfin);
// return;
//}
byte is_def = 0;
int offset = GetMethodReference(meth, ref is_def);
bw.Write(is_def);
bw.Write(offset);
}
internal function_node GenerateGetMethodForField(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)
{
if (((function_node)(exist_si.sym_info)).parameters.Count == 0)
{
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);
cmn.return_value_type = cf.type;
cmn.is_overload = true;
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 = new return_node(var_ref, loc);
cf.cont_type.scope.AddSymbol(AcessorName, new SymbolInfo(cmn));
return cmn;
}
private void add_overloads_for_default_parameter()
{
List<parameter> default_params = new List<parameter>();
foreach (parameter p in top_function.parameters)
{
if (p.default_value != null)
{
default_params.Add(p);
}
}
int num_of_defaults = default_params.Count-1;
if (default_params.Count > 0 && converted_func_stack.size == 1)
while (num_of_defaults >= 0)
{
if (converted_type == null)
{
common_namespace_function_node cnfn = new common_namespace_function_node(top_function.name, top_function.return_value_type, null, converted_namespace, null);
foreach (parameter p in top_function.parameters)
{
if (p.default_value == null)
cnfn.parameters.AddElement(p);
}
for (int i = 0; i < num_of_defaults; i++)
cnfn.parameters.AddElement(default_params[i]);
statements_list sl = new statements_list(null);
common_namespace_function_call cnfc = new common_namespace_function_call(top_function as common_namespace_function_node, null);
foreach (common_parameter p in cnfn.parameters)
{
cnfc.parameters.AddElement(new common_parameter_reference(p, 0, null));
}
for (int i = num_of_defaults; i < default_params.Count; i++)
cnfc.parameters.AddElement(default_params[i].default_value);
if (cnfn.return_value_type != null)
sl.statements.AddElement(new return_node(cnfc, null));
else
sl.statements.AddElement(cnfc);
cnfn.function_code = sl;
converted_namespace.functions.AddElement(cnfn);
}
else
{
common_method_node cmn = top_function as common_method_node;
common_method_node cnfn = new common_method_node(top_function.name, top_function.return_value_type, null, converted_type, top_function.polymorphic_state, top_function.field_access_level, null);
foreach (parameter p in top_function.parameters)
{
if (p.default_value == null)
cnfn.parameters.AddElement(p);
}
for (int i = 0; i < num_of_defaults; i++)
cnfn.parameters.AddElement(default_params[i]);
statements_list sl = new statements_list(null);
common_method_call cnfc = new common_method_call(cmn, (cnfn.polymorphic_state != SemanticTree.polymorphic_state.ps_static) ? new this_node(converted_type, null) : null, null);
foreach (common_parameter p in cnfn.parameters)
{
cnfc.parameters.AddElement(new common_parameter_reference(p, 0, null));
}
for (int i = num_of_defaults; i < default_params.Count; i++)
cnfc.parameters.AddElement(default_params[i].default_value);
if (cnfn.return_value_type != null)
sl.statements.AddElement(new return_node(cnfc, null));
else
sl.statements.AddElement(cnfc);
cnfn.function_code = sl;
cnfn.is_constructor = cmn.is_constructor;
converted_type.methods.AddElement(cnfn);
}
num_of_defaults--;
}
}
private int GetMethodReference(common_method_node meth, ref byte is_def)
{
int off = 0;
if (members.TryGetValue(meth, out off)) //если этот тип описан в этом модуле
{
is_def = 1;
return off;//возвращаем его смещение
}
is_def = 0;
ImportedEntity ie = null;
if (ext_members.TryGetValue(meth, out ie))
{
return ie.index * ie.GetSize();
}
ie = new ImportedEntity();
ie.flag = ImportKind.Common;
ie.num_unit = GetExtTypeReference(meth.cont_type);
ie.offset = GetExternalOffset(meth);
int offset = imp_entitles.Count*ie.GetSize();
ie.index = imp_entitles.Count;
imp_entitles.Add(ie);
ext_members[meth] = ie;
return offset;
}
//(ssyy) Создаёт метод псевдо-инстанции generic-типа.
protected common_method_node make_method(function_node orig_fn, location loc)
{
if (orig_fn == null)
{
return null;
}
List<type_node> meth_inst_pars = null;
SemanticTree.IClassMemberNode orig_member = orig_fn as SemanticTree.IClassMemberNode;
common_method_node cmn = new common_method_node(
orig_fn.name,
//generic_convertions.determine_type(orig_fn.return_value_type, _instance_params, false),
null,
loc, this, orig_member.polymorphic_state, orig_member.field_access_level,
null);
if (orig_fn.is_generic_function)
{
List<type_node> orig_tpars = orig_fn.get_generic_params_list();
int type_count = orig_tpars.Count;
cmn.generic_params = new List<PascalABCCompiler.SemanticTree.ICommonTypeNode>(orig_tpars.Count);
foreach (type_node t in orig_tpars)
{
common_type_node par = new common_type_node(t.name, PascalABCCompiler.SemanticTree.type_access_level.tal_public,
null, SystemLibrary.SystemLibrary.syn_visitor.convertion_data_and_alghoritms.symbol_table.CreateInterfaceScope(null, SystemLibrary.SystemLibrary.object_type.Scope, null), null);
SystemLibrary.SystemLibrary.init_reference_type(par);
par.SetBaseType(SystemLibrary.SystemLibrary.object_type);
cmn.generic_params.Add(par);
par.generic_function_container = cmn;
}
meth_inst_pars = cmn.get_generic_params_list();
List<generic_parameter_eliminations> gpes = orig_fn.parameters_eliminations;
for (int i = 0; i < type_count; ++i)
{
common_type_node p = (common_type_node)(meth_inst_pars[i]);
generic_parameter_eliminations gpe = gpes[i];
p.SetBaseType(generic_convertions.determine_type(
generic_convertions.determine_type(gpe.base_class, _instance_params, false),
meth_inst_pars, true));
p.is_class = gpe.is_class;
p.internal_is_value = gpe.is_value;
foreach (type_node interf in gpe.implementing_interfaces)
{
type_table.AddInterface(p, generic_convertions.determine_type(
generic_convertions.determine_type(interf, _instance_params, false),
meth_inst_pars, true), null);
}
if (gpe.has_default_ctor)
{
generic_parameter_eliminations.add_default_ctor(p);
}
}
}
cmn.parameters.AddRange(make_parameters(orig_fn.parameters, cmn));
if (orig_fn.is_generic_function)
{
foreach (common_parameter cp in cmn.parameters)
{
cp.type = generic_convertions.determine_type(cp.type, meth_inst_pars, true);
}
}
common_method_node common_orig = orig_fn as common_method_node;
if (common_orig != null)
{
cmn.num_of_default_variables = common_orig.num_of_default_variables;
}
compiled_constructor_node compiled_orig = orig_fn as compiled_constructor_node;
cmn.is_constructor = (compiled_orig != null ||
(common_orig != null && common_orig.is_constructor));
cmn.return_value_type = generic_convertions.determine_type(orig_fn.return_value_type, _instance_params, false);
if (orig_fn.is_generic_function)
{
cmn.return_value_type = generic_convertions.determine_type(cmn.return_value_type, meth_inst_pars, true);
}
return cmn;
}
private void VisitMethodDefinition(common_method_node meth, int offset)
{
//DarkStar это вроде не нужно, он и так сохраняется ???
//Вероятно здесь ошибка!!!
if (IsDefined(meth))
return;
SavePositionAndConstPool(meth);
bw.Write((byte)meth.semantic_node_type);
bw.Write(GetNameIndex(meth));
if (meth.is_final)
{
bw.Write((byte)1);
}
else
{
bw.Write((byte)0);
}
if (meth.newslot_awaited)
{
bw.Write((byte)1);
}
else
{
bw.Write((byte)0);
}
//Является ли метод описанием дженерика
WriteGenericFunctionInformation(meth);
//if (meth.is_generic_function)
//{
// bw.Write((byte)1);
// //Число типов-параметров
// bw.Write(meth.generic_params.Count);
// //Имена параметров
// foreach (common_type_node par in meth.generic_params)
// {
// bw.Write(par.name);
// }
// WriteTypeParamsEliminations(meth.generic_params);
//}
//else
//{
// bw.Write((byte)0);
//}
if (meth.return_value_type == null)
bw.Write((byte)0);
else
{
bw.Write((byte)1);
WriteTypeReference(meth.return_value_type);
if (meth.return_variable != null)
{
bw.Write((byte)1);
VisitLocalVariable(meth.return_variable);
}
else
bw.Write((byte)0);
}
bw.Write(meth.parameters.Count);
foreach (common_parameter p in meth.parameters)
VisitParameter(p);
bw.Write(offset);
SaveOffsetForAttribute(meth);
bw.Write(0);//attributes;
bw.Write(meth.is_constructor);
bw.Write(meth.is_forward);
bw.Write(meth.is_overload);
bw.Write((byte)meth.field_access_level);
bw.Write((byte)meth.polymorphic_state);
bw.Write(meth.num_of_default_variables);
bw.Write(meth.num_of_for_cycles);
bw.Write(meth.overrided_method != null);
//ssyy-
//if (meth.pascal_associated_constructor != null)
//{
// bw.Write((byte)1);
// bw.Write(GetMemberOffset(meth.pascal_associated_constructor));
//}
//else
// bw.Write((byte)0);
//\ssyy
if (meth.return_variable!=null)
bw.Write(meth.var_definition_nodes_list.Count-1);
else
bw.Write(meth.var_definition_nodes_list.Count);
foreach (local_variable var in meth.var_definition_nodes_list)
{
if (var != meth.return_variable)
VisitLocalVariable(var);
}
bw.Write(meth.constants.Count);
foreach (function_constant_definition cnst in meth.constants)
VisitFunctionConstant(cnst);
bw.Write(meth.functions_nodes_list.Count);
foreach (common_in_function_function_node nest_func in meth.functions_nodes_list)
VisitNestedFunctionDefinition(nest_func);
WriteDebugInfo(meth.loc);
SaveCodeReference(meth);
bw.Write(0);//????
}
private common_method_node CreateInterfaceMethod(string name, int offset)
{
definition_node dn = null;
if (members.TryGetValue(offset, out dn))
return dn as common_method_node;
common_method_node cmn = new common_method_node(name,null,null);
//members[offset] = cmn;
AddMember(cmn, offset);
int name_ref = br.ReadInt32();
cmn.is_final = br.ReadByte() == 1;
cmn.newslot_awaited = br.ReadByte() == 1;
ReadGenericFunctionInformation(cmn);
//if (CanReadObject())
//{
// cmn.generic_params = ReadGenericParams(cun.namespaces[0]);
// foreach (common_type_node par in cmn.generic_params)
// {
// par.generic_function_container = cmn;
// ReadTypeParameterEliminations(par);
// }
//}
if (br.ReadByte() == 1) //return_value_type
{
cmn.return_value_type = GetTypeReference();
if (br.ReadByte() == 1)
{
cmn.return_variable = GetLocalVariable(cmn);
cmn.var_definition_nodes_list.AddElement(cmn.return_variable);
}
}
int num_par = br.ReadInt32();
for (int i = 0; i < num_par; i++)
cmn.parameters.AddElement(GetParameter(cmn));
cmn.cont_type = (common_type_node)GetTypeReference(br.ReadInt32());
if (name==null || true)
cmn.SetName(GetStringInClass(cmn.cont_type, name_ref));
cmn.attributes.AddRange(GetAttributes());
cmn.is_constructor = br.ReadBoolean();
cmn.is_forward = br.ReadBoolean();
cmn.is_overload = br.ReadBoolean();
cmn.set_access_level((SemanticTree.field_access_level)br.ReadByte());
cmn.polymorphic_state = (SemanticTree.polymorphic_state)br.ReadByte();
if (cmn.is_constructor && cmn.polymorphic_state == SemanticTree.polymorphic_state.ps_static)
cmn.cont_type.static_constr = cmn;
cmn.num_of_default_variables = br.ReadInt32();
cmn.num_of_for_cycles = br.ReadInt32();
br.ReadBoolean();
int num_var = br.ReadInt32();
for (int i = 0; i < num_var; i++)
{
local_variable lv = GetLocalVariable(cmn);
if (lv != cmn.return_variable)
cmn.var_definition_nodes_list.AddElement(lv);
}
int num_consts = br.ReadInt32();
for (int i = 0; i < num_consts; i++)
{
function_constant_definition fcd = GetFunctionConstant(cmn);
cmn.constants.AddElement(fcd);
}
int num_nest_funcs = br.ReadInt32();
for (int i = 0; i < num_nest_funcs; i++)
cmn.functions_nodes_list.AddElement(GetNestedFunction());
//br.ReadInt32();//code;
cmn.loc = ReadDebugInfo();
cmn.function_code = GetCode(br.ReadInt32());
cmn.cont_type.methods.AddElement(cmn);
return cmn;
}
private void VisitMethod(common_method_node cmn)
{
if (extended_mode)
VisitVariables(cmn.var_definition_nodes_list);
foreach (var_definition_node vdn in cmn.var_definition_nodes_list)
helper.AddVariable(vdn);
foreach (common_parameter prm in cmn.parameters)
helper.AddParameter(prm);
foreach (common_in_function_function_node nested in cmn.functions_nodes_list)
VisitNestedFunction(nested);
cur_func = cmn;
VisitStatement(cmn.function_code);
foreach (var_definition_node vdn2 in cmn.var_definition_nodes_list)
{
if (vdn2 is local_variable)
{
local_variable vdn = vdn2 as local_variable;
VarInfo vi = helper.GetVariable(vdn);
if (vi.num_use == 0 && !vdn.is_special_name) warns.Add(new UnusedVariable(vdn.name, vdn.loc));
else if (vi.num_ass == 0 && vdn.is_ret_value && !cmn.name.StartsWith("<>") && !cmn.cont_type.IsInterface && cmn.polymorphic_state != SemanticTree.polymorphic_state.ps_virtual_abstract
&& cmn.return_value_type != null && !cmn.return_value_type.IsPointer && !cmn.is_constructor && cmn.return_value_type.type_special_kind != SemanticTree.type_special_kind.record && cmn.return_value_type.type_special_kind != SemanticTree.type_special_kind.array_wrapper
&& !helper.IsExternal(cmn)) warns.Add(new UndefinedReturnValue(cmn.name, cmn.function_code.location));
//if (vi.num_ass > 0 && vi.act_num_use == 0 && !vdn.name.Contains("$")) warns.Add(new AssignWithoutUsing(vdn.name, vi.last_ass_loc));
}
else if (vdn2 is local_block_variable)
{
local_block_variable vdn = vdn2 as local_block_variable;
VarInfo vi = helper.GetVariable(vdn);
if (vi.num_use == 0 && !vdn.is_special_name) warns.Add(new UnusedVariable(vdn.name, vdn.loc));
else if (vi.num_ass == 0 && vdn.is_ret_value && !cmn.name.StartsWith("<>") && !cmn.cont_type.IsInterface && cmn.polymorphic_state != SemanticTree.polymorphic_state.ps_virtual_abstract
&& cmn.return_value_type != null && !cmn.return_value_type.IsPointer && !cmn.is_constructor && cmn.return_value_type.type_special_kind != SemanticTree.type_special_kind.record && cmn.return_value_type.type_special_kind != SemanticTree.type_special_kind.array_wrapper
&& !helper.IsExternal(cmn)) warns.Add(new UndefinedReturnValue(cmn.name, cmn.function_code.location));
}
if (vdn2.inital_value != null) VisitExpression(vdn2.inital_value);
}
foreach (common_parameter prm in cmn.parameters)
{
ParamInfo vi = helper.GetParameter(prm);
if (prm.inital_value != null) VisitExpression(prm.inital_value);
//if (vi.num_use == 0 && !prm.name.Contains("$")) warns.Add(new UnusedParameter(prm.name, prm.loc));
}
foreach (var_definition_node vdn in cmn.var_definition_nodes_list)
{
VarInfo vi = helper.GetVariable(vdn);
if (vdn.inital_value != null) VisitExpression(vdn.inital_value);
}
}
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;
}
