public bool Run(ForStatement forStatement, Variable breakFlag, string keywordName, ParsingResult logger) { keyword = keywordName; Visit(forStatement.Body); if (logger != null) parserResult.CopyTo(logger); if (parserResult.HasErrors) return false; TransformBreaks(breakFlag); return scopeList.Count > 0; }
public virtual void Visit(ForStatement forStatement) { WriteLine(); WriteLinkLine(forStatement); Visit((Statement)forStatement); Write("for").WriteSpace().Write("("); EnableNewLine = false; VisitDynamic(forStatement.Start); WriteSpace(); VisitDynamic(forStatement.Condition); Write(";"); WriteSpace(); VisitDynamic(forStatement.Next); EnableNewLine = true; Write(")"); WriteStatementContent(forStatement.Body); }
/// <summary> /// Creates a ForStatement with the same behavior /// </summary> /// <param name="forEachStatement">the ForEachStatement</param> /// <returns>the ForStatement</returns> private static ForStatement ExpandForEachStatement(ForEachStatement forEachStatement) { if (forEachStatement != null) { var collec = forEachStatement.Collection.TypeInference.Declaration as Variable; LiteralExpression dimLit = null; if (collec.Type is ArrayType) { if ((collec.Type as ArrayType).Dimensions.Count == 1) { dimLit = (collec.Type as ArrayType).Dimensions[0] as LiteralExpression; } } if (dimLit != null) { var initializer = new Variable(ScalarType.Int, forEachStatement.Variable.Name.Text + "Iter", new LiteralExpression(0)); var vre = new VariableReferenceExpression(initializer.Name); var condition = new BinaryExpression(BinaryOperator.Less, vre, dimLit); var next = new UnaryExpression(UnaryOperator.PreIncrement, vre); ForStatement forStatement = new ForStatement(new DeclarationStatement(initializer), condition, next); var body = new BlockStatement(); var variable = forEachStatement.Variable; variable.InitialValue = new IndexerExpression(forEachStatement.Collection, new VariableReferenceExpression(initializer)); body.Statements.Add(new DeclarationStatement(variable)); if (forEachStatement.Body is BlockStatement) body.Statements.AddRange((forEachStatement.Body as BlockStatement).Statements); else body.Statements.Add(forEachStatement.Body); forStatement.Body = body; return forStatement; } // TODO: multidimension-array? // TODO: unroll? // TODO: multiple foreach? } return null; }
/// <summary> /// Creates assignement statements with its default value /// </summary> /// <param name="streamStruct">the stream structure</param> /// <param name="streamName">the name of the stream</param> /// <param name="inputStruct">the input structure</param> /// <param name="initialValue">the initial value</param> /// <param name="scopeStack">???</param> /// <returns>A collection of statements</returns> private static IEnumerable<Statement> AssignStreamFromInput(StructType streamStruct, string streamName, StructType inputStruct, Expression initialValue, bool basicTransformation) { foreach (var currentField in inputStruct.Fields) { // Ignore fields that don't exist in Streams. // It could happen if HSConstantMain references a stream (gets added to HS_OUTPUT), // and in HSMain CreateStreamFromInput() is called (this stream doesn't exist in DS_STREAMS). if (streamStruct.Fields.All(x => x.Name != currentField.Name)) continue; // If we have a scope stack (advanced analysis), then convert expression by appending // field to each reference to a variable of inputStruct type // i.e. "output = input1 * 3 + input2 * 5" will become "output.A = input1.A * 3 + input2.A * 5" // Otherwise consider it is as a simple a variable reference and directly append field. if (basicTransformation) { yield return new ExpressionStatement( new AssignmentExpression( AssignmentOperator.Default, new MemberReferenceExpression(new VariableReferenceExpression(streamName), currentField.Name), new MemberReferenceExpression(initialValue, currentField.Name))); } else { //yield return AssignStreamFieldFromInput(streamName, inputStruct, initialValue, scopeStack, currentField); foreach (var field in streamStruct.Fields.Where(x => x.Name == currentField.Name)) // TODO: where might be useless { if (field.Type is ArrayType) { //create a for loop var iteratorName = field.Name.Text + "_Iter"; var iterator = new Variable(ScalarType.Int, iteratorName, new LiteralExpression(0)); var start = new DeclarationStatement(iterator); var condition = new BinaryExpression(BinaryOperator.Less, new VariableReferenceExpression(iterator), (field.Type as ArrayType).Dimensions[0]); var next = new UnaryExpression(UnaryOperator.PreIncrement, new VariableReferenceExpression(iterator)); var forLoop = new ForStatement(start, condition, next); var fieldAssigner = new StreamFieldVisitor(field, new VariableReferenceExpression(iterator)); var clonedExpression = fieldAssigner.Run(ParadoxAssignmentCloner.Run(initialValue)); forLoop.Body = new ExpressionStatement( new AssignmentExpression( AssignmentOperator.Default, new IndexerExpression(new MemberReferenceExpression(new VariableReferenceExpression(streamName), currentField.Name), new VariableReferenceExpression(iterator)), clonedExpression)); yield return forLoop; } else { var fieldAssigner = new StreamFieldVisitor(field); //var clonedExpression = fieldAssigner.Run(initialValue.DeepClone()); var clonedExpression = fieldAssigner.Run(ParadoxAssignmentCloner.Run(initialValue)); yield return new ExpressionStatement( new AssignmentExpression( AssignmentOperator.Default, new MemberReferenceExpression(new VariableReferenceExpression(streamName), currentField.Name), clonedExpression)); } } } } }
protected void Visit(ForStatement forStatement) { }
public override void Visit(ForStatement forStatement) { }