/*******************************************************************************
* 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 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.StringLiteralType;
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 unary operator '-' on a ValueType
* as described by JSP.2.3.5.4
*
*
* @author cbateman
*
*/
/*package*/class MinusUnaryOperator extends UnaryOperator
{
private static final String UNARY_MINUS = "unary minus"; //$NON-NLS-1$
MinusUnaryOperator(DiagnosticFactory diagnosticFactory)
{
super(diagnosticFactory);
}
public Diagnostic validate(ValueType type)
{
if (TypeConstants.TYPE_JAVAOBJECT.equals(type.getSignature())) {
return Diagnostic.OK_INSTANCE;
}
// must coerce to numeric type
try
{
// if coerceTypeNumber doesn't throw an exception, then
// give the benefit of the doubt
final String coercedType =
TypeCoercer.
coerceToNumber(TypeTransformer.
transformBoxPrimitives(type.getSignature()));
if (TypeCoercer.typeIsNull(coercedType))
{
// null always coerces to 0L on this operator
return _diagnosticFactory.
create_UNARY_OP_MINUS_ON_NULL_ALWAYS_ZERO();
}
// JSP.2.3.5.4, step 2 if BigDecimal or BigInteger, then can't be
// literal and retains type
if (TypeConstants.TYPE_BIG_DOUBLE.equals(coercedType)
|| TypeConstants.TYPE_BIG_INTEGER.equals(coercedType))
{
return Diagnostic.OK_INSTANCE;
}
// JSP.2.4.5.4, step 3: if String
// note, use uncoerced type, since type coercer will return null for strings
if (TypeCoercer.typeIsString(type.getSignature()))
{
// if it's a string and we have the value, we can determine for
// sure whether or not it's coercable to a number
// per JSP.2.3.5.4 step 3.1
if (type instanceof StringLiteralType)
{
String literalValue = ((LiteralType)type).getLiteralValue();
if (literalValue.indexOf('.') > -1
|| literalValue.indexOf('e') > -1
|| literalValue.indexOf('E') > -1)
{
// if it coerces to double, then it's a double
((LiteralType)type).coerceToNumber(Double.class);
// this is okay, because an expression like #{-3.3} can't be folded
return Diagnostic.OK_INSTANCE;
}
// per JSP.2.3.5.4, step 3.2 try to coerce to long
// if it coerces to long, then it's a long
((LiteralType)type).coerceToNumber(Long.class);
// this is okay, because an expression like #{-3} can't be folded
return Diagnostic.OK_INSTANCE;
}
// if non-literal string, warn that coercion to number is not
// guaranteed since Long.valueOf and Double.valueOf
// (unlike Boolean.valueOf) throw NumberFormatExceptions
return _diagnosticFactory.create_UNARY_OP_STRING_CONVERSION_NOT_GUARANTEED(UNARY_MINUS);
}
// JSP.2.3.5.4, step 4, for all numeric types, retain type,
// validate constant folding
// note that this return true for big int and decimal, so those cases
// must already have been handled.
if (TypeCoercer.typeIsNumeric(coercedType))
{
// otherwise, we are fine
return Diagnostic.OK_INSTANCE;
}
}
catch (TypeCoercionException tce)
{
// fallthrough to error below
}
// otherwise, error
return _diagnosticFactory.create_UNARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION(UNARY_MINUS);
}
/**
* Based on JSP.2.3.5.4
*
* @param type
* @return type of type after a minus is applied or null if unknown
*/
public ValueType performOperation(ValueType type)
{
try
{
final String boxedType =
TypeTransformer.transformBoxPrimitives(type.getSignature());
// check for valid type coercion
String coercedType = TypeCoercer.coerceToNumber(boxedType);
if (TypeCoercer.typeIsNull(coercedType))
{
// null always coerces to 0L on this operator
return new IntegerLiteralType(0L);
}
// JSP.2.3.5.4, step 2 if BigDecimal or BigInteger, then can't be
// literal and retains type
if (TypeConstants.TYPE_BIG_DOUBLE.equals(coercedType))
{
return new ValueType(TypeConstants.TYPE_BIG_DOUBLE, IAssignable.ASSIGNMENT_TYPE_RHS);
}
else if (TypeConstants.TYPE_BIG_INTEGER.equals(coercedType))
{
return new ValueType(TypeConstants.TYPE_BIG_INTEGER, IAssignable.ASSIGNMENT_TYPE_RHS);
}
if (TypeCoercer.typeIsString(type.getSignature()))
{
// if it's string and we have the value, we can determine for
// sure whether or not it's coercable to a number
// per JSP.2.3.5.4 step 3
if (type instanceof StringLiteralType)
{
String literalValue = ((LiteralType)type).getLiteralValue();
if (literalValue.indexOf('.') > -1
|| literalValue.indexOf('e') > -1
|| literalValue.indexOf('E') > -1)
{
// if it coerces to double, then it's a double
Number value = ((LiteralType)type).coerceToNumber(Double.class);
return new FloatLiteralType(-1 * value.doubleValue());
}
// if it coerces to long, then it's a long
Number value = ((LiteralType)type).coerceToNumber(Long.class);
return new IntegerLiteralType(-1 * value.longValue());
}
// otherwise, just return a long typed value
return new ValueType(Signature.SIG_LONG, IAssignable.ASSIGNMENT_TYPE_RHS);
}
// JSP.2.3.5.4
// big integer and big decimal retain type
// all numeric types retain type
if (TypeCoercer.typeIsNumeric(boxedType))
{
// integer and float literals are special because -1 or -1.0
// is syntically minusOp(1) and minusOp(1.0)
if (type instanceof IntegerLiteralType)
{
return new IntegerLiteralType(-1 * ((IntegerLiteralType)type).coerceToNumber(Long.class).longValue());
}
else if (type instanceof FloatLiteralType)
{
return new FloatLiteralType(-1 * ((FloatLiteralType)type).coerceToNumber(Double.class).doubleValue());
}
return type;
}
// all other cases, return null
// even is type represents a String, without it's value, we have
// no idea how to coerce it without it's value
// fall through and return null
}
catch (TypeCoercionException tce)
{
// do nothing, fall through and return null
}
return null;
}
}