/// <summary>
/// generate local variables and code to do the calculation of the math.
/// the calculation result is assigned to the variable this[4]
/// </summary>
/// <returns></returns>
public override void ExportCodeStatements(IMethodCompile method)
{
MathNode.Trace("ExportCodeStatements for {0}", this.GetType());
//0:function
//1:index
//2:begin
//3:end
//4:sum
OnPrepareVariable(method);
CodeVariableReferenceExpression sum = new CodeVariableReferenceExpression(((IVariable)this[4]).CodeVariableName);
CodeVariableDeclarationStatement p;
if (((IVariable)this[4]).VariableType.Type.IsValueType)
{
p = new CodeVariableDeclarationStatement(((IVariable)this[4]).VariableType.Type, ((IVariable)this[4]).CodeVariableName);
}
else
{
p = new CodeVariableDeclarationStatement(((IVariable)this[4]).VariableType.Type, ((IVariable)this[4]).CodeVariableName,
ValueTypeUtil.GetDefaultCodeByType(((IVariable)this[4]).VariableType.Type));
}
method.MethodCode.Statements.Add(p);
CodeExpression idx = this[1].ExportCode(method);
CodeIterationStatement cis = new CodeIterationStatement(
new CodeVariableDeclarationStatement(this[1].DataType.Type, ((IVariable)this[1]).CodeVariableName,
this[2].ExportCode(method)),
new CodeBinaryOperatorExpression(idx, CodeBinaryOperatorType.LessThanOrEqual, this[3].ExportCode(method)),
new CodeAssignStatement(idx, new CodeBinaryOperatorExpression(idx, CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))),
new CodeStatement[] {
new CodeAssignStatement(sum, new CodeBinaryOperatorExpression(sum, CodeBinaryOperatorType.Add, this[0].ExportCode(method)))
});
method.MethodCode.Statements.Add(cis);
}
public CodeIterationStatement forOn(CodeStatement initStatement,
CodeStatement incrementStatement)
{
currFor = forOn(initStatement);
forInc(incrementStatement);
return(currFor);
}
/// <inheritdoc/>
protected override void HandleWhile(CodeIterationStatement obj, Context ctx)
{
ctx.Writer.Write("while (");
ctx.HandlerProvider.ExpressionHandler.Handle(obj.TestExpression, ctx);
ctx.Writer.Write(")");
CSharpUtils.HandleStatementCollection(obj.Statements, ctx, true, false);
}
public StatementBuilder AddForLoop(string iteratorName, int numLoops, StatementBuilder builder)
{
// Declares and initializes an integer variable named testInt.
CodeVariableDeclarationStatement iteratorVariable = new CodeVariableDeclarationStatement(typeof(int), iteratorName, new CodePrimitiveExpression(0));
var iteratorReference = new CodeVariableReferenceExpression(iteratorName);
// Creates a for loop that sets testInt to 0 and continues incrementing testInt by 1 each loop until testInt is not less than 10.
CodeIterationStatement forLoop = new CodeIterationStatement(
// initStatement parameter for pre-loop initialization.
new CodeAssignStatement(iteratorReference, new CodePrimitiveExpression(0)),
// testExpression parameter to test for continuation condition.
new CodeBinaryOperatorExpression(
iteratorReference,
CodeBinaryOperatorType.LessThan,
new CodePrimitiveExpression(numLoops)),
// incrementStatement parameter indicates statement to execute after each iteration.
new CodeAssignStatement(iteratorReference, new CodeBinaryOperatorExpression(
iteratorReference, CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))),
// statements parameter contains the statements to execute during each interation of the loop.
// Each loop iteration the value of the integer is output using the Console.WriteLine method.
builder.Expressions.ToArray()
);
Expressions.Add(iteratorVariable);
Expressions.Add(forLoop);
/*var body = new CodeStatement[] { new CodeExpressionStatement( new CodeMethodInvokeExpression( new CodeMethodReferenceExpression(
new CodeTypeReferenceExpression("Console"), "WriteLine" ), new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression("testInt"), "ToString" ) ) ) }
*/
return this;
}
private CodeIterationStatement GenerateForRepeat(GroupActivity groupActivity, bool isRepeat)
{
var coreGroupMethodStatement = new CodeStatementCollection();
// get the core loop code
coreGroupMethodStatement.AddRange(this.GenerateCoreGroupMethod(groupActivity));
var coreOfTheLoop = new CodeStatement[coreGroupMethodStatement.Count];
coreGroupMethodStatement.CopyTo(coreOfTheLoop, 0);
string outCondition;
if (isRepeat)
{
outCondition = "!(" + this.xpathBuilder.Build(groupActivity.RepeatCondition) + ")";
}
else
{
outCondition = this.xpathBuilder.Build(groupActivity.RepeatCondition);
}
var whileLoop = new CodeIterationStatement(
new CodeSnippetStatement(string.Empty),
new CodeSnippetExpression(outCondition),
new CodeSnippetStatement(string.Empty),
coreOfTheLoop);
return(whileLoop);
}
private static CodeIterationStatement CreateLoopOverEvents(AsyncDomainHook hook)
{
var codeWhile = new CodeIterationStatement();
codeWhile.IncrementStatement = new CodeSnippetStatement("");
codeWhile.InitStatement = new CodeSnippetStatement("");
codeWhile.TestExpression = new CodeSnippetExpression("enumerator.MoveNext()");
codeWhile.Statements.Add(new CodeSnippetExpression("var eventWrapper = enumerator.Current"));
codeWhile.Statements.Add(new CodeSnippetExpression($"var domainEvent = ({hook.ClassType}{hook.MethodName}Event) eventWrapper.DomainEvent"));
if (hook.IsCreateHook)
{
codeWhile.Statements.Add(new CodeSnippetExpression($"var entity = await {hook.ClassType}Repository.Get{hook.ClassType}(domainEvent.Id)"));
}
if (hook.IsCreateHook)
{
codeWhile.Statements.Add(new CodeSnippetExpression($"var newCreateEvent = new {hook.ClassType}{hook.MethodName}Event(entity, domainEvent.EntityId)"));
}
if (hook.IsCreateHook)
{
codeWhile.Statements.Add(new CodeSnippetExpression($"var hookResult = await AsyncHook.Execute(newCreateEvent)"));
}
else
{
codeWhile.Statements.Add(new CodeSnippetExpression($"var hookResult = await AsyncHook.Execute(domainEvent)"));
}
codeWhile.Statements.Add(CreateIfState());
return(codeWhile);
}
private static void AddWriteXml(CodeTypeDeclaration classToGen)
{
CodeMemberMethod writeXml = new CodeMemberMethod();
writeXml.Name = "WriteXml";
writeXml.Attributes = MemberAttributes.Public;
writeXml.ImplementationTypes.Add(classToGen.BaseTypes[1]);
writeXml.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(Microsoft.Xml.XmlWriter)), "writer"));
CodeVariableDeclarationStatement enumeratorDec =
new CodeVariableDeclarationStatement(
CreateTypeReference("System.Collections.Generic.IEnumerator`1", xelementType), "e",
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("nodesList"), "GetEnumerator"));
writeXml.Statements.Add(enumeratorDec);
CodeVariableReferenceExpression eRef = new CodeVariableReferenceExpression("e");
CodePropertyReferenceExpression eCurrent = new CodePropertyReferenceExpression(eRef, "Current");
CodeCastExpression iXmlSerCast = new CodeCastExpression(new CodeTypeReference(typeof(Microsoft.Xml.Serialization.IXmlSerializable)), eCurrent);
CodeMethodInvokeExpression codeWrite = new CodeMethodInvokeExpression(iXmlSerCast, "WriteXml", new CodeVariableReferenceExpression("writer"));
CodeIterationStatement codeFor = new CodeIterationStatement();
codeFor.TestExpression = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeVariableReferenceExpression("e"), "MoveNext"));
codeFor.Statements.Add(codeWrite);
codeFor.IncrementStatement = new CodeSnippetStatement("");
codeFor.InitStatement = new CodeSnippetStatement("");
writeXml.Statements.Add(codeFor);
classToGen.Members.Add(writeXml);
}
private CodeIterationStatement GenerateForLoop(GroupActivity groupActivity)
{
var coreGroupMethodStatement = new CodeStatementCollection();
// put the current element in the declare variable
// TODO convert the $Variable in variable like in Xpath
var iterationElementSlotDeclaration = new CodeVariableDeclarationStatement("var", groupActivity.IterationElementSlot, new CodeVariableReferenceExpression(this.xpathBuilder.Build(groupActivity.Over) + "[" + groupActivity.IndexSlot + "]"));
coreGroupMethodStatement.Add(iterationElementSlotDeclaration);
// Get the core loop code
coreGroupMethodStatement.AddRange(this.GenerateCoreGroupMethod(groupActivity));
var coreOfTheLoop = new CodeStatement[coreGroupMethodStatement.Count];
coreGroupMethodStatement.CopyTo(coreOfTheLoop, 0);
// put it then in the loop
var forLoop = new CodeIterationStatement(
new CodeVariableDeclarationStatement(typeof(int), groupActivity.IndexSlot, new CodePrimitiveExpression(0)),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(groupActivity.IndexSlot), CodeBinaryOperatorType.LessThan, new CodeVariableReferenceExpression(this.xpathBuilder.Build(groupActivity.Over) + ".Length")),
new CodeAssignStatement(new CodeVariableReferenceExpression(groupActivity.IndexSlot), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(groupActivity.IndexSlot), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))),
coreOfTheLoop);
return(forLoop);
}
void EmitIterationStatement(CodeIterationStatement Iterate)
{
Depth++;
Debug("Emitting iteration statement");
// Used for break and continue later on
var Meta = new LoopMetadata {
Begin = Generator.DefineLabel(),
End = Generator.DefineLabel(),
};
Loops.Push(Meta);
EmitStatement(Iterate.InitStatement, false);
// The beginning of our loop: check the limit
Generator.MarkLabel(Meta.Begin);
EmitExpression(Iterate.TestExpression, false);
Generator.Emit(OpCodes.Brfalse, Meta.End);
// Emit the actual statements within
EmitStatementCollection(Iterate.Statements);
// Increase the counter by one
EmitStatement(Iterate.IncrementStatement, false);
// Start all over again
Generator.Emit(OpCodes.Br, Meta.Begin);
Generator.MarkLabel(Meta.End);
Loops.Pop();
Depth--;
}
private CodeStatement[] GenerateSerializeVectorStatements(Variable var)
{
List <CodeStatement> retVal = new List <CodeStatement>();
retVal.Add(new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("writer"), "WriteShort", new CodeExpression[] { new CodeCastExpression(typeof(short), new CodeVariableReferenceExpression("m_" + var.Name + ".Count")) })));
retVal.Add(new CodeVariableDeclarationStatement(typeof(int), var.Name + "Index"));
CodeIterationStatement forStatement = GenerateForStatement(new CodeVariableReferenceExpression("m_" + var.Name + ".Count"), new CodeVariableReferenceExpression(var.Name + "Index"));
switch (var.MethodeType)
{
case ReadMethodeType.ProtocolTypeManager:
forStatement.Statements.Add(new CodeVariableDeclarationStatement(var.ObjectType, "objectToSend", new CodeArrayIndexerExpression(new CodeVariableReferenceExpression("m_" + var.Name), new CodeExpression[] { new CodeVariableReferenceExpression(var.Name + "Index") })));
forStatement.Statements.Add(new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("writer"), "WriteUShort", new CodeExpression[] { new CodeCastExpression(typeof(ushort), new CodeVariableReferenceExpression("objectToSend.ProtocolId")) })));
forStatement.Statements.Add(new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("objectToSend"), "Serialize", new CodeExpression[] { new CodeVariableReferenceExpression("writer") })));
break;
case ReadMethodeType.SerializeOrDeserialize:
forStatement.Statements.Add(new CodeVariableDeclarationStatement(var.ObjectType, "objectToSend", new CodeArrayIndexerExpression(new CodeVariableReferenceExpression("m_" + var.Name), new CodeExpression[] { new CodeVariableReferenceExpression(var.Name + "Index") })));
forStatement.Statements.Add(new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("objectToSend"), "Serialize", new CodeExpression[] { new CodeVariableReferenceExpression("writer") })));
break;
case ReadMethodeType.Primitive:
forStatement.Statements.Add(new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("writer"), var.WriteMethode, new CodeExpression[] { new CodeArrayIndexerExpression(new CodeVariableReferenceExpression("m_" + var.Name), new CodeExpression[] { new CodeVariableReferenceExpression(var.Name + "Index") }) })));
break;
}
retVal.Add(forStatement);
return(retVal.ToArray());
}
private static CodeIterationStatement GetReturnAttributeLoop()
{
/*
* for (var i=0; i < members.Length; i++)
* {
* var attribute = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(enumType, typeof(OptionSetMetadataAttribute));
* if (attribute != null)struct
* {
* return (OptionSetMetadataAttribute)attribute;
* }
* }
*/
var loopInit = new CodeVariableDeclarationStatement
{
Type = new CodeTypeReference(typeof(int)),
Name = "i",
InitExpression = new CodePrimitiveExpression(0)
};
var loopTest = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.LessThan, new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("members"), "Length"));
var loop = new CodeIterationStatement(loopInit, loopTest, new CodeSnippetStatement("i++"),
new CodeVariableDeclarationStatement
{
Type = new CodeTypeReference(typeof(Attribute)),
Name = "attribute",
InitExpression = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(CustomAttributeExtensions)), "GetCustomAttribute", new CodeVariableReferenceExpression("members[i]"), new CodeTypeOfExpression(new CodeTypeReference("OptionSetMetadataAttribute")))
},
new CodeConditionStatement(new CodeSnippetExpression("attribute != null"),
new CodeMethodReturnStatement(new CodeCastExpression(new CodeTypeReference("OptionSetMetadataAttribute"), new CodeVariableReferenceExpression("attribute"))))
);
return(loop);
}
static CodeStatement _ParseWhileStatement(_PC pc)
{
var l = pc.Line;
var c = pc.Column;
var p = pc.Position;
if (ST.whileKeyword != pc.SymbolId)
{
pc.Error("Expecting while");
}
pc.Advance();
if (ST.lparen != pc.SymbolId)
{
pc.Error("Expecting ( in while statement");
}
pc.Advance();
var test = _ParseExpression(pc);
if (ST.rparen != pc.SymbolId)
{
pc.Error("Expecting ) in while statement");
}
pc.Advance();
var result = new CodeIterationStatement(new CodeSnippetStatement().SetLoc(l, c, p), test, new CodeSnippetStatement().SetLoc(l, c, p)).Mark(l, c, p);
result.Statements.AddRange(_ParseStatementOrBlock(pc));
return(result);
}
public CodeIterationStatementExample()
{
//<Snippet2>
// Declares and initializes an integer variable named testInt.
CodeVariableDeclarationStatement testInt = new CodeVariableDeclarationStatement(typeof(int), "testInt", new CodePrimitiveExpression(0));
// Creates a for loop that sets testInt to 0 and continues incrementing testInt by 1 each loop until testInt is not less than 10.
CodeIterationStatement forLoop = new CodeIterationStatement(
// initStatement parameter for pre-loop initialization.
new CodeAssignStatement(new CodeVariableReferenceExpression("testInt"), new CodePrimitiveExpression(1)),
// testExpression parameter to test for continuation condition.
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("testInt"),
CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(10)),
// incrementStatement parameter indicates statement to execute after each iteration.
new CodeAssignStatement(new CodeVariableReferenceExpression("testInt"), new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("testInt"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))),
// statements parameter contains the statements to execute during each interation of the loop.
// Each loop iteration the value of the integer is output using the Console.WriteLine method.
new CodeStatement[] { new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(
new CodeTypeReferenceExpression("Console"), "WriteLine"), new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression("testInt"), "ToString"))) });
// A C# code generator produces the following source code for the preceeding example code:
// int testInt = 0;
// for (testInt = 1; (testInt < 10); testInt = (testInt + 1)) {
// Console.WriteLine(testInt.ToString());
//</Snippet2>
}
/// <summary>
///
/// </summary>
/// <param name="previousAction"></param>
/// <param name="nextAction"></param>
/// <param name="compiler"></param>
/// <param name="method"></param>
/// <param name="statements"></param>
public override bool OnExportCode(ActionBranch previousAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, CodeMemberMethod method, CodeStatementCollection statements)
{
string indexName = RepeatIndex.CodeName;
CodeExpression c = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(indexName), CodeBinaryOperatorType.LessThan, RepeatCount.GetReferenceCode(Method, statements, true));
CodeIterationStatement cis = new CodeIterationStatement();
cis.TestExpression = c;
cis.InitStatement = new CodeVariableDeclarationStatement(typeof(int), indexName, new CodePrimitiveExpression(0));
cis.IncrementStatement = new CodeSnippetStatement(indexName + "++");
statements.Add(cis);
if (_iconList != null)
{
foreach (ComponentIcon ci in _iconList)
{
ComponentIconLocal cil = ci as ComponentIconLocal;
if (cil != null && cil.ScopeGroupId == this.BranchId)
{
cil.LocalPointer.AddVariableDeclaration(cis.Statements);
}
}
}
SetWithinLoop();
Method.SubMethod.Push(this);
CompilerUtil.AddSubMethod(method, this);
bool bRet = base.OnExportCode(previousAction, nextAction, compiler, method, cis.Statements);
Method.SubMethod.Pop();
bRet = CompilerUtil.FinishSubMethod(method, this, cis.Statements, bRet);
return(bRet);
}
public void Visit(WhileStatement whileStatement)
{
using (Scope.Push(_mainType))
{
var tableArg = VisitChild(whileStatement.TableReference);
CodeMemberMethod method = new CodeMemberMethod();
method.Name = "While_" + tableArg.MethodIdentifier;
method.Attributes = MemberAttributes.Private;
GenerateCallStatement(method.Statements, whileStatement.Line.Line);
var loop = new CodeIterationStatement();
loop.InitStatement = new CodeSnippetStatement();
loop.IncrementStatement = new CodeSnippetStatement();
loop.TestExpression = new CodeBinaryOperatorExpression(new CodePropertyReferenceExpression(tableArg.CodeExpression, "RowCount"), CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(0));
method.Statements.Add(loop);
var blockArgs = VisitChild(whileStatement.Block, new CodeDomArg()
{
Tag = true
});
loop.Statements.AddRange(blockArgs.ParentStatements);
var methodcall = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(null, method.Name));
_mainType.Type.Members.Add(method);
_codeStack.Peek().ParentStatements.Add(methodcall);
_codeStack.Peek().CodeExpression = methodcall;
}
}
private static CodeStatement LoopThroughArray(CodeExpression array, CodeStatementCollection statements)
{
var returnValue = new CodeIterationStatement
{
InitStatement =
new CodeAssignStatement(new CodeVariableReferenceExpression("index"), new CodePrimitiveExpression(0)),
TestExpression = new CodeBinaryOperatorExpression
{
Left = new CodeVariableReferenceExpression("index"),
Operator = CodeBinaryOperatorType.LessThan,
Right = new CodePropertyReferenceExpression
{
PropertyName = "Length",
TargetObject = array
}
},
IncrementStatement = new CodeAssignStatement
{
Left = new CodeVariableReferenceExpression("index"),
Right = new CodeBinaryOperatorExpression
{
Left = new CodeVariableReferenceExpression("index"),
Operator = CodeBinaryOperatorType.Add,
Right = new CodePrimitiveExpression(1)
}
}
};
returnValue.Statements.AddRange(statements);
return(returnValue);
}
static CodeIterationStatement _ParseWhileStatement(_PC pc)
{
// expects to be on while.
if (!pc.Advance())
{
throw new ArgumentException("Unterminated while statement", "input");
}
_SkipComments(pc);
if (ST.lparen != pc.SymbolId || !pc.Advance())
{
throw new ArgumentException("Unterminated while statement", "input");
}
_SkipComments(pc);
if (pc.IsEnded)
{
throw new ArgumentException("Unterminated while statement", "input");
}
var cnd = _ParseExpression(pc);
_SkipComments(pc);
if (ST.rparen != pc.SymbolId || !pc.Advance())
{
throw new ArgumentException("Unterminated while statement", "input");
}
_SkipComments(pc);
if (pc.IsEnded)
{
throw new ArgumentException("Unterminated while statement", "input");
}
var result = new CodeIterationStatement(new CodeSnippetStatement(), cnd, new CodeSnippetStatement());
if (ST.lbrace == pc.SymbolId)
{
if (!pc.Advance())
{
throw new ArgumentException("Unterminated while statement", "input");
}
while (!pc.IsEnded && ST.rbrace != pc.SymbolId)
{
result.Statements.Add(_ParseStatement(pc, true));
}
if (ST.rbrace != pc.SymbolId)
{
throw new ArgumentException("Unterminated while statement", "input");
}
pc.Advance();
_SkipComments(pc);
if (pc.IsEnded)
{
return(result);
}
}
else
{
result.Statements.Add(_ParseStatement(pc));
}
_SkipComments(pc);
return(result);
}
private void ValidateIterationStatement(CodeIterationStatement e)
{
this.ValidateStatement(e.InitStatement);
this.ValidateExpression(e.TestExpression);
this.ValidateStatement(e.IncrementStatement);
this.ValidateStatements(e.Statements);
}
public override void ExportCodeStatements(IMethodCompile method)
{
MathNode.Trace("ExportCodeStatements for {0}", this.GetType());
//0: start
//1: end
//2: function
//3: dx IsParam
//4: sum IsLocal
//5: summing index IsLocal IsParam
base.ExportCodeStatements(method);
//assign code expression to all x in the function
OnPrepareVariable(method);
MathNodeVariable.DeclareVariable(method.MethodCode.Statements, (IVariable)this[4]);
CodeVariableReferenceExpression sum = new CodeVariableReferenceExpression(((IVariable)this[4]).CodeVariableName);
method.MethodCode.Statements.Add(new CodeAssignStatement(sum, new CodePrimitiveExpression(0)));
CodeExpression c5 = this.GetParameterCode(method, 5);
CodeIterationStatement cis = new CodeIterationStatement(
new CodeVariableDeclarationStatement(this[5].DataType.Type, ((IVariable)this[5]).CodeVariableName,
new CodePrimitiveExpression(1)),
new CodeBinaryOperatorExpression(c5, CodeBinaryOperatorType.LessThanOrEqual, new CodePrimitiveExpression(_intervals - 1)),
new CodeAssignStatement(c5, new CodeBinaryOperatorExpression(c5, CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))),
new CodeStatement[] {
new CodeAssignStatement(sum, new CodeBinaryOperatorExpression(sum, CodeBinaryOperatorType.Add, this.GetParameterCode(method, 2)))
});
method.MethodCode.Statements.Add(cis);
//clear code expression to all x in the function
this[2].AssignCodeExp(null, ((MathNodeVariable)this[3]).CodeVariableName);
}
protected override void GenerateIterationStatement
(CodeIterationStatement e)
{
if (e.InitStatement != null)
{
GenerateStatement(e.InitStatement);
}
Output.Write("While ");
if (e.TestExpression != null)
{
GenerateExpression(e.TestExpression);
}
else
{
Output.Write("True");
}
Output.WriteLine();
++Indent;
GenerateStatements(e.Statements);
if (e.IncrementStatement != null)
{
GenerateStatement(e.IncrementStatement);
}
--Indent;
Output.WriteLine("End While");
}
void VisitCodeIterationStatement(CodeIterationStatement statement)
{
WriteLine("VisitIterationStatement");
WriteLine("Init statement follows");
using (IDisposable currentLevel = Indentation.IncrementLevel()) {
VisitCodeStatement(statement.InitStatement);
}
WriteLine("Increment statement follows");
using (IDisposable currentLevel = Indentation.IncrementLevel()) {
VisitCodeStatement(statement.IncrementStatement);
}
WriteLine("Test expression follows");
using (IDisposable currentLevel = Indentation.IncrementLevel()) {
VisitCodeExpression(statement.TestExpression);
}
WriteLine("Statements follow");
using (IDisposable currentLevel = Indentation.IncrementLevel()) {
foreach (CodeStatement currentStatement in statement.Statements)
{
VisitCodeStatement(currentStatement);
}
}
}
private CodeMemberMethod GenerateCopyTo(IEnumerable <IReference> implementingReferences, CodeTypeReference elementType, CodeExpression standardValuesRef, ITransformationContext context)
{
var copyTo = new CodeMemberMethod()
{
Name = "CopyTo",
Attributes = MemberAttributes.Public | MemberAttributes.Override,
ReturnType = null
};
copyTo.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(elementType, 1), "array"));
copyTo.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "arrayIndex"));
var arrayRef = new CodeArgumentReferenceExpression("array");
var arrayIndexRef = new CodeArgumentReferenceExpression("arrayIndex");
foreach (var reference in implementingReferences)
{
var propertyRef = GetPropertyReference(reference, context);
if (reference.UpperBound == 1)
{
var ifNull = new CodeConditionStatement();
ifNull.Condition = new CodeBinaryOperatorExpression(propertyRef, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null));
ifNull.TrueStatements.Add(new CodeAssignStatement(new CodeArrayIndexerExpression(arrayRef, arrayIndexRef), propertyRef));
ifNull.TrueStatements.Add(new CodeAssignStatement(arrayIndexRef, new CodeBinaryOperatorExpression(arrayIndexRef, CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))));
copyTo.Statements.Add(ifNull);
}
else
{
if (reference.Type == null)
{
copyTo.Statements.Add(new CodeMethodInvokeExpression(propertyRef, "CopyTo", arrayRef, arrayIndexRef));
copyTo.Statements.Add(new CodeAssignStatement(arrayIndexRef, new CodeBinaryOperatorExpression(arrayIndexRef, CodeBinaryOperatorType.Add, new CodePropertyReferenceExpression(propertyRef, "Count"))));
}
else
{
var usingEnumerator = new CodeTryCatchFinallyStatement();
var enumeratorDeclaration = new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(IEnumerator <>).Name, elementType), reference.Name.ToCamelCase() + "Enumerator");
enumeratorDeclaration.InitExpression = new CodeMethodInvokeExpression(propertyRef, "GetEnumerator");
var enumeratorRef = new CodeVariableReferenceExpression(enumeratorDeclaration.Name);
var whileElements = new CodeIterationStatement();
whileElements.InitStatement = new CodeSnippetStatement("");
whileElements.IncrementStatement = new CodeSnippetStatement("");
whileElements.TestExpression = new CodeMethodInvokeExpression(enumeratorRef, "MoveNext");
whileElements.Statements.Add(new CodeAssignStatement(new CodeArrayIndexerExpression(arrayRef, arrayIndexRef), new CodePropertyReferenceExpression(enumeratorRef, "Current")));
whileElements.Statements.Add(new CodeAssignStatement(arrayIndexRef, new CodeBinaryOperatorExpression(arrayIndexRef, CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))));
usingEnumerator.TryStatements.Add(whileElements);
usingEnumerator.FinallyStatements.Add(new CodeMethodInvokeExpression(enumeratorRef, "Dispose"));
copyTo.Statements.Add(enumeratorDeclaration);
copyTo.Statements.Add(usingEnumerator);
}
}
}
copyTo.WriteDocumentation("Copies the contents of the collection to the given array starting from the given array index", null,
new Dictionary <string, string>()
{
{ "array", "The array in which the elements should be copied" }, { "arrayIndex", "The starting index" }
});
return(copyTo);
}
static CodeStatement _ParseForStatement(_PC pc)
{
var l = pc.Line;
var c = pc.Column;
var p = pc.Position;
if (ST.forKeyword != pc.SymbolId)
{
pc.Error("Expecting for");
}
pc.Advance();
if (ST.lparen != pc.SymbolId)
{
pc.Error("Expecting ( in for statement");
}
pc.Advance();
var init = _ParseStatement(pc, false);
var test = _ParseExpression(pc);
if (ST.semi != pc.SymbolId)
{
pc.Error("Expecting ; in for statement");
}
pc.Advance();
CodeStatement inc = null;
CodeExpression ince = null;
if (ST.rparen != pc.SymbolId)
{
ince = _ParseExpression(pc);
}
if (ST.rparen != pc.SymbolId)
{
pc.Error("Expecting ) in for statement");
}
if (null == ince)
{
inc = new CodeSnippetStatement().SetLoc(pc);
}
else
{
var bo = ince as CodeBinaryOperatorExpression;
if (null != bo && CodeBinaryOperatorType.Assign == bo.Operator)
{
// probably not an attach or detach statement but we can't rule it out
var ur = bo.UserData.Contains("slang:unresolved");
inc = new CodeAssignStatement(bo.Left, bo.Right).Mark(ince, ur);
}
else
{
inc = new CodeExpressionStatement(ince).Mark(ince);
}
}
pc.Advance();
var result = new CodeIterationStatement(init, test, inc).Mark(l, c, p);
result.Statements.AddRange(_ParseStatementOrBlock(pc));
return(result);
}
public CodeIterationStatement forOn(CodeStatement initStatement,
CodeExpression testExpression, CodeStatement incrementStatement)
{
currFor = forOn(initStatement);
forTest(testExpression);
forInc(incrementStatement);
return(currFor);
}
protected override void Visit(CodeIterationStatement statement)
{
Enumerate(statement.InitStatement);
Enumerate(statement.TestExpression);
Enumerate(statement.Statements);
Enumerate(statement.TestExpression);
base.Visit(statement);
}
public void Visit(EachStatement eachStatement)
{
using (Scope.Push(_mainType))
{
var iterationArg = VisitChild(eachStatement.IterationVariable);
var tableArg = VisitChild(eachStatement.TableReference);
var rowType = iterationArg.Scope.CodeDomReference;
CodeMemberMethod method = new CodeMemberMethod();
method.Name = "Each_" + iterationArg.MethodIdentifier;
method.Attributes = MemberAttributes.Private;
GenerateCallStatement(method.Statements, eachStatement.Line.Line);
var progressInc = new CodeAssignStatement(new CodePropertyReferenceExpression(null, "TotalOperations"),
new CodeBinaryOperatorExpression(new CodePropertyReferenceExpression(null, "TotalOperations"),
CodeBinaryOperatorType.Add,
new CodePropertyReferenceExpression(tableArg.CodeExpression, "RowCount"))
);
method.Statements.Add(progressInc);
method.Statements.Add(
new CodeVariableDeclarationStatement(new CodeTypeReference("IEnumerator", rowType),
"x",
new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(tableArg.CodeExpression, "GetCopyEnumerator",
null)))
);
var loop = new CodeIterationStatement();
loop.InitStatement = new CodeSnippetStatement();
loop.IncrementStatement = new CodeSnippetStatement();
loop.TestExpression = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(new CodeTypeReferenceExpression("x"), "MoveNext",
null));
var rowReference = VisitChild(new TableVariableRowReference()
{
Id = eachStatement.IterationVariable.Variable, Line = eachStatement.IterationVariable.Line
});
loop.Statements.Add(new CodeAssignStatement(rowReference.CodeExpression, new CodePropertyReferenceExpression(new CodeTypeReferenceExpression("x"), "Current")));
var blockArgs = VisitChild(eachStatement.Block, new CodeDomArg()
{
Tag = true
});
loop.Statements.AddRange(blockArgs.ParentStatements);
CallOnProgress(loop.Statements, false);
method.Statements.Add(loop);
var methodcall = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(null, method.Name));
_mainType.Type.Members.Add(method);
_codeStack.Peek().ParentStatements.Add(methodcall);
_codeStack.Peek().CodeExpression = methodcall;
}
}
/// <summary>
/// For 循环
/// </summary>
/// <param name="inType">要循环的类型 eg. typeof(int)</param>
/// <param name="inTypeName">循环变量 eg. i</param>
/// <param name="inTypeValue">循环变量的起始值 eg. 0</param>
/// <param name="inLessthan">循环变量的临界值 eg. 10 (i等于9时结束循环)</param>
/// <returns></returns>
public CodeIterationStatement AddFor(Type inType, string inTypeName, object inTypeValue, string inLessthan)
{
CodeIterationStatement curFor = new CodeIterationStatement();
curFor.InitStatement = new CodeVariableDeclarationStatement(inType, inTypeName, new CodePrimitiveExpression(inTypeValue));
curFor.TestExpression = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(inTypeName), CodeBinaryOperatorType.LessThan, new CodeVariableReferenceExpression(inLessthan));
curFor.IncrementStatement = new CodeAssignStatement(new CodeVariableReferenceExpression(inTypeName), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(inTypeName), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1)));
return(curFor);
}
private CodeIterationStatement GenerateForStatement(CodeExpression VarCount, CodeExpression VarIndex)
{
CodeIterationStatement retVal = new CodeIterationStatement();
retVal.InitStatement = new CodeAssignStatement(VarIndex, new CodePrimitiveExpression(0));
retVal.TestExpression = new CodeBinaryOperatorExpression(VarIndex, CodeBinaryOperatorType.LessThan, VarCount);
retVal.IncrementStatement = new CodeAssignStatement(VarIndex, new CodeBinaryOperatorExpression(VarIndex, CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1)));
return(retVal);
}
public static CodeIterationStatement IterationStatement(CodeStatement initStatement, CodeExpression testExpression, CodeStatement incrementStatement, CodeStatement[] statements, CodeDirective[] startDirectives, CodeDirective[] endDirectives, CodeLinePragma linePragma)
{
var result = new CodeIterationStatement(initStatement, testExpression, incrementStatement, statements);
result.StartDirectives.AddRange(startDirectives);
result.EndDirectives.AddRange(endDirectives);
result.LinePragma = linePragma;
return(result);
}
public static CodeIterationStatement While(CodeExpression testExpression)
{
CodeIterationStatement result = new CodeIterationStatement();
result.TestExpression = testExpression;
result.IncrementStatement = new CodeSnippetStatement("");
result.InitStatement = new CodeSnippetStatement("");
return(result);
}
private void GenerateIterationStatement(CodeIterationStatement e)
{
generatingForLoop = true;
Output.Write("for (");
GenerateStatement(e.InitStatement);
Output.Write("; ");
GenerateExpression(e.TestExpression);
Output.Write("; ");
GenerateStatement(e.IncrementStatement);
Output.Write(")");
OutputStartingBrace();
generatingForLoop = false;
Indent++;
GenerateStatements(e.Statements);
Indent--;
Output.WriteLine("}");
}
public void Visit(CodeIterationStatement o)
{
g.GenerateIterationStatement(o);
}
public void ForLoops()
{
var nspace = new CodeNamespace("NSPC");
CodeTypeDeclaration class1 = new CodeTypeDeclaration("ClassWithMethod");
class1.IsClass = true;
nspace.Types.Add(class1);
var cmm = new CodeMemberMethod();
cmm.Name = "TestBasicIterationStatement";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int)), "i"));
cmm.Statements.Add(new CodeIterationStatement(new CodeAssignStatement(new
CodeVariableReferenceExpression("i"), new CodePrimitiveExpression(1)),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(8)),
new CodeAssignStatement(new CodeVariableReferenceExpression("i"),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Multiply,
new CodePrimitiveExpression(2)))));
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("i")));
class1.Members.Add(cmm);
cmm = new CodeMemberMethod();
cmm.Name = "TestComplexIterationStatement";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int)), "i"));
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int)), "a", new CodePrimitiveExpression(7)));
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int)), "b"));
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int)), "c", new CodePrimitiveExpression(9)));
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int)), "d", new CodePrimitiveExpression(2)));
CodeIterationStatement iteration = new CodeIterationStatement();
iteration.IncrementStatement = new CodeAssignStatement(new CodeVariableReferenceExpression("i"),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(1)));
iteration.InitStatement = new CodeAssignStatement(new CodeVariableReferenceExpression("i"), new
CodePrimitiveExpression(0));
iteration.TestExpression = (new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(2)));
CodeConditionStatement secondIf = new CodeConditionStatement(new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("c"), CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(10)),
new CodeAssignStatement(new CodeVariableReferenceExpression("d"), new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("d"), CodeBinaryOperatorType.Subtract, new CodePrimitiveExpression(1))));
CodeIterationStatement secondFor = new CodeIterationStatement();
secondFor.Statements.Add(secondIf);
secondFor.IncrementStatement = new CodeAssignStatement(new CodeVariableReferenceExpression("b"),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("b"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(1)));
secondFor.InitStatement = new CodeAssignStatement(new CodeVariableReferenceExpression("b"), new
CodePrimitiveExpression(0));
secondFor.TestExpression = (new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("b"),
CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(2)));
secondFor.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("d"),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("d"), CodeBinaryOperatorType.Multiply,
new CodePrimitiveExpression(2))));
CodeConditionStatement firstIf = new CodeConditionStatement();
firstIf.Condition = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.LessThan,
new CodePrimitiveExpression(16));
firstIf.TrueStatements.Add(secondFor);
iteration.Statements.Add(firstIf);
cmm.Statements.Add(iteration);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("d")));
class1.Members.Add(cmm);
AssertEqual(nspace,
@"namespace NSPC {
public class ClassWithMethod {
public static int TestBasicIterationStatement() {
int i;
for (i = 1; (i < 8); i = (i * 2)) {
}
return i;
}
public static int TestComplexIterationStatement() {
int i;
int a = 7;
int b;
int c = 9;
int d = 2;
for (i = 0; (i < 2); i = (i + 1)) {
if ((a < 16)) {
for (b = 0; (b < 2); b = (b + 1)) {
if ((c < 10)) {
d = (d - 1);
}
d = (d * 2);
}
}
}
return d;
}
}
}");
}
protected abstract void GenerateIterationStatement(CodeIterationStatement e);
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
// GENERATES (C#):
//
// namespace NSPC {
//
//
// public class ClassWithMethod {
//
// public int TestBasicIterationStatement() {
// int i;
// for (i = 1; (i < 8); i = (i * 2)) {
// }
// return i;
// }
//
// public int TestComplexIterationStatement() {
// int i;
// int a = 7;
// int b;
// int c = 9;
// int d = 2;
// for (i = 0; (i < 2); i = (i + 1)) {
// if ((a < 16)) {
// for (b = 0; (b < 2); b = (b + 1)) {
// if ((c < 10)) {
// d = (d - 1);
// }
// d = (d * 2);
// }
// }
// }
// return d;
// }
// }
// }
CodeNamespace nspace = new CodeNamespace ("NSPC");
cu.Namespaces.Add (nspace);
CodeTypeDeclaration class1 = new CodeTypeDeclaration ("ClassWithMethod");
class1.IsClass = true;
nspace.Types.Add (class1);
AddScenario ("CheckTestBasicIterationStatement");
CodeMemberMethod cmm = new CodeMemberMethod ();
cmm.Name = "TestBasicIterationStatement";
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add (new CodeVariableDeclarationStatement (new CodeTypeReference (typeof (int)), "i"));
cmm.Statements.Add (new CodeIterationStatement (new CodeAssignStatement (new
CodeVariableReferenceExpression ("i"), new CodePrimitiveExpression (1)),
new CodeBinaryOperatorExpression (new CodeVariableReferenceExpression ("i"),
CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression (8)),
new CodeAssignStatement (new CodeVariableReferenceExpression ("i"),
new CodeBinaryOperatorExpression (new CodeVariableReferenceExpression ("i"), CodeBinaryOperatorType.Multiply,
new CodePrimitiveExpression (2)))));
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeVariableReferenceExpression ("i")));
class1.Members.Add (cmm);
AddScenario ("CheckTestComplexIterationStatement");
cmm = new CodeMemberMethod ();
cmm.Name = "TestComplexIterationStatement";
cmm.Attributes = MemberAttributes.Public;
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Statements.Add (new CodeVariableDeclarationStatement (new CodeTypeReference (typeof (int)), "i"));
cmm.Statements.Add (new CodeVariableDeclarationStatement (new CodeTypeReference (typeof (int)), "a", new CodePrimitiveExpression (7)));
cmm.Statements.Add (new CodeVariableDeclarationStatement (new CodeTypeReference (typeof (int)), "b"));
cmm.Statements.Add (new CodeVariableDeclarationStatement (new CodeTypeReference (typeof (int)), "c", new CodePrimitiveExpression (9)));
cmm.Statements.Add (new CodeVariableDeclarationStatement (new CodeTypeReference (typeof (int)), "d", new CodePrimitiveExpression (2)));
CodeIterationStatement iteration = new CodeIterationStatement ();
iteration.IncrementStatement = new CodeAssignStatement (new CodeVariableReferenceExpression ("i")
, new CodeBinaryOperatorExpression (new CodeVariableReferenceExpression ("i"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression (1)));
iteration.InitStatement = new CodeAssignStatement (new CodeVariableReferenceExpression ("i"), new
CodePrimitiveExpression (0));
iteration.TestExpression = (new CodeBinaryOperatorExpression (new CodeVariableReferenceExpression ("i"),
CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression (2)));
CodeConditionStatement secondIf = new CodeConditionStatement (new CodeBinaryOperatorExpression (
new CodeVariableReferenceExpression ("c"), CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression (10)),
new CodeAssignStatement (new CodeVariableReferenceExpression ("d"), new CodeBinaryOperatorExpression (
new CodeVariableReferenceExpression ("d"), CodeBinaryOperatorType.Subtract, new CodePrimitiveExpression (1))));
CodeIterationStatement secondFor = new CodeIterationStatement ();
secondFor.Statements.Add (secondIf);
secondFor.IncrementStatement = new CodeAssignStatement (new CodeVariableReferenceExpression ("b")
, new CodeBinaryOperatorExpression (new CodeVariableReferenceExpression ("b"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression (1)));
secondFor.InitStatement = new CodeAssignStatement (new CodeVariableReferenceExpression ("b"), new
CodePrimitiveExpression (0));
secondFor.TestExpression = (new CodeBinaryOperatorExpression (new CodeVariableReferenceExpression ("b"),
CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression (2)));
secondFor.Statements.Add (new CodeAssignStatement (new CodeVariableReferenceExpression ("d"),
new CodeBinaryOperatorExpression (new CodeVariableReferenceExpression ("d"), CodeBinaryOperatorType.Multiply,
new CodePrimitiveExpression (2))));
CodeConditionStatement firstIf = new CodeConditionStatement ();
firstIf.Condition = new CodeBinaryOperatorExpression (new CodeVariableReferenceExpression ("a"), CodeBinaryOperatorType.LessThan,
new CodePrimitiveExpression (16));
firstIf.TrueStatements.Add (secondFor);
iteration.Statements.Add (firstIf);
cmm.Statements.Add (iteration);
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeVariableReferenceExpression ("d")));
class1.Members.Add (cmm);
}
public void ForLoops()
{
CodeNamespace nspace = new CodeNamespace("NSPC");
CodeTypeDeclaration class1 = new CodeTypeDeclaration("ClassWithMethod");
class1.IsClass = true;
nspace.Types.Add(class1);
CodeMemberMethod cmm = new CodeMemberMethod();
cmm.Name = "TestBasicIterationStatement";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int)), "i"));
cmm.Statements.Add(new CodeIterationStatement(new CodeAssignStatement(new
CodeVariableReferenceExpression("i"), new CodePrimitiveExpression(1)),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(8)),
new CodeAssignStatement(new CodeVariableReferenceExpression("i"),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Multiply,
new CodePrimitiveExpression(2)))));
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("i")));
class1.Members.Add(cmm);
cmm = new CodeMemberMethod();
cmm.Name = "TestComplexIterationStatement";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int)), "i"));
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int)), "a", new CodePrimitiveExpression(7)));
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int)), "b"));
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int)), "c", new CodePrimitiveExpression(9)));
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int)), "d", new CodePrimitiveExpression(2)));
CodeIterationStatement iteration = new CodeIterationStatement();
iteration.IncrementStatement = new CodeAssignStatement(new CodeVariableReferenceExpression("i"),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(1)));
iteration.InitStatement = new CodeAssignStatement(new CodeVariableReferenceExpression("i"), new
CodePrimitiveExpression(0));
iteration.TestExpression = (new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(2)));
CodeConditionStatement secondIf = new CodeConditionStatement(new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("c"), CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(10)),
new CodeAssignStatement(new CodeVariableReferenceExpression("d"), new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("d"), CodeBinaryOperatorType.Subtract, new CodePrimitiveExpression(1))));
CodeIterationStatement secondFor = new CodeIterationStatement();
secondFor.Statements.Add(secondIf);
secondFor.IncrementStatement = new CodeAssignStatement(new CodeVariableReferenceExpression("b"),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("b"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(1)));
secondFor.InitStatement = new CodeAssignStatement(new CodeVariableReferenceExpression("b"), new
CodePrimitiveExpression(0));
secondFor.TestExpression = (new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("b"),
CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(2)));
secondFor.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("d"),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("d"), CodeBinaryOperatorType.Multiply,
new CodePrimitiveExpression(2))));
CodeConditionStatement firstIf = new CodeConditionStatement();
firstIf.Condition = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.LessThan,
new CodePrimitiveExpression(16));
firstIf.TrueStatements.Add(secondFor);
iteration.Statements.Add(firstIf);
cmm.Statements.Add(iteration);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("d")));
class1.Members.Add(cmm);
AssertEqual(nspace,
@"Namespace NSPC
Public Class ClassWithMethod
Public Shared Function TestBasicIterationStatement() As Integer
Dim i As Integer
i = 1
Do While (i < 8)
i = (i * 2)
Loop
Return i
End Function
Public Shared Function TestComplexIterationStatement() As Integer
Dim i As Integer
Dim a As Integer = 7
Dim b As Integer
Dim c As Integer = 9
Dim d As Integer = 2
i = 0
Do While (i < 2)
If (a < 16) Then
b = 0
Do While (b < 2)
If (c < 10) Then
d = (d - 1)
End If
d = (d * 2)
b = (b + 1)
Loop
End If
i = (i + 1)
Loop
Return d
End Function
End Class
End Namespace");
}
protected override void GenerateIterationStatement
(CodeIterationStatement e)
{
if(e.InitStatement == null &&
e.TestExpression != null &&
e.IncrementStatement == null)
{
// Special case - output a "while" statement.
Output.Write("while (");
GenerateExpression(e.TestExpression);
Output.Write(")");
StartBlock();
GenerateStatements(e.Statements);
EndBlock();
}
else
{
// Output a "for" statement.
Output.Write("for (");
outputForInit = true;
if(e.InitStatement != null)
{
GenerateStatement(e.InitStatement);
}
Output.Write("; ");
if(e.TestExpression != null)
{
GenerateExpression(e.TestExpression);
}
Output.Write("; ");
if(e.IncrementStatement != null)
{
GenerateStatement(e.IncrementStatement);
}
outputForInit = false;
Output.Write(")");
StartBlock();
GenerateStatements(e.Statements);
EndBlock();
}
}
/// <summary>
/// For 循环
/// </summary>
/// <param name="inType">循环的类型 eg. typeof(int)</param>
/// <param name="inTypeName">循环变量 eg. i</param>
/// <param name="inTypeValue">循环变量的起始值</param>
/// <param name="inLessthan">循环的极值</param>
/// <returns></returns>
public CodeIterationStatement AddFor(Type inType, string inTypeName, object inTypeValue, string inLessthan)
{
CodeIterationStatement curFor = new CodeIterationStatement();
curFor.InitStatement = new CodeVariableDeclarationStatement(inType, inTypeName, new CodePrimitiveExpression(inTypeValue));
curFor.TestExpression = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(inTypeName), CodeBinaryOperatorType.LessThan, new CodeVariableReferenceExpression(inLessthan));
curFor.IncrementStatement = new CodeAssignStatement(new CodeVariableReferenceExpression(inTypeName), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(inTypeName), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1)));
return curFor;
}
private void ValidateIterationStatement(CodeIterationStatement e)
{
ValidateStatement(e.InitStatement);
ValidateExpression(e.TestExpression);
ValidateStatement(e.IncrementStatement);
ValidateStatements(e.Statements);
}
protected override void GenerateIterationStatement
(CodeIterationStatement e)
{
if(e.InitStatement != null)
{
GenerateStatement(e.InitStatement);
}
Output.Write("While ");
if(e.TestExpression != null)
{
GenerateExpression(e.TestExpression);
}
else
{
Output.Write("True");
}
Output.WriteLine();
++Indent;
GenerateStatements(e.Statements);
if(e.IncrementStatement != null)
{
GenerateStatement(e.IncrementStatement);
}
--Indent;
Output.WriteLine("End While");
}
