Java SwitchNode类代码示例

import jdk.nashorn.internal.ir.SwitchNode; //导入依赖的package包/类
@Override
public boolean enterSwitchNode(final SwitchNode switchNode) {
    final List<CaseNode> caseNodes = switchNode.getCases();
    final List<CaseTreeImpl> caseTrees = new ArrayList<>(caseNodes.size());
    for (final CaseNode caseNode : caseNodes) {
        final Block body = caseNode.getBody();
        caseTrees.add(
                new CaseTreeImpl(caseNode,
                        translateExpr(caseNode.getTest()),
                        translateStats(body != null? body.getStatements() : null)));
    }

    curStat = new SwitchTreeImpl(switchNode,
            translateExpr(switchNode.getExpression()),
            caseTrees);
    return false;
}
 

import jdk.nashorn.internal.ir.SwitchNode; //导入依赖的package包/类
@Override
public boolean enterSwitchNode(final SwitchNode switchNode) {
    switchNode.toString(sb);
    sb.append(" {");

    final List<CaseNode> cases = switchNode.getCases();

    for (final CaseNode caseNode : cases) {
        sb.append(EOLN);
        indent();
        caseNode.toString(sb);
        indent += TABWIDTH;
        caseNode.getBody().accept(this);
        indent -= TABWIDTH;
        sb.append(EOLN);
    }

    sb.append(EOLN);
    indent();
    sb.append("}");

    return false;
}
 

import jdk.nashorn.internal.ir.SwitchNode; //导入依赖的package包/类
@Override
public Node leaveSwitchNode(final SwitchNode switchNode) {
    final boolean allInteger = switchNode.getTag().getSymbolType().isInteger();

    if (allInteger) {
        return switchNode;
    }

    final Expression     expression  = switchNode.getExpression();
    final List<CaseNode> cases       = switchNode.getCases();
    final List<CaseNode> newCases    = new ArrayList<>();

    for (final CaseNode caseNode : cases) {
        final Expression test = caseNode.getTest();
        newCases.add(test != null ? caseNode.setTest(convert(test, Type.OBJECT)) : caseNode);
    }

    return switchNode.
        setExpression(lc, convert(expression, Type.OBJECT)).
        setCases(lc, newCases);
}
 

import jdk.nashorn.internal.ir.SwitchNode; //导入依赖的package包/类
@Override
public boolean enterSwitchNode(final SwitchNode switchNode) {
    enterDefault(switchNode);

    type("SwitchStatement");
    comma();

    property("discriminant");
    switchNode.getExpression().accept(this);
    comma();

    array("cases", switchNode.getCases());

    return leave();
}
 

import jdk.nashorn.internal.ir.SwitchNode; //导入依赖的package包/类
@Override
public boolean enterSwitchNode(final SwitchNode switchNode) {
    switchNode.toString(sb, printTypes);
    sb.append(" {");

    final List<CaseNode> cases = switchNode.getCases();

    for (final CaseNode caseNode : cases) {
        sb.append(EOLN);
        indent();
        caseNode.toString(sb, printTypes);
        printLocalVariableConversion(caseNode);
        indent += TABWIDTH;
        caseNode.getBody().accept(this);
        indent -= TABWIDTH;
        sb.append(EOLN);
    }
    if(switchNode.getLocalVariableConversion() != null) {
        sb.append(EOLN);
        indent();
        sb.append("default: ");
        printLocalVariableConversion(switchNode);
        sb.append("{}");
    }
    sb.append(EOLN);
    indent();
    sb.append("}");

    return false;
}
 

import jdk.nashorn.internal.ir.SwitchNode; //导入依赖的package包/类
@Override
public Node leaveSwitchNode(final SwitchNode switchNode) {
    // We only need a symbol for the tag if it's not an integer switch node
    if(!switchNode.isUniqueInteger()) {
        switchNode.setTag(newObjectInternal(SWITCH_TAG_PREFIX));
    }
    return switchNode;
}
 

import jdk.nashorn.internal.ir.SwitchNode; //导入依赖的package包/类
private static boolean isUniqueIntegerSwitchNode(final SwitchNode switchNode) {
    final Set<Integer> alreadySeen = new HashSet<>();
    for (final CaseNode caseNode : switchNode.getCases()) {
        final Expression test = caseNode.getTest();
        if (test != null && !isUniqueIntegerLiteral(test, alreadySeen)) {
            return false;
        }
    }
    return true;
}
 

import jdk.nashorn.internal.ir.SwitchNode; //导入依赖的package包/类
@Override
public Node leaveSwitchNode(final SwitchNode switchNode) {
    if(!switchNode.isUniqueInteger()) {
        // Wrap it in a block so its internally created tag is restricted in scope
        addStatementEnclosedInBlock(switchNode);
    } else {
        addStatement(switchNode);
    }
    return switchNode;
}
 

import jdk.nashorn.internal.ir.SwitchNode; //导入依赖的package包/类
SwitchTreeImpl(final SwitchNode node,
        final ExpressionTree expr,
        final List<? extends CaseTree> cases) {
    super(node);
    this.expr = expr;
    this.cases = cases;
}
 

import jdk.nashorn.internal.ir.SwitchNode; //导入依赖的package包/类
@Override
public Node leaveSwitchNode(final SwitchNode switchNode) {
    // We only need a symbol for the tag if it's not an integer switch node
    if(!switchNode.isUniqueInteger()) {
        return switchNode.setTag(lc, newObjectInternal(SWITCH_TAG_PREFIX));
    }
    return switchNode;
}
 

import jdk.nashorn.internal.ir.SwitchNode; //导入依赖的package包/类
SwitchTreeImpl(final SwitchNode node,
        final ExpressionTree expr,
        List<? extends CaseTree> cases) {
    super(node);
    this.expr = expr;
    this.cases = cases;
}