public override AssociativeNode VisitRangeExprNode(RangeExprNode node)
{
var newFromNode = node.From.Accept(this);
if (node.From != newFromNode)
{
node.From = newFromNode;
}
var newToNode = node.To.Accept(this);
if (node.To != newToNode)
{
node.To = newToNode;
}
if (node.Step != null)
{
var newStepNode = node.Step.Accept(this);
if (node.Step != newStepNode)
{
node.Step = newStepNode;
}
}
return(node);
}
public AssociativeNode GetAstNode(Dictionary <string, AssociativeNode> idLookup)
{
var rangeExpr = new RangeExprNode
{
From = _start.GetAstNode(idLookup),
To = _end.GetAstNode(idLookup),
Step = _step.GetAstNode(idLookup),
StepOperator = GetRangeExpressionOperator()
};
return(rangeExpr);
}
public AssociativeNode GetAstNode(Dictionary <string, AssociativeNode> idLookup)
{
var rangeExpr = new RangeExprNode
{
From = _start.GetAstNode(idLookup),
To = _count.GetAstNode(idLookup),
Step = _step.GetAstNode(idLookup),
HasRangeAmountOperator = true,
StepOperator = RangeStepOperator.StepSize
};
return(rangeExpr);
}
public override bool VisitRangeExprNode(RangeExprNode node)
{
if (forDefinition)
{
return(false);
}
if (node.FromNode.Accept(this) || node.ToNode.Accept(this))
{
return(true);
}
return(node.StepNode != null?node.StepNode.Accept(this) : false);
}
public virtual void VisitRangeExprNode(RangeExprNode node)
{
node.From.Accept(this);
node.To.Accept(this);
if (node.Step != null)
{
node.Step.Accept(this);
}
if (node.ArrayDimensions != null)
{
node.ArrayDimensions.Accept(this);
}
}
private void EmitRangeExpNode(Func node, out AssociativeNode outnode)
{
Validity.Assert(node != null);
Validity.Assert(node.isRange);
RangeExprNode rangeNode = new RangeExprNode();
// Set FromNode, ToNode, stepOperator and StepNode for rangeNode
Dictionary <int, Node> nodes = node.GetChildrenWithIndices();
//int numParams = node.numParameters;
AssociativeNode startNode = null;
AssociativeNode endNode = null;
AssociativeNode stepNode = null;
if (nodes.Count >= 1)
{
DFSTraverse(nodes[0], out startNode);
}
if (nodes.Count >= 2)
{
DFSTraverse(nodes[1], out endNode);
}
if (nodes.Count >= 3)
{
DFSTraverse(nodes[2], out stepNode);
}
rangeNode.FromNode = startNode;
rangeNode.ToNode = endNode;
rangeNode.StepNode = stepNode;
if (node.Name == "Range.ByIncrementValue")
{
rangeNode.stepoperator = ProtoCore.DSASM.RangeStepOperator.stepsize;
}
else if (node.Name == "Range.ByIntervals")
{
rangeNode.stepoperator = ProtoCore.DSASM.RangeStepOperator.num;
}
else
{
rangeNode.stepoperator = ProtoCore.DSASM.RangeStepOperator.approxsize;
}
outnode = rangeNode;
//outnode = CreateBinaryExpNode(node, rangeNode);
}
public virtual bool VisitRangeExprNode(RangeExprNode node)
{
node.From.Accept(this);
node.To.Accept(this);
if (node.Step != null)
{
node.Step.Accept(this);
}
if (node.ArrayDimensions != null)
{
node.ArrayDimensions.Accept(this);
}
return(true);
}
void RangeExpr(out Node node)
{
rel(out node);
if (la.kind == 17)
{
RangeExprNode rnode = new RangeExprNode();
rnode.FromNode = node;
Get();
rel(out node);
rnode.ToNode = node;
if (la.kind == 17)
{
RangeStepOperator op;
Get();
rangeStepOperator(out op);
rnode.stepoperator = op;
rel(out node);
rnode.StepNode = node;
}
node = rnode;
}
}
private void TraverseToSplit(AssociativeNode node, out AssociativeNode outNode, ref List <AssociativeNode> splitList)
{
if (node is BinaryExpressionNode)
{
BinaryExpressionNode ben = node as BinaryExpressionNode;
BinaryExpressionNode newNode = new BinaryExpressionNode();
AssociativeNode lNode = null;
TraverseToSplit(ben.LeftNode, out lNode, ref splitList);
newNode.LeftNode = lNode;
newNode.Optr = ben.Optr;
AssociativeNode rNode = null;
TraverseToSplit(ben.RightNode, out rNode, ref splitList);
newNode.RightNode = rNode;
if (ben.Optr == ProtoCore.DSASM.Operator.assign)
{
if (NotEnlisted(splitList, newNode))
{
splitList.Add(newNode);
}
outNode = lNode;
}
else
{
outNode = newNode;
}
}
else if (node is FunctionCallNode)
{
FunctionCallNode funcCallNode = node as FunctionCallNode;
AssociativeNode statement = null;
foreach (AssociativeNode argNode in funcCallNode.FormalArguments)
{
TraverseToSplit(argNode, out statement, ref splitList);
}
for (int i = 0; i < funcCallNode.FormalArguments.Count; i++)
{
AssociativeNode argNode = funcCallNode.FormalArguments[i];
if (argNode is BinaryExpressionNode)
{
funcCallNode.FormalArguments[i] = (argNode as BinaryExpressionNode).LeftNode;
}
}
//if (statement is BinaryExpressionNode)
//{
// splitList.Add(statement);
//}
outNode = funcCallNode;
}
else if (node is FunctionDotCallNode)
{
FunctionDotCallNode funcDotNode = node as FunctionDotCallNode;
AssociativeNode statement = null;
TraverseToSplit(funcDotNode.FunctionCall, out statement, ref splitList);
funcDotNode.FunctionCall = (statement as FunctionCallNode);
TraverseToSplit(funcDotNode.DotCall.FormalArguments[0], out statement, ref splitList);
if (statement is BinaryExpressionNode)
{
funcDotNode.DotCall.FormalArguments[0] = (statement as BinaryExpressionNode).LeftNode;
}
else
{
funcDotNode.DotCall.FormalArguments[0] = statement;
}
outNode = funcDotNode;
}
else if (node is ProtoCore.AST.AssociativeAST.ImportNode)
{
outNode = node;
splitList.Add(outNode);
}
else if (node is ProtoCore.AST.AssociativeAST.ArrayIndexerNode)
{
ArrayIndexerNode arrIdxNode = node as ArrayIndexerNode;
AssociativeNode statement = null;
TraverseToSplit(arrIdxNode.Array, out statement, ref splitList);
arrIdxNode.Array = statement;
outNode = arrIdxNode;
}
else if (node is ProtoCore.AST.AssociativeAST.ExprListNode)
{
ExprListNode exprListNode = node as ExprListNode;
AssociativeNode statement = null;
//for (int i=0; i<exprListNode.list.Count; i++)
foreach (AssociativeNode listNode in exprListNode.list)
{
TraverseToSplit(listNode, out statement, ref splitList);
}
for (int i = 0; i < exprListNode.list.Count; i++)
{
AssociativeNode argNode = exprListNode.list[i];
if (argNode is BinaryExpressionNode)
{
exprListNode.list[i] = (argNode as BinaryExpressionNode).LeftNode;
}
}
outNode = exprListNode;
}
//else if (node is ProtoCore.AST.AssociativeAST.ArrayNode)
//{
// k
//}
else if (node is ProtoCore.AST.AssociativeAST.RangeExprNode)
{
RangeExprNode rangeExprNode = node as RangeExprNode;
AssociativeNode statement = null;
TraverseToSplit(rangeExprNode.FromNode, out statement, ref splitList);
TraverseToSplit(rangeExprNode.StepNode, out statement, ref splitList);
TraverseToSplit(rangeExprNode.ToNode, out statement, ref splitList);
if (rangeExprNode.FromNode is BinaryExpressionNode)
{
rangeExprNode.FromNode = (rangeExprNode.FromNode as BinaryExpressionNode).LeftNode;
}
if (rangeExprNode.StepNode is BinaryExpressionNode)
{
rangeExprNode.StepNode = (rangeExprNode.StepNode as BinaryExpressionNode).LeftNode;
}
if (rangeExprNode.ToNode is BinaryExpressionNode)
{
rangeExprNode.ToNode = (rangeExprNode.ToNode as BinaryExpressionNode).LeftNode;
}
outNode = rangeExprNode;
}
else
{
outNode = node;
}
}
public virtual TAssociative VisitRangeExprNode(RangeExprNode node)
{
return(VisitAssociativeNode(node));
}
public RangeExprNode(RangeExprNode rhs) : base(rhs)
{
FromNode = ProtoCore.Utils.NodeUtils.Clone(rhs.FromNode);
ToNode = ProtoCore.Utils.NodeUtils.Clone(rhs.ToNode);
if (null != rhs.StepNode)
{
StepNode = ProtoCore.Utils.NodeUtils.Clone(rhs.StepNode);
}
stepoperator = rhs.stepoperator;
HasRangeAmountOperator = rhs.HasRangeAmountOperator;
}
public RangeExprNode(RangeExprNode rhs) : base(rhs)
{
From = NodeUtils.Clone(rhs.From);
To = NodeUtils.Clone(rhs.To);
if (null != rhs.Step)
{
Step = NodeUtils.Clone(rhs.Step);
}
StepOperator = rhs.StepOperator;
HasRangeAmountOperator = rhs.HasRangeAmountOperator;
}
