Java BinaryNode.isLogical方法代码示例

import jdk.nashorn.internal.ir.BinaryNode; //导入方法依赖的package包/类
@Override
public boolean enterBinaryNode(final BinaryNode binaryNode) {
    enterDefault(binaryNode);

    final String name;
    if (binaryNode.isAssignment()) {
        name = "AssignmentExpression";
    } else if (binaryNode.isLogical()) {
        name = "LogicalExpression";
    } else {
        name = "BinaryExpression";
    }

    type(name);
    comma();

    property("operator", binaryNode.tokenType().getName());
    comma();

    property("left");
    binaryNode.lhs().accept(this);
    comma();

    property("right");
    binaryNode.rhs().accept(this);

    return leave();
}
 

import jdk.nashorn.internal.ir.BinaryNode; //导入方法依赖的package包/类
@Override
public boolean enterBinaryNode(final BinaryNode binaryNode) {
    // NOTE: regardless of operator's lexical associativity, lhs is always evaluated first.
    final Expression lhs = binaryNode.lhs();
    final LvarType lhsType;
    if (!(lhs instanceof IdentNode && binaryNode.isTokenType(TokenType.ASSIGN))) {
        lhsType = visitExpression(lhs);
    } else {
        // Can't visit IdentNode on LHS of a simple assignment, as visits imply use, and this is def.
        // The type is irrelevant, as only RHS is used to determine the type anyway.
        lhsType = LvarType.UNDEFINED;
    }

    final boolean isLogical = binaryNode.isLogical();
    final Label joinLabel = isLogical ? new Label("") : null;
    if(isLogical) {
        jumpToLabel((JoinPredecessor)lhs, joinLabel);
    }

    final Expression rhs = binaryNode.rhs();
    final LvarType rhsType = visitExpression(rhs);
    if(isLogical) {
        jumpToLabel((JoinPredecessor)rhs, joinLabel);
    }
    joinOnLabel(joinLabel);

    final LvarType type = toLvarType(binaryNode.setOperands(lhsType.typeExpression, rhsType.typeExpression).getType());

    if(binaryNode.isAssignment() && lhs instanceof IdentNode) {
        if(binaryNode.isSelfModifying()) {
            onSelfAssignment((IdentNode)lhs, type);
        } else {
            onAssignment((IdentNode)lhs, type);
        }
    }
    typeStack.push(type);
    return false;
}
 

import jdk.nashorn.internal.ir.BinaryNode; //导入方法依赖的package包/类
/**
 * Verify an assignment expression.
 * @param op  Operation token.
 * @param lhs Left hand side expression.
 * @param rhs Right hand side expression.
 * @return Verified expression.
 */
private Expression verifyAssignment(final long op, final Expression lhs, final Expression rhs) {
    final TokenType opType = Token.descType(op);

    switch (opType) {
    case ASSIGN:
    case ASSIGN_ADD:
    case ASSIGN_BIT_AND:
    case ASSIGN_BIT_OR:
    case ASSIGN_BIT_XOR:
    case ASSIGN_DIV:
    case ASSIGN_MOD:
    case ASSIGN_MUL:
    case ASSIGN_SAR:
    case ASSIGN_SHL:
    case ASSIGN_SHR:
    case ASSIGN_SUB:
        if (!(lhs instanceof AccessNode ||
              lhs instanceof IndexNode ||
              lhs instanceof IdentNode)) {
            return referenceError(lhs, rhs, env._early_lvalue_error);
        }

        if (lhs instanceof IdentNode) {
            if (!checkIdentLValue((IdentNode)lhs)) {
                return referenceError(lhs, rhs, false);
            }
            verifyStrictIdent((IdentNode)lhs, "assignment");
        }
        break;

    default:
        break;
    }

    // Build up node.
    if(BinaryNode.isLogical(opType)) {
        return new BinaryNode(op, new JoinPredecessorExpression(lhs), new JoinPredecessorExpression(rhs));
    }
    return new BinaryNode(op, lhs, rhs);
}
 

import jdk.nashorn.internal.ir.BinaryNode; //导入方法依赖的package包/类
/**
 * Verify an assignment expression.
 * @param op  Operation token.
 * @param lhs Left hand side expression.
 * @param rhs Right hand side expression.
 * @return Verified expression.
 */
private Expression verifyAssignment(final long op, final Expression lhs, final Expression rhs) {
    final TokenType opType = Token.descType(op);

    switch (opType) {
    case ASSIGN:
    case ASSIGN_ADD:
    case ASSIGN_BIT_AND:
    case ASSIGN_BIT_OR:
    case ASSIGN_BIT_XOR:
    case ASSIGN_DIV:
    case ASSIGN_MOD:
    case ASSIGN_MUL:
    case ASSIGN_SAR:
    case ASSIGN_SHL:
    case ASSIGN_SHR:
    case ASSIGN_SUB:
        if (lhs instanceof IdentNode) {
            if (!checkIdentLValue((IdentNode)lhs)) {
                return referenceError(lhs, rhs, false);
            }
            verifyIdent((IdentNode)lhs, "assignment");
            break;
        } else if (lhs instanceof AccessNode || lhs instanceof IndexNode) {
            break;
        } else if (opType == ASSIGN && isDestructuringLhs(lhs)) {
            verifyDestructuringAssignmentPattern(lhs, "assignment");
            break;
        } else {
            return referenceError(lhs, rhs, env._early_lvalue_error);
        }
    default:
        break;
    }

    // Build up node.
    if(BinaryNode.isLogical(opType)) {
        return new BinaryNode(op, new JoinPredecessorExpression(lhs), new JoinPredecessorExpression(rhs));
    }
    return new BinaryNode(op, lhs, rhs);
}