Java BinaryExpression.getOperation方法代码示例

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包/类
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包/类
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包/类
private void transformSpreadOnLHS(BinaryExpression origin) {
    PropertyExpression spreadExpression = (PropertyExpression) origin.getLeftExpression();
    Expression value = origin.getRightExpression();
    WriterController controller = getController();
    MethodVisitor mv = controller.getMethodVisitor();
    CompileStack compileStack = controller.getCompileStack();
    TypeChooser typeChooser = controller.getTypeChooser();
    OperandStack operandStack = controller.getOperandStack();
    ClassNode classNode = controller.getClassNode();
    int counter = labelCounter.incrementAndGet();
    Expression receiver = spreadExpression.getObjectExpression();

    // create an empty arraylist
    VariableExpression result = new VariableExpression(
            this.getClass().getSimpleName()+"$spreadresult" + counter,
            ARRAYLIST_CLASSNODE
    );
    ConstructorCallExpression cce = new ConstructorCallExpression(ARRAYLIST_CLASSNODE, ArgumentListExpression.EMPTY_ARGUMENTS);
    cce.setNodeMetaData(StaticTypesMarker.DIRECT_METHOD_CALL_TARGET, ARRAYLIST_CONSTRUCTOR);
    DeclarationExpression declr = new DeclarationExpression(
            result,
            Token.newSymbol("=", spreadExpression.getLineNumber(), spreadExpression.getColumnNumber()),
            cce
    );
    declr.visit(controller.getAcg());
    // if (receiver != null)
    receiver.visit(controller.getAcg());
    Label ifnull = compileStack.createLocalLabel("ifnull_" + counter);
    mv.visitJumpInsn(IFNULL, ifnull);
    operandStack.remove(1); // receiver consumed by if()
    Label nonull = compileStack.createLocalLabel("nonull_" + counter);
    mv.visitLabel(nonull);
    ClassNode componentType = StaticTypeCheckingVisitor.inferLoopElementType(typeChooser.resolveType(receiver, classNode));
    Parameter iterator = new Parameter(componentType, "for$it$" + counter);
    VariableExpression iteratorAsVar = new VariableExpression(iterator);
    PropertyExpression pexp = spreadExpression instanceof AttributeExpression ?
            new AttributeExpression(iteratorAsVar, spreadExpression.getProperty(), true):
            new PropertyExpression(iteratorAsVar, spreadExpression.getProperty(), true);
    pexp.setImplicitThis(spreadExpression.isImplicitThis());
    pexp.setSourcePosition(spreadExpression);
    BinaryExpression assignment = new BinaryExpression(
            pexp,
            origin.getOperation(),
            value
    );
    MethodCallExpression add = new MethodCallExpression(
            result,
            "add",
            assignment
    );
    add.setMethodTarget(ARRAYLIST_ADD_METHOD);
    // for (e in receiver) { result.add(e?.method(arguments) }
    ForStatement stmt = new ForStatement(
            iterator,
            receiver,
            new ExpressionStatement(add)
    );
    stmt.visit(controller.getAcg());
    // else { empty list }
    mv.visitLabel(ifnull);

    // end of if/else
    // return result list
    result.visit(controller.getAcg());

}