| public static IfThen ( Expression test ) : Expression | ||
| test | Expression | |
| Результат | Expression | |
internal override MSA.Expression /*!*/ TransformRead(AstGenerator /*!*/ gen)
{
if (_value != null)
{
return(Ast.Block(
AstUtils.IfThen(
_condition.TransformReadBoolean(gen, !_negateCondition),
_jumpStatement.Transform(gen)
),
_value.TransformRead(gen)
));
}
else
{
MSA.Expression tmpVariable = gen.CurrentScope.DefineHiddenVariable("#tmp_cond", typeof(object));
return(Ast.Block(
Ast.Assign(tmpVariable, AstUtils.Box(_condition.TransformRead(gen))),
AstUtils.IfThen(
(_negateCondition ? Methods.IsFalse : Methods.IsTrue).OpCall(tmpVariable),
_jumpStatement.Transform(gen)
),
tmpVariable
));
}
}
internal MSA.Expression /*!*/ TransformOptionalsInitialization(AstGenerator /*!*/ gen)
{
Assert.NotNull(gen);
if (_optional == null)
{
return(AstUtils.Empty());
}
MSA.Expression singleton = gen.CurrentScope.DefineHiddenVariable("#default", typeof(object));
MSA.Expression result = AstUtils.Empty();
for (int i = 0; i < _optional.Count; i++)
{
result = AstUtils.IfThen(Ast.Equal(_optional[i].Left.TransformRead(gen), singleton),
result,
_optional[i].TransformRead(gen)
);
}
return(Ast.Block(
Ast.Assign(singleton, Ast.Field(null, Fields.DefaultArgument)),
result,
AstUtils.Empty()
));
}
// see Ruby Language.doc/Runtime/Control Flow Implementation/Yield
internal override MSA.Expression /*!*/ TransformRead(AstGenerator /*!*/ gen)
{
MSA.Expression bfcVariable = gen.CurrentScope.DefineHiddenVariable("#yielded-bfc", typeof(BlockParam));
MSA.Expression resultVariable = gen.CurrentScope.DefineHiddenVariable("#result", typeof(object));
MSA.Expression postYield;
if (gen.CompilerOptions.IsEval)
{
// eval:
postYield = Methods.EvalYield.OpCall(gen.CurrentScopeVariable, bfcVariable, resultVariable);
}
else if (gen.CurrentBlock != null)
{
// block:
postYield = Methods.BlockYield.OpCall(gen.CurrentScopeVariable, gen.CurrentBlock.BfcVariable, bfcVariable, resultVariable);
}
else
{
// method:
postYield = Methods.MethodYield.OpCall(gen.CurrentScopeVariable, bfcVariable, resultVariable);
}
return(new AstBlock {
gen.DebugMarker("#RB: yield begin"),
Ast.Assign(bfcVariable, Methods.CreateBfcForYield.OpCall(gen.MakeMethodBlockParameterRead())),
Ast.Assign(
resultVariable,
(Arguments ?? Arguments.Empty).TransformToYield(gen, bfcVariable, gen.MakeMethodBlockParameterSelfRead())
),
AstUtils.IfThen(postYield, gen.Return(resultVariable)),
gen.DebugMarker("#RB: yield end"),
resultVariable
});
}
/// <summary>
/// WithStatement is translated to the DLR AST equivalent to
/// the following Python code snippet (from with statement spec):
///
/// mgr = (EXPR)
/// exit = mgr.__exit__ # Not calling it yet
/// value = mgr.__enter__()
/// exc = True
/// try:
/// VAR = value # Only if "as VAR" is present
/// BLOCK
/// except:
/// # The exceptional case is handled here
/// exc = False
/// if not exit(*sys.exc_info()):
/// raise
/// # The exception is swallowed if exit() returns true
/// finally:
/// # The normal and non-local-goto cases are handled here
/// if exc:
/// exit(None, None, None)
///
/// </summary>
public override MSAst.Expression Reduce()
{
// Five statements in the result...
ReadOnlyCollectionBuilder <MSAst.Expression> statements = new ReadOnlyCollectionBuilder <MSAst.Expression>(6);
ReadOnlyCollectionBuilder <MSAst.ParameterExpression> variables = new ReadOnlyCollectionBuilder <MSAst.ParameterExpression>(6);
MSAst.ParameterExpression lineUpdated = Ast.Variable(typeof(bool), "$lineUpdated_with");
variables.Add(lineUpdated);
//******************************************************************
// 1. mgr = (EXPR)
//******************************************************************
MSAst.ParameterExpression manager = Ast.Variable(typeof(object), "with_manager");
variables.Add(manager);
statements.Add(
GlobalParent.AddDebugInfo(
Ast.Assign(
manager,
_contextManager
),
new SourceSpan(Start, _header)
)
);
//******************************************************************
// 2. exit = mgr.__exit__ # Not calling it yet
//******************************************************************
MSAst.ParameterExpression exit = Ast.Variable(typeof(object), "with_exit");
variables.Add(exit);
statements.Add(
MakeAssignment(
exit,
GlobalParent.Get(
"__exit__",
manager
)
)
);
//******************************************************************
// 3. value = mgr.__enter__()
//******************************************************************
MSAst.ParameterExpression value = Ast.Variable(typeof(object), "with_value");
variables.Add(value);
statements.Add(
GlobalParent.AddDebugInfoAndVoid(
MakeAssignment(
value,
Parent.Invoke(
new CallSignature(0),
Parent.LocalContext,
GlobalParent.Get(
"__enter__",
manager
)
)
),
new SourceSpan(Start, _header)
)
);
//******************************************************************
// 4. exc = True
//******************************************************************
MSAst.ParameterExpression exc = Ast.Variable(typeof(bool), "with_exc");
variables.Add(exc);
statements.Add(
MakeAssignment(
exc,
AstUtils.Constant(true)
)
);
//******************************************************************
// 5. The final try statement:
//
// try:
// VAR = value # Only if "as VAR" is present
// BLOCK
// except:
// # The exceptional case is handled here
// exc = False
// if not exit(*sys.exc_info()):
// raise
// # The exception is swallowed if exit() returns true
// finally:
// # The normal and non-local-goto cases are handled here
// if exc:
// exit(None, None, None)
//******************************************************************
MSAst.ParameterExpression exception;
MSAst.ParameterExpression nestedFrames = Ast.Variable(typeof(List <DynamicStackFrame>), "$nestedFrames");
variables.Add(nestedFrames);
statements.Add(
// try:
AstUtils.Try(
AstUtils.Try(// try statement body
PushLineUpdated(false, lineUpdated),
_var != null ?
(MSAst.Expression)Ast.Block(
// VAR = value
_var.TransformSet(SourceSpan.None, value, PythonOperationKind.None),
// BLOCK
_body,
AstUtils.Empty()
) :
// BLOCK
(MSAst.Expression)_body // except:, // try statement location
).Catch(exception = Ast.Variable(typeof(Exception), "exception"),
// Python specific exception handling code
TryStatement.GetTracebackHeader(
this,
exception,
GlobalParent.AddDebugInfoAndVoid(
Ast.Block(
// exc = False
MakeAssignment(
exc,
AstUtils.Constant(false)
),
Ast.Assign(
nestedFrames,
Ast.Call(AstMethods.GetAndClearDynamicStackFrames)
),
// if not exit(*sys.exc_info()):
// raise
AstUtils.IfThen(
GlobalParent.Convert(
typeof(bool),
ConversionResultKind.ExplicitCast,
GlobalParent.Operation(
typeof(bool),
PythonOperationKind.IsFalse,
MakeExitCall(exit, exception)
)
),
UpdateLineUpdated(true),
Ast.Call(
AstMethods.SetDynamicStackFrames,
nestedFrames
),
Ast.Throw(
Ast.Call(
AstMethods.MakeRethrowExceptionWorker,
exception
)
)
)
),
_body.Span
)
),
Ast.Call(
AstMethods.SetDynamicStackFrames,
nestedFrames
),
PopLineUpdated(lineUpdated),
Ast.Empty()
)
// finally:
).Finally(
// if exc:
// exit(None, None, None)
AstUtils.IfThen(
exc,
GlobalParent.AddDebugInfoAndVoid(
Ast.Block(
Ast.Dynamic(
GlobalParent.PyContext.Invoke(
new CallSignature(3) // signature doesn't include function
),
typeof(object),
new MSAst.Expression[] {
Parent.LocalContext,
exit,
AstUtils.Constant(null),
AstUtils.Constant(null),
AstUtils.Constant(null)
}
),
Ast.Empty()
),
_contextManager.Span
)
)
)
);
statements.Add(AstUtils.Empty());
return(Ast.Block(variables.ToReadOnlyCollection(), statements.ToReadOnlyCollection()));
}
public override MSAst.Expression Reduce()
{
// allocated all variables here so they won't be shared w/ other
// locals allocated during the body or except blocks.
MSAst.ParameterExpression lineUpdated = null;
MSAst.ParameterExpression runElse = null;
if (_else != null || (_handlers != null && _handlers.Length > 0))
{
lineUpdated = Ast.Variable(typeof(bool), "$lineUpdated_try");
if (_else != null)
{
runElse = Ast.Variable(typeof(bool), "run_else");
}
}
// don't allocate locals below here...
MSAst.Expression body = _body;
MSAst.Expression @else = _else;
MSAst.Expression @catch, result;
MSAst.ParameterExpression exception;
if (_handlers != null && _handlers.Length > 0)
{
exception = Ast.Variable(typeof(Exception), "$exception");
@catch = TransformHandlers(exception);
}
else
{
exception = null;
@catch = null;
}
// We have else clause, must generate guard around it
if (@else != null)
{
Debug.Assert(@catch != null);
// run_else = true;
// try {
// try_body
// } catch ( ... ) {
// run_else = false;
// catch_body
// }
// if (run_else) {
// else_body
// }
result =
Ast.Block(
Ast.Assign(runElse, AstUtils.Constant(true)),
// save existing line updated, we could choose to do this only for nested exception handlers.
PushLineUpdated(false, lineUpdated),
AstUtils.Try(
Parent.AddDebugInfo(AstUtils.Empty(), new SourceSpan(Span.Start, _header)),
body
).Catch(exception,
Ast.Assign(runElse, AstUtils.Constant(false)),
@catch,
// restore existing line updated after exception handler completes
PopLineUpdated(lineUpdated),
Ast.Assign(exception, Ast.Constant(null, typeof(Exception))),
AstUtils.Default(body.Type)
),
AstUtils.IfThen(runElse,
@else
),
AstUtils.Empty()
);
}
else if (@catch != null) // no "else" clause
// try {
// <try body>
// } catch (Exception e) {
// ... catch handling ...
// }
//
{
result =
AstUtils.Try(
GlobalParent.AddDebugInfo(AstUtils.Empty(), new SourceSpan(Span.Start, _header)),
// save existing line updated
PushLineUpdated(false, lineUpdated),
body
).Catch(exception,
@catch,
// restore existing line updated after exception handler completes
PopLineUpdated(lineUpdated),
Ast.Call(AstMethods.ExceptionHandled, Parent.LocalContext),
Ast.Assign(exception, Ast.Constant(null, typeof(Exception))),
AstUtils.Default(body.Type)
);
}
else
{
result = body;
}
return(Ast.Block(
GetVariables(lineUpdated, runElse),
AddFinally(result)
));
}
private MSA.Expression /*!*/ TransformExceptionHandling(AstGenerator /*!*/ gen, ResultOperation resultOperation)
{
Assert.NotNull(gen);
MSA.Expression exceptionThrownVariable = gen.CurrentScope.DefineHiddenVariable("#exception-thrown", typeof(bool));
MSA.Expression exceptionRethrowVariable = gen.CurrentScope.DefineHiddenVariable("#exception-rethrow", typeof(bool));
MSA.Expression retryingVariable = gen.CurrentScope.DefineHiddenVariable("#retrying", typeof(bool));
MSA.Expression oldExceptionVariable = gen.CurrentScope.DefineHiddenVariable("#old-exception", typeof(Exception));
MSA.ParameterExpression unwinder, exceptionVariable;
MSA.Expression transformedBody;
MSA.Expression transformedEnsure;
MSA.Expression transformedElse;
if (_ensureStatements != null)
{
transformedEnsure = Ast.Block(
// ensure:
Ast.Assign(oldExceptionVariable, Methods.GetCurrentException.OpCall(gen.CurrentScopeVariable)),
gen.TransformStatements(_ensureStatements, ResultOperation.Ignore),
Methods.SetCurrentException.OpCall(gen.CurrentScopeVariable, oldExceptionVariable),
// rethrow:
AstUtils.IfThen(
Ast.AndAlso(
exceptionRethrowVariable,
Ast.NotEqual(oldExceptionVariable, AstUtils.Constant(null))
),
Ast.Throw(oldExceptionVariable)
)
);
}
else
{
// rethrow:
transformedEnsure = AstUtils.IfThen(
Ast.AndAlso(
exceptionRethrowVariable,
Ast.NotEqual(
Ast.Assign(oldExceptionVariable, Methods.GetCurrentException.OpCall(gen.CurrentScopeVariable)),
AstUtils.Constant(null, typeof(Exception)))
),
Ast.Throw(oldExceptionVariable)
);
}
if (_elseStatements != null)
{
transformedElse = gen.TransformStatements(_elseStatements, resultOperation);
}
else
{
transformedElse = AstUtils.Empty();
}
// body should do return, but else-clause is present => we cannot do return from the guarded statements:
// (the value of the last expression in the body cannot be the last executed expression statement => we can ignore it):
transformedBody = gen.TransformStatements(_statements, (_elseStatements != null) ? ResultOperation.Ignore : resultOperation);
MSA.Expression enterRescue = null, leaveRescue = null;
var retryLabel = Ast.Label("retry");
// make rescue clause:
MSA.Expression transformedRescue;
if (_rescueClauses != null)
{
// outer-most EH blocks sets and clears runtime flag RuntimeFlowControl.InTryRescue:
if (gen.CurrentRescue == null)
{
enterRescue = Methods.EnterRescue.OpCall(gen.CurrentScopeVariable);
leaveRescue = Methods.LeaveRescue.OpCall(gen.CurrentScopeVariable);
}
else
{
enterRescue = leaveRescue = AstUtils.Empty();
}
gen.EnterRescueClause(retryingVariable, retryLabel);
var handlers = new IfStatementTest[_rescueClauses.Count];
for (int i = 0; i < handlers.Length; i++)
{
handlers[i] = _rescueClauses[i].Transform(gen, resultOperation);
}
transformedRescue =
AstUtils.Try(
enterRescue,
AstUtils.If(handlers, Ast.Assign(exceptionRethrowVariable, AstUtils.Constant(true)))
).Filter(unwinder = Ast.Parameter(typeof(EvalUnwinder), "#u"),
Ast.Equal(Ast.Field(unwinder, EvalUnwinder.ReasonField), AstUtils.Constant(BlockReturnReason.Retry)),
Ast.Block(
Ast.Assign(retryingVariable, AstUtils.Constant(true)),
Ast.Continue(retryLabel),
AstUtils.Empty()
)
);
gen.LeaveRescueClause();
}
else
{
transformedRescue = Ast.Assign(exceptionRethrowVariable, AstUtils.Constant(true));
}
if (_elseStatements != null)
{
transformedElse = AstUtils.Unless(exceptionThrownVariable, transformedElse);
}
var result = Ast.Block(
Ast.Label(retryLabel),
AstUtils.Try(
Ast.Assign(exceptionThrownVariable, AstUtils.Constant(false)),
Ast.Assign(exceptionRethrowVariable, AstUtils.Constant(false)),
Ast.Assign(retryingVariable, AstUtils.Constant(false)),
// save exception (old_$! is not used unless there is a rescue clause):
(_rescueClauses == null) ? (MSA.Expression)AstUtils.Empty() :
Ast.Assign(oldExceptionVariable, Methods.GetCurrentException.OpCall(gen.CurrentScopeVariable)),
AstUtils.Try(
Ast.Block(transformedBody, AstUtils.Empty())
).Filter(exceptionVariable = Ast.Parameter(typeof(Exception), "#e"),
Methods.CanRescue.OpCall(gen.CurrentScopeVariable, exceptionVariable),
Ast.Assign(exceptionThrownVariable, AstUtils.Constant(true)),
transformedRescue,
AstUtils.Empty()
).FinallyIf((_rescueClauses != null),
// restore previous exception if the current one has been handled:
AstUtils.Unless(exceptionRethrowVariable,
Methods.SetCurrentException.OpCall(gen.CurrentScopeVariable, oldExceptionVariable)
),
leaveRescue
),
// unless (exception_thrown) do <else-statements> end
transformedElse,
AstUtils.Empty()
).FilterIf((_rescueClauses != null || _elseStatements != null),
exceptionVariable = Ast.Parameter(typeof(Exception), "#e"),
Methods.CanRescue.OpCall(gen.CurrentScopeVariable, exceptionVariable),
Ast.Assign(exceptionRethrowVariable, AstUtils.Constant(true)),
AstUtils.Empty()
).FinallyWithJumps(
AstUtils.Unless(retryingVariable, transformedEnsure)
)
);
return(result);
}
public override MSAst.Expression Reduce()
{
// allocated all variables here so they won't be shared w/ other
// locals allocated during the body or except blocks.
MSAst.ParameterExpression?lineUpdated = null;
MSAst.ParameterExpression?runElse = null;
MSAst.ParameterExpression?previousExceptionContext = null;
Debug.Assert(Else is null || _handlers.Length > 0);
if (_handlers.Length > 0)
{
lineUpdated = Ast.Variable(typeof(bool), "$lineUpdated_try");
if (Else != null)
{
runElse = Ast.Variable(typeof(bool), "run_else");
}
}
// don't allocate locals below here...
MSAst.Expression body = Body;
MSAst.Expression? @else = Else;
MSAst.Expression? @catch;
MSAst.Expression result;
MSAst.ParameterExpression?exception;
if (_handlers.Length > 0)
{
previousExceptionContext = Ast.Variable(typeof(Exception), "$previousException");
exception = Ast.Variable(typeof(Exception), "$exception");
@catch = TransformHandlers(exception, previousExceptionContext);
}
else if (Finally != null)
{
exception = Ast.Variable(typeof(Exception), "$exception");
@catch = null;
}
else
{
exception = null;
@catch = null;
}
// We have else clause, must generate guard around it
if (@else != null)
{
Debug.Assert(runElse != null);
Debug.Assert(previousExceptionContext != null && exception != null && @catch != null);
// run_else = true;
// try {
// try_body
// } catch ( ... ) {
// run_else = false;
// catch_body
// }
// if (run_else) {
// else_body
// }
result =
Ast.Block(
Ast.Assign(runElse, AstUtils.Constant(true)),
// save existing line updated, we could choose to do this only for nested exception handlers.
PushLineUpdated(false, lineUpdated),
LightExceptions.RewriteExternal(
AstUtils.Try(
Parent.AddDebugInfo(AstUtils.Empty(), new SourceSpan(Span.Start, GlobalParent.IndexToLocation(HeaderIndex))),
Ast.Assign(previousExceptionContext, Ast.Call(AstMethods.SaveCurrentException)),
body,
AstUtils.Constant(null)
).Catch(exception,
Ast.Assign(runElse, AstUtils.Constant(false)),
@catch,
// restore existing line updated after exception handler completes
PopLineUpdated(lineUpdated),
Ast.Assign(exception, Ast.Constant(null, typeof(Exception))),
AstUtils.Constant(null)
)
),
AstUtils.IfThen(runElse,
@else
),
AstUtils.Empty()
);
}
else if (@catch != null) // no "else" clause
// try {
// <try body>
// } catch (Exception e) {
// ... catch handling ...
// }
//
{
Debug.Assert(previousExceptionContext != null && exception != null);
result =
LightExceptions.RewriteExternal(
AstUtils.Try(
GlobalParent.AddDebugInfo(AstUtils.Empty(), new SourceSpan(Span.Start, GlobalParent.IndexToLocation(HeaderIndex))),
// save existing line updated
PushLineUpdated(false, lineUpdated),
Ast.Assign(previousExceptionContext, Ast.Call(AstMethods.SaveCurrentException)),
body,
AstUtils.Constant(null)
).Catch(exception,
@catch,
// restore existing line updated after exception handler completes
PopLineUpdated(lineUpdated),
Ast.Assign(exception, Ast.Constant(null, typeof(Exception))),
AstUtils.Constant(null)
)
);
}
else
{
result = body;
}
return(Ast.Block(
GetVariables(lineUpdated, runElse, previousExceptionContext),
AddFinally(result),
AstUtils.Default(typeof(void))
));
}
