Java WhileNode类代码示例

import jdk.nashorn.internal.ir.WhileNode; //导入依赖的package包/类
/**
 * ...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);
    }
}
 

import jdk.nashorn.internal.ir.WhileNode; //导入依赖的package包/类
@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();
}
 

import jdk.nashorn.internal.ir.WhileNode; //导入依赖的package包/类
/**
 * ...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);
    }
}
 

import jdk.nashorn.internal.ir.WhileNode; //导入依赖的package包/类
@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;
}
 

import jdk.nashorn.internal.ir.WhileNode; //导入依赖的package包/类
/**
 * ...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);
    }
}
 

import jdk.nashorn.internal.ir.WhileNode; //导入依赖的package包/类
@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;
}
 

import jdk.nashorn.internal.ir.WhileNode; //导入依赖的package包/类
/**
 * ...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);
    }
}
 

import jdk.nashorn.internal.ir.WhileNode; //导入依赖的package包/类
@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;
}
 

import jdk.nashorn.internal.ir.WhileNode; //导入依赖的package包/类
@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));
}
 

import jdk.nashorn.internal.ir.WhileNode; //导入依赖的package包/类
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);
}
 

import jdk.nashorn.internal.ir.WhileNode; //导入依赖的package包/类
@Override
public boolean enterWhileNode(final WhileNode whileNode) {
    if(!reachable) {
        return false;
    }
    if(whileNode.isDoWhile()) {
        enterDoWhileLoop(whileNode);
    } else {
        enterTestFirstLoop(whileNode, null, null, false);
    }
    return false;
}
 

import jdk.nashorn.internal.ir.WhileNode; //导入依赖的package包/类
@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;
}
 

import jdk.nashorn.internal.ir.WhileNode; //导入依赖的package包/类
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);
}
 

import jdk.nashorn.internal.ir.WhileNode; //导入依赖的package包/类
@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;
}
 

import jdk.nashorn.internal.ir.WhileNode; //导入依赖的package包/类
/**
 * ...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));
    }
}