本文整理汇总了Java中org.codehaus.groovy.ast.expr.BinaryExpression.getRightExpression方法的典型用法代码示例。如果您正苦于以下问题:Java BinaryExpression.getRightExpression方法的具体用法?Java BinaryExpression.getRightExpression怎么用?Java BinaryExpression.getRightExpression使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类org.codehaus.groovy.ast.expr.BinaryExpression
的用法示例。
在下文中一共展示了BinaryExpression.getRightExpression方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Java代码示例。
示例1: parseLine
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;
}
示例2: visitBinaryExpression
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(")");
}
示例3: transformDeclarationExpression
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;
}
示例4: transformBinaryExpression
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;
}
示例5: visitBinaryExpression
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);
}
}
示例6: evaluateCompareTo
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);
}
示例7: evaluateInstanceof
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);
}
示例8: doPrimitiveCompare
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;
}
示例9: visitBinaryExpression
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());
}
}
示例10: evaluateElvisEqual
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);
}
示例11: evaluateCompareExpression
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);
}
}
示例12: evaluateBinaryExpression
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();
}
示例13: evaluateArrayAssignmentWithOperator
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());
}
示例14: loadWithSubscript
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;
}
示例15: evaluateCompareExpression
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);
}
}