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; }