private ConstantValue evaluateLogicalExpr(
Expression lhs, Expression rhs, Type resultType, LogicalBinaryOperation operation) {
// Evaluate the first subexpression
final ConstantValue valueLhs = lhs.accept(this, null);
// Get the factory for the result type
final ConstantType resultConstantType = typeFactory.newConstantType(resultType);
checkArgument(
resultConstantType.getType() == ConstantType.Type.SIGNED_INTEGER,
"result of logical AND or logical OR expression has not a signed integer type");
final boolean resultValue;
/* Determine the result - we use the fact the Java '&&' and '||'
operators are evaluated lazily. */
switch (operation) {
case LOGICAL_AND:
resultValue = valueLhs.logicalValue() && rhs.accept(this, null).logicalValue();
break;
case LOGICAL_OR:
resultValue = valueLhs.logicalValue() || rhs.accept(this, null).logicalValue();
break;
default:
throw new RuntimeException("unexpected logical binary operation '" + operation + "'");
}
return UnsignedIntegerConstantValue.getLogicalValue(resultValue).castTo(resultConstantType);
}
private ConstantValue evaluateBinaryExpr(
Expression lhs, Expression rhs, Type resultType, ArithmeticBinaryOperation operation) {
// Evaluate subexpressions
ConstantValue valueLhs = lhs.accept(this, null);
ConstantValue valueRhs = rhs.accept(this, null);
// Convert to type implied by usual arithmetic conversions
final ArithmeticType commonType =
TypeUtils.doUsualArithmeticConversions(
(ArithmeticType) lhs.getType().get(), (ArithmeticType) rhs.getType().get());
final ConstantType commonConstantType = typeFactory.newConstantType(commonType);
final ConstantType resultConstantType = typeFactory.newConstantType(resultType);
valueLhs = valueLhs.castTo(commonConstantType);
valueRhs = valueRhs.castTo(commonConstantType);
// Perform the operation
switch (operation) {
case ADDITION:
return valueLhs.add(valueRhs);
case SUBTRACTION:
return valueLhs.subtract(valueRhs);
case MULTIPLICATION:
return valueLhs.multiply(valueRhs);
case DIVISION:
return valueLhs.divide(valueRhs);
case REMAINDER:
return valueLhs.remainder(valueRhs);
case BITWISE_AND:
return valueLhs.bitwiseAnd(valueRhs);
case BITWISE_OR:
return valueLhs.bitwiseOr(valueRhs);
case BITWISE_XOR:
return valueLhs.bitwiseXor(valueRhs);
case LESS:
return valueLhs.less(valueRhs).castTo(resultConstantType);
case LESS_OR_EQUAL:
return valueLhs.lessOrEqual(valueRhs).castTo(resultConstantType);
case GREATER:
return valueLhs.greater(valueRhs).castTo(resultConstantType);
case GREATER_OR_EQUAL:
return valueLhs.greaterOrEqual(valueRhs).castTo(resultConstantType);
case EQUAL:
return valueLhs.equalTo(valueRhs).castTo(resultConstantType);
case NOT_EQUAL:
return valueLhs.notEqualTo(valueRhs).castTo(resultConstantType);
default:
throw new RuntimeException("unexpected arithmetic binary operation '" + operation + "'");
}
}
private ConstantValue evaluateShiftExpr(
Expression lhs, Expression rhs, Type resultType, ShiftOperation operation) {
// Evaluate subexpressions
ConstantValue valueLhs = lhs.accept(this, null);
ConstantValue valueRhs = rhs.accept(this, null);
// Make integer promotions
final ConstantType leftPromotedType = typeFactory.newConstantType(resultType);
final ConstantType rightPromotedType =
typeFactory.newConstantType(rhs.getType().get().promote());
valueLhs = valueLhs.castTo(leftPromotedType);
valueRhs = valueRhs.castTo(rightPromotedType);
// Perform the operation
switch (operation) {
case LEFT_SHIFT:
return valueLhs.shiftLeft(valueRhs);
case RIGHT_SHIFT:
return valueLhs.shiftRight(valueRhs);
default:
throw new RuntimeException("unexpected shift operation kind '" + operation + "'");
}
}
private ConstantValue evaluateUnaryExpr(
Expression opParam, Type resultType, UnaryArithmeticOperation operation) {
// Evaluate the subexpression
ConstantValue paramValue = opParam.accept(this, null);
// Make the integer promotion
final ConstantType resultConstantType = typeFactory.newConstantType(resultType);
paramValue = paramValue.castTo(resultConstantType);
// Perform the operation
switch (operation) {
case IDENTITY:
return paramValue;
case NEGATION:
return paramValue.negate();
case BITWISE_NOT:
return paramValue.bitwiseNot();
default:
throw new RuntimeException("unexpected unary arithmetic operation '" + operation + "'");
}
}
@Override
public ConstantValue evaluate(Expression expr) {
checkNotNull(expr, "expression cannot be null");
prepare(expr);
return expr.accept(interpreter, null);
}
