/** * ...IterationStatement : * ... * while ( Expression ) Statement * ... * * See 12.6 * * Parse while statement. */ private void whileStatement() { // Capture WHILE token. final long whileToken = token; // WHILE tested in caller. next(); // Construct WHILE node. WhileNode whileNode = new WhileNode(line, whileToken, Token.descPosition(whileToken), false); lc.push(whileNode); try { expect(LPAREN); final int whileLine = line; final JoinPredecessorExpression test = joinPredecessorExpression(); expect(RPAREN); final Block body = getStatement(); appendStatement(whileNode = new WhileNode(whileLine, whileToken, finish, false). setTest(lc, test). setBody(lc, body)); } finally { lc.pop(whileNode); } }
@Override public boolean enterWhileNode(final WhileNode whileNode) { enterDefault(whileNode); type(whileNode.isDoWhile() ? "DoWhileStatement" : "WhileStatement"); comma(); if (whileNode.isDoWhile()) { property("body"); whileNode.getBody().accept(this); comma(); property("test"); whileNode.getTest().accept(this); } else { property("test"); whileNode.getTest().accept(this); comma(); property("body"); whileNode.getBody().accept(this); } return leave(); }
/** * ...IterationStatement : * ... * while ( Expression ) Statement * ... * * See 12.6 * * Parse while statement. */ private void whileStatement() { // Capture WHILE token. final long whileToken = token; // WHILE tested in caller. next(); // Construct WHILE node. WhileNode whileNode = new WhileNode(line, whileToken, Token.descPosition(whileToken), false); lc.push(whileNode); try { expect(LPAREN); final int whileLine = line; final Expression test = expression(); expect(RPAREN); final Block body = getStatement(); appendStatement(whileNode = new WhileNode(whileLine, whileToken, finish, false). setTest(lc, test). setBody(lc, body)); } finally { lc.pop(whileNode); } }
@Override public boolean enterWhileNode(final WhileNode whileNode) { final Expression test = whileNode.getTest(); final Block body = whileNode.getBody(); final Label breakLabel = whileNode.getBreakLabel(); final Label continueLabel = whileNode.getContinueLabel(); final boolean isDoWhile = whileNode.isDoWhile(); final Label loopLabel = new Label("loop"); if (!isDoWhile) { method._goto(continueLabel); } method.label(loopLabel); body.accept(this); if (!whileNode.isTerminal()) { method.label(continueLabel); lineNumber(whileNode); new BranchOptimizer(this, method).execute(test, loopLabel, true); method.label(breakLabel); } return false; }
/** * ...IterationStatement : * ... * while ( Expression ) Statement * ... * * See 12.6 * * Parse while statement. */ private void whileStatement() { // Capture WHILE token. final int whileLine = line; final long whileToken = token; // WHILE tested in caller. next(); // Construct WHILE node. WhileNode whileNode = new WhileNode(whileLine, whileToken, Token.descPosition(whileToken), false); lc.push(whileNode); try { expect(LPAREN); whileNode = whileNode.setTest(lc, expression()); expect(RPAREN); whileNode = whileNode.setBody(lc, getStatement()); appendStatement(whileNode); } finally { lc.pop(whileNode); } }
@Override public boolean enterWhileNode(final WhileNode whileNode) { lineNumber(whileNode); final Expression test = whileNode.getTest(); final Block body = whileNode.getBody(); final Label breakLabel = whileNode.getBreakLabel(); final Label continueLabel = whileNode.getContinueLabel(); final Label loopLabel = new Label("loop"); if (!whileNode.isDoWhile()) { method._goto(continueLabel); } method.label(loopLabel); body.accept(this); if (!whileNode.isTerminal()) { method.label(continueLabel); new BranchOptimizer(this, method).execute(test, loopLabel, true); method.label(breakLabel); } return false; }
/** * ...IterationStatement : * ... * do Statement while( Expression ) ; * ... * * See 12.6 * * Parse DO WHILE statement. */ private void doStatement() { // Capture DO token. final long doToken = token; // DO tested in the caller. next(); WhileNode doWhileNode = new WhileNode(-1, doToken, Token.descPosition(doToken), true); lc.push(doWhileNode); try { // Get DO body. final Block body = getStatement(); expect(WHILE); expect(LPAREN); final int doLine = line; final JoinPredecessorExpression test = joinPredecessorExpression(); expect(RPAREN); if (type == SEMICOLON) { endOfLine(); } doWhileNode.setFinish(finish); //line number is last appendStatement(doWhileNode = new WhileNode(doLine, doToken, finish, true). setBody(lc, body). setTest(lc, test)); } finally { lc.pop(doWhileNode); } }
@Override public boolean enterWhileNode(final WhileNode whileNode) { printLocalVariableConversion(whileNode); if (whileNode.isDoWhile()) { sb.append("do"); whileNode.getBody().accept(this); sb.append(' '); whileNode.toString(sb, printTypes); } else { whileNode.toString(sb, printTypes); whileNode.getBody().accept(this); } return false; }
@Override public Node leaveWhileNode(final WhileNode whileNode) { final Expression test = whileNode.getTest(); final Block body = whileNode.getBody(); if (isAlwaysTrue(test)) { //turn it into a for node without a test. final ForNode forNode = (ForNode)new ForNode(whileNode.getLineNumber(), whileNode.getToken(), whileNode.getFinish(), body, 0).accept(this); lc.replace(whileNode, forNode); return forNode; } return addStatement(checkEscape(whileNode)); }
private void enterDoWhileLoop(final WhileNode loopNode) { final JoinPredecessorExpression test = loopNode.getTest(); final Block body = loopNode.getBody(); final Label continueLabel = loopNode.getContinueLabel(); final Label breakLabel = loopNode.getBreakLabel(); final Map<Symbol, LvarType> beforeLoopTypes = localVariableTypes; final Label repeatLabel = new Label(""); for(;;) { jumpToLabel(loopNode, repeatLabel, beforeLoopTypes); final Map<Symbol, LvarType> beforeRepeatTypes = localVariableTypes; body.accept(this); if(reachable) { jumpToLabel(body, continueLabel); } joinOnLabel(continueLabel); if(!reachable) { break; } test.accept(this); jumpToLabel(test, breakLabel); if(isAlwaysFalse(test)) { break; } jumpToLabel(test, repeatLabel); joinOnLabel(repeatLabel); if(localVariableTypes.equals(beforeRepeatTypes)) { break; } resetJoinPoint(continueLabel); resetJoinPoint(breakLabel); resetJoinPoint(repeatLabel); } if(isAlwaysTrue(test)) { doesNotContinueSequentially(); } leaveBreakable(loopNode); }
@Override public boolean enterWhileNode(final WhileNode whileNode) { if(!reachable) { return false; } if(whileNode.isDoWhile()) { enterDoWhileLoop(whileNode); } else { enterTestFirstLoop(whileNode, null, null, false); } return false; }
@Override public boolean enterWhileNode(final WhileNode whileNode) { if(!method.isReachable()) { return false; } if(whileNode.isDoWhile()) { enterDoWhile(whileNode); } else { enterStatement(whileNode); enterForOrWhile(whileNode, null); } return false; }
private void enterDoWhile(final WhileNode whileNode) { final int liveLocalsOnContinueOrBreak = method.getUsedSlotsWithLiveTemporaries(); method.beforeJoinPoint(whileNode); final Block body = whileNode.getBody(); body.accept(this); emitContinueLabel(whileNode.getContinueLabel(), liveLocalsOnContinueOrBreak); if(method.isReachable()) { lineNumber(whileNode); final JoinPredecessorExpression test = whileNode.getTest(); final Label bodyEntryLabel = body.getEntryLabel(); final boolean testHasLiveConversion = LocalVariableConversion.hasLiveConversion(test); if(Expression.isAlwaysFalse(test)) { loadAndDiscard(test); if(testHasLiveConversion) { method.beforeJoinPoint(test); } } else if(testHasLiveConversion) { // If we have conversions after the test in do-while, they need to be effected on both branches. final Label beforeExit = new Label("do_while_preexit"); emitBranch(test.getExpression(), beforeExit, false); method.beforeJoinPoint(test); method._goto(bodyEntryLabel); method.label(beforeExit); method.beforeJoinPoint(test); } else { emitBranch(test.getExpression(), bodyEntryLabel, true); } } method.breakLabel(whileNode.getBreakLabel(), liveLocalsOnContinueOrBreak); }
@Override public boolean enterWhileNode(final WhileNode whileNode) { final ExpressionTree condTree = translateExpr(whileNode.getTest()); final StatementTree statTree = translateBlock(whileNode.getBody()); if (whileNode.isDoWhile()) { curStat = new DoWhileLoopTreeImpl(whileNode, condTree, statTree); } else { curStat = new WhileLoopTreeImpl(whileNode, condTree, statTree); } return false; }
/** * ...IterationStatement : * ... * while ( Expression ) Statement * ... * * See 12.6 * * Parse while statement. */ private void whileStatement() { // Capture WHILE token. final long whileToken = token; final int whileLine = line; // WHILE tested in caller. next(); final ParserContextLoopNode whileNode = new ParserContextLoopNode(); lc.push(whileNode); JoinPredecessorExpression test = null; Block body = null; try { expect(LPAREN); test = joinPredecessorExpression(); expect(RPAREN); body = getStatement(); } finally { lc.pop(whileNode); } if (body != null) { appendStatement(new WhileNode(whileLine, whileToken, body.getFinish(), false, test, body)); } }
/** * ...IterationStatement : * ... * do Statement while( Expression ) ; * ... * * See 12.6 * * Parse DO WHILE statement. */ private void doStatement() { // Capture DO token. final long doToken = token; int doLine = 0; // DO tested in the caller. next(); final ParserContextLoopNode doWhileNode = new ParserContextLoopNode(); lc.push(doWhileNode); Block body = null; JoinPredecessorExpression test = null; try { // Get DO body. body = getStatement(); expect(WHILE); expect(LPAREN); doLine = line; test = joinPredecessorExpression(); expect(RPAREN); if (type == SEMICOLON) { endOfLine(); } } finally { lc.pop(doWhileNode); } appendStatement(new WhileNode(doLine, doToken, finish, true, test, body)); }
private void enterDoWhileLoop(final WhileNode loopNode) { assertTypeStackIsEmpty(); final JoinPredecessorExpression test = loopNode.getTest(); final Block body = loopNode.getBody(); final Label continueLabel = loopNode.getContinueLabel(); final Label breakLabel = loopNode.getBreakLabel(); final Map<Symbol, LvarType> beforeLoopTypes = localVariableTypes; final Label repeatLabel = new Label(""); for(;;) { jumpToLabel(loopNode, repeatLabel, beforeLoopTypes); final Map<Symbol, LvarType> beforeRepeatTypes = localVariableTypes; body.accept(this); if(reachable) { jumpToLabel(body, continueLabel); } joinOnLabel(continueLabel); if(!reachable) { break; } visitExpressionOnEmptyStack(test); jumpToLabel(test, breakLabel); if(isAlwaysFalse(test)) { break; } jumpToLabel(test, repeatLabel); joinOnLabel(repeatLabel); if(localVariableTypes.equals(beforeRepeatTypes)) { break; } resetJoinPoint(continueLabel); resetJoinPoint(breakLabel); resetJoinPoint(repeatLabel); } if(isAlwaysTrue(test)) { doesNotContinueSequentially(); } leaveBreakable(loopNode); }