public ContainerAccumulationYield(String variable, String unprefixedVariable, String variableType, String index, String unprefixedIndex, String indexType, String container, String unprefixedContainer, String containerType, Yielding[] statement)
{
Variable = variable;
UnprefixedVariable = unprefixedVariable;
VariableType = variableType;
Index = index;
UnprefixedIndex = unprefixedIndex;
IndexType = indexType;
Container = container;
UnprefixedContainer = unprefixedContainer;
ContainerType = containerType;
Statements = statement;
}
public IteratedAccumulationYield(String variable, String unprefixedVariable, String iterated, Yielding[] statements)
{
Variable = variable;
UnprefixedVariable = unprefixedVariable;
Iterated = iterated;
Statements = statements;
}
public override Yielding Copy(string renameSuffix)
{
Yielding[] statementsCopy = new Yielding[Statements.Length];
for(int i = 0; i < Statements.Length; ++i)
statementsCopy[i] = Statements[i].Copy(renameSuffix);
return new IteratedAccumulationYield(Variable + renameSuffix, UnprefixedVariable + renameSuffix, Iterated, statementsCopy);
}
public override Yielding Copy(string renameSuffix)
{
Yielding[] statementsCopy = new Yielding[Statements.Length];
for(int i = 0; i < Statements.Length; ++i)
statementsCopy[i] = Statements[i].Copy(renameSuffix);
return new ForIndexAccessEquality(IndexSetType, Index, Variable + renameSuffix, UnprefixedVariable + renameSuffix, VariableType,
Expr.Copy(renameSuffix), statementsCopy);
}
public override Yielding Copy(string renameSuffix)
{
Yielding[] statementsCopy = new Yielding[Statements.Length];
for(int i = 0; i < Statements.Length; ++i)
statementsCopy[i] = Statements[i].Copy(renameSuffix);
return new MultiStatement(statementsCopy);
}
public override Yielding Copy(string renameSuffix)
{
Yielding[] statementsCopy = new Yielding[Statements.Length];
for(int i = 0; i < Statements.Length; ++i)
statementsCopy[i] = Statements[i].Copy(renameSuffix);
return new IntegerRangeIterationYield(Variable + renameSuffix, UnprefixedVariable + renameSuffix, VariableType, Left, Right, statementsCopy);
}
public override Yielding Copy(string renameSuffix)
{
Yielding[] statementsCopy = new Yielding[Statements.Length];
for(int i = 0; i < Statements.Length; ++i)
statementsCopy[i] = Statements[i].Copy(renameSuffix);
return new ForFunction(Variable + renameSuffix, UnprefixedVariable + renameSuffix, VariableType, Function.Copy(renameSuffix), statementsCopy);
}
public override Yielding Copy(string renameSuffix)
{
Yielding[] statementsCopy = new Yielding[Statements.Length];
for(int i = 0; i < Statements.Length; ++i)
statementsCopy[i] = Statements[i].Copy(renameSuffix);
return new CaseStatement(CaseConstExpression!=null ? CaseConstExpression.Copy(renameSuffix) : null, statementsCopy);
}
public WhileStatement(Expression condition, Yielding[] loopedStatements)
{
Condition = condition;
LoopedStatements = loopedStatements;
}
public override Yielding Copy(string renameSuffix)
{
Yielding[] trueCaseStatementsCopy = new Yielding[TrueCaseStatements.Length];
for(int i = 0; i < TrueCaseStatements.Length; ++i)
trueCaseStatementsCopy[i] = TrueCaseStatements[i].Copy(renameSuffix);
Yielding[] falseCaseStatementsCopy = null;
if(FalseCaseStatements != null)
{
falseCaseStatementsCopy = new Yielding[FalseCaseStatements.Length];
for(int i = 0; i < FalseCaseStatements.Length; ++i)
falseCaseStatementsCopy[i] = FalseCaseStatements[i].Copy(renameSuffix);
}
return new ConditionStatement(Condition.Copy(renameSuffix), trueCaseStatementsCopy, falseCaseStatementsCopy);
}
public CaseStatement(Expression switchExpression, Yielding[] statements)
{
CaseConstExpression = switchExpression;
Statements = statements;
}
public ConditionStatement(Expression condition, Yielding[] trueCaseStatements, Yielding[] falseCaseStatements)
{
Condition = condition;
TrueCaseStatements = trueCaseStatements;
FalseCaseStatements = falseCaseStatements;
}
public override Yielding Copy(string renameSuffix)
{
Yielding[] statementsCopy = new Yielding[Statements.Length];
for(int i = 0; i < Statements.Length; ++i)
statementsCopy[i] = Statements[i].Copy(renameSuffix);
return new ForIndexAccessOrdering(IndexSetType, Index, Variable + renameSuffix, UnprefixedVariable + renameSuffix, VariableType,
Ascending, IncludingFrom, IncludingTo, From!=null ? From.Copy(renameSuffix) : null, To!=null ? To.Copy(renameSuffix) : null,
statementsCopy);
}
public ForIndexAccessOrdering(String indexSetType, IndexDescription index, String variable, String unprefixedVariable, String variableType,
bool ascending, bool includingFrom, bool includingTo,
Expression from, Expression to, Yielding[] statements)
{
IndexSetType = indexSetType;
Index = index;
Variable = variable;
UnprefixedVariable = unprefixedVariable;
VariableType = variableType;
Ascending = ascending;
IncludingFrom = includingFrom;
IncludingTo = includingTo;
From = from;
To = to;
Statements = statements;
}
public override Yielding Copy(string renameSuffix)
{
Yielding[] statementsCopy = new Yielding[Statements.Length];
for(int i = 0; i < Statements.Length; ++i)
statementsCopy[i] = Statements[i].Copy(renameSuffix);
if(Index != null)
return new ContainerAccumulationYield(Variable + renameSuffix, UnprefixedVariable + renameSuffix, VariableType, Index + renameSuffix, UnprefixedIndex + renameSuffix, IndexType, Container, UnprefixedContainer + renameSuffix, ContainerType, statementsCopy);
else
return new ContainerAccumulationYield(Variable + renameSuffix, UnprefixedVariable + renameSuffix, VariableType, Container, UnprefixedContainer + renameSuffix, ContainerType, statementsCopy);
}
public DoWhileStatement(Yielding[] loopedStatements, Expression condition)
{
LoopedStatements = loopedStatements;
Condition = condition;
}
public IntegerRangeIterationYield(String variable, String unprefixedVariable, String variableType,
Expression left, Expression right, Yielding[] statements)
{
Variable = variable;
UnprefixedVariable = unprefixedVariable;
VariableType = variableType;
Left = left;
Right = right;
Statements = statements;
}
public override Yielding Copy(string renameSuffix)
{
Yielding[] loopedStatementsCopy = new Yielding[LoopedStatements.Length];
for(int i = 0; i < LoopedStatements.Length; ++i)
loopedStatementsCopy[i] = LoopedStatements[i].Copy(renameSuffix);
return new WhileStatement(Condition.Copy(renameSuffix), loopedStatementsCopy);
}
public ForFunction(String variable, String unprefixedVariable, String variableType, Expression function, Yielding[] statements)
{
Variable = variable;
UnprefixedVariable = unprefixedVariable;
VariableType = variableType;
Function = function;
Statements = statements;
}
public MultiStatement(Yielding[] statements)
{
Statements = statements;
}
////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Constructs a PatternYielding object.
/// </summary>
/// <param name="name">The name of the yielding to execute.</param>
/// <param name="elementaryYieldings">An array of elementary yieldings to execute.</param>
/// <param name="neededNodes">An array of node names needed by this yielding.</param>
/// <param name="neededEdges">An array of edge names needed by this yielding.</param>
/// <param name="neededVariables">An array of variable names needed by this yielding.</param>
/// <param name="neededVariableTypes">An array of variable types (corresponding to the variable names) needed by this yielding.</param>
public PatternYielding(String name, Yielding[] elementaryYieldings,
String[] neededNodes, String[] neededEdges, String[] neededVariables, VarType[] neededVariableTypes)
{
Name = name;
ElementaryYieldings = elementaryYieldings;
NeededNodes = neededNodes;
NeededEdges = neededEdges;
NeededVariables = neededVariables;
NeededVariableTypes = neededVariableTypes;
}
public ForIndexAccessEquality(String indexSetType, IndexDescription index, String variable, String unprefixedVariable, String variableType, Expression expr, Yielding[] statements)
{
IndexSetType = indexSetType;
Index = index;
Variable = variable;
UnprefixedVariable = unprefixedVariable;
VariableType = variableType;
Expr = expr;
Statements = statements;
}
