Java BinaryExpression.getRightExpression方法代码示例

import org.codehaus.groovy.ast.expr.BinaryExpression; //导入方法依赖的package包/类
List<T> parseLine(BinaryExpression exp, Class<T> cls) {

        List<T> constantExpressions = new LinkedList<>();

        Expression leftExpression = exp.getLeftExpression();

        if (leftExpression.getClass().equals(cls)) {
            T leftConstantExpression = (T) leftExpression;
            constantExpressions.add(leftConstantExpression);
        } else {
            BinaryExpression leftBinaryExpression = (BinaryExpression) leftExpression;
            List<T> leftConstantExpressions = parseLine(leftBinaryExpression, cls);
            constantExpressions.addAll(leftConstantExpressions);
        }

        T rightExpression = (T) exp.getRightExpression();
        constantExpressions.add(rightExpression);

        return constantExpressions;

    }
 

import org.codehaus.groovy.ast.expr.BinaryExpression; //导入方法依赖的package包/类
public void visitBinaryExpression(BinaryExpression expression) {
    Expression left = expression.getLeftExpression();
    Expression right = expression.getRightExpression();
    boolean leaf = (right instanceof ConstantExpression || left instanceof ConstantExpression);

    if (!leaf) buffer.append("(");
    left.visit(this);
    buffer.append(" ");

    Token token = expression.getOperation();
    buffer.append(tokenAsSql(token));

    buffer.append(" ");
    right.visit(this);
    if (!leaf) buffer.append(")");
}
 

import org.codehaus.groovy.ast.expr.BinaryExpression; //导入方法依赖的package包/类
private static Expression transformDeclarationExpression(final BinaryExpression bin) {
    Expression leftExpression = bin.getLeftExpression();
    if (leftExpression instanceof VariableExpression) {
        if (ClassHelper.char_TYPE.equals(((VariableExpression) leftExpression).getOriginType())) {
            Expression rightExpression = bin.getRightExpression();
            if (rightExpression instanceof ConstantExpression && ClassHelper.STRING_TYPE.equals(rightExpression.getType())) {
                String text = (String) ((ConstantExpression) rightExpression).getValue();
                if (text.length() == 1) {
                    // optimize char initialization
                    ConstantExpression ce = new ConstantExpression(
                            text.charAt(0),
                            true
                    );
                    ce.setSourcePosition(rightExpression);
                    bin.setRightExpression(ce);
                    return bin;
                }
            }
        }
    }
    return null;
}
 

import org.codehaus.groovy.ast.expr.BinaryExpression; //导入方法依赖的package包/类
private Expression transformBinaryExpression(final BinaryExpression exp) {
    final int op = exp.getOperation().getType();
    int token = TokenUtil.removeAssignment(op);
    if (token == op) {
        // no transform needed
        return super.transform(exp);
    }
    BinaryExpression operation = new BinaryExpression(
            exp.getLeftExpression(),
            Token.newSymbol(token, -1, -1),
            exp.getRightExpression()
    );
    operation.setSourcePosition(exp);
    BinaryExpression result = new BinaryExpression(
            exp.getLeftExpression(),
            Token.newSymbol(EQUAL, -1, -1),
            operation
    );
    result.setSourcePosition(exp);
    return result;
}
 

import org.codehaus.groovy.ast.expr.BinaryExpression; //导入方法依赖的package包/类
@Override
public void visitBinaryExpression(final BinaryExpression expression) {
    boolean assignment = StaticTypeCheckingSupport.isAssignment(expression.getOperation().getType());
    boolean isDeclaration = expression instanceof DeclarationExpression;
    Expression leftExpression = expression.getLeftExpression();
    Expression rightExpression = expression.getRightExpression();
    if (isDeclaration) {
        recordFinalVars(leftExpression);
    }
    // visit RHS first for expressions like a = b = 0
    inAssignment = assignment;
    rightExpression.visit(this);
    inAssignment = false;
    leftExpression.visit(this);
    if (assignment) {
        recordAssignments(expression, isDeclaration, leftExpression, rightExpression);
    }
}
 

import org.codehaus.groovy.ast.expr.BinaryExpression; //导入方法依赖的package包/类
private void evaluateCompareTo(BinaryExpression expression) {
    Expression leftExpression = expression.getLeftExpression();
    AsmClassGenerator acg = controller.getAcg();
    OperandStack operandStack = controller.getOperandStack();
    
    leftExpression.visit(acg);
    operandStack.box();

    // if the right hand side is a boolean expression, we need to autobox
    Expression rightExpression = expression.getRightExpression();
    rightExpression.visit(acg);
    operandStack.box();

    compareToMethod.call(controller.getMethodVisitor());
    operandStack.replace(ClassHelper.Integer_TYPE,2);
}
 

import org.codehaus.groovy.ast.expr.BinaryExpression; //导入方法依赖的package包/类
private void evaluateInstanceof(BinaryExpression expression) {
    OperandStack operandStack = controller.getOperandStack();
    
    expression.getLeftExpression().visit(controller.getAcg());
    operandStack.box();
    Expression rightExp = expression.getRightExpression();
    ClassNode classType;
    if (rightExp instanceof ClassExpression) {
        ClassExpression classExp = (ClassExpression) rightExp;
        classType = classExp.getType();
    } else {
        throw new RuntimeException(
                "Right hand side of the instanceof keyword must be a class name, not: " + rightExp);
    }
    String classInternalName = BytecodeHelper.getClassInternalName(classType);
    controller.getMethodVisitor().visitTypeInsn(INSTANCEOF, classInternalName);
    operandStack.replace(ClassHelper.boolean_TYPE);
}
 

import org.codehaus.groovy.ast.expr.BinaryExpression; //导入方法依赖的package包/类
protected boolean doPrimitiveCompare(ClassNode leftType, ClassNode rightType, BinaryExpression binExp) {
    Expression leftExp = binExp.getLeftExpression();
    Expression rightExp = binExp.getRightExpression();
    int operation = binExp.getOperation().getType();
    
    int operationType = getOperandConversionType(leftType,rightType);
    BinaryExpressionWriter bew = binExpWriter[operationType];

    if (!bew.write(operation, true)) return false;
        
    AsmClassGenerator acg = getController().getAcg();
    OperandStack os = getController().getOperandStack();
    leftExp.visit(acg);
    os.doGroovyCast(bew.getNormalOpResultType());
    rightExp.visit(acg);
    os.doGroovyCast(bew.getNormalOpResultType());
    bew.write(operation, false);
    
    return true;
}
 

import org.codehaus.groovy.ast.expr.BinaryExpression; //导入方法依赖的package包/类
public void visitBinaryExpression(BinaryExpression expression) {
    if (expression.getOperation().getType() == Types.LEFT_SQUARE_BRACKET &&
            expression.getRightExpression() instanceof MapEntryExpression) {
        addError("You tried to use a map entry for an index operation, this is not allowed. " +
                "Maybe something should be set in parentheses or a comma is missing?",
                expression.getRightExpression());
    }
    super.visitBinaryExpression(expression);

    if (Types.isAssignment(expression.getOperation().getType())) {
        checkFinalFieldAccess(expression.getLeftExpression());
        checkSuperOrThisOnLHS(expression.getLeftExpression());
    }
}
 

import org.codehaus.groovy.ast.expr.BinaryExpression; //导入方法依赖的package包/类
public void evaluateElvisEqual(BinaryExpression expression) {
    Token operation = expression.getOperation();
    BinaryExpression elvisAssignmentExpression =
            new BinaryExpression(
                    expression.getLeftExpression(),
                    Token.newSymbol(Types.EQUAL, operation.getStartLine(), operation.getStartColumn()),
                    new ElvisOperatorExpression(expression.getLeftExpression(), expression.getRightExpression())
            );

    this.evaluateEqual(elvisAssignmentExpression, false);
}
 

import org.codehaus.groovy.ast.expr.BinaryExpression; //导入方法依赖的package包/类
protected void evaluateCompareExpression(MethodCaller compareMethod, BinaryExpression expression) {
    Expression leftExp = expression.getLeftExpression();
    TypeChooser typeChooser = controller.getTypeChooser();
    ClassNode cn = controller.getClassNode();
    ClassNode leftType = typeChooser.resolveType(leftExp,cn);
    Expression rightExp = expression.getRightExpression();
    ClassNode rightType = typeChooser.resolveType(rightExp,cn);

    boolean done = false;
    if (    ClassHelper.isPrimitiveType(leftType) &&
            ClassHelper.isPrimitiveType(rightType))
    {
        BinaryExpressionMultiTypeDispatcher helper = new BinaryExpressionMultiTypeDispatcher(getController());
        done = helper.doPrimitiveCompare(leftType, rightType, expression);
    }
    
    if (!done) {
        AsmClassGenerator acg = controller.getAcg();
        OperandStack operandStack = controller.getOperandStack();
        
        leftExp.visit(acg);
        operandStack.box();
        rightExp.visit(acg);
        operandStack.box();

        compareMethod.call(controller.getMethodVisitor());
        ClassNode resType = ClassHelper.boolean_TYPE;
        if (compareMethod==findRegexMethod) {
            resType = ClassHelper.OBJECT_TYPE;
        } 
        operandStack.replace(resType,2);
    }
}
 

import org.codehaus.groovy.ast.expr.BinaryExpression; //导入方法依赖的package包/类
protected void evaluateBinaryExpression(String message, BinaryExpression binExp) {
    CompileStack compileStack = controller.getCompileStack();

    Expression receiver = binExp.getLeftExpression();
    Expression arguments = binExp.getRightExpression();

    // ensure VariableArguments are read, not stored
    compileStack.pushLHS(false);
    controller.getInvocationWriter().makeSingleArgumentCall(receiver, message, arguments, binExp.isSafe());
    compileStack.popLHS();        
}
 

import org.codehaus.groovy.ast.expr.BinaryExpression; //导入方法依赖的package包/类
protected void evaluateArrayAssignmentWithOperator(String method, BinaryExpression expression, BinaryExpression leftBinExpr) {
    CompileStack compileStack    = getController().getCompileStack();
    AsmClassGenerator acg             = getController().getAcg();
    OperandStack os              = getController().getOperandStack();

    // e.g. x[a] += b
    // to avoid loading x and a twice we transform the expression to use
    // ExpressionAsVariableSlot
    // -> subscript=a, receiver=x, receiver[subscript]+b, =, receiver[subscript]
    // -> subscript=a, receiver=x, receiver#getAt(subscript)#plus(b), =, receiver#putAt(subscript)
    // -> subscript=a, receiver=x, receiver#putAt(subscript, receiver#getAt(subscript)#plus(b))
    // the result of x[a] += b is x[a]+b, thus:
    // -> subscript=a, receiver=x, receiver#putAt(subscript, ret=receiver#getAt(subscript)#plus(b)), ret
    ExpressionAsVariableSlot subscript = new ExpressionAsVariableSlot(controller, leftBinExpr.getRightExpression(), "subscript");
    ExpressionAsVariableSlot receiver  = new ExpressionAsVariableSlot(controller, leftBinExpr.getLeftExpression(), "receiver");
    MethodCallExpression getAt = new MethodCallExpression(receiver, "getAt", new ArgumentListExpression(subscript));
    MethodCallExpression operation = new MethodCallExpression(getAt, method, expression.getRightExpression());
    ExpressionAsVariableSlot ret = new ExpressionAsVariableSlot(controller, operation, "ret");
    MethodCallExpression putAt = new MethodCallExpression(receiver, "putAt", new ArgumentListExpression(subscript, ret));

    putAt.visit(acg);
    os.pop();
    os.load(ret.getType(), ret.getIndex());

    compileStack.removeVar(ret.getIndex());
    compileStack.removeVar(subscript.getIndex());
    compileStack.removeVar(receiver.getIndex());
}
 

import org.codehaus.groovy.ast.expr.BinaryExpression; //导入方法依赖的package包/类
private VariableSlotLoader loadWithSubscript(Expression expression) {
    final OperandStack operandStack = controller.getOperandStack();
    // if we have a BinaryExpression, let us check if it is with
    // subscription
    if (expression instanceof BinaryExpression) {
        BinaryExpression be = (BinaryExpression) expression;
        if (be.getOperation().getType()== Types.LEFT_SQUARE_BRACKET) {
            // right expression is the subscript expression
            // we store the result of the subscription on the stack
            Expression subscript = be.getRightExpression();
            subscript.visit(controller.getAcg());
            ClassNode subscriptType = operandStack.getTopOperand();
            int id = controller.getCompileStack().defineTemporaryVariable("$subscript", subscriptType, true);
            VariableSlotLoader subscriptExpression = new VariableSlotLoader(subscriptType, id, operandStack);
            // do modified visit
            BinaryExpression newBe = new BinaryExpression(be.getLeftExpression(), be.getOperation(), subscriptExpression);
            newBe.copyNodeMetaData(be);
            newBe.setSourcePosition(be);
            newBe.visit(controller.getAcg());
            return subscriptExpression;
        } 
    } 
    
    // normal loading of expression
    expression.visit(controller.getAcg());
    return null;
}
 

import org.codehaus.groovy.ast.expr.BinaryExpression; //导入方法依赖的package包/类
@Override
protected void evaluateCompareExpression(final MethodCaller compareMethod, BinaryExpression binExp) {
    ClassNode current =  getController().getClassNode();
    TypeChooser typeChooser = getController().getTypeChooser();
    
    Expression leftExp = binExp.getLeftExpression();
    ClassNode leftType = typeChooser.resolveType(leftExp, current);
    Expression rightExp = binExp.getRightExpression();
    ClassNode rightType = typeChooser.resolveType(rightExp, current);
    
    if (!doPrimitiveCompare(leftType, rightType, binExp)) {
        super.evaluateCompareExpression(compareMethod, binExp);
    }
}