public bounded_array_interface(ordinal_type_interface oti, type_node element_type,
common_property_node index_property, type_node index_type, class_field int_array)
{
_oti = oti;
_element_type = element_type;
_index_property = index_property;
_index_type = index_type;
_int_array = int_array;
}
private void VisitPropertyDefinition(common_property_node prop, int offset)
{
if (members.ContainsKey(prop)) return;
SavePositionAndConstPool(prop);
bw.Write((byte)prop.semantic_node_type);
bw.Write(GetNameIndex(prop));
WriteTypeReference(prop.property_type);
if (prop.get_function != null)
{
bw.Write((byte)1);
bw.Write(GetMemberOffset(prop.get_function));
}
else bw.Write((byte)0);
if (prop.set_function != null)
{
bw.Write((byte)1);
bw.Write(GetMemberOffset(prop.set_function));
}
else bw.Write((byte)0);
bw.Write(prop.parameters.Count);
foreach (common_parameter p in prop.parameters)
VisitParameter(p);
bw.Write(offset);
bw.Write((byte)prop.field_access_level);
bw.Write((byte)prop.polymorphic_state);
SaveOffsetForAttribute(prop);
bw.Write(0);//attributes;
WriteDebugInfo(prop.loc);
}
private void WritePropertyReference(common_property_node prop)
{
//ssyy
generic_instance_type_node gitn = prop.common_comprehensive_type as generic_instance_type_node;
if (gitn != null)
{
bw.Write(PCUConsts.generic_prop);
WriteGenericTypeInstance(gitn);
if (gitn is compiled_generic_instance_type_node)
{
WriteCompiledProperty(
gitn.get_member_definition(prop) as compiled_property_node
);
}
else
{
WritePropertyReference(gitn.get_member_definition(prop) as common_property_node);
}
return;
}
common_type_node ctnode = prop.common_comprehensive_type as common_type_node;
if (ctnode != null && ctnode.original_template != null)
{
bw.Write(PCUConsts.template_prop); //т.е. пишем на место is_def
WriteTemplateInstance(ctnode);
bw.Write(ctnode.properties.IndexOf(prop));
return;
}
//\ssyy
byte is_def = 0;
int offset = GetPropertyReference(prop, ref is_def);
bw.Write(is_def);
bw.Write(offset);
}
private int GetPropertyReference(common_property_node prop, ref byte is_def)
{
int off = 0;
if (members.TryGetValue(prop, out off)) //если этот тип описан в этом модуле
{
is_def = 1;
return off;//возвращаем его смещение
}
is_def = 0;
ImportedEntity ie = null;
if (ext_members.TryGetValue(prop, out ie))
{
return ie.index * ie.GetSize();
}
ie = new ImportedEntity();
ie.flag = ImportKind.Common;
ie.num_unit = GetExtTypeReference(prop.common_comprehensive_type);
ie.offset = GetExternalOffset(prop);
int offset = imp_entitles.Count * ie.GetSize();
ie.index = imp_entitles.Count;
imp_entitles.Add(ie);
ext_members[prop] = ie;
return offset;
}
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;
}
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 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;
}
public common_property_node add_property(string property_name,location loc)
{
if (_ctn==null)
{
throw new CompilerInternalError("Property without class");
}
check_name_free(property_name,loc);
common_property_node pn = new common_property_node(property_name, _ctn, loc, _fal,
SemanticTree.polymorphic_state.ps_common);
_ctn.Scope.AddSymbol(property_name,new SymbolInfo(pn));
_ctn.properties.AddElement(pn);
return pn;
}
private definition_node CreateInterfaceProperty(string name, int offset)
{
definition_node dn = null;
if (members.TryGetValue(offset, out dn))
return dn as common_property_node;
common_property_node prop = null;
int name_ref = br.ReadInt32();
type_node type = GetTypeReference();
common_method_node get_meth = null;
if (br.ReadByte() == 1) get_meth = GetClassMethod(br.ReadInt32());
common_method_node set_meth = null;
if (br.ReadByte() == 1) set_meth = GetClassMethod(br.ReadInt32());
int num = br.ReadInt32();
parameter_list pl = new parameter_list();
for (int i = 0; i < num; i++)
pl.AddElement(GetParameter());
common_type_node cont = (common_type_node)GetTypeReference(br.ReadInt32());
SemanticTree.field_access_level fal = (SemanticTree.field_access_level)br.ReadByte();
SemanticTree.polymorphic_state ps = (SemanticTree.polymorphic_state)br.ReadByte();
attributes_list attrs = GetAttributes();
location loc = ReadDebugInfo();
if (name==null)
name = GetStringInClass(cont, name_ref);
prop = new common_property_node(name, cont, type, get_meth, set_meth, loc, fal, ps);
prop.attributes.AddRange(attrs);
prop.parameters.AddRange(pl);
cont.properties.AddElement(prop);
//members[offset] = prop;
AddMember(prop, offset);
return prop;
}
protected common_property_node make_property(property_node orig_pn, location loc)
{
AddPropertyAccessors(orig_pn);
common_property_node cpn = new common_property_node(
orig_pn.name, this, generic_convertions.determine_type(
orig_pn.property_type, _instance_params, false),
(orig_pn.get_function == null) ? null : _members[orig_pn.get_function] as common_method_node,
(orig_pn.set_function == null) ? null : _members[orig_pn.set_function] as common_method_node,
loc, orig_pn.field_access_level, orig_pn.polymorphic_state);
cpn.parameters.AddRange(make_parameters(orig_pn.parameters, null));
return cpn;
}
private void SaveProperty(common_property_node cfn)
{
if (!string.IsNullOrEmpty(cfn.documentation))
{
if (!cfn.documentation.Trim(' ','\t').StartsWith("<summary>"))
{
xtw.WriteStartElement("member");
xtw.WriteStartAttribute("name");
if (is_assembly)
xtw.WriteString("P:"+get_name(cfn.comprehensive_type)+"."+cfn.name);
else
xtw.WriteString("P:"+cfn.comprehensive_type.name+"."+cfn.name);
xtw.WriteEndAttribute();
xtw.WriteStartElement("summary");
xtw.WriteString(cfn.documentation);
xtw.WriteEndElement();
xtw.WriteEndElement();
}
else
{
string doc = string.Concat("<member name=\""+(is_assembly?("P:"+get_name(cfn.comprehensive_type)+"."+cfn.name):("P:"+cfn.comprehensive_type.name+"."+cfn.name))+"\">",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 SymbolInfo(common_property_node value)
{
//_name_information_type=name_information_type.nit_common_property;
_sym_info=value;
_access_level=get_class_member_access_level(value);
_symbol_kind=symbol_kind.sk_none;
}
public PropertyAndWriteAccessorParamsCountConvergence(function_node accessor, common_property_node prop, location loc)
{
_accessor = accessor;
_prop = prop;
_loc = loc;
}
public override void visit(ident id)
{
var idName = id.name.ToLower();
var si = _visitor.context.find(idName);
if (si == null)
{
if (InLambdaContext)
{
_visitor.AddError(new ThisTypeOfVariablesCannotBeCaptured(_visitor.get_location(id)));
return;
}
return;
}
if (si.sym_info.semantic_node_type == semantic_node_type.namespace_variable ||
si.sym_info.semantic_node_type == semantic_node_type.common_namespace_function_node ||
si.sym_info.semantic_node_type == semantic_node_type.namespace_constant_definition ||
si.sym_info.semantic_node_type == semantic_node_type.compiled_function_node ||
si.sym_info.semantic_node_type == semantic_node_type.compiled_namespace_node ||
si.sym_info.semantic_node_type == semantic_node_type.compiled_variable_definition ||
si.sym_info.semantic_node_type == semantic_node_type.common_type_node ||
si.sym_info.semantic_node_type == semantic_node_type.compiled_type_node ||
si.sym_info.semantic_node_type == semantic_node_type.basic_interface_node ||
si.sym_info.semantic_node_type == semantic_node_type.common_unit_node ||
si.sym_info.semantic_node_type == semantic_node_type.compiled_unit_node ||
si.sym_info.semantic_node_type == semantic_node_type.template_type)
{
return;
}
var acceptableVarType = si.sym_info.semantic_node_type == semantic_node_type.local_variable ||
si.sym_info.semantic_node_type == semantic_node_type.local_block_variable ||
si.sym_info.semantic_node_type == semantic_node_type.common_parameter ||
si.sym_info.semantic_node_type == semantic_node_type.class_field;
if (!(acceptableVarType) && InLambdaContext)
{
_visitor.AddError(new ThisTypeOfVariablesCannotBeCaptured(_visitor.get_location(id)));
return;
}
if (si.sym_info.semantic_node_type == semantic_node_type.class_field && InLambdaContext)
{
var semClassField = (class_field)si.sym_info;
if (semClassField.polymorphic_state != polymorphic_state.ps_common)
{
_visitor.AddError(new ThisTypeOfVariablesCannotBeCaptured(_visitor.get_location(id)));
return;
}
}
if (si.scope == null)
{
return;
}
var scopeIndex = si.scope.ScopeNum;
var selfWordInClass = false;
CapturedVariablesTreeNode scope;
if (_scopesCapturedVarsNodesDictionary.TryGetValue(scopeIndex, out scope))
{
var prScope = scope as CapturedVariablesTreeNodeProcedureScope;
if (prScope != null && acceptableVarType)
{
if (si.sym_info.semantic_node_type == semantic_node_type.local_variable)
{
if (!(idName == compiler_string_consts.self_word && si.scope is SymbolTable.ClassMethodScope && _classScope != null) && InLambdaContext)
{
_visitor.AddError(new ThisTypeOfVariablesCannotBeCaptured(_visitor.get_location(id)));
}
}
if (si.sym_info.semantic_node_type == semantic_node_type.common_parameter && prScope.FunctionNode.parameters.First(v => v.name.ToLower() == idName).parameter_type != parameter_type.value && InLambdaContext)
{
_visitor.AddError(new CannotCaptureNonValueParameters(_visitor.get_location(id)));
}
if (idName == compiler_string_consts.self_word && si.scope is SymbolTable.ClassMethodScope &&
_classScope != null)
{
var selfField = _classScope.VariablesDefinedInScope.Find(var => var.SymbolInfo == si);
if (selfField == null)
{
_classScope.VariablesDefinedInScope.Add(
new CapturedVariablesTreeNode.CapturedSymbolInfo(null, si));
}
selfWordInClass = true;
}
else
{
var field = prScope.VariablesDefinedInScope.Find(var => var.SymbolInfo == si);
if (field == null)
{
prScope.VariablesDefinedInScope.Add(new CapturedVariablesTreeNode.CapturedSymbolInfo(null,
si));
}
}
}
var clScope = scope as CapturedVariablesTreeNodeClassScope;
if (clScope != null && acceptableVarType)
{
var field = clScope.VariablesDefinedInScope.Find(var => var.SymbolInfo == si);
if (field == null)
{
clScope.VariablesDefinedInScope.Add(new CapturedVariablesTreeNode.CapturedSymbolInfo(null, si));
}
if (si.access_level != access_level.al_public)
{
if (!clScope.NonPublicMembersNamesMapping.ContainsKey(idName))
{
var name = LambdaHelper.GetNameForNonPublicMember(idName);
var semClassField = (class_field) si.sym_info;
var pn = new common_property_node(name, _visitor.context._ctn, null, field_access_level.fal_public, semClassField.polymorphic_state);
pn.internal_property_type = _visitor.convert_strong(id).type;
clScope.NonPublicMembersNamesMapping.Add(idName, new Tuple<string, class_field, semantic_node>(name, semClassField, pn));
}
}
}
var idRef = (selfWordInClass ? _classScope : scope)
.VariablesDefinedInScope
.Find(var => var.SymbolInfo == si);
if (idRef == null) //TODO: Осторожнее переделать
{
{
return;
}
}
if (_currentTreeNode.CorrespondingSyntaxTreeNode != null)
{
var varName = ((IVAriableDefinitionNode)idRef.SymbolInfo.sym_info).name; //TODO: случай параметров и полей класса!!!!!!!!!!!!!!!!!!
var substKey = new SubstitutionKey(varName, idRef.SyntaxTreeNodeWithVarDeclaration, _currentTreeNode.CorrespondingSyntaxTreeNode);
if (!_identsReferences.ContainsKey(substKey))
{
_identsReferences.Add(substKey, new List<ident>());
}
_identsReferences[substKey].Add(id);
}
if (InLambdaContext && scope is CapturedVariablesTreeNodeLambdaScope &&
scopeIndex < _currentLambdaScopeNodeStack.Peek().ScopeIndex) //TODO: Захват параметров лямбды в другой лямбде
{
_visitor.AddError(new ThisTypeOfVariablesCannotBeCaptured(_visitor.get_location(id)));
return;
}
if (!InLambdaContext ||
scopeIndex >= _currentLambdaScopeNodeStack.Peek().ScopeIndex)
{
return;
}
var stackAsList = _currentLambdaScopeNodeStack.ToList();
stackAsList.RemoveAt(0);
if (!_currentLambdaScopeNodeStack.Peek().CapturedVarsSymbolInfo.Contains(si))
{
_currentLambdaScopeNodeStack.Peek().CapturedVarsSymbolInfo.Add(si);
foreach (var capturedVariablesTreeNodeLambdaScope in stackAsList)
{
if (!capturedVariablesTreeNodeLambdaScope.CapturedVarsSymbolInfo.Contains(si))
{
capturedVariablesTreeNodeLambdaScope.CapturedVarsSymbolInfo.Add(si);
}
}
}
if (!idRef.ReferencingLambdas.Contains(_currentLambdaScopeNodeStack.Peek()))
{
idRef.ReferencingLambdas.Add(_currentLambdaScopeNodeStack.Peek());
foreach (var capturedVariablesTreeNodeLambdaScope in stackAsList)
{
if (!idRef.ReferencingLambdas.Contains(capturedVariablesTreeNodeLambdaScope))
{
idRef.ReferencingLambdas.Add(capturedVariablesTreeNodeLambdaScope);
}
}
}
}
}
public bounded_array_interface(ordinal_type_interface oti, type_node element_type,
common_property_node index_property, type_node index_type, class_field int_array)
{
_oti = oti;
_element_type = element_type;
_index_property = index_property;
_index_type = index_type;
_int_array = int_array;
}
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;
}
