Skip to main content
summaryrefslogtreecommitdiffstats
path: root/jsf/plugins/org.eclipse.jst.jsf.core/src/org/eclipse/jst/jsf/validation/internal/el/operators/NoDivArithmeticBinaryOperator.java
diff options
context:
space:
mode:
Diffstat (limited to 'jsf/plugins/org.eclipse.jst.jsf.core/src/org/eclipse/jst/jsf/validation/internal/el/operators/NoDivArithmeticBinaryOperator.java')
-rw-r--r--jsf/plugins/org.eclipse.jst.jsf.core/src/org/eclipse/jst/jsf/validation/internal/el/operators/NoDivArithmeticBinaryOperator.java300
1 files changed, 0 insertions, 300 deletions
diff --git a/jsf/plugins/org.eclipse.jst.jsf.core/src/org/eclipse/jst/jsf/validation/internal/el/operators/NoDivArithmeticBinaryOperator.java b/jsf/plugins/org.eclipse.jst.jsf.core/src/org/eclipse/jst/jsf/validation/internal/el/operators/NoDivArithmeticBinaryOperator.java
deleted file mode 100644
index 5bdc163fc..000000000
--- a/jsf/plugins/org.eclipse.jst.jsf.core/src/org/eclipse/jst/jsf/validation/internal/el/operators/NoDivArithmeticBinaryOperator.java
+++ /dev/null
@@ -1,300 +0,0 @@
-/*******************************************************************************
- * 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 non-dividing arithmetic EL operators: +,-,*
- * Based on JSP.2.3.5.1
- *
- * @author cbateman
- *
- */
-/*package*/ abstract class NoDivArithmeticBinaryOperator extends ArithmeticBinaryOperator
-{
- NoDivArithmeticBinaryOperator(DiagnosticFactory diagnosticFactory) {
- super(diagnosticFactory);
- }
-
- protected abstract Long doRealOperation(Long firstArg, Long secondArg);
-
- protected abstract Double doRealOperation(Double firstArg, Double secondArg);
-
- public ValueType performOperation(ValueType firstArg, ValueType secondArg)
- {
- // JSP.2.3.5.1, step 1, if either arg is null, return (Long) 0
- if (TypeCoercer.typeIsNull(firstArg.getSignature())
- && TypeCoercer.typeIsNull(secondArg.getSignature()))
- {
- return new IntegerLiteralType(0);
- }
-
- final String boxedFirstArg = TypeTransformer.transformBoxPrimitives(firstArg.getSignature());
- final String boxedSecondArg = TypeTransformer.transformBoxPrimitives(secondArg.getSignature());
-
- // JSP.2.3.5.1, step 2, if either arg is a BigDecimal, coerce to BigDecimal
- // and apply
- if (TypeConstants.TYPE_BIG_DOUBLE.equals(boxedFirstArg)
- || TypeConstants.TYPE_BIG_DOUBLE.equals(boxedSecondArg))
- {
- return handleNumericArithmetic(firstArg, secondArg, BigDecimal.class);
- }
-
- // JSP.2.3.5.1, step 3, if either arg is float or double or
- // a String containing "., e or E", then coerce if the other is
- // a big int, coerce up to BigDecimal, else to Double
- // Note: we are ignoring strings we can't resolve to figure out
- // if the contain "., e or E". Assume they always do
- if (TypeConstants.TYPE_BOXED_DOUBLE.equals(boxedFirstArg)
- ||TypeConstants.TYPE_BOXED_DOUBLE.equals(boxedSecondArg)
- ||TypeConstants.TYPE_BOXED_FLOAT.equals(boxedFirstArg)
- ||TypeConstants.TYPE_BOXED_FLOAT.equals(boxedSecondArg))
- {
- if (TypeConstants.TYPE_BIG_INTEGER.equals(boxedFirstArg)
- ||TypeConstants.TYPE_BIG_INTEGER.equals(boxedSecondArg))
- {
- // if the other operand is BigInteger, treat as BigDecimal
- return handleNumericArithmetic(firstArg, secondArg, BigDecimal.class);
- }
-
- // otherwise as double
- return handleNumericArithmetic(firstArg, secondArg, Double.class);
- }
-
- // JSP.2.3.5.1, step 4, if one is a big integer, coerce to big integer
- if (TypeConstants.TYPE_BIG_INTEGER.equals(boxedFirstArg)
- || TypeConstants.TYPE_BIG_INTEGER.equals(boxedSecondArg))
- {
- return handleNumericArithmetic(firstArg, secondArg, BigInteger.class);
- }
-
- // JSP.2.3.5.1, step 5, otherwise, try to coerce to Long
- return handleNumericArithmetic(firstArg, secondArg, Long.class);
- }
-
- public Diagnostic validate(ValueType firstArg, ValueType secondArg)
- {
- // JSP.2.3.5.1, step 1, if either arg is null, return (Long) 0
- if (TypeCoercer.typeIsNull(firstArg.getSignature())
- && TypeCoercer.typeIsNull(secondArg.getSignature()))
- {
- return _diagnosticFactory.create_BINARY_OP_BOTH_OPERANDS_NULL(getOperatorName());
- }
-
- final String boxedFirstArg = TypeTransformer.transformBoxPrimitives(firstArg.getSignature());
- final String boxedSecondArg = TypeTransformer.transformBoxPrimitives(secondArg.getSignature());
-
- // JSP.2.3.5.1, step 2, if either arg is a BigDecimal, coerce to BigDecimal
- // and apply
- if (TypeConstants.TYPE_BIG_DOUBLE.equals(boxedFirstArg)
- || TypeConstants.TYPE_BIG_DOUBLE.equals(boxedSecondArg))
- {
- return validateNumericArithmetic(firstArg, secondArg, BigDecimal.class);
- }
-
- // JSP.2.3.5.1, step 3, if either arg is float or double or
- // a String containing "., e or E", then coerce if the other is
- // a big int, coerce up to BigDecimal, else to Double
- // Note: we are ignoring strings we can't resolve to figure out
- // if the contain "., e or E". Assume they always do
- if (TypeConstants.TYPE_BOXED_DOUBLE.equals(boxedFirstArg)
- ||TypeConstants.TYPE_BOXED_DOUBLE.equals(boxedSecondArg)
- ||TypeConstants.TYPE_BOXED_FLOAT.equals(boxedFirstArg)
- ||TypeConstants.TYPE_BOXED_FLOAT.equals(boxedSecondArg))
- {
- if (TypeConstants.TYPE_BIG_INTEGER.equals(boxedFirstArg)
- ||TypeConstants.TYPE_BIG_INTEGER.equals(boxedSecondArg))
- {
- // if the other operand is BigInteger, treat as BigDecimal
- return validateNumericArithmetic(firstArg, secondArg, BigDecimal.class);
- }
-
- // otherwise as double
- return validateNumericArithmetic(firstArg, secondArg, Double.class);
- }
-
- // JSP.2.3.5.1, step 4, if one is a big integer, coerce to big integer
- if (TypeConstants.TYPE_BIG_INTEGER.equals(boxedFirstArg)
- || TypeConstants.TYPE_BIG_INTEGER.equals(boxedSecondArg))
- {
- return validateNumericArithmetic(firstArg, secondArg, BigInteger.class);
- }
-
- // JSP.2.3.5.1, step 5, otherwise, try to coerce to Long
- return validateNumericArithmetic(firstArg, secondArg, Long.class);
- }
-
- /**
- * @param firstArg
- * @param secondArg
- * @param numberType
- * @return a value type based on the result of the arithmetic operation
- */
- protected ValueType handleNumericArithmetic(ValueType firstArg, ValueType secondArg, Class numberType)
- {
- try
- {
-// final String coercedFirstArg =
- TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(firstArg.getSignature()));
-// final String coercedSecondArg =
- TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(secondArg.getSignature()));
-
- if (firstArg instanceof LiteralType && secondArg instanceof LiteralType)
- {
- try
- {
- Number firstValue =
- ((LiteralType)firstArg).coerceToNumber(numberType);
- Number secondValue =
- ((LiteralType)secondArg).coerceToNumber(numberType);
-
- LiteralType result = null;
-
- if (numberType == Double.class)
- {
- Double resultValue =
- doRealOperation((Double)firstValue,
- (Double) secondValue);
- result = new FloatLiteralType(resultValue.doubleValue());
- }
- else if (numberType == Long.class)
- {
- Long resultValue =
- doRealOperation((Long) firstValue, (Long) secondValue);
- result = new IntegerLiteralType(resultValue.longValue());
- }
- else
- {
- throw new AssertionError("unsupport arithmetic upcast type");
- }
-
- return result;
- }
- catch (TypeCoercionException tce)
- {
- // could happen if two string literals passed
- return null;
- }
- }
-
- // if we get to here, then we have two valid numeric arith
- // types, but at least one is not a literal, so the best we can
- // say is that the return will be the same asthe type of numeric
- // coercion
- if (numberType == BigDecimal.class)
- {
- return new ValueType(TypeConstants.TYPE_BIG_DOUBLE, IAssignable.ASSIGNMENT_TYPE_RHS);
- }
- else if (numberType == Double.class)
- {
- return new ValueType(Signature.SIG_DOUBLE, IAssignable.ASSIGNMENT_TYPE_RHS);
- }
- else if (numberType == BigInteger.class)
- {
- return new ValueType(TypeConstants.TYPE_BIG_INTEGER, IAssignable.ASSIGNMENT_TYPE_RHS);
- }
- else
- {
- return new ValueType(Signature.SIG_LONG, IAssignable.ASSIGNMENT_TYPE_RHS);
- }
- }
- catch (TypeCoercionException tce)
- {
- // coercion to number failed, so no go
- return null;
- }
- }
-
- /**
- * @param firstArg
- * @param secondArg
- * @param numberType
- * @return a diagnostic validating the arithmetic expr firstArg op secondArg
- */
- protected Diagnostic validateNumericArithmetic(ValueType firstArg, ValueType secondArg, Class numberType)
- {
- try
- {
-// final String coercedFirstArg =
- TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(firstArg.getSignature()));
-// final String coercedSecondArg =
- TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(secondArg.getSignature()));
-
- if (firstArg instanceof LiteralType && secondArg instanceof LiteralType)
- {
- try
- {
- Number firstValue =
- ((LiteralType)firstArg).coerceToNumber(numberType);
- Number secondValue =
- ((LiteralType)secondArg).coerceToNumber(numberType);
-
- Number result = null;
-
- if (numberType == Double.class)
- {
- result =
- doRealOperation((Double)firstValue,
- (Double) secondValue);
- }
- else if (numberType == Long.class)
- {
- result =
- doRealOperation((Long) firstValue, (Long) secondValue);
- }
- else
- {
- throw new AssertionError("unsupport arithmetic upcast type");
- }
-
- return _diagnosticFactory.
- create_BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME
- (getOperatorName(), result.toString());
- }
- catch (TypeCoercionException tce)
- {
- // could happen when two strings are passed
- return _diagnosticFactory.
- create_BINARY_OP_COULD_NOT_COERCE_LITERALS_TO_NUMBERS();
- }
- }
-
- // if we get to here, then we have two valid numeric arith
- // types, but at least one is not a literal
- // everything should be ok
- return Diagnostic.OK_INSTANCE;
- }
- catch (TypeCoercionException tce)
- {
- // coercion to number failed, so no go
- return _diagnosticFactory.
- create_BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION(getOperatorName());
- }
- }
-
-}

Back to the top