private void EvaluateWhileStatement(BoundWhileStatement node) { while ((bool)EvaluateExpression(node.Condition)) { EvaluateStatement(node.Body); } }
protected override BoundStatement RewriteForStatement(BoundForStatement node) { /* * { * let upperBound = <UpperBound> * <variable> = <lowerBound> * while <variable> < <UpperBound> * { * <statement> * <variable> = <variable> + 1 * } * } */ var upperBoundSymbol = new VariableSymbol("upperBound", true, node.UpperBound.Type, true); var upperBoundDeclaration = new BoundVariableDeclaration(upperBoundSymbol, node.UpperBound); var upperBoundExpression = new BoundVariableExpression(upperBoundSymbol); var variableDeclaration = new BoundVariableDeclaration(node.Variable, node.LowerBound); // LowerBound shouldn't be rewriten? var variableExpression = new BoundVariableExpression(node.Variable); var conditionOperator = BoundBinaryOperator.Bind(SyntaxKind.LessToken, TypeSymbol.Int, TypeSymbol.Int); var condition = new BoundBinaryExpression(variableExpression, conditionOperator, upperBoundExpression); // UpperBound shouldn't be rewriten? var incrementOperator = BoundBinaryOperator.Bind(SyntaxKind.PlusToken, node.Variable.Type, TypeSymbol.Int); var increment = new BoundBinaryExpression(variableExpression, incrementOperator, new BoundLiteralExpression(1)); var incrementAssignment = new BoundAssignmentExpression(node.Variable, increment); var incrementStatement = new BoundExpressionStatement(incrementAssignment); var whileBlockStatement = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>(node.Statement, incrementStatement)); var whileStatement = new BoundWhileStatement(condition, whileBlockStatement); var result = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>(upperBoundDeclaration, variableDeclaration, whileStatement)); return(RewriteStatement(result)); }
protected override BoundStatement RewriteWhileStatement(BoundWhileStatement node) { // while <condition> // <body> // // -----> // // goto continue // body: // <body> // continue: // gotoTrue <condition> body // break: var bodyLabel = GenerateLabel(); var result = Block( node.Syntax, Goto(node.Syntax, node.ContinueLabel), Label(node.Syntax, bodyLabel), node.Body, Label(node.Syntax, node.ContinueLabel), GotoTrue(node.Syntax, bodyLabel, node.Condition), Label(node.Syntax, node.BreakLabel) ); return(RewriteStatement(result)); }
public override BoundNode VisitWhileStatement(BoundWhileStatement node) { AddAll(node.Locals); base.VisitWhileStatement(node); RemoveAll(node.Locals); return(null); }
protected override BoundStatement RewriteWhileStatement(BoundWhileStatement node) { // goto continue // body: // <body> // continue: // goto body if <condition> // break: var bodyLabel = CreateLabel(); var gotoContinue = new BoundGotoStatement(node.ContinueLabel, node.IsValid); var gotoBody = new BoundConditionalGotoStatement(bodyLabel, node.Condition, jumpIfFalse: false, node.IsValid); var continueLabelStmt = new BoundLabelStatement(node.ContinueLabel, node.IsValid); var bodyLabelStmt = new BoundLabelStatement(bodyLabel, node.IsValid); var breakLabelStmt = new BoundLabelStatement(node.BreakLabel, node.IsValid); var res = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>( gotoContinue, bodyLabelStmt, node.Body, continueLabelStmt, gotoBody, breakLabelStmt ), node.IsValid); return(RewriteStatement(res)); }
protected override BoundStatement RewriteForStatement(BoundForStatement node) { //For Statements are now all While Statements var variableDeclaration = new BoundVariableDeclaration(node.Variable, node.LowerBound); var variableExpression = new BoundVariableExpression(node.Variable); var upperBoundSymbol = new VariableSymbol("upperBound", true, typeof(int)); var upperBoundDeclaration = new BoundVariableDeclaration(upperBoundSymbol, node.UpperBound); var condition = new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.LessOrEqualsToken, typeof(int), typeof(int)), new BoundVariableExpression(upperBoundSymbol) ); var increment = new BoundExpressionStatement( new BoundAssignmentExpression( node.Variable, new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.PlusToken, typeof(int), typeof(int)), new BoundLiteralExpression(1) ) ) ); var whileBody = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>(node.Body, increment)); var whileStatement = new BoundWhileStatement(condition, whileBody); var result = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>( variableDeclaration, upperBoundDeclaration, whileStatement )); return(RewriteStatement(result)); }
public virtual BoundExpression InstrumentWhileStatementCondition(BoundWhileStatement original, BoundExpression rewrittenCondition, SyntheticBoundNodeFactory factory) { Debug.Assert(!original.WasCompilerGenerated); Debug.Assert(original.Syntax.Kind() == SyntaxKind.WhileStatement); Debug.Assert(factory != null); return(rewrittenCondition); }
protected override BoundStatement RewriteWhileStatement(BoundWhileStatement node) { // while <condition> // <bode> // // -----> // // goto continue // <body> // continue: // gotoTrue <condition> body // Break // var gotoContinue = new BoundGotoStatment(node.ContinueLabel); var bodyLabelStatement = new BoundLabelStatement(node.BodyLabel); var continueLabelStatement = new BoundLabelStatement(node.ContinueLabel); var gotoTrue = new BoundConditionalGotoStatment(node.BodyLabel, node.Condition); var breakLabelStatement = new BoundLabelStatement(node.BreakLabel); var result = new BoundBlockStatemnet(ImmutableArray.Create <BoundStatement>( gotoContinue, bodyLabelStatement, node.Body, continueLabelStatement, gotoTrue, breakLabelStatement )); return(RewriteStatement(result)); }
protected override BoundStatement RewriteWhileStatement(BoundWhileStatement node) { // while <condition> <body> // --- to ---> // { // continue: // gotoFalse <condition> break // <body> // goto continue // break: // } var continueLabel = node.ContinueLabel; var breakLabel = node.BreakLabel; var continueStatement = new BoundLabelStatement(continueLabel); var gotoFalseStatement = new BoundConditionalGotoStatement(breakLabel, node.Condition, jumpIfTrue: false); var gotoContinue = new BoundGotoStatement(continueLabel); var breakStatement = new BoundLabelStatement(breakLabel); var result = new BoundBlockStatement( continueStatement, gotoFalseStatement, node.Body, gotoContinue, breakStatement); return(RewriteStatement(result)); }
protected override BoundStatement RewriteWhileStatement(BoundWhileStatement node) { // while <condition> // <body> // // ---> // // goto check // continue: // <body> // check: // gotoTrue <condition> continue // break: // var checkLabel = GenerateLabel("Check"); var gotoCheck = new BoundGotoStatement(checkLabel); var continueLabelStatement = new BoundLabelStatement(node.ContinueLabel); var checkLabelStatement = new BoundLabelStatement(checkLabel); var gotoTrue = new BoundConditionalGotoStatement(node.ContinueLabel, node.Condition); var breakLabelStatement = new BoundLabelStatement(node.BreakLabel); var result = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>( gotoCheck, continueLabelStatement, node.Body, checkLabelStatement, gotoTrue, breakLabelStatement )); return(RewriteStatement(result)); }
public override BoundNode VisitWhileStatement(BoundWhileStatement node) { var newLocals = RewriteLocals(node.Locals); BoundExpression condition = (BoundExpression)this.Visit(node.Condition); BoundStatement body = (BoundStatement)this.Visit(node.Body); return node.Update(newLocals, condition, body, node.BreakLabel, node.ContinueLabel); }
protected override BoundStatement RewriteForStatement(BoundForStatement statement) { /* for(<assignment>, <condition>, <step>) <body> * * <assignment> * while (<condition>) { * body * step * } */ var whileStatements = ImmutableArray.CreateBuilder <BoundStatement>(); whileStatements.AddRange(new BoundStatement[] { statement.Body, new BoundLabel(statement.ContinueLabel), new BoundExpressionStatement(statement.Step) }); var whileStatement = new BoundWhileStatement(statement.Condition, new BoundBlock(whileStatements.ToImmutable()), statement.BreakLabel, statement.ContinueLabel, false); var finalStatements = ImmutableArray.CreateBuilder <BoundStatement>(); finalStatements.AddRange(new BoundStatement[] { statement.Assignment, whileStatement }); return(RewriteStatement(new BoundBlock(finalStatements.ToImmutable()))); }
public override BoundNode VisitWhileStatement(BoundWhileStatement node) { if (IsInside) { _labelsInside.Add(node.BreakLabel); } return(base.VisitWhileStatement(node)); }
protected override BoundStatement RewriteForStatement(BoundForStatement node) { /* * for <var> = <lower> to <upper> * <body> * * -----> * { * var <var> = <lower> * let upperBound = <upper> * while (<var> <= <upperBound>) * { * <body> * <var> = <var> + 1 * } * } */ // var <var> = <lower> var variableDeclaration = new BoundVariableDeclaration(node.Variable, node.LowerBound); // let upperBound = <upper> var upperBoundSymbol = new VariableSymbol("upperBound", true, TypeSymbol.Int); var upperBoundDeclaration = new BoundVariableDeclaration(upperBoundSymbol, node.UpperBound); // <var> var variableExpression = new BoundVariableExpression(node.Variable); //<var> <= <upperBound> var condition = new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.LessOrEqualsToken, TypeSymbol.Int, TypeSymbol.Int), new BoundVariableExpression(upperBoundSymbol) ); // <var> = <var> + 1 var increment = new BoundExpressionStatement( new BoundAssignmentExpression( node.Variable, new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.PlusToken, TypeSymbol.Int, TypeSymbol.Int), new BoundLiteralExpression(1) ) ) ); var whileBlock = new BoundBlockStatement(ImmutableArray.Create(node.Body, increment)); var whileStatement = new BoundWhileStatement(condition, whileBlock); var result = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>( variableDeclaration, upperBoundDeclaration, whileStatement)); return(RewriteStatement(result)); }
protected override BoundStatement RewriteForStatement(BoundForStatement node) { // for <var> = <lower> to <upper> // <body> // // ----> // { // var <var> = <lower> // let upperBound = <upper> // while (<var> <= upperBound) // { // <body> // continue: // <var> = <var> + 1 // } // } var variableDeclaration = new BoundVariableDeclaration(node.Variable, node.LowerBound); var variableExpression = new BoundVariableExpression(node.Variable); var upperBoundSymbol = new LocalVariableSymbol("upperBound", true, TypeSymbol.Int); var upperBoundDeclaration = new BoundVariableDeclaration(upperBoundSymbol, node.UpperBound); var condition = new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.LessOrEqualsToken, TypeSymbol.Int, TypeSymbol.Int), new BoundVariableExpression(upperBoundSymbol) ); var continueLabelStatement = new BoundLabelStatement(node.ContinueLabel); var increment = new BoundExpressionStatement( new BoundAssignmentExpression( node.Variable, new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.PlusToken, TypeSymbol.Int, TypeSymbol.Int), new BoundLiteralExpression(1) ) ) ); var whileBody = new BoundBlockStatement( ImmutableArray.Create <BoundStatement>( node.Body, continueLabelStatement, increment ) ); var whileStatement = new BoundWhileStatement(condition, whileBody, node.BreakLabel, GenerateLabel()); var result = new BoundBlockStatement( ImmutableArray.Create <BoundStatement>( variableDeclaration, upperBoundDeclaration, whileStatement ) ); return(RewriteStatement(result)); }
protected override BoundStatement RewriteForStatement(BoundForStatement node) { var initializer = new BoundExpressionStatement(node.Initializer); var loop = new BoundExpressionStatement(node.Loop); var continueLabelStatement = new BoundLabelStatement(node.ContinueLabel); var whileBlock = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>(node.Body, continueLabelStatement, loop)); var whileStatement = new BoundWhileStatement(node.Condition, whileBlock, node.BreakLabel, GenerateLabel()); var result = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>(initializer, whileStatement)); return(RewriteStatement(result)); }
protected virtual BoundStatement RewriteWhileStatement(BoundWhileStatement statement) { var cond = RewriteExpression(statement.Condition); var body = RewriteStatement(statement.Body); if (cond == statement.Condition && body == statement.Body) { return(statement); } return(new BoundWhileStatement(cond, body, statement.BreakLabel, statement.ContinueLabel)); }
private BoundStatement RewriteWhileStatement( BoundWhileStatement loop, ImmutableArray <LocalSymbol> locals, BoundExpression rewrittenCondition, BoundStatement rewrittenBody, GeneratedLabelSymbol breakLabel, GeneratedLabelSymbol continueLabel, bool hasErrors) { if (locals.IsEmpty) { return(RewriteWhileStatement(loop, rewrittenCondition, rewrittenBody, breakLabel, continueLabel, hasErrors)); } // We need to enter scope-block from the top, that is where an instance of a display class will be created // if any local is captured within a lambda. // while (condition) // body; // // becomes // // continue: // { // GotoIfFalse condition break; // body // goto continue; // } // break: SyntaxNode syntax = loop.Syntax; BoundStatement continueLabelStatement = new BoundLabelStatement(syntax, continueLabel); BoundStatement ifNotConditionGotoBreak = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, breakLabel); if (this.Instrument && !loop.WasCompilerGenerated) { ifNotConditionGotoBreak = _instrumenter.InstrumentWhileStatementConditionalGotoStartOrBreak(loop, ifNotConditionGotoBreak); continueLabelStatement = new BoundSequencePoint(null, continueLabelStatement); } return(BoundStatementList.Synthesized(syntax, hasErrors, continueLabelStatement, new BoundBlock(syntax, locals, ImmutableArray.Create( ifNotConditionGotoBreak, rewrittenBody, new BoundGotoStatement(syntax, continueLabel))), new BoundLabelStatement(syntax, breakLabel))); }
protected override BoundStatement RewriteForToStatement(BoundForToStatement node) { // for <var> = <lower> to <upper> <body> // --- to ---> // { // var <var> = <lower> // let upperBound = <upper> // while <var> <= upperBound // <body> // continue: // <var> = <var> + 1 // } var variableDeclaration = new BoundVariableDeclarationStatement(node.Variable, node.LowerBound); var upperBoundSymbol = new LocalVariableSymbol("upperBound", true, TypeSymbol.Int); var upperBoundDeclaration = new BoundVariableDeclarationStatement(upperBoundSymbol, node.UpperBound); var upperBoundExpression = new BoundVariableExpression(upperBoundSymbol); var condition = new BoundBinaryExpression( new BoundVariableExpression(node.Variable), BoundBinaryOperator.Bind(Lexing.TokenKind.LessOrEquals, TypeSymbol.Int, TypeSymbol.Int), upperBoundExpression); var increment = new BoundExpressionStatement( new BoundAssignmentExpression( node.Variable, new BoundBinaryExpression( new BoundVariableExpression(node.Variable), BoundBinaryOperator.Bind(Lexing.TokenKind.Plus, TypeSymbol.Int, TypeSymbol.Int), new BoundLiteralExpression(1)))); var whileBlock = new BoundBlockStatement( node.Body, increment); var whileStatement = new BoundWhileStatement(condition, whileBlock, node.BreakLabel, node.ContinueLabel); var result = new BoundBlockStatement( variableDeclaration, upperBoundDeclaration, whileStatement); return(RewriteStatement(result)); }
public override object VisitWhileStatement(BoundWhileStatement node, object arg) { // while (node.Condition) { node.Body; node.ContinueLabel: } node.BreakLabel: LoopHead(node); VisitCondition(node.Condition); var bodyState = new FlowAnalysisLocalState(this.state.Reachable && !IsConstantFalse(node.Condition), this.state.AssignedWhenTrue); var breakState = new FlowAnalysisLocalState(this.state.Reachable && !IsConstantTrue(node.Condition), this.state.AssignedWhenFalse); var oldPendingBranches = SavePending(); this.state = bodyState; VisitStatement(node.Body); ResolveContinues(node.ContinueLabel); LoopTail(node); ResolveBreaks(oldPendingBranches, breakState, node.BreakLabel); return(null); }
private void EmitWhileStatement(BoundWhileStatement statement) { string startOfLoopLabel = this.GenerateJumpLabel(); string endOfLoopLabel = this.GenerateJumpLabel(); this.instructions.Add(new TransientLabelInstruction(startOfLoopLabel, statement.Syntax.WhileToken.Range)); this.EmitExpression(statement.Condition); this.instructions.Add(new TransientConditionalGoToInstruction(null, endOfLoopLabel, statement.Syntax.Condition.Range)); this.EmitBlockStatement(statement.Body); TextRange endOfLoopRange = this.instructions.Last().Range; this.instructions.Add(new TransientUnconditionalGoToInstruction(startOfLoopLabel, endOfLoopRange)); this.instructions.Add(new TransientLabelInstruction(endOfLoopLabel, endOfLoopRange)); }
protected override BoundStatement RewriteWhileStatement(BoundWhileStatement node) { /* * check: * gotoIfFalse <condition> end * <statement> * goto check * end: */ var checkLabelStatement = new BoundLabelStatement(GenerateLabel()); var endLabelStatement = new BoundLabelStatement(GenerateLabel()); var gotoIfFalseStatement = new BoundConditionalGotoStatement(endLabelStatement.Label, node.Condition, false); var gotoCheckStatement = new BoundGotoStatement(checkLabelStatement.Label); var statements = ImmutableArray.Create <BoundStatement>(checkLabelStatement, gotoIfFalseStatement, node.Statement, gotoCheckStatement, endLabelStatement); var result = new BoundBlockStatement(statements); return(RewriteStatement(result)); }
protected override BoundStatement RewriteForStatement(BoundForStatement node) { // for <var> = <lower> to <upper> // <body> // // ----> // // { // var <var> = <lower> // while (<var> <= <upper>) // { // <body> // <var> = <var> + 1 // } // } var variableDeclaration = new BoundVeriableDeclaration(node.Variable, node.LowerBound); var variableExpression = new BoundVariableExpression(node.Variable); var upperBoundSybmle = new VariableSymble("upperBound", true, typeof(int)); var upperBoundDeclaration = new BoundVeriableDeclaration(upperBoundSybmle, node.UpperBound); var condition = new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.LessOrEqualToken, typeof(int), typeof(int)), new BoundVariableExpression(upperBoundSybmle) ); var increment = new BoundExpressionStatemnet( new BoundAssignmentExpression( node.Variable, new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.PlusToken, typeof(int), typeof(int)), new BoundLiteralExpression(1) ) ) ); var whileBody = new BoundBlockStatemnet(ImmutableArray.Create <BoundStatement>(node.Body, increment)); var whileStatement = new BoundWhileStatement(condition, whileBody); var result = new BoundBlockStatemnet(ImmutableArray.Create <BoundStatement>( variableDeclaration, upperBoundDeclaration, whileStatement)); return(RewriteStatement(result)); }
protected override BoundStatement RewriteWhileStatement(BoundWhileStatement node) { var bodyLabel = GenerateLabel(); var gotoContinue = new BoundGotoStatement(node.ContinueLabel); var bodyLabelStatement = new BoundLabelStatement(bodyLabel); var continueLabelStatement = new BoundLabelStatement(node.ContinueLabel); var gotoTrue = new BoundConditionalGotoStatement(bodyLabel, node.Condition); var breakLabelStatement = new BoundLabelStatement(node.BreakLabel); var result = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>( gotoContinue, bodyLabelStatement, node.Body, continueLabelStatement, gotoTrue, breakLabelStatement )); return(RewriteStatement(result)); }
protected override BoundStatement RewriteForStatement(BoundForStatement node) { var condition = node.Condition; var continueLabelStatement = new BoundLabelStatement(node.ContinueLabel); var increment = new BoundExpressionStatement( node.Action ); var whileBody = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>( node.Body, continueLabelStatement, increment) ); var whileStatement = new BoundWhileStatement(condition, whileBody, node.BreakLabel, GenerateLabel()); var result = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>( node.Variable, whileStatement )); return(RewriteStatement(result)); }
protected override BoundStatement RewriteWhileStatement(BoundWhileStatement statement) { /* while(<condition>) <body> * * branch conditionCheck * #start * <body> * #conditionCheck * conditional branch <condition> start */ var startLabel = CreateNextLabel(); var conditionCheckLabel = CreateNextLabel(); var firstBranch = new BoundBranchStatement(conditionCheckLabel); var condBranch = new BoundConditionalBranchStatement(startLabel, statement.Condition, true); var statements = ImmutableArray.CreateBuilder <BoundStatement>(); statements.AddRange(new BoundStatement[] { firstBranch, new BoundLabel(startLabel), statement.Body }); if (statement.AddContinue) { statements.Add(new BoundLabel(statement.ContinueLabel)); } statements.AddRange(new BoundStatement[] { new BoundLabel(conditionCheckLabel), condBranch, new BoundLabel(statement.BreakLabel) }); var rewrite = RewriteStatement(new BoundBlock(statements.ToImmutable())); return(rewrite); }
public override BoundNode VisitWhileStatement(BoundWhileStatement node) { Debug.Assert(node != null); var rewrittenCondition = (BoundExpression)Visit(node.Condition); var rewrittenBody = (BoundStatement)Visit(node.Body); TextSpan conditionSequencePointSpan = default(TextSpan); if (this.generateDebugInfo) { if (!node.WasCompilerGenerated) { WhileStatementSyntax whileSyntax = (WhileStatementSyntax)node.Syntax; conditionSequencePointSpan = TextSpan.FromBounds( whileSyntax.WhileKeyword.Span.Start, whileSyntax.CloseParenToken.Span.End); } } return(RewriteWhileStatement(node.Syntax, rewrittenCondition, conditionSequencePointSpan, rewrittenBody, node.BreakLabel, node.ContinueLabel, node.HasErrors)); }
protected override BoundStatement RewriteForStatement(BoundForStatement node) { BoundVariableDeclaration variableDeclaration = new BoundVariableDeclaration(node.Variable, node.LowerBound); BoundVariableExpression variableExpression = new BoundVariableExpression(node.Variable); VariableSymbol upperVariableSymbol = new LocalVariableSymbol("upperBound", true, TypeSymbol.Int); BoundVariableDeclaration upperVariableDeclaration = new BoundVariableDeclaration(upperVariableSymbol, node.UpperBound); BoundBinaryExpression condition = new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.LessOrEqualsToken, TypeSymbol.Int, TypeSymbol.Int), new BoundVariableExpression(upperVariableSymbol) ); BoundLabelStatement continueLabelStatement = new BoundLabelStatement(node.ContinueLabel); BoundExpressionStatement increment = new BoundExpressionStatement( new BoundAssignmentExpression( node.Variable, new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.PlusToken, TypeSymbol.Int, TypeSymbol.Int), new BoundLiteralExpression(1) ) ) ); BoundBlockStatement whileBody = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>( node.Body, continueLabelStatement, increment )); BoundWhileStatement whileStatement = new BoundWhileStatement(condition, whileBody, node.BreakLabel, GenerateLabel()); BoundBlockStatement result = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>( variableDeclaration, upperVariableDeclaration, whileStatement )); return(RewriteStatement(result)); }
protected override BoundStatement RewriteForStatement(BoundForStatement node) { // for <var> = <lower> to <upper> // <body> // is rewritten to // { // var <Var> = <lower> // while () // var variableDeclaration = new BoundVariableDeclaration(node.Variable, node.LowerBound); var variableExpression = new BoundVariableExpression(node.Variable); var condition = new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.LessOrEqualsToken, typeof(int), typeof(int)), node.UpperBound); var increment = new BoundExpressionStatement( new BoundAssignmentExpression( node.Variable, new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind( SyntaxKind.PlusToken, typeof(int), typeof(int)), new BoundLiteralExpression(1) ) ) ); var whileBlock = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>(node.Body, increment)); var whileStatement = new BoundWhileStatement(condition, whileBlock); var result = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>(variableDeclaration, whileStatement)); return(RewriteStatement(result)); }
protected override BoundStatement RewriteWhileStatement(BoundWhileStatement node) { // goto check: // continue: // <body> // check: // gotoTrue condition continue: // end: // ------------------------------------------------------- // later try out //- begin //- gotoFalse <condition> end //- <body> //- goto begin //- end var endLabel = GenerateLabel(); var checkLabel = GenerateLabel(); var continueLabel = GenerateLabel(); var gotoCheck = new BoundGotoStatement(checkLabel); var gotoTrue = new BoundConditionalGotoStatement(continueLabel, node.Condition); var continueLabelStatement = new BoundLabelStatement(continueLabel); var checkLabelStatement = new BoundLabelStatement(checkLabel); var endLabelStatement = new BoundLabelStatement(endLabel); var result = new BoundBlockStatement( ImmutableArray.Create <BoundStatement>( gotoCheck, continueLabelStatement, node.Body, checkLabelStatement, gotoTrue, endLabelStatement)); return(RewriteStatement(result)); }
public override BoundNode VisitWhileStatement(BoundWhileStatement node) { Debug.Assert(node != null); var rewrittenCondition = (BoundExpression)Visit(node.Condition); var rewrittenBody = (BoundStatement)Visit(node.Body); TextSpan conditionSequencePointSpan = default(TextSpan); if (this.generateDebugInfo) { if (!node.WasCompilerGenerated) { WhileStatementSyntax whileSyntax = (WhileStatementSyntax)node.Syntax; conditionSequencePointSpan = TextSpan.FromBounds( whileSyntax.WhileKeyword.Span.Start, whileSyntax.CloseParenToken.Span.End); } } return RewriteWhileStatement(node.Syntax, rewrittenCondition, conditionSequencePointSpan, rewrittenBody, node.BreakLabel, node.ContinueLabel, node.HasErrors); }