|
public static IsTrue ( System.Linq.Expressions expression ) : |
||
| expression | System.Linq.Expressions | |
| return | ||
internal override MSA.Expression /*!*/ TransformRead(AstGenerator /*!*/ gen)
{
return(AstFactory.Condition(
AstFactory.IsTrue(_condition.TransformRead(gen)),
_trueExpression.TransformRead(gen),
_falseExpression.TransformRead(gen)
));
}
// when <expr>
// generates into:
// RubyOps.IsTrue(<expr>) if the case has no value, otherise:
// RubyOps.IsTrue(Call("===", <expr>, <value>))
private static MSA.Expression /*!*/ MakeTest(AstGenerator /*!*/ gen, MSA.Expression /*!*/ expr, MSA.Expression value)
{
if (value != null)
{
expr = CallSiteBuilder.InvokeMethod(gen.Context, "===", RubyCallSignature.WithScope(1),
gen.CurrentScopeVariable,
expr,
value
);
}
return(AstFactory.IsTrue(expr));
}
// when <expr>
// generates into:
// RubyOps.IsTrue(<expr>) if the case has no value, otherise:
// RubyOps.IsTrue(InvokeMember("===", <expr>, <value>))
private static MSA.Expression /*!*/ MakeTest(AstGenerator /*!*/ gen, MSA.Expression /*!*/ expr, MSA.Expression /*!*/ value)
{
if (value != null)
{
// InvokeMember("===", <expr>, <value>)
expr = Ast.Dynamic(RubyCallAction.Make("===", RubyCallSignature.WithScope(1)), typeof(object),
gen.CurrentScopeVariable,
expr,
value
);
}
return(AstFactory.IsTrue(expr));
}
internal override MSA.Expression /*!*/ TransformRead(AstGenerator /*!*/ gen)
{
MSA.Expression transformedCondition = AstFactory.Box(_condition.TransformRead(gen));
MSA.Expression tmpVariable = gen.CurrentScope.DefineHiddenVariable("#tmp_cond", transformedCondition.Type);
return(AstFactory.Block(
Ast.Assign(tmpVariable, transformedCondition),
AstUtils.IfThen(
(_negateCondition ? AstFactory.IsFalse(tmpVariable) : AstFactory.IsTrue(tmpVariable)),
_jumpStatement.Transform(gen)
),
(_value != null) ? _value.TransformRead(gen) : tmpVariable
));
}
// when <expr>
// generates into:
// RubyOps.IsTrue(<expr>) if the case has no value, otherise:
// RubyOps.IsTrue(Call("===", <expr>, <value>))
private static MSA.Expression /*!*/ MakeTest(AstGenerator /*!*/ gen, Expression /*!*/ expr, MSA.Expression value)
{
MSA.Expression transformedExpr = expr.TransformRead(gen);
if (expr is SplattedArgument)
{
if (value != null)
{
return(Methods.ExistsUnsplatCompare.OpCall(
Ast.Constant(CallSite <Func <CallSite, object, object, object> > .Create(
RubyCallAction.Make(gen.Context, "===", RubyCallSignature.WithImplicitSelf(2))
)),
AstUtils.LightDynamic(ExplicitTrySplatAction.Make(gen.Context), transformedExpr),
AstUtils.Box(value)
));
}
else
{
return(Methods.ExistsUnsplat.OpCall(
AstUtils.LightDynamic(ExplicitTrySplatAction.Make(gen.Context), transformedExpr)
));
}
}
else
{
if (value != null)
{
return(AstFactory.IsTrue(
CallSiteBuilder.InvokeMethod(gen.Context, "===", RubyCallSignature.WithScope(1),
gen.CurrentScopeVariable,
transformedExpr,
value
)
));
}
else
{
return(AstFactory.IsTrue(transformedExpr));
}
}
}
internal override MSA.Expression /*!*/ TransformRead(AstGenerator /*!*/ gen)
{
MSA.Expression result;
int i = _elseIfClauses.Count - 1;
if (i >= 0 && _elseIfClauses[i].Condition == null)
{
// ... else body end
result = gen.TransformStatementsToExpression(_elseIfClauses[i].Statements);
i--;
}
else
{
// no else clause => the result of the if-expression is nil:
result = Ast.Constant(null);
}
while (i >= 0)
{
// emit: else (if (condition) body else result)
result = AstFactory.Condition(
AstFactory.IsTrue(_elseIfClauses[i].Condition.TransformRead(gen)),
gen.TransformStatementsToExpression(_elseIfClauses[i].Statements),
result
);
i--;
}
// if (condition) body else result
return(AstFactory.Condition(
AstFactory.IsTrue(_condition.TransformRead(gen)),
gen.TransformStatementsToExpression(_body),
result
));
}
private MSA.Expression /*!*/ TransformCondition(AstGenerator /*!*/ gen)
{
var transformedCondition = _condition.TransformRead(gen);
return((_negateCondition) ? AstFactory.IsFalse(transformedCondition) : AstFactory.IsTrue(transformedCondition));
}
// see Ruby Language.doc/Runtime/Control Flow Implementation/While-Until
internal override MSA.Expression /*!*/ TransformRead(AstGenerator /*!*/ gen)
{
MSA.Expression resultVariable = gen.CurrentScope.DefineHiddenVariable("#loop-result", typeof(object));
MSA.Expression redoVariable = gen.CurrentScope.DefineHiddenVariable("#skip-condition", typeof(bool));
MSA.ParameterExpression blockUnwinder = gen.CurrentScope.DefineHiddenVariable("#unwinder", typeof(BlockUnwinder));
MSA.ParameterExpression evalUnwinder = gen.CurrentScope.DefineHiddenVariable("#unwinder", typeof(EvalUnwinder));
bool isInnerLoop = gen.CurrentLoop != null;
MSA.LabelTarget breakLabel = Ast.Label();
MSA.LabelTarget continueLabel = Ast.Label();
gen.EnterLoop(redoVariable, resultVariable, breakLabel, continueLabel);
MSA.Expression transformedBody = gen.TransformStatements(_statements, ResultOperation.Ignore);
MSA.Expression transformedCondition = AstFactory.IsTrue(_condition.TransformRead(gen));
gen.LeaveLoop();
MSA.Expression conditionPositiveStmt, conditionNegativeStmt;
if (_isWhileLoop)
{
conditionPositiveStmt = Ast.Empty();
conditionNegativeStmt = Ast.Break(breakLabel);
}
else
{
conditionPositiveStmt = Ast.Break(breakLabel);
conditionNegativeStmt = Ast.Empty();
}
// make the loop first:
MSA.Expression loop = Ast.Block(
Ast.Assign(redoVariable, Ast.Constant(_isPostTest)),
AstFactory.Infinite(breakLabel, continueLabel,
AstUtils.Try(
AstUtils.If(redoVariable,
Ast.Assign(redoVariable, Ast.Constant(false))
).ElseIf(transformedCondition,
conditionPositiveStmt
).Else(
conditionNegativeStmt
),
transformedBody
).Catch(blockUnwinder,
// redo = u.IsRedo
Ast.Assign(redoVariable, Ast.Field(blockUnwinder, BlockUnwinder.IsRedoField))
).Filter(evalUnwinder, Ast.Equal(Ast.Field(evalUnwinder, EvalUnwinder.ReasonField), AstFactory.BlockReturnReasonBreak),
// result = unwinder.ReturnValue
Ast.Assign(resultVariable, Ast.Field(evalUnwinder, EvalUnwinder.ReturnValueField)),
Ast.Break(breakLabel)
)
),
Ast.Empty()
);
// wrap it to try finally that updates RFC state:
if (!isInnerLoop)
{
loop = AstUtils.Try(
Ast.Assign(Ast.Field(gen.CurrentRfcVariable, RuntimeFlowControl.InLoopField), Ast.Constant(true)),
loop
).Finally(
Ast.Assign(Ast.Field(gen.CurrentRfcVariable, RuntimeFlowControl.InLoopField), Ast.Constant(false))
);
}
return(AstFactory.Block(loop, resultVariable));
}
