/// <summary>
/// Apppend replication guide to the input parameter based on lacing
/// strategy.
/// </summary>
/// <param name="inputs"></param>
/// <returns></returns>
private void AppendReplicationGuides(List <AssociativeNode> inputs)
{
if (inputs == null || !inputs.Any())
{
return;
}
switch (ArgumentLacing)
{
case LacingStrategy.Longest:
for (int i = 0; i < inputs.Count(); ++i)
{
if (inputs[i] is ArrayNameNode)
{
var astNode = NodeUtils.Clone(inputs[i]) as ArrayNameNode;
astNode.ReplicationGuides = new List <AssociativeNode>();
var guideNode = new ReplicationGuideNode
{
RepGuide = AstFactory.BuildIdentifier("1"),
IsLongest = true
};
astNode.ReplicationGuides.Add(guideNode);
inputs[i] = astNode;
}
}
break;
case LacingStrategy.CrossProduct:
int guide = 1;
for (int i = 0; i < inputs.Count(); ++i)
{
if (inputs[i] is ArrayNameNode)
{
var astNode = NodeUtils.Clone(inputs[i]) as ArrayNameNode;
astNode.ReplicationGuides = new List <AssociativeNode>();
var guideNode = new ReplicationGuideNode
{
RepGuide = AstFactory.BuildIdentifier(guide.ToString())
};
astNode.ReplicationGuides.Add(guideNode);
inputs[i] = astNode;
guide++;
}
}
break;
}
}
public virtual void VisitReplicationGuideNode(ReplicationGuideNode node)
{
DefaultVisit(node);
}
public virtual TAssociative VisitReplicationGuideNode(ReplicationGuideNode node)
{
return(VisitAssociativeNode(node));
}
public virtual bool VisitReplicationGuideNode(ReplicationGuideNode node)
{
return(DefaultVisit(node));
}
void Associative_NameReference(out ProtoCore.AST.AssociativeAST.AssociativeNode node) {
ProtoCore.AST.AssociativeAST.ArrayNameNode nameNode = null;
ProtoCore.AST.AssociativeAST.GroupExpressionNode groupExprNode = null;
if (la.kind == 12) {
Get();
Associative_Expression(out node);
if (node is ProtoCore.AST.AssociativeAST.ArrayNameNode)
{
nameNode = node as ProtoCore.AST.AssociativeAST.ArrayNameNode;
}
else
{
groupExprNode = new ProtoCore.AST.AssociativeAST.GroupExpressionNode();
groupExprNode.Expression = node;
nameNode = groupExprNode;
}
Expect(13);
} else if (IsFunctionCall()) {
if (isLeft)
{
errors.SemErr(la.line, la.col, Resources.FunctionCallCannotBeAtLeftSide);
}
Associative_FunctionCall(out node);
nameNode = node as ProtoCore.AST.AssociativeAST.ArrayNameNode;
} else if (la.kind == 1) {
Associative_Ident(out node);
nameNode = node as ProtoCore.AST.AssociativeAST.ArrayNameNode;
} else if (la.kind == 45) {
Associative_ArrayExprList(out node);
nameNode = node as ProtoCore.AST.AssociativeAST.ArrayNameNode;
} else SynErr(99);
if (la.kind == 10) {
ProtoCore.AST.AssociativeAST.ArrayNode array = new ProtoCore.AST.AssociativeAST.ArrayNode();
Get();
if (StartOf(4)) {
bool tmpIsLeft = isLeft;
isLeft = false;
Associative_Expression(out node);
isLeft = tmpIsLeft;
array.Expr = node;
array.Type = nameNode.ArrayDimensions;
NodeUtils.SetNodeLocation(array, t);
nameNode.ArrayDimensions = array;
}
Expect(11);
while (la.kind == 10) {
Get();
if (StartOf(4)) {
bool tmpIsLeft = isLeft;
isLeft = false;
Associative_Expression(out node);
isLeft = tmpIsLeft;
ProtoCore.AST.AssociativeAST.ArrayNode array2 = new ProtoCore.AST.AssociativeAST.ArrayNode();
array2.Expr = node;
array2.Type = null;
NodeUtils.SetNodeLocation(array2, t);
array.Type = array2;
array = array2;
}
Expect(11);
}
if (groupExprNode != null)
{
var expr = groupExprNode.Expression;
if (expr is ProtoCore.AST.AssociativeAST.IdentifierListNode)
{
var rightNode = (expr as ProtoCore.AST.AssociativeAST.IdentifierListNode).RightNode;
if (rightNode is ProtoCore.AST.AssociativeAST.ArrayNameNode)
{
var rightMostArrayNameNode = rightNode as ProtoCore.AST.AssociativeAST.ArrayNameNode;
if (rightMostArrayNameNode.ArrayDimensions == null)
{
rightMostArrayNameNode.ArrayDimensions = groupExprNode.ArrayDimensions;
}
else
{
rightMostArrayNameNode.ArrayDimensions.Type = groupExprNode.ArrayDimensions;
}
groupExprNode.ArrayDimensions = null;
}
}
else if (expr is ProtoCore.AST.AssociativeAST.RangeExprNode)
{
var rangeExprNode = expr as ProtoCore.AST.AssociativeAST.RangeExprNode;
if (rangeExprNode.ArrayDimensions == null)
{
rangeExprNode.ArrayDimensions = groupExprNode.ArrayDimensions;
}
else
{
rangeExprNode.ArrayDimensions.Type = groupExprNode.ArrayDimensions;
}
groupExprNode.ArrayDimensions = null;
}
else if (expr is ProtoCore.AST.AssociativeAST.ExprListNode)
{
var exprListNode = expr as ProtoCore.AST.AssociativeAST.ExprListNode;
if (exprListNode.ArrayDimensions == null)
{
exprListNode.ArrayDimensions = groupExprNode.ArrayDimensions;
}
else
{
exprListNode.ArrayDimensions.Type = groupExprNode.ArrayDimensions;
}
groupExprNode.ArrayDimensions = null;
}
else if (expr is ProtoCore.AST.AssociativeAST.FunctionDotCallNode)
{
var dotCall = (expr as ProtoCore.AST.AssociativeAST.FunctionDotCallNode).DotCall;
var arrayExpr = (dotCall.FormalArguments[2] as ProtoCore.AST.AssociativeAST.ExprListNode);
var dimCount = (dotCall.FormalArguments[3] as ProtoCore.AST.AssociativeAST.IntNode);
var dims = dimCount.Value;
var newdims = dims;
if (arrayExpr != null)
{
var newarray = groupExprNode.ArrayDimensions;
while (newarray != null)
{
arrayExpr.Exprs.Add(newarray.Expr);
newdims++;
newarray = (newarray.Type as ProtoCore.AST.AssociativeAST.ArrayNode);
}
(dotCall.FormalArguments[3] as ProtoCore.AST.AssociativeAST.IntNode).Value = newdims;
}
groupExprNode.ArrayDimensions = null;
}
}
}
if (la.kind == 8 || la.kind == 9) {
AssociativeNode levelNode = null;
bool isDominant = false;
if (la.kind == 8) {
Get();
Associative_Number(out levelNode);
} else {
Get();
Associative_Number(out levelNode);
isDominant = true;
}
IntNode listAtLevel = levelNode as IntNode;
if (listAtLevel != null)
{
var atLevel = new AtLevelNode { Level = listAtLevel.Value, IsDominant = isDominant };
nameNode.AtLevel = atLevel;
}
}
if (IsReplicationGuide()) {
var guides = new List<AssociativeNode>();
Expect(17);
string repguide = String.Empty;
bool isLongest = false;
ReplicationGuideNode repGuideNode = null;
if (IsPostfixedReplicationGuide()) {
Expect(7);
isLongest = true;
} else if (la.kind == 2) {
Get();
isLongest = false;
} else SynErr(100);
repguide = t.val;
if (isLongest)
{
repguide = repguide.Remove(repguide.Length - 1);
}
var numNode = new IdentifierNode() { Value = repguide };
repGuideNode = new ReplicationGuideNode();
repGuideNode.RepGuide = numNode;
repGuideNode.IsLongest = isLongest;
NodeUtils.SetNodeLocation(numNode, t);
Expect(18);
guides.Add(repGuideNode);
while (la.kind == 17) {
Get();
if (IsPostfixedReplicationGuide()) {
Expect(7);
isLongest = true;
} else if (la.kind == 2) {
Get();
isLongest = false;
} else SynErr(101);
repguide = t.val;
if (isLongest)
{
repguide = repguide.Remove(repguide.Length - 1);
}
numNode = AstFactory.BuildIdentifier(repguide);
repGuideNode = new ReplicationGuideNode();
repGuideNode.RepGuide = numNode;
repGuideNode.IsLongest = isLongest;
NodeUtils.SetNodeLocation(numNode, t);
Expect(18);
guides.Add(repGuideNode);
}
nameNode.ReplicationGuides = guides;
if (groupExprNode != null)
{
var expr = groupExprNode.Expression;
if (expr is IdentifierListNode)
{
var rightNode = (expr as IdentifierListNode).RightNode;
if (rightNode is ArrayNameNode)
{
var rightMostArrayNameNode = rightNode as ArrayNameNode;
if (rightMostArrayNameNode.ReplicationGuides == null)
{
rightMostArrayNameNode.ReplicationGuides = guides;
}
else
{
rightMostArrayNameNode.ReplicationGuides.InsertRange(0, guides);
}
groupExprNode.ReplicationGuides = null;
}
}
else if (expr is FunctionDotCallNode)
{
var functionCall = (expr as FunctionDotCallNode).FunctionCall;
var function = (functionCall.Function as ArrayNameNode);
if (function.ReplicationGuides == null)
{
function.ReplicationGuides = guides;
}
else
{
function.ReplicationGuides.InsertRange(0, guides);
}
groupExprNode.ReplicationGuides = null;
}
}
}
if (groupExprNode != null && groupExprNode.ArrayDimensions == null && (groupExprNode.ReplicationGuides == null || groupExprNode.ReplicationGuides.Count == 0))
{
node = groupExprNode.Expression;
}
else
{
node = nameNode;
}
}
/// <summary>
/// Apppend replication guide to the input parameter based on lacing
/// strategy.
/// </summary>
/// <param name="inputs"></param>
/// <returns></returns>
private void AppendReplicationGuides(List<AssociativeNode> inputs)
{
if (inputs == null || !inputs.Any())
return;
switch (ArgumentLacing)
{
case LacingStrategy.Longest:
for (int i = 0; i < inputs.Count(); ++i)
{
if (inputs[i] is ArrayNameNode)
{
var astNode = NodeUtils.Clone(inputs[i]) as ArrayNameNode;
astNode.ReplicationGuides = new List<AssociativeNode>();
var guideNode = new ReplicationGuideNode
{
RepGuide = AstFactory.BuildIdentifier("1"),
IsLongest = true
};
astNode.ReplicationGuides.Add(guideNode);
inputs[i] = astNode;
}
}
break;
case LacingStrategy.CrossProduct:
int guide = 1;
for (int i = 0; i < inputs.Count(); ++i)
{
if (inputs[i] is ArrayNameNode)
{
var astNode = NodeUtils.Clone(inputs[i]) as ArrayNameNode;
astNode.ReplicationGuides = new List<AssociativeNode>();
var guideNode = new ReplicationGuideNode
{
RepGuide = AstFactory.BuildIdentifier(guide.ToString())
};
astNode.ReplicationGuides.Add(guideNode);
inputs[i] = astNode;
guide++;
}
}
break;
}
}
