public expression NewVariable(addressed_value variable, expression var_specifiers, LexLocation loc)
{
if (var_specifiers is dot_node)
{
var dn = (dot_node)var_specifiers;
dn.left = variable;
}
else if (var_specifiers is template_param_list)
{
var tpl = (template_param_list)var_specifiers;
((dot_node)tpl.dereferencing_value).left = variable;
parsertools.create_source_context(tpl.dereferencing_value, variable, tpl.dereferencing_value);
}
else if (var_specifiers is dereference)
{
((dereference)var_specifiers).dereferencing_value = variable;
}
else if (var_specifiers is ident_with_templateparams)
{
((ident_with_templateparams)var_specifiers).name = (addressed_value_funcname)variable;
}
var_specifiers.source_context = loc;
return(var_specifiers);
}
public addressed_value NewVarReference(get_address var_address, addressed_value variable, LexLocation loc)
{
var_address.address_of = variable;
parsertools.create_source_context(parsertools.NodesStack.Peek(), parsertools.NodesStack.Peek(),
variable);
return((addressed_value)parsertools.NodesStack.Pop());
}
public addressed_value Into(addressed_value x, addressed_value v) // При возникновении новой конструкции в грамматике variable добавить обработку сюда
{
if (v.GetType() == typeof(dot_question_node))
{
var vv = v as dot_question_node;
var res = new dot_question_node(Into(x, vv.left), vv.right, x.source_context);
return(res);
}
else if (v.GetType() == typeof(dot_node))
{
var vv = v as dot_node;
var res = new dot_node(Into(x, vv.left), vv.right, x.source_context);
return(res);
}
else if (v.GetType() == typeof(indexer))
{
var vv = v as indexer;
var res = new indexer(Into(x, vv.dereferencing_value), vv.indexes, x.source_context);
return(res);
}
else if (v.GetType() == typeof(slice_expr))
{
var vv = v as slice_expr;
var res = new slice_expr(Into(x, vv.dereferencing_value), vv.from, vv.to, vv.step, x.source_context);
return(res);
}
else if (v.GetType() == typeof(slice_expr_question))
{
var vv = v as slice_expr_question;
var res = new slice_expr_question(Into(x, vv.dereferencing_value), vv.from, vv.to, vv.step, x.source_context);
return(res);
}
else if (v.GetType() == typeof(method_call))
{
var vv = v as method_call;
var res = new method_call(Into(x, vv.dereferencing_value), vv.parameters, x.source_context);
return(res);
}
else if (v.GetType() == typeof(roof_dereference))
{
var vv = v as roof_dereference;
var res = new roof_dereference(Into(x, vv.dereferencing_value), x.source_context);
return(res);
}
else if (v.GetType() == typeof(ident_with_templateparams))
{
var vv = v as ident_with_templateparams;
var res = new ident_with_templateparams(Into(x, vv.name), vv.template_params, x.source_context);
return(res);
}
else
{
var res = new dot_node(x, v, x.source_context);
return(res);
}
}
private expression GetCollectionItemsEqualCheckAfterGap(addressed_value matchingExpression,
List <pattern_parameter> toCompare,
CollectionDesugaringResult desugaringResult)
{
var elemFromTail = 1;
expression equalChecks = null;
foreach (var param in toCompare)
{
var indexerCall = new indexer(
matchingExpression,
new expression_list(
new bin_expr(
new method_call(
new dot_node(
matchingExpression,
new ident("Count", matchingExpression.source_context)),
new expression_list()),
new int32_const(elemFromTail, matchingExpression.source_context),
Operators.Minus),
matchingExpression.source_context),
matchingExpression.source_context);
if (param is const_pattern_parameter constParam)
{
var eqParams = new expression_list(
new List <expression>()
{
indexerCall,
constParam.const_param
}
);
var equalCall = new method_call(
new dot_node(
new ident("object"),
new ident("Equals")),
eqParams,
matchingExpression.source_context
);
equalChecks = equalChecks == null ? (expression)equalCall : bin_expr.LogicalAnd(equalChecks, equalCall);
desugaringResult.ElemTypeChecks.Add(GetTypeCompatibilityCheck(indexerCall, constParam.const_param));
}
if (param is collection_pattern_var_parameter varParam)
{
desugaringResult.VarParametersDeclarations.Add(
new var_statement(varParam.identifier, indexerCall));
}
++elemFromTail;
}
return(equalChecks);
}
/*public question_colon_expression ConvertToQCE1(dot_question_node dqn)
* {
* addressed_value left = dqn.left;
* addressed_value right = dqn.right;
*
* var eq = new bin_expr(left, new nil_const(), Operators.Equal, left.source_context);
*
* var nr = Into(left, right);
*
* var q = new question_colon_expression(eq, new nil_const(), nr, dqn.source_context);
* nr.Parent = q;
* return q;
* }*/
public question_colon_expression ConvertToQCE1(dot_question_node dqn, string name)
{
addressed_value right = dqn.right;
var eq = new bin_expr(new ident(name), new nil_const(), Operators.Equal, dqn.left.source_context);
var nr = Into(new ident(name), right);
var q = new question_colon_expression(eq, new nil_const(), nr, dqn.source_context);
nr.Parent = q;
return(q);
}
private expression GetCollectionItemsEqualCheckBeforeGap(addressed_value matchingExpression,
List <pattern_parameter> toCompare,
CollectionDesugaringResult desugaringResult)
{
var fromIndex = 0;
expression equalChecks = null;
foreach (var param in toCompare)
{
if (param is const_pattern_parameter constParam)
{
var indexerCall = new indexer(
matchingExpression,
new expression_list(
new int32_const(fromIndex, matchingExpression.source_context),
matchingExpression.source_context),
matchingExpression.source_context);
var eqParams = new expression_list(
new List <expression>()
{
indexerCall,
constParam.const_param
}
);
var equalCall = new method_call(
new dot_node(
new ident("object"),
new ident("Equals")),
eqParams,
matchingExpression.source_context
);
equalChecks = equalChecks == null ? (expression)equalCall : bin_expr.LogicalAnd(equalChecks, equalCall);
desugaringResult.ElemTypeChecks.Add(GetTypeCompatibilityCheck(indexerCall, constParam.const_param));
}
if (param is collection_pattern_var_parameter varParam)
{
desugaringResult.VarParametersDeclarations.Add(
new var_statement(varParam.identifier,
GetIndexerCallForCollectionPattern(matchingExpression as addressed_value, fromIndex)));
}
++fromIndex;
}
return(equalChecks);
}
public question_colon_expression ConvertToQCE(dot_question_node dqn)
{
addressed_value left = dqn.left;
addressed_value right = dqn.right;
var eq = new bin_expr(left, new nil_const(), Operators.Equal, left.source_context);
addressed_value dn = null;
var dnleft = right; // Левая часть dn
addressed_value rdqn = null;
addressed_value ldqn = null;
// Если right - это dot_question_node, то протащить внутрь него left. В силу ассоциирования слева направо достаточно на первый уровень.
if (right.GetType() == typeof(dot_question_node))
{
var dqn_int = right as dot_question_node;
ldqn = dqn_int.left;
dnleft = ldqn;
rdqn = dqn_int.right;
// необходимо left протащить внутрь в ldqn
}
// Пока right - это dot_node, то необходимо протаскивать left чтобы присоединить его к первому не dot_node
while (dnleft.GetType() == typeof(dot_node))
{
dn = dnleft;
dnleft = (dnleft as dot_node).left;
}
// В итоге в dnleft - самый внутренний left, который уже не является dot_node
dnleft = new dot_node(left, dnleft, left.source_context); // Прикрепили right к самому внутреннему левому узлу в нотации a.b.c.d
if (dn != null)
{
(dn as dot_node).left = dnleft;
}
else if (rdqn == null)
{
right = dnleft;
}
else
{
right = new dot_question_node(dnleft, (right as dot_question_node).right, dnleft.source_context);
}
var q = new question_colon_expression(eq, new nil_const(), right, dqn.source_context);
right.Parent = q;
return(q);
}
public override void visit(addressed_value _addressed_value)
{
DefaultVisit(_addressed_value);
pre_do_visit(_addressed_value);
post_do_visit(_addressed_value);
}
public virtual void post_do_visit(addressed_value _addressed_value)
{
}
public virtual void visit(addressed_value _addressed_value)
{
}
public virtual void visit(addressed_value _addressed_value)
{
}
public virtual void visit(addressed_value _addressed_value)
{
DefaultVisit(_addressed_value);
}
public addressed_expression visit(addressed_value av)
{
av.visit(syntax_tree_visitor);
return(ret_semantic as addressed_expression);
}
private expression GetIndexerCallForCollectionPattern(addressed_value matchingExpression, int ind)
{
var indexerCall = new indexer(matchingExpression, new int32_const(ind), matchingExpression.source_context);
return(indexerCall);
}
public override void visit(addressed_value _addressed_value)
{
executer.visit(_addressed_value);
if (_addressed_value.attributes != null)
this.visit((dynamic)_addressed_value.attributes);
}
public virtual void visit(addressed_value _addressed_value)
{
DefaultVisit(_addressed_value);
}
public override void visit(addressed_value _addressed_value)
{
}
public override void visit(addressed_value _addressed_value)
{
throw new NotImplementedException();
}
