public static CodegenExpression Codegen(
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope,
ExprNode[] nodes,
Type returnType)
{
return(MinMaxTypeCodegen
.CodegenMinMax(true, codegenMethodScope, exprSymbol, codegenClassScope, nodes, returnType));
}
public static CodegenExpression Codegen(
bool max,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope,
ExprNode[] nodes,
BigIntegerCoercer[] convertors)
{
var r0Type = nodes[0].Forge.EvaluationType.GetBoxedType();
var r1Type = nodes[1].Forge.EvaluationType.GetBoxedType();
if (r0Type == null || r1Type == null)
{
return(CodegenExpressionBuilder.ConstantNull());
}
var methodNode = codegenMethodScope.MakeChild(
typeof(BigInteger?),
typeof(ComputerBigIntCoerce),
codegenClassScope);
var block = methodNode.Block;
block.DeclareVar(
r0Type,
"r0",
nodes[0].Forge.EvaluateCodegen(r0Type, methodNode, exprSymbol, codegenClassScope));
if (r0Type.CanBeNull())
{
block.IfRefNullReturnNull("r0");
}
block.DeclareVar(
r1Type,
"r1",
nodes[1].Forge.EvaluateCodegen(r1Type, methodNode, exprSymbol, codegenClassScope));
if (r1Type.CanBeNull())
{
block.IfRefNullReturnNull("r1");
}
block.DeclareVar <BigInteger?>(
"bi0",
convertors[0].CoerceBoxedBigIntCodegen(CodegenExpressionBuilder.Ref("r0"), r0Type));
block.DeclareVar <BigInteger?>(
"bi1",
convertors[1].CoerceBoxedBigIntCodegen(CodegenExpressionBuilder.Ref("r1"), r1Type));
block.DeclareVarNoInit(typeof(BigInteger?), "result");
block.IfCondition(
MinMaxTypeCodegen.CodegenCompareCompareTo(
CodegenExpressionBuilder.Unbox(CodegenExpressionBuilder.Ref("bi0")),
CodegenExpressionBuilder.Unbox(CodegenExpressionBuilder.Ref("bi1")),
max))
.AssignRef("result", CodegenExpressionBuilder.Ref("bi0"))
.IfElse()
.AssignRef("result", CodegenExpressionBuilder.Ref("bi1"))
.BlockEnd();
for (var i = 2; i < nodes.Length; i++)
{
var nodeType = nodes[i].Forge.EvaluationType;
var refnameNumber = "r" + i;
block.DeclareVar(
nodeType,
refnameNumber,
nodes[i].Forge.EvaluateCodegen(nodeType, methodNode, exprSymbol, codegenClassScope));
if (nodeType.CanBeNull())
{
block.IfRefNullReturnNull(refnameNumber);
}
var refnameBigint = "bi" + i;
block.DeclareVar <BigInteger>(
refnameBigint,
convertors[i].CoerceBoxedBigIntCodegen(CodegenExpressionBuilder.Ref(refnameNumber), nodeType));
block.IfCondition(
CodegenExpressionBuilder.Not(
MinMaxTypeCodegen.CodegenCompareCompareTo(
CodegenExpressionBuilder.Ref("result"),
CodegenExpressionBuilder.Ref(refnameBigint),
max)))
.AssignRef("result", CodegenExpressionBuilder.Ref(refnameBigint))
.BlockEnd();
}
block.MethodReturn(CodegenExpressionBuilder.Ref("result"));
return(CodegenExpressionBuilder.LocalMethod(methodNode));
}
