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);
}
/// <summary>
/// generate code and put final result to n-th node
/// </summary>
/// <returns></returns>
public override void ExportCodeStatements(IMethodCompile method)
{
int n = Branches;
MathNode.Trace("ExportCodeStatements for {0}, branches: {1}", this.GetType(), n);
IVariable v = (IVariable)this[n + 1];
string resultName = v.CodeVariableName;
v.VariableType = this.ResultType;
OnPrepareVariable(method);
MathNode.Trace("result is varibale {0}", resultName);
CodeVariableReferenceExpression result = new CodeVariableReferenceExpression(resultName);
MathNodeVariable.DeclareVariable(method.MethodCode.Statements, v);
MathNode.Trace("default value: {0}", this[n].ToString());
CodeExpression eDefault = this[n].ExportCode(method);
if (!this[n].DataType.IsSameType(this.DataType))
{
MathNode.Trace("last code conversion from default value of {0} to {1}", this[n].DataType, this.DataType);
eDefault = convert(eDefault);
}
CodeAssignStatement stDefault = new CodeAssignStatement(result, eDefault);
if (n == 0)
{
MathNode.Trace("no condition given");
method.MethodCode.Statements.Add(stDefault);
}
else
{
CodeExpression e = this[0][1].ExportCode(method);
if (!this[0][1].DataType.IsSameType(this.DataType))
{
e = convert(e);
}
CodeConditionStatement ccs = new CodeConditionStatement();
CodeExpression ce = this[0][0].ExportCode(method);
if (!(this[0][0].DataType.Type.Equals(typeof(bool))))
{
ce = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Convert)), "ToBoolean", new CodeExpression[] { ce });
}
ccs.Condition = ce;
bool isSameVariable = false;
if (e is CodeVariableReferenceExpression)
{
if (string.CompareOrdinal(((CodeVariableReferenceExpression)e).VariableName, resultName) == 0)
{
isSameVariable = true;
}
}
if (!isSameVariable)
{
ccs.TrueStatements.Add(new CodeAssignStatement(result, e));
}
method.MethodCode.Statements.Add(ccs);
for (int i = 1; i < n; i++)
{
CodeConditionStatement ccs1 = new CodeConditionStatement();
ccs.FalseStatements.Add(ccs1);
ccs = ccs1;
e = this[i][1].ExportCode(method);
if (!this[i][1].DataType.IsSameType(this.DataType))
{
e = convert(e);
}
ccs.TrueStatements.Add(new CodeAssignStatement(result, e));
ce = this[i][0].ExportCode(method);
if (!(this[i][0].DataType.Type.Equals(typeof(bool))))
{
ce = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Convert)), "ToBoolean", new CodeExpression[] { ce });
}
ccs.Condition = ce;
}
ccs.FalseStatements.Add(stDefault);
}
}
