private void VisitNonStaticPropertyReference(non_static_property_reference en)
{
VisitExpression(en.expression);
for (int i = 0; i < en.fact_parametres.Count; i++)
VisitExpression(en.fact_parametres[i]);
}
private addressed_expression address_expression_reciving(SyntaxTree.ident id_right, SymbolInfo si,
expression_node en)
{
if (si != null && si.sym_info != null &&
si.sym_info.semantic_node_type == semantic_node_type.indefinite_definition_node)
{
return new indefinite_reference(si.sym_info as indefinite_definition_node, get_location(id_right));
}
definition_node dn = null;
if (!internal_is_assign)
dn = context.check_name_node_type(id_right.name, si, get_location(id_right),
general_node_type.variable_node, general_node_type.property_node, general_node_type.event_node);
else
dn = context.check_name_node_type(id_right.name, si, get_location(id_right),
general_node_type.variable_node, general_node_type.property_node, general_node_type.event_node, general_node_type.constant_definition);
if (dn.general_node_type == general_node_type.constant_definition)
{
AddError(get_location(id_right), "CAN_NOT_ASSIGN_TO_CONSTANT_OBJECT");
}
switch (dn.general_node_type)
{
case general_node_type.variable_node:
{
return create_class_field_reference(en, dn, id_right);
}
case general_node_type.property_node:
{
property_node pn = (property_node)dn;
if (pn.polymorphic_state == SemanticTree.polymorphic_state.ps_static)
{
AddError(new CanNotReferenceToStaticPropertyWithExpression(pn, get_location(id_right), pn.comprehensive_type));
}
try_convert_typed_expression_to_function_call(ref en);
non_static_property_reference pr = new non_static_property_reference(pn, en, get_location(id_right));
return pr;
}
case general_node_type.event_node:
{
if (dn.semantic_node_type == semantic_node_type.compiled_event)
{
compiled_event ce = (compiled_event)dn;
if (ce.is_static)
{
//throw new NonStaticAndStaticEvevnt();
}
nonstatic_event_reference ser = new nonstatic_event_reference(en, ce, get_location(id_right));
return ser;
}
else if (dn.semantic_node_type == semantic_node_type.common_event)
{
common_event ce = (common_event)dn;
if (ce.is_static)
{
//throw new NonStaticAndStaticEvevnt();
}
nonstatic_event_reference ser = new nonstatic_event_reference(en, ce, get_location(id_right));
return ser;
}
break;
}
default : return null;
}
throw new CompilerInternalError("Undefined expression to address reciving");
}
private void VisitNonStaticPropertyReference(non_static_property_reference expr)
{
VisitExpression(expr.expression);
WritePropertyReference((common_property_node)expr.property);
bw.Write(expr.fact_parametres.Count);
for (int i = 0; i < expr.fact_parametres.Count; i++)
VisitExpression(expr.fact_parametres[i]);
}
private addressed_expression ident_address_reciving(SymbolInfo si, SyntaxTree.ident _ident)
{
location lloc = get_location(_ident);
definition_node dn = null;
if (!internal_is_assign)
dn = context.check_name_node_type(_ident.name, si, lloc,
general_node_type.variable_node, general_node_type.property_node, general_node_type.event_node);
else
dn = context.check_name_node_type(_ident.name, si, lloc,
general_node_type.variable_node, general_node_type.property_node, general_node_type.event_node, general_node_type.constant_definition);
if (dn.general_node_type == general_node_type.constant_definition)
AddError(get_location(_ident), "CAN_NOT_ASSIGN_TO_CONSTANT_OBJECT");
switch (dn.general_node_type)
{
case general_node_type.variable_node:
{
local_variable lv = dn as local_variable;
if (lv != null && (lv.function is common_method_node))
{
//self variable
if ((lv.function as common_method_node).self_variable == lv)
AddError(lloc, "VARIABLE_{0}_READONLY", lv.name);
}
return create_variable_reference(dn, lloc);
}
case general_node_type.property_node:
{
property_node pn = (property_node)dn;
if (pn.polymorphic_state == SemanticTree.polymorphic_state.ps_static)
{
static_property_reference spr = new static_property_reference(pn, lloc);
return spr;
}
//this_node thisnode=new this_node(context.converted_type,lloc);
if (pn.comprehensive_type.Scope == null && pn is compiled_property_node)
(pn.comprehensive_type as compiled_type_node).init_scope();
non_static_property_reference nspr = new non_static_property_reference(pn, GetCurrentObjectReference(pn.comprehensive_type.Scope, pn, lloc), lloc);
return nspr;
}
case general_node_type.event_node:
{
if (dn.semantic_node_type == semantic_node_type.compiled_event)
{
compiled_event ce = (compiled_event)dn;
if (ce.is_static)
{
static_event_reference ser = new static_event_reference(ce, get_location(_ident));
return ser;
}
nonstatic_event_reference nser = new nonstatic_event_reference(
GetCurrentObjectReference(ce.comprehensive_type.Scope, ce, lloc), ce, lloc);
return nser;
}
else if (dn.semantic_node_type == semantic_node_type.common_event)
{
common_event ce = (common_event)dn;
if (ce.is_static)
{
static_event_reference ser = new static_event_reference(ce, get_location(_ident));
return ser;
}
nonstatic_event_reference nser = new nonstatic_event_reference(
GetCurrentObjectReference(ce.comprehensive_type.Scope, ce, lloc), ce, lloc);
return nser;
}
else if (dn.semantic_node_type == semantic_node_type.common_namespace_event)
{
common_namespace_event cne = (common_namespace_event)dn;
static_event_reference ser = new static_event_reference(cne, get_location(_ident));
return ser;
}
break;
}
}
return null;
}
private void check_property_params(non_static_property_reference pr, location loc)
{
if (pr.property.parameters.Count != pr.fact_parametres.Count)
{
AddError(loc, "PROPERTY_{0}_REFERENCE_WITH_INVALID_PARAMS_COUNT", pr.property.name);
}
}
public override void visit(SyntaxTree.indexer _indexer)
{
//SSM 11/02/16 - нет, это глупость
/*if (_indexer.dereferencing_value is SyntaxTree.question_colon_expression) // то разбросать индекс по компонентам
{
var q = _indexer.dereferencing_value as SyntaxTree.question_colon_expression;
var nodeToVisit = new SyntaxTree.question_colon_expression(q.condition, new indexer(q.ret_if_true as addressed_value, _indexer.indexes, _indexer.source_context),
new indexer(q.ret_if_false as addressed_value, _indexer.indexes, _indexer.source_context), _indexer.source_context);
visit(nodeToVisit);
return;
}*/
//end SSM 11/02/16
//lroman
if (_indexer.dereferencing_value is closure_substituting_node)
{
var nodeToVisit = new indexer(((closure_substituting_node) _indexer.dereferencing_value).substitution,
_indexer.indexes);
visit(nodeToVisit);
return;
}
motivation mot = motivation_keeper.motivation;
SyntaxTree.ident idi = _indexer.dereferencing_value as SyntaxTree.ident;
if (idi != null)
{
SymbolInfo si = context.find(idi.name);
if (si == null)
{
AddError(new UndefinedNameReference(idi.name, get_location(idi)));
}
if (si.sym_info.general_node_type == general_node_type.type_node)
{
indexer_as_type_indexes((type_node)si.sym_info, _indexer.indexes, mot, get_location(idi));
return;
}
if (si.sym_info.general_node_type == general_node_type.property_node)
{
property_node pn = (property_node)si.sym_info;
if (pn.polymorphic_state == SemanticTree.polymorphic_state.ps_static)
{
static_property_reference spr = new static_property_reference(pn, get_location(idi));
indexer_as_property_indexes(spr, _indexer.indexes, mot, get_location(idi));
return;
}
else
{
this_node thisnode = new this_node(pn.comprehensive_type, get_location(_indexer));
location loc111 = get_location(idi);
non_static_property_reference nspr = new non_static_property_reference(pn, thisnode, loc111);
indexer_as_property_indexes(nspr, _indexer.indexes, mot, loc111);
return;
}
}
expression_node en = ident_value_reciving(si, idi);
indexer_as_expression_index(en, _indexer.indexes, mot, get_location(idi));
return;
}
else
{
SyntaxTree.dot_node dotnd = _indexer.dereferencing_value as SyntaxTree.dot_node;
if (dotnd != null)
{
SyntaxTree.ident id = dotnd.right as SyntaxTree.ident;
semantic_node sn = convert_semantic_strong(dotnd.left);
switch (sn.general_node_type)
{
case general_node_type.type_node:
{
type_node ttp = (type_node)sn;
SymbolInfo si = ttp.find_in_type(id.name, context.CurrentScope);
if (si == null)
{
AddError(new UndefinedNameReference(id.name, get_location(id)));
}
if (si.sym_info.general_node_type == general_node_type.property_node)
{
property_node pn = (property_node)si.sym_info;
static_property_reference spr = new static_property_reference(pn, get_location(id));
indexer_as_property_indexes(spr, _indexer.indexes, mot, get_location(dotnd));
return;
}
expression_node exp1 = create_static_expression(ttp, id, si);
indexer_as_expression_index(exp1, _indexer.indexes, mot, get_location(id));
return;
}
case general_node_type.namespace_node:
case general_node_type.unit_node:
{
SymbolInfo si = null;
if (sn is namespace_node)
si = ((namespace_node)sn).find(id.name);
else
si = ((unit_node)sn).find_only_in_namespace(id.name);
if (si == null)
{
AddError(new UndefinedNameReference(id.name, get_location(id)));
}
location lloc = get_location(id);
if (si.sym_info.general_node_type == general_node_type.type_node)
{
type_node tn = (type_node)si.sym_info;
indexer_as_type_indexes(tn, _indexer.indexes, mot, lloc);
return;
}
expression_node exp2 = ident_value_reciving(si, id);
indexer_as_expression_index(exp2, _indexer.indexes, mot, get_location(id));
return;
}
case general_node_type.expression:
{
expression_node ex = (expression_node)sn;
SymbolInfo si = ex.type.find_in_type(id.name, context.CurrentScope);
if (si == null)
{
AddError(new UndefinedNameReference(id.name, get_location(id)));
}
if (si.sym_info.general_node_type == general_node_type.property_node)
{
property_node pn = (property_node)si.sym_info;
if (pn.polymorphic_state == SemanticTree.polymorphic_state.ps_static)
{
AddError(new CanNotReferenceToStaticPropertyWithExpression(pn, get_location(dotnd), ex.type));
}
location lloc11 = get_location(dotnd);
try_convert_typed_expression_to_function_call(ref ex);
non_static_property_reference nspr = new non_static_property_reference(pn, ex, lloc11);
indexer_as_property_indexes(nspr, _indexer.indexes, mot, lloc11);
return;
}
expression_node en2 = expression_value_reciving(id, si, ex, false);
indexer_as_expression_index(en2, _indexer.indexes, mot, get_location(id));
return;
}
}
}
else
{
expression_node expr = convert_strong(_indexer.dereferencing_value);
indexer_as_expression_index(expr, _indexer.indexes, mot, get_location(_indexer.dereferencing_value));
return;
}
}
/*expression_node left=convert_strong(_indexer.dereferencing_value);
foreach(SyntaxTree.expression exp in _indexer.indexes.expressions)
{
expression_node right=convert_strong(exp);
SymbolInfo si=left.type.find_in_type(compiler_string_consts.indexer_name);
definition_node dn=check_name_node_type(compiler_string_consts.indexer_name,si,get_location(exp),
general_node_type.function_node);
expression_nodeArrayList exprs=new expression_nodeArrayList();
exprs.Add(right);
function_node fn=convertion_data_and_alghoritms.select_function(exprs,si,get_location(exp));
base_function_call_with_method bfc=create_not_static_method_call(fn,left,get_location(exp),false);
bfc.parameters.AddRange(exprs);
left=bfc;
}*/
/*switch (mot)
{
case motivation.address_reciving:
{
return_addressed_value(left);
return;
}
case motivation.expression_evaluation:
{
return_value(left);
return;
}
case motivation.semantic_node_reciving:
{
return_semantic_value(left);
return;
}
}*/
}
private void indexer_as_property_indexes(non_static_property_reference nspr, SyntaxTree.expression_list parameters,
motivation mot, location loc)
{
if (nspr.property.parameters.Count != 0)
{
if (parameters.expressions.Count != nspr.property.parameters.Count)
{
internal_interface ii = nspr.property.comprehensive_type.get_internal_interface(internal_interface_kind.bounded_array_interface);
if (ii != null)
{
//bounded_array_interface dii = (bounded_array_interface)ii;
expression_node exp = convert_strong(parameters.expressions[0]);
exp = convertion_data_and_alghoritms.convert_type(exp, nspr.property.parameters[0].type);
nspr.fact_parametres.AddElement(exp);
base_function_call bfc = null;
for (int i = 1; i < parameters.expressions.Count; i++)
{
bfc = create_not_static_method_call(nspr.property.get_function, nspr.expression, exp.location, false);
bfc.parameters.AddRange(nspr.fact_parametres);
location lloc = get_location(parameters.expressions[i]);
ii = bfc.type.get_internal_interface(internal_interface_kind.bounded_array_interface);
if (ii == null)
{
AddError(lloc, "{0}_DIMENSIONAL_ARRAY_CAN_NOT_HAVE_{1}_AND_MORE_INDEXING", i, i+1);
}
bounded_array_interface bii = (bounded_array_interface)ii;
exp = convert_strong(parameters.expressions[i]);
exp = convertion_data_and_alghoritms.convert_type(exp, bii.index_type);
nspr = new non_static_property_reference(bii.index_property, bfc, lloc);
nspr.fact_parametres.AddElement(exp);
}
}
else
{
AddError(loc, "PROPERTY_{0}_REFERENCE_WITH_INVALID_PARAMS_COUNT", nspr.property.name);
}
}
else
{
//String 1 based
if (parameters.expressions.Count == 1 &&
nspr.property.comprehensive_type == SystemLibrary.SystemLibrary.string_type &&
!SemanticRules.NullBasedStrings)
{
nspr.fact_parametres.AddElement(
ConstructDecExpr(
convertion_data_and_alghoritms.convert_type(
convert_strong(parameters.expressions[0]), nspr.property.parameters[0].type), null));
}
else
for (int i = 0; i < parameters.expressions.Count; i++)
{
expression_node exp = convert_strong(parameters.expressions[i]);
exp = convertion_data_and_alghoritms.convert_type(exp, nspr.property.parameters[i].type);
nspr.fact_parametres.AddElement(exp);
}
}
}
switch (mot)
{
case motivation.expression_evaluation:
case motivation.semantic_node_reciving:
{
function_node fn = nspr.property.get_function;
if (fn == null)
{
AddError(new ThisPropertyCanNotBeReaded(nspr.property, loc));
}
base_function_call bfc = create_not_static_method_call(fn, nspr.expression, loc, false);
bfc.parameters.AddRange(nspr.fact_parametres);
if (nspr.property.parameters.Count != 0)
{
return_value(bfc);
return;
}
indexer_as_expression_index(bfc, parameters, mot, loc);
return;
}
case motivation.address_reciving:
{
if (nspr.property.parameters.Count != 0)
{
return_addressed_value(nspr);
return;
}
function_node fn = nspr.property.get_function;
if (fn == null)
{
AddError(new ThisPropertyCanNotBeReaded(nspr.property, loc));
}
base_function_call bfc = create_not_static_method_call(fn, nspr.expression, loc, false);
bfc.parameters.AddRange(nspr.fact_parametres);
indexer_as_expression_index(bfc, parameters, mot, loc);
return;
}
}
throw new CompilerInternalError("Unsupported motivation");
}
private void indexer_as_expression_index(expression_node expr, SyntaxTree.expression_list parameters,
motivation mot, location loc)
{
try_convert_typed_expression_to_function_call(ref expr);
// SSM 10.01.16 Tuple t[i]
var ent = expr.type as compiled_type_node;
if (ent== null)
{
var eeee = expr.type as compiled_generic_instance_type_node;
if (eeee!= null)
ent = eeee.original_generic as compiled_type_node;
}
if (ent != null)
{
var t = ent.compiled_type;
if (t.FullName.StartsWith("System.Tuple"))
{
expression eee = parameters.expressions[0];
if (parameters.expressions.Count > 1)
AddError(get_location(eee), "TUPLE_CAN_HAVE_ONLY_ONE_INDEX");
var cn = convert_strong_to_constant_node(eee);
var v = cn as int_const_node;
if (v != null)
{
if (v.constant_value<0 || v.constant_value >= t.GetGenericArguments().Count())
AddError(cn.location, "TUPLE_INDEX_OUT_OF_RANGE_{0}", t.GetGenericArguments().Count()-1);
var dn = new dot_node(new semantic_addr_value(expr), new ident("Item" + (v.constant_value + 1).ToString(), eee.source_context),new SourceContext(loc.begin_line_num,loc.begin_column_num,loc.end_line_num,loc.end_column_num));
visit(dn);
return;
}
else AddError(cn.location, "TUPLE_INDEX_MUST_BE_INTEGER_CONSTANT");
}
}
// end SSM 09.01.16 Tuple t[i]
if (expr.type.type_special_kind == SemanticTree.type_special_kind.array_kind)
{
internal_interface ii = expr.type.get_internal_interface(internal_interface_kind.unsized_array_interface);
array_internal_interface aii = (array_internal_interface)ii;
int rank = aii.rank;
//TODO: Многомерные массивы.
expression_node ind_expr = convert_strong(parameters.expressions[0]);
ind_expr = additional_indexer_convertion(ind_expr, expr.type);
simple_array_indexing sai = new simple_array_indexing(expr, ind_expr, aii.element_type, loc);
if (rank == 1)
for (int i = 1; i < parameters.expressions.Count; i++)
{
ii = sai.type.get_internal_interface(internal_interface_kind.unsized_array_interface);
location lloc = get_location(parameters.expressions[i]);
if (ii == null)
{
AddError(lloc, "{0}_DIMENSIONAL_ARRAY_CAN_NOT_HAVE_{1}_AND_MORE_INDEXING", i, i+1);
}
aii = (array_internal_interface)ii;
ind_expr = convert_strong(parameters.expressions[i]);
ind_expr = additional_indexer_convertion(ind_expr, sai.type);
sai = new simple_array_indexing(sai, ind_expr, aii.element_type, lloc);
}
else
{
if (rank != parameters.expressions.Count)
AddError(get_location(parameters), "{0}_DIMENSIONAL_ARRAY_CAN_NOT_HAVE_{1}_AND_MORE_INDEXING", rank, rank + 1);
List<expression_node> lst = new List<expression_node>();
for (int i = 0; i < parameters.expressions.Count; i++)
{
location lloc = get_location(parameters.expressions[i]);
ind_expr = convert_strong(parameters.expressions[i]);
ind_expr = additional_indexer_convertion(ind_expr, sai.type);
lst.Add(ind_expr);
}
sai = new simple_array_indexing(expr, lst[0], aii.element_type, get_location(parameters));
sai.expr_indices = lst.ToArray();
}
switch (mot)
{
case motivation.address_reciving:
{
return_addressed_value(sai);
break;
}
case motivation.expression_evaluation:
{
return_value(sai);
break;
}
case motivation.semantic_node_reciving:
{
return_semantic_value(sai);
break;
}
}
return;
}
else if (expr.type.type_special_kind == SemanticTree.type_special_kind.short_string)
{
if (parameters.expressions.Count != 1)
AddError(loc, "INVALID_PARAMETER_COUNT_IN_INDEXER");
expression_node ind_expr = convert_strong(parameters.expressions[0]);
ind_expr = additional_indexer_convertion(ind_expr, expr.type);
//expression_node en = convertion_data_and_alghoritms.create_simple_function_call(SystemLibrary.SystemLibInitializer.GetCharInShortStringProcedure.sym_info as function_node,loc,ind_expr,new int_const_node((expr.type as short_string_type_node).Length,null));
switch (mot)
{
case motivation.address_reciving:
{
simple_array_indexing sai = new simple_array_indexing(expr, ind_expr, SystemLibrary.SystemLibrary.char_type, loc);
return_addressed_value(sai);
//return_addressed_value(convertion_data_and_alghoritms.create_simple_function_call(SystemLibrary.SystemLibInitializer.SetCharInShortStringProcedure.sym_info as function_node,loc,expr,ind_expr) as common_namespace_function_call);
break;
}
case motivation.expression_evaluation:
{
return_value(convertion_data_and_alghoritms.create_simple_function_call(SystemLibrary.SystemLibInitializer.GetCharInShortStringProcedure.sym_info as function_node,loc,expr,ind_expr,new int_const_node((expr.type as short_string_type_node).Length,null)));
break;
}
case motivation.semantic_node_reciving:
{
return_semantic_value(convertion_data_and_alghoritms.create_simple_function_call(SystemLibrary.SystemLibInitializer.GetCharInShortStringProcedure.sym_info as function_node,loc,expr,ind_expr,new int_const_node((expr.type as short_string_type_node).Length,null)));
break;
}
}
return;
}
/*else if (expr.type.type_special_kind == SemanticTree.type_special_kind.array_wrapper)
{
internal_interface ii = expr.type.get_internal_interface(internal_interface_kind.bounded_array_interface);
array_internal_interface aii = (array_internal_interface)ii;
//TODO: Многомерные массивы.
expression_node ind_expr = convert_strong(parameters.expressions[0]);
ind_expr = additional_indexer_convertion(ind_expr, expr.type);
simple_array_indexing sai = new simple_array_indexing(expr, ind_expr, aii.element_type, loc);
for (int i = 1; i < parameters.expressions.Count; i++)
{
ii = sai.type.get_internal_interface(internal_interface_kind.bounded_array_interface);
location lloc = get_location(parameters.expressions[i]);
if (ii == null)
{
throw new NDimensionalArrayCanNotHaveNPlusOneIndexer(lloc, expr, i);
}
aii = (array_internal_interface)ii;
ind_expr = convert_strong(parameters.expressions[i]);
ind_expr = create_simple_function_call(SystemLibrary.SystemLibrary.int_sub, cmc.location, ind_expr,
new int_const_node(ii.ordinal_type_interface.ordinal_type_to_int(bai.ordinal_type_interface.lower_value),cmc.location));
ind_expr = additional_indexer_convertion(ind_expr, sai.type);
sai = new simple_array_indexing(sai, ind_expr, aii.element_type, lloc);
}
switch (mot)
{
case motivation.address_reciving:
{
return_addressed_value(sai);
break;
}
case motivation.expression_evaluation:
{
return_value(sai);
break;
}
case motivation.semantic_node_reciving:
{
return_semantic_value(sai);
break;
}
}
return;
if (factparams[i].semantic_node_type == semantic_node_type.common_method_call)
{
common_method_call cmc = (common_method_call)factparams[i];
internal_interface ii = cmc.obj.type.get_internal_interface(internal_interface_kind.bounded_array_interface);
if (ii != null)
{
if (cmc.function_node.name == compiler_string_consts.get_val_pascal_array_name)
{
bounded_array_interface bai = (bounded_array_interface)ii;
class_field cf = bai.int_array;
expression_node left = new class_field_reference(cf, cmc.obj, cmc.location);
expression_node right = cmc.parameters[0];
//right = convert_type(right, SystemLibrary.SystemLibrary.integer_type);
right = convert_type(right, (ii as bounded_array_interface).ordinal_type_interface.elems_type);
right = create_simple_function_call(SystemLibrary.SystemLibrary.int_sub, cmc.location, right,
new int_const_node(bai.ordinal_type_interface.ordinal_type_to_int(bai.ordinal_type_interface.lower_value),cmc.location));
factparams[i] = new simple_array_indexing(left, right, cmc.type, cmc.location);
is_pascal_array_ref = true;
}
}
}
}*/
if (expr.type.default_property_node == null)
{
if (expr.type.semantic_node_type != semantic_node_type.delegated_method)
{
AddError(loc, "NO_DEFAULT_PROPERTY_TO_TYPE_{0}", expr.type.PrintableName);
}
else
{
AddError(loc, "NO_DEFAULT_PROPERTY_TO_FUNCTION_TYPE");
}
}
if (expr.type.default_property_node.polymorphic_state == SemanticTree.polymorphic_state.ps_static)
{
AddError(new CanNotReferenceToStaticPropertyWithExpression(expr.type.default_property_node, loc, expr.type));
}
non_static_property_reference nspr = new non_static_property_reference(expr.type.default_property_node, expr, loc);
indexer_as_property_indexes(nspr, parameters, mot, loc);
//eto vrode rabotaet normalno. no imet v vidu
if (expr.type.type_special_kind == SemanticTree.type_special_kind.array_wrapper)
{
expression_node en = ret.get_expression();
if (en is non_static_property_reference)
{
non_static_property_reference cmc = (non_static_property_reference)en;
internal_interface ii = cmc.expression.type.get_internal_interface(internal_interface_kind.bounded_array_interface);
if (ii != null)
{
//if (cmc.function_node.name == compiler_string_consts.get_val_pascal_array_name)
{
bounded_array_interface bai = (bounded_array_interface)ii;
class_field cf = bai.int_array;
expression_node left = new class_field_reference(cf, cmc.expression, cmc.location);
expression_node right = cmc.fact_parametres[0];
//right = convert_type(right, SystemLibrary.SystemLibrary.integer_type);
right = convertion_data_and_alghoritms.convert_type(right, (ii as bounded_array_interface).ordinal_type_interface.elems_type);
right = convertion_data_and_alghoritms.create_simple_function_call(SystemLibrary.SystemLibrary.int_sub, cmc.location, right,
new int_const_node(bai.ordinal_type_interface.ordinal_type_to_int(bai.ordinal_type_interface.lower_value), cmc.location));
en = new simple_array_indexing(left, right, cmc.type, cmc.location);
//is_pascal_array_ref = true;
}
}
}
else
{
common_method_call cmc = (common_method_call)en;
internal_interface ii = cmc.obj.type.get_internal_interface(internal_interface_kind.bounded_array_interface);
if (ii != null)
{
//if (cmc.function_node.name == compiler_string_consts.get_val_pascal_array_name)
{
bounded_array_interface bai = (bounded_array_interface)ii;
class_field cf = bai.int_array;
expression_node left = new class_field_reference(cf, cmc.obj, cmc.location);
expression_node right = cmc.parameters[0];
//right = convert_type(right, SystemLibrary.SystemLibrary.integer_type);
right = convertion_data_and_alghoritms.convert_type(right, (ii as bounded_array_interface).ordinal_type_interface.elems_type);
right = convertion_data_and_alghoritms.create_simple_function_call(SystemLibrary.SystemLibrary.int_sub, cmc.location, right,
new int_const_node(bai.ordinal_type_interface.ordinal_type_to_int(bai.ordinal_type_interface.lower_value), cmc.location));
en = new simple_array_indexing(left, right, cmc.type, cmc.location);
//is_pascal_array_ref = true;
}
}
}
return_value(en);
}
return;
}
private expression_node CreateNonStaticPropertyReference()
{
expression_node obj = CreateExpression();
property_node prop = GetPropertyByOffset();
non_static_property_reference nspr = new non_static_property_reference(prop,obj,null);
int num = br.ReadInt32();
for (int i = 0; i < num; i++)
nspr.fact_parametres.AddElement(CreateExpression());
return nspr;
}
public override void visit(SyntaxTree.indexer _indexer)
{
//SSM 11/02/16 - нет, это глупость
/*if (_indexer.dereferencing_value is SyntaxTree.question_colon_expression) // то разбросать индекс по компонентам
{
var q = _indexer.dereferencing_value as SyntaxTree.question_colon_expression;
var nodeToVisit = new SyntaxTree.question_colon_expression(q.condition, new indexer(q.ret_if_true as addressed_value, _indexer.indexes, _indexer.source_context),
new indexer(q.ret_if_false as addressed_value, _indexer.indexes, _indexer.source_context), _indexer.source_context);
visit(nodeToVisit);
return;
}*/
//end SSM 11/02/16
// SSM 18.08.16 - пробуем обработать захват enn[i] в yieldах где enn - поле класса и нуждается в переименовании
// Так же ниже делает lroman
if (_indexer.dereferencing_value is yield_unknown_ident)
{
var yui = (yield_unknown_ident)_indexer.dereferencing_value;
var av = ProcessUnknownIdent(yui);
var nodeToVisit = new indexer(av,_indexer.indexes);
visit(nodeToVisit);
return;
}
//lroman
if (_indexer.dereferencing_value is closure_substituting_node)
{
var nodeToVisit = new indexer(((closure_substituting_node) _indexer.dereferencing_value).substitution,
_indexer.indexes);
visit(nodeToVisit);
return;
}
var mot = motivation_keeper.motivation;
motivation_keeper.reset();
SyntaxTree.ident idi = _indexer.dereferencing_value as SyntaxTree.ident;
if (idi != null)
{
SymbolInfo si = context.find(idi.name);
if (si == null)
{
AddError(new UndefinedNameReference(idi.name, get_location(idi)));
}
if (si.sym_info.general_node_type == general_node_type.type_node)
{
indexer_as_type_indexes((type_node)si.sym_info, _indexer.indexes, mot, get_location(idi));
return;
}
if (si.sym_info.general_node_type == general_node_type.property_node)
{
property_node pn = (property_node)si.sym_info;
if (pn.polymorphic_state == SemanticTree.polymorphic_state.ps_static)
{
static_property_reference spr = new static_property_reference(pn, get_location(idi));
indexer_as_property_indexes(spr, _indexer.indexes, mot, get_location(idi));
return;
}
else
{
this_node thisnode = new this_node(pn.comprehensive_type, get_location(_indexer));
location loc111 = get_location(idi);
non_static_property_reference nspr = new non_static_property_reference(pn, thisnode, loc111);
indexer_as_property_indexes(nspr, _indexer.indexes, mot, loc111);
return;
}
}
expression_node en = ident_value_reciving(si, idi);
indexer_as_expression_index(en, _indexer.indexes, mot, get_location(idi));
return;
}
else
{
SyntaxTree.dot_node dotnd = _indexer.dereferencing_value as SyntaxTree.dot_node;
if (dotnd != null)
{
SyntaxTree.ident id = dotnd.right as SyntaxTree.ident;
semantic_node sn = convert_semantic_strong(dotnd.left);
switch (sn.general_node_type)
{
case general_node_type.type_node:
{
type_node ttp = (type_node)sn;
SymbolInfo si = ttp.find_in_type(id.name, context.CurrentScope);
if (si == null)
{
AddError(new UndefinedNameReference(id.name, get_location(id)));
}
if (si.sym_info.general_node_type == general_node_type.property_node)
{
property_node pn = (property_node)si.sym_info;
static_property_reference spr = new static_property_reference(pn, get_location(id));
indexer_as_property_indexes(spr, _indexer.indexes, mot, get_location(dotnd));
return;
}
expression_node exp1 = create_static_expression(ttp, id, si);
indexer_as_expression_index(exp1, _indexer.indexes, mot, get_location(id));
return;
}
case general_node_type.namespace_node:
case general_node_type.unit_node:
{
SymbolInfo si = null;
if (sn is namespace_node)
si = ((namespace_node)sn).find(id.name);
else
si = ((unit_node)sn).find_only_in_namespace(id.name);
if (si == null)
{
AddError(new UndefinedNameReference(id.name, get_location(id)));
}
location lloc = get_location(id);
if (si.sym_info.general_node_type == general_node_type.type_node)
{
type_node tn = (type_node)si.sym_info;
indexer_as_type_indexes(tn, _indexer.indexes, mot, lloc);
return;
}
expression_node exp2 = ident_value_reciving(si, id);
indexer_as_expression_index(exp2, _indexer.indexes, mot, get_location(id));
return;
}
case general_node_type.expression:
{
expression_node ex = (expression_node)sn;
SymbolInfo si = ex.type.find_in_type(id.name, context.CurrentScope);
if (si == null)
{
AddError(new UndefinedNameReference(id.name, get_location(id)));
}
if (si.sym_info.general_node_type == general_node_type.property_node)
{
property_node pn = (property_node)si.sym_info;
if (pn.polymorphic_state == SemanticTree.polymorphic_state.ps_static)
{
AddError(new CanNotReferenceToStaticPropertyWithExpression(pn, get_location(dotnd), ex.type));
}
location lloc11 = get_location(dotnd);
try_convert_typed_expression_to_function_call(ref ex);
non_static_property_reference nspr = new non_static_property_reference(pn, ex, lloc11);
indexer_as_property_indexes(nspr, _indexer.indexes, mot, lloc11);
return;
}
expression_node en2 = expression_value_reciving(id, si, ex, false);
indexer_as_expression_index(en2, _indexer.indexes, mot, get_location(id));
return;
}
}
}
else
{
expression_node expr = convert_strong(_indexer.dereferencing_value);
indexer_as_expression_index(expr, _indexer.indexes, mot, get_location(_indexer.dereferencing_value));
return;
}
}
}
