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) { }