| /******************************************************************************* |
| * Copyright (c) 2006 Oracle Corporation. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Cameron Bateman/Oracle - initial API and implementation |
| * |
| ********************************************************************************/ |
| |
| package org.eclipse.jst.jsf.validation.internal.el.operators; |
| |
| import java.math.BigDecimal; |
| import java.math.BigInteger; |
| |
| import org.eclipse.emf.common.util.Diagnostic; |
| import org.eclipse.jdt.core.Signature; |
| import org.eclipse.jst.jsf.common.internal.types.FloatLiteralType; |
| import org.eclipse.jst.jsf.common.internal.types.IAssignable; |
| import org.eclipse.jst.jsf.common.internal.types.IntegerLiteralType; |
| import org.eclipse.jst.jsf.common.internal.types.LiteralType; |
| import org.eclipse.jst.jsf.common.internal.types.TypeCoercer; |
| import org.eclipse.jst.jsf.common.internal.types.TypeCoercionException; |
| import org.eclipse.jst.jsf.common.internal.types.TypeConstants; |
| import org.eclipse.jst.jsf.common.internal.types.TypeTransformer; |
| import org.eclipse.jst.jsf.common.internal.types.ValueType; |
| import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory; |
| |
| /** |
| * Represents the EL modulo operator: % or mod |
| * Based JSP.2.3.5.3 |
| * |
| * @author cbateman |
| * |
| */ |
| /*package*/ class ModArithmeticBinaryOperator extends ArithmeticBinaryOperator |
| { |
| private static final String MODULO = "modulo"; //$NON-NLS-1$ |
| |
| ModArithmeticBinaryOperator(DiagnosticFactory diagnosticFactory) { |
| super(diagnosticFactory); |
| } |
| |
| public ValueType performOperation(ValueType firstArg, ValueType secondArg) |
| { |
| // JSP.2.3.5.3, step 1 if both null, then return zero |
| if (TypeCoercer.typeIsNull(firstArg.getSignature()) |
| && TypeCoercer.typeIsNull(secondArg.getSignature())) |
| { |
| return IntegerLiteralType.ZERO; |
| } |
| |
| final String boxedFirstArg = TypeTransformer.transformBoxPrimitives(firstArg.getSignature()); |
| final String boxedSecondArg = TypeTransformer.transformBoxPrimitives(secondArg.getSignature()); |
| |
| // JSP.2.3.5.3, step 2, if either arg is BigDecimal, Float, Double |
| // or String (ignoring whether it is value coercable), then coerce |
| // to Double and do op |
| if (TypeConstants.TYPE_BIG_DOUBLE.equals(boxedFirstArg) |
| || TypeConstants.TYPE_BIG_DOUBLE.equals(boxedSecondArg) |
| || TypeConstants.TYPE_BOXED_DOUBLE.equals(boxedFirstArg) |
| || TypeConstants.TYPE_BOXED_DOUBLE.equals(boxedSecondArg) |
| || TypeConstants.TYPE_BOXED_FLOAT.equals(boxedFirstArg) |
| || TypeConstants.TYPE_BOXED_FLOAT.equals(boxedSecondArg)) |
| { |
| // TODO: handle case where one is a literal or resolvable string value |
| // that containss ".", "e" or "E" |
| return performDouble(firstArg, secondArg); |
| } |
| |
| // JSP.2.3.5.3, step 3, if either arg is a BigInteger, coerce |
| // both to BigInteger |
| if (TypeConstants.TYPE_BIG_INTEGER.equals(boxedFirstArg) |
| || TypeConstants.TYPE_BIG_INTEGER.equals(boxedSecondArg)) |
| { |
| return performBigInteger(firstArg, secondArg); |
| } |
| |
| // JSP.2.3.5.3, step 4, otherwise try to perform as a Long op |
| return performLong(firstArg, secondArg); |
| } |
| |
| public Diagnostic validate(ValueType firstArg, ValueType secondArg) { |
| if (TypeConstants.TYPE_JAVAOBJECT.equals(firstArg.getSignature()) || |
| TypeConstants.TYPE_JAVAOBJECT.equals(secondArg.getSignature())) { |
| return Diagnostic.OK_INSTANCE; |
| } |
| |
| // JSP.2.3.5.3, step 1 if both null, then return zero |
| if (TypeCoercer.typeIsNull(firstArg.getSignature()) |
| && TypeCoercer.typeIsNull(secondArg.getSignature())) |
| { |
| return _diagnosticFactory.create_BINARY_OP_BOTH_OPERANDS_NULL(MODULO); |
| } |
| |
| final String boxedFirstArg = TypeTransformer.transformBoxPrimitives(firstArg.getSignature()); |
| final String boxedSecondArg = TypeTransformer.transformBoxPrimitives(secondArg.getSignature()); |
| |
| // JSP.2.3.5.3, step 2, if either arg is BigDecimal, Float, Double |
| // or String (ignoring whether it is value coercable), then coerce |
| // to Double and do op |
| if (TypeConstants.TYPE_BIG_DOUBLE.equals(boxedFirstArg) |
| || TypeConstants.TYPE_BIG_DOUBLE.equals(boxedSecondArg) |
| || TypeConstants.TYPE_BOXED_DOUBLE.equals(boxedFirstArg) |
| || TypeConstants.TYPE_BOXED_DOUBLE.equals(boxedSecondArg) |
| || TypeConstants.TYPE_BOXED_FLOAT.equals(boxedFirstArg) |
| || TypeConstants.TYPE_BOXED_FLOAT.equals(boxedSecondArg)) |
| { |
| // TODO: handle case where one is a literal or resolvable string value |
| // that containss ".", "e" or "E" |
| return validateDouble(firstArg, secondArg); |
| } |
| |
| // JSP.2.3.5.3, step 3, if either arg is a BigInteger, coerce |
| // both to BigInteger |
| if (TypeConstants.TYPE_BIG_INTEGER.equals(boxedFirstArg) |
| || TypeConstants.TYPE_BIG_INTEGER.equals(boxedSecondArg)) |
| { |
| return validateBigInteger(firstArg, secondArg); |
| } |
| |
| // JSP.2.3.5.3, step 4, otherwise try to perform as a Long op |
| return validateLong(firstArg, secondArg); |
| } |
| |
| private ValueType performDouble(ValueType firstArg, ValueType secondArg) |
| { |
| try |
| { |
| TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(firstArg.getSignature())); |
| TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(secondArg.getSignature())); |
| |
| Number secondValue = null; |
| |
| if (secondArg instanceof LiteralType) |
| { |
| secondValue = ((LiteralType)secondArg).coerceToNumber(Double.class); |
| |
| if (secondValue.doubleValue() == 0.0) |
| { |
| // division by zero |
| return null; |
| } |
| } |
| |
| Number firstValue = null; |
| |
| if (firstArg instanceof LiteralType) |
| { |
| firstValue = ((LiteralType)firstArg).coerceToNumber(Double.class); |
| } |
| |
| if (firstValue != null && secondValue != null) |
| { |
| return new FloatLiteralType( |
| doRealOperation(new Double(firstValue.doubleValue()), |
| new Double(secondValue.doubleValue())).doubleValue()); |
| } |
| |
| // if we get to here, the coercion is valid, so a Double will be |
| // returned |
| return new ValueType(Signature.SIG_DOUBLE, IAssignable.ASSIGNMENT_TYPE_RHS); |
| } |
| catch (TypeCoercionException tce) |
| { |
| // could not coerce, so null |
| return null; |
| } |
| } |
| |
| private ValueType performBigInteger(ValueType firstArg, ValueType secondArg) |
| { |
| try |
| { |
| TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(firstArg.getSignature())); |
| TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(secondArg.getSignature())); |
| |
| // check second arg for zero |
| if (secondArg instanceof LiteralType) |
| { |
| if (((LiteralType)secondArg).coerceToNumber(BigInteger.class).equals(BigInteger.ZERO)) |
| { |
| // division by zero |
| return null; |
| } |
| } |
| |
| // since one of the args is BigInteger, they are not both literals, |
| // so if we get to here, we have a successful mod of two |
| // big integers to one big integer |
| return new ValueType(TypeConstants.TYPE_BIG_INTEGER, IAssignable.ASSIGNMENT_TYPE_RHS); |
| } |
| catch (TypeCoercionException tce) |
| { |
| // no coercion |
| return null; |
| } |
| } |
| |
| private ValueType performLong(ValueType firstArg, ValueType secondArg) |
| { |
| try |
| { |
| TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(firstArg.getSignature())); |
| TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(secondArg.getSignature())); |
| |
| Number secondValue = null; |
| |
| if (secondArg instanceof LiteralType) |
| { |
| secondValue = ((LiteralType)secondArg).coerceToNumber(Long.class); |
| |
| if (secondValue.longValue() == 0) |
| { |
| // division by zero |
| return null; |
| } |
| } |
| |
| Number firstValue = null; |
| |
| if (firstArg instanceof LiteralType) |
| { |
| firstValue = ((LiteralType)firstArg).coerceToNumber(Long.class); |
| } |
| |
| if (firstValue != null && secondValue != null) |
| { |
| return new IntegerLiteralType( |
| doRealOperation(Long.valueOf(firstValue.longValue()), |
| Long.valueOf(secondValue.longValue())).longValue()); |
| } |
| |
| // if we get to here, the coercion is valid, so a Long will be |
| // returned |
| return new ValueType(Signature.SIG_LONG, IAssignable.ASSIGNMENT_TYPE_RHS); |
| } |
| catch (TypeCoercionException tce) |
| { |
| // could not coerce, so null |
| return null; |
| } |
| } |
| |
| private Diagnostic validateDouble(ValueType firstArg, ValueType secondArg) |
| { |
| try |
| { |
| TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(firstArg.getSignature())); |
| TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(secondArg.getSignature())); |
| |
| Number secondValue = null; |
| |
| if (secondArg instanceof LiteralType) |
| { |
| secondValue = ((LiteralType)secondArg).coerceToNumber(Double.class); |
| |
| if (secondValue.doubleValue() == 0.0) |
| { |
| // division by zero |
| return _diagnosticFactory.create_BINARY_OP_POSSIBLE_DIVISION_BY_ZERO(); |
| } |
| } |
| |
| Number firstValue = null; |
| |
| if (firstArg instanceof LiteralType) |
| { |
| firstValue = ((LiteralType)firstArg).coerceToNumber(Double.class); |
| } |
| |
| if (firstValue != null && secondValue != null) |
| { |
| return _diagnosticFactory. |
| create_BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME |
| (MODULO, Double.toString( |
| firstValue.doubleValue()%secondValue.doubleValue())); |
| } |
| |
| // if we get to here, the coercion is valid, so a Double will be |
| // returned and everything is good |
| return Diagnostic.OK_INSTANCE; |
| } |
| catch (TypeCoercionException tce) |
| { |
| // could not coerce, so error |
| return _diagnosticFactory. |
| create_BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION(MODULO); |
| } |
| } |
| |
| private Diagnostic validateBigInteger(ValueType firstArg, ValueType secondArg) |
| { |
| try |
| { |
| TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(firstArg.getSignature())); |
| TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(secondArg.getSignature())); |
| |
| // check second arg for zero |
| if (secondArg instanceof LiteralType) |
| { |
| if (((LiteralType)secondArg).coerceToNumber(BigInteger.class).equals(BigInteger.ZERO)) |
| { |
| // division by zero |
| return _diagnosticFactory.create_BINARY_OP_POSSIBLE_DIVISION_BY_ZERO(); |
| } |
| } |
| |
| // since one of the args is BigInteger, they are not both literals, |
| // so if we get to here, we have a successful mod of two |
| // big integers to one big integer |
| return Diagnostic.OK_INSTANCE; |
| } |
| catch (TypeCoercionException tce) |
| { |
| // no coercion |
| return _diagnosticFactory. |
| create_BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION(MODULO); |
| } |
| } |
| |
| private Diagnostic validateLong(ValueType firstArg, ValueType secondArg) |
| { |
| try |
| { |
| TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(firstArg.getSignature())); |
| TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(secondArg.getSignature())); |
| |
| Number secondValue = null; |
| |
| if (secondArg instanceof LiteralType) |
| { |
| secondValue = ((LiteralType)secondArg).coerceToNumber(Long.class); |
| |
| if (secondValue.longValue() == 0) |
| { |
| // division by zero |
| return _diagnosticFactory. |
| create_BINARY_OP_POSSIBLE_DIVISION_BY_ZERO(); |
| } |
| } |
| |
| Number firstValue = null; |
| |
| if (firstArg instanceof LiteralType) |
| { |
| firstValue = ((LiteralType)firstArg).coerceToNumber(Long.class); |
| } |
| |
| if (firstValue != null && secondValue != null) |
| { |
| return _diagnosticFactory. |
| create_BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME |
| (MODULO, Long.toString(firstValue.longValue()%secondValue.longValue())); |
| } |
| |
| // if we get to here, the coercion is valid, so a Long will be |
| // returned |
| return Diagnostic.OK_INSTANCE; |
| } |
| catch (TypeCoercionException tce) |
| { |
| // could not coerce, so error |
| return _diagnosticFactory. |
| create_BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION(MODULO); |
| } |
| } |
| |
| protected Long doRealOperation(Long firstArg, Long secondArg) { |
| return Long.valueOf(firstArg.longValue() % secondArg.longValue()); |
| } |
| |
| protected Double doRealOperation(Double firstArg, Double secondArg) { |
| return new Double(firstArg.doubleValue() % secondArg.doubleValue()); |
| } |
| |
| protected BigDecimal doRealOperation(BigDecimal firstArg, |
| BigDecimal secondArg) { |
| return new BigDecimal(firstArg.doubleValue() % secondArg.doubleValue()); |
| } |
| |
| protected String getOperatorName() { |
| return MODULO; |
| } |
| |
| } |
