package org.apache.commons.ognl;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import org.apache.commons.ognl.enhance.UnsupportedCompilationException;

import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Enumeration;

/**
 * This is an abstract class with static methods that define the operations of OGNL.
 */
public abstract class OgnlOps
    implements NumericTypes
{

    /**
     * Compares two objects for equality, even if it has to convert one of them to the other type. If both objects are
     * numeric they are converted to the widest type and compared. If one is non-numeric and one is numeric the
     * non-numeric is converted to double and compared to the double numeric value. If both are non-numeric and
     * Comparable and the types are compatible (i.e. v1 is of the same or superclass of v2's type) they are compared
     * with Comparable.compareTo(). If both values are non-numeric and not Comparable or of incompatible classes this
     * will throw and IllegalArgumentException.
     *
     * @param v1 First value to compare
     * @param v2 second value to compare
     * @return integer describing the comparison between the two objects. A negative number indicates that v1 < v2.
     *         Positive indicates that v1 > v2. Zero indicates v1 == v2.
     * @throws IllegalArgumentException if the objects are both non-numeric yet of incompatible types or do not
     *             implement Comparable.
     */
    public static int compareWithConversion( Object v1, Object v2 )
    {
        int result;

        if ( v1 == v2 )
        {
            result = 0;
        }
        else
        {
            int t1 = getNumericType( v1 ), t2 = getNumericType( v2 ), type = getNumericType( t1, t2, true );

            switch ( type )
            {
                case BIGINT:
                    result = bigIntValue( v1 ).compareTo( bigIntValue( v2 ) );
                    break;

                case BIGDEC:
                    result = bigDecValue( v1 ).compareTo( bigDecValue( v2 ) );
                    break;

                case NONNUMERIC:
                    if ( ( t1 == NONNUMERIC ) && ( t2 == NONNUMERIC ) )
                    {
                        if ( ( v1 instanceof Comparable ) && v1.getClass().isAssignableFrom( v2.getClass() ) )
                        {
                            result = ( (Comparable) v1 ).compareTo( v2 );
                            break;
                        }
                        throw new IllegalArgumentException( "invalid comparison: " + v1.getClass().getName()
                            + " and " + v2.getClass().getName() );
                    }
                    // else fall through
                case FLOAT:
                case DOUBLE:
                    double dv1 = doubleValue( v1 ),
                    dv2 = doubleValue( v2 );

                    return ( dv1 == dv2 ) ? 0 : ( ( dv1 < dv2 ) ? -1 : 1 );

                default:
                    long lv1 = longValue( v1 ),
                    lv2 = longValue( v2 );

                    return ( lv1 == lv2 ) ? 0 : ( ( lv1 < lv2 ) ? -1 : 1 );
            }
        }
        return result;
    }

    /**
     * Returns true if object1 is equal to object2 in either the sense that they are the same object or, if both are
     * non-null if they are equal in the <CODE>equals()</CODE> sense.
     *
     * @param object1 First object to compare
     * @param object2 Second object to compare
     * @return true if v1 == v2
     */
    public static boolean isEqual( Object object1, Object object2 )
    {
        boolean result = false;

        if ( object1 == object2 )
        {
            result = true;
        }
        else
        {
            if ( ( object1 != null ) && object1.getClass().isArray() )
            {
                if ( ( object2 != null ) && object2.getClass().isArray() && ( object2.getClass()
                    == object1.getClass() ) )
                {
                    result = ( Array.getLength( object1 ) == Array.getLength( object2 ) );
                    if ( result )
                    {
                        for ( int i = 0, icount = Array.getLength( object1 ); result && ( i < icount ); i++ )
                        {
                            result = isEqual( Array.get( object1, i ), Array.get( object2, i ) );
                        }
                    }
                }
            }
            else
            {
                // Check for converted equivalence first, then equals() equivalence
                result =
                    ( object1 != null ) && ( object2 != null )
                        && ( object1.equals( object2 ) || ( compareWithConversion( object1, object2 ) == 0 ) );
            }
        }
        return result;
    }

    public static boolean booleanValue( boolean value )
    {
        return value;
    }

    public static boolean booleanValue( int value )
    {
        return value > 0;
    }

    public static boolean booleanValue( float value )
    {
        return value > 0;
    }

    public static boolean booleanValue( long value )
    {
        return value > 0;
    }

    public static boolean booleanValue( double value )
    {
        return value > 0;
    }

    /**
     * Evaluates the given object as a boolean: if it is a Boolean object, it's easy; if it's a Number or a Character,
     * returns true for non-zero objects; and otherwise returns true for non-null objects.
     *
     * @param value an object to interpret as a boolean
     * @return the boolean value implied by the given object
     */
    public static boolean booleanValue( Object value )
    {
        if ( value == null )
        {
            return false;
        }
        Class<?> c = value.getClass();

        if ( c == Boolean.class )
        {
            return (Boolean) value;
        }
        // if ( c == String.class )
        // return ((String)value).length() > 0;

        if ( c == Character.class )
        {
            return (Character) value != 0;
        }
        return !( value instanceof Number ) || ( (Number) value ).doubleValue() != 0;

    }

    /**
     * Evaluates the given object as a long integer.
     *
     * @param value an object to interpret as a long integer
     * @return the long integer value implied by the given object
     * @throws NumberFormatException if the given object can't be understood as a long integer
     */
    public static long longValue( Object value )
    {
        if ( value == null )
        {
            return 0L;
        }
        Class<?> c = value.getClass();
        if ( c.getSuperclass() == Number.class )
        {
            return ( (Number) value ).longValue();
        }
        if ( c == Boolean.class )
        {
            return (Boolean) value ? 1 : 0;
        }
        if ( c == Character.class )
        {
            return (Character) value;
        }
        return Long.parseLong( stringValue( value, true ) );
    }

    /**
     * Evaluates the given object as a double-precision floating-point number.
     *
     * @param value an object to interpret as a double
     * @return the double value implied by the given object
     * @throws NumberFormatException if the given object can't be understood as a double
     */
    public static double doubleValue( Object value )
    {
        if ( value == null )
        {
            return 0.0;
        }
        Class<?> c = value.getClass();
        if ( c.getSuperclass() == Number.class )
        {
            return ( (Number) value ).doubleValue();
        }
        if ( c == Boolean.class )
        {
            return (Boolean) value ? 1 : 0;
        }
        if ( c == Character.class )
        {
            return (Character) value;
        }
        String s = stringValue( value, true );

        return ( s.isEmpty() ) ? 0.0 : Double.parseDouble( s );
    }

    /**
     * Evaluates the given object as a BigInteger.
     *
     * @param value an object to interpret as a BigInteger
     * @return the BigInteger value implied by the given object
     * @throws NumberFormatException if the given object can't be understood as a BigInteger
     */
    public static BigInteger bigIntValue( Object value )
    {
        if ( value == null )
        {
            return BigInteger.valueOf( 0L );
        }
        Class<?> c = value.getClass();
        if ( c == BigInteger.class )
        {
            return (BigInteger) value;
        }
        if ( c == BigDecimal.class )
        {
            return ( (BigDecimal) value ).toBigInteger();
        }
        if ( c.getSuperclass() == Number.class )
        {
            return BigInteger.valueOf( ( (Number) value ).longValue() );
        }
        if ( c == Boolean.class )
        {
            return BigInteger.valueOf( (Boolean) value ? 1 : 0 );
        }
        if ( c == Character.class )
        {
            return BigInteger.valueOf( (Character) value );
        }
        return new BigInteger( stringValue( value, true ) );
    }

    /**
     * Evaluates the given object as a BigDecimal.
     *
     * @param value an object to interpret as a BigDecimal
     * @return the BigDecimal value implied by the given object
     * @throws NumberFormatException if the given object can't be understood as a BigDecimal
     */
    public static BigDecimal bigDecValue( Object value )
    {
        if ( value == null )
        {
            return BigDecimal.valueOf( 0L );
        }
        Class<?> c = value.getClass();
        if ( c == BigDecimal.class )
        {
            return (BigDecimal) value;
        }
        if ( c == BigInteger.class )
        {
            return new BigDecimal( (BigInteger) value );
        }
        if ( c == Boolean.class )
        {
            return BigDecimal.valueOf( (Boolean) value ? 1 : 0 );
        }
        if ( c == Character.class )
        {
            return BigDecimal.valueOf( ( (Character) value ).charValue() );
        }
        return new BigDecimal( stringValue( value, true ) );
    }

    /**
     * Evaluates the given object as a String and trims it if the trim flag is true.
     *
     * @param value an object to interpret as a String
     * @param trim if true trims the result
     * @return the String value implied by the given object as returned by the toString() method, or "null" if the
     *         object is null.
     */
    public static String stringValue( Object value, boolean trim )
    {
        String result;

        if ( value == null )
        {
            result = OgnlRuntime.NULL_STRING;
        }
        else
        {
            result = value.toString();
            if ( trim )
            {
                result = result.trim();
            }
        }
        return result;
    }

    /**
     * Evaluates the given object as a String.
     *
     * @param value an object to interpret as a String
     * @return the String value implied by the given object as returned by the toString() method, or "null" if the
     *         object is null.
     */
    public static String stringValue( Object value )
    {
        return stringValue( value, false );
    }

    /**
     * Returns a constant from the NumericTypes interface that represents the numeric type of the given object.
     *
     * @param value an object that needs to be interpreted as a number
     * @return the appropriate constant from the NumericTypes interface
     */
    public static int getNumericType( Object value )
    {
        if ( value != null )
        {
            Class<?> c = value.getClass();
            if ( c == Integer.class )
            {
                return INT;
            }
            if ( c == Double.class )
            {
                return DOUBLE;
            }
            if ( c == Boolean.class )
            {
                return BOOL;
            }
            if ( c == Byte.class )
            {
                return BYTE;
            }
            if ( c == Character.class )
            {
                return CHAR;
            }
            if ( c == Short.class )
            {
                return SHORT;
            }
            if ( c == Long.class )
            {
                return LONG;
            }
            if ( c == Float.class )
            {
                return FLOAT;
            }
            if ( c == BigInteger.class )
            {
                return BIGINT;
            }
            if ( c == BigDecimal.class )
            {
                return BIGDEC;
            }
        }
        return NONNUMERIC;
    }

    public static Object toArray( char value, Class<?> toType )
        throws OgnlException
    {
        return toArray( Character.valueOf( value ), toType );
    }

    public static Object toArray( byte value, Class<?> toType )
        throws OgnlException
    {
        return toArray( Byte.valueOf( value ), toType );
    }

    public static Object toArray( int value, Class<?> toType )
        throws OgnlException
    {
        return toArray( Integer.valueOf( value ), toType );
    }

    public static Object toArray( long value, Class<?> toType )
        throws OgnlException
    {
        return toArray( Long.valueOf( value ), toType );
    }

    public static Object toArray( float value, Class<?> toType )
        throws OgnlException
    {
        return toArray( Float.valueOf( value ), toType );
    }

    public static Object toArray( double value, Class<?> toType )
        throws OgnlException
    {
        return toArray( Double.valueOf( value ), toType );
    }

    public static Object toArray( boolean value, Class<?> toType )
        throws OgnlException
    {
        return toArray( Boolean.valueOf( value ), toType );
    }

    public static <T> Object convertValue( char value, Class<T> toType )
        throws OgnlException
    {
        return convertValue( Character.valueOf(value), toType );
    }

    public static <T> Object convertValue( byte value, Class<T> toType )
        throws OgnlException
    {
        return convertValue( Byte.valueOf( value ), toType );
    }

    public static <T> Object convertValue( int value, Class<T> toType )
        throws OgnlException
    {
        return convertValue( Integer.valueOf( value ), toType );
    }

    public static <T> Object convertValue( long value, Class<T> toType )
        throws OgnlException
    {
        return convertValue( Long.valueOf( value ), toType );
    }

    public static <T> Object convertValue( float value, Class<T> toType )
        throws OgnlException
    {
        return convertValue( Float.valueOf( value ), toType );
    }

    public static <T> Object convertValue( double value, Class<T> toType )
        throws OgnlException
    {
        return convertValue( Double.valueOf( value ), toType );
    }

    public static <T> Object convertValue( boolean value, Class<T> toType )
        throws OgnlException
    {
        return convertValue( Boolean.valueOf( value ), toType );
    }

    // //////////////////////////////////////////////////////////////

    public static <T> Object convertValue( char value, Class<T> toType, boolean preventNull )
        throws OgnlException
    {
        return convertValue( Character.valueOf( value ), toType, preventNull );
    }

    public static <T> Object convertValue( byte value, Class<T> toType, boolean preventNull )
        throws OgnlException
    {
        return convertValue( Byte.valueOf( value ), toType, preventNull );
    }

    public static <T> Object convertValue( int value, Class<T> toType, boolean preventNull )
        throws OgnlException
    {
        return convertValue( Integer.valueOf( value ), toType, preventNull );
    }

    public static <T> Object convertValue( long value, Class<T> toType, boolean preventNull )
        throws OgnlException
    {
        return convertValue( Long.valueOf( value ), toType, preventNull );
    }

    public static <T> Object convertValue( float value, Class<T> toType, boolean preventNull )
        throws OgnlException
    {
        return convertValue( new Float( value ), toType, preventNull );
    }

    public static <T> Object convertValue( double value, Class<T> toType, boolean preventNull )
        throws OgnlException
    {
        return convertValue( new Double( value ), toType, preventNull );
    }

    public static <T> Object convertValue( boolean value, Class<T> toType, boolean preventNull )
        throws OgnlException
    {
        return convertValue( Boolean.valueOf( value ), toType, preventNull );
    }

    // ///////////////////////////////////////////////////////////////

    public static Object toArray( char value, Class<?> toType, boolean preventNull )
        throws OgnlException
    {
        return toArray( Character.valueOf( value ), toType, preventNull );
    }

    public static Object toArray( byte value, Class<?> toType, boolean preventNull )
        throws OgnlException
    {
        return toArray( Byte.valueOf( value ), toType, preventNull );
    }

    public static Object toArray( int value, Class<?> toType, boolean preventNull )
        throws OgnlException
    {
        return toArray( Integer.valueOf( value ), toType, preventNull );
    }

    public static Object toArray( long value, Class<?> toType, boolean preventNull )
        throws OgnlException
    {
        return toArray( Long.valueOf(value), toType, preventNull );
    }

    public static Object toArray( float value, Class<?> toType, boolean preventNull )
        throws OgnlException
    {
        return toArray( Float.valueOf( value ), toType, preventNull );
    }

    public static Object toArray( double value, Class<?> toType, boolean preventNull )
        throws OgnlException
    {
        return toArray( Double.valueOf(value), toType, preventNull );
    }

    public static Object toArray( boolean value, Class<?> toType, boolean preventNull )
        throws OgnlException
    {
        return toArray( Boolean.valueOf( value ), toType, preventNull );
    }

    /**
     * Returns the value converted numerically to the given class type This method also detects when arrays are being
     * converted and converts the components of one array to the type of the other.
     *
     * @param value an object to be converted to the given type
     * @param toType class type to be converted to
     * @return converted value of the type given, or value if the value cannot be converted to the given type.
     */
    public static Object convertValue( Object value, Class<?> toType )
    {
        return convertValue( value, toType, false );
    }

    public static Object toArray( Object value, Class<?> toType )
        throws OgnlException
    {
        return toArray( value, toType, false );
    }

    public static Object toArray( Object value, Class<?> toType, boolean preventNulls )
        throws OgnlException
    {
        if ( value == null )
        {
            return null;
        }

        Object result;

        Class<?> aClass = value.getClass();
        if ( aClass.isArray() && toType.isAssignableFrom( aClass.getComponentType() ) )
        {
            return value;
        }

        if ( !aClass.isArray() )
        {

            if ( toType == Character.TYPE )
            {
                return stringValue( value ).toCharArray();
            }

            Object arr = Array.newInstance( toType, 1 );
            Array.set( arr, 0, convertValue( value, toType, preventNulls ) );

            return arr;
        }

        result = Array.newInstance( toType, Array.getLength( value ) );
        for ( int i = 0, icount = Array.getLength( value ); i < icount; i++ )
        {
            Array.set( result, i, convertValue( Array.get( value, i ), toType ) );
        }

        if ( result == null && preventNulls )
        {
            return value;
        }

        return result;
    }

    public static <T> Object convertValue( Object value, Class<T> toType, boolean preventNulls )
    {
        Object result = null;

        if ( value != null && toType.isAssignableFrom( value.getClass() ) )
        {
            return value;
        }

        if ( value != null )
        {
            /* If array -> array then convert components of array individually */
            boolean classIsArray = value.getClass().isArray();
            boolean toTypeIsArray = toType.isArray();
            if ( classIsArray && toTypeIsArray)
            {
                Class<?> componentType = toType.getComponentType();

                result = Array.newInstance( componentType, Array.getLength( value ) );
                for ( int i = 0, icount = Array.getLength( value ); i < icount; i++ )
                {
                    Array.set( result, i, convertValue( Array.get( value, i ), componentType ) );
                }
            }
            else if ( classIsArray && !toTypeIsArray)
            {

                return convertValue( Array.get( value, 0 ), toType );
            }
            else if ( toTypeIsArray )
            {

                if ( toType.getComponentType() == Character.TYPE )
                {

                    result = stringValue( value ).toCharArray();
                }
                else if ( toType.getComponentType() == Object.class )
                {
                    return new Object[] { value };
                }
            }
            else
            {
                if ( ( toType == Integer.class ) || ( toType == Integer.TYPE ) )
                {
                    result = (int) longValue( value );
                }
                else if ( ( toType == Double.class ) || ( toType == Double.TYPE ) )
                {
                    result = doubleValue( value );
                }
                else if ( ( toType == Boolean.class ) || ( toType == Boolean.TYPE ) )
                {
                    result = booleanValue( value ) ? Boolean.TRUE : Boolean.FALSE;
                }
                else if ( ( toType == Byte.class ) || ( toType == Byte.TYPE ) )
                {
                    result = (byte) longValue( value );
                }
                else if ( ( toType == Character.class ) || ( toType == Character.TYPE ) )
                {
                    result = (char) longValue( value );
                }
                else if ( ( toType == Short.class ) || ( toType == Short.TYPE ) )
                {
                    result = (short) longValue( value );
                }
                else if ( ( toType == Long.class ) || ( toType == Long.TYPE ) )
                {
                    result = longValue( value );
                }
                else if ( ( toType == Float.class ) || ( toType == Float.TYPE ) )
                {
                    result = new Float( doubleValue( value ) );
                }
                else if ( toType == BigInteger.class )
                {
                    result = bigIntValue( value );
                }
                else if ( toType == BigDecimal.class )
                {
                    result = bigDecValue( value );
                }
                else if ( toType == String.class )
                {
                    result = stringValue( value );
                }
            }
        }
        else
        {
            if ( toType.isPrimitive() )
            {
                result = OgnlRuntime.getPrimitiveDefaultValue( toType );
            }
            else if ( preventNulls && toType == Boolean.class )
            {
                result = Boolean.FALSE;
            }
            else if ( preventNulls && Number.class.isAssignableFrom( toType ) )
            {
                result = OgnlRuntime.getNumericDefaultValue( toType );
            }
        }

        if ( result == null && preventNulls )
        {
            return value;
        }

        if ( value != null && result == null )
        {

            throw new IllegalArgumentException( "Unable to convert type " + value.getClass().getName() + " of " + value
                + " to type of " + toType.getName() );
        }

        return result;
    }

    /**
     * Converts the specified value to a primitive integer value.
     * <ul>
     * <li>Null values will cause a -1 to be returned.</li>
     * <li>{@link Number} instances have their intValue() methods invoked.</li>
     * <li>All other types result in calling Integer.parseInt(value.toString());</li>
     * </ul>
     *
     * @param value The object to get the value of.
     * @return A valid integer.
     */
    public static int getIntValue( Object value )
    {
        try
        {
            if ( value == null )
            {
                return -1;
            }

            if ( Number.class.isInstance( value ) )
            {

                return ( (Number) value ).intValue();
            }

            String str = String.class.isInstance( value ) ? (String) value : value.toString();

            return Integer.parseInt( str );
        }
        catch ( Throwable t )
        {
            throw new RuntimeException( "Error converting " + value + " to integer:", t );
        }
    }

    /**
     * Returns the constant from the NumericTypes interface that best expresses the type of a numeric operation on the
     * two given objects.
     *
     * @param v1 one argument to a numeric operator
     * @param v2 the other argument
     * @return the appropriate constant from the NumericTypes interface
     */
    public static int getNumericType( Object v1, Object v2 )
    {
        return getNumericType( v1, v2, false );
    }

    /**
     * Returns the constant from the NumericTypes interface that best expresses the type of an operation, which can be
     * either numeric or not, on the two given types.
     *
     * @param t1 type of one argument to an operator
     * @param t2 type of the other argument
     * @param canBeNonNumeric whether the operator can be interpreted as non-numeric
     * @return the appropriate constant from the NumericTypes interface
     */
    public static int getNumericType( int t1, int t2, boolean canBeNonNumeric )
    {
        if ( t1 == t2 )
        {
            return t1;
        }

        if ( canBeNonNumeric && ( t1 == NONNUMERIC || t2 == NONNUMERIC || t1 == CHAR || t2 == CHAR ) )
        {
            return NONNUMERIC;
        }

        if ( t1 == NONNUMERIC )
        {
            t1 = DOUBLE; // Try to interpret strings as doubles...
        }
        if ( t2 == NONNUMERIC )
        {
            t2 = DOUBLE; // Try to interpret strings as doubles...
        }

        if ( t1 >= MIN_REAL_TYPE )
        {
            if ( t2 >= MIN_REAL_TYPE )
            {
                return Math.max( t1, t2 );
            }
            if ( t2 < INT )
            {
                return t1;
            }
            if ( t2 == BIGINT )
            {
                return BIGDEC;
            }
            return Math.max( DOUBLE, t1 );
        }
        if ( t2 < MIN_REAL_TYPE ) {
            return Math.max( t1, t2 );
        }
        if ( t1 < INT )
        {
            return t2;
        }
        if ( t1 == BIGINT )
        {
            return BIGDEC;
        }
        return Math.max( DOUBLE, t2 );
    }

    /**
     * Returns the constant from the NumericTypes interface that best expresses the type of an operation, which can be
     * either numeric or not, on the two given objects.
     *
     * @param v1 one argument to an operator
     * @param v2 the other argument
     * @param canBeNonNumeric whether the operator can be interpreted as non-numeric
     * @return the appropriate constant from the NumericTypes interface
     */
    public static int getNumericType( Object v1, Object v2, boolean canBeNonNumeric )
    {
        return getNumericType( getNumericType( v1 ), getNumericType( v2 ), canBeNonNumeric );
    }

    /**
     * Returns a new Number object of an appropriate type to hold the given integer value. The type of the returned
     * object is consistent with the given type argument, which is a constant from the NumericTypes interface.
     *
     * @param type the nominal numeric type of the result, a constant from the NumericTypes interface
     * @param value the integer value to convert to a Number object
     * @return a Number object with the given value, of type implied by the type argument
     */
    public static Number newInteger( int type, long value )
    {
        switch ( type )
        {
            case BOOL:
            case CHAR:
            case INT:
                return (int) value;

            case FLOAT:
                if ( (long) (float) value == value )
                {
                    return (float) value;
                }
                // else fall through:
            case DOUBLE:
                if ( (long) (double) value == value )
                {
                    return (double) value;
                }
                // else fall through:
            case LONG:
                return value;

            case BYTE:
                return (byte) value;

            case SHORT:
                return (short) value;

            default:
                return BigInteger.valueOf( value );
        }
    }

    /**
     * Returns a new Number object of an appropriate type to hold the given real value. The type of the returned object
     * is always either Float or Double, and is only Float if the given type tag (a constant from the NumericTypes
     * interface) is FLOAT.
     *
     * @param type the nominal numeric type of the result, a constant from the NumericTypes interface
     * @param value the real value to convert to a Number object
     * @return a Number object with the given value, of type implied by the type argument
     */
    public static Number newReal( int type, double value )
    {
        if ( type == FLOAT )
        {
            return (float) value;
        }
        return value;
    }

    public static Object binaryOr( Object v1, Object v2 )
    {
        int type = getNumericType( v1, v2 );
        if ( type == BIGINT || type == BIGDEC )
        {
            return bigIntValue( v1 ).or( bigIntValue( v2 ) );
        }
        return newInteger( type, longValue( v1 ) | longValue( v2 ) );
    }

    public static Object binaryXor( Object v1, Object v2 )
    {
        int type = getNumericType( v1, v2 );
        if ( type == BIGINT || type == BIGDEC )
        {
            return bigIntValue( v1 ).xor( bigIntValue( v2 ) );
        }
        return newInteger( type, longValue( v1 ) ^ longValue( v2 ) );
    }

    public static Object binaryAnd( Object v1, Object v2 )
    {
        int type = getNumericType( v1, v2 );
        if ( type == BIGINT || type == BIGDEC )
        {
            return bigIntValue( v1 ).and( bigIntValue( v2 ) );
        }
        return newInteger( type, longValue( v1 ) & longValue( v2 ) );
    }

    public static boolean equal( Object v1, Object v2 )
    {
        if ( v1 == null )
        {
            return v2 == null;
        }
        if ( v1 == v2 || isEqual( v1, v2 ) )
        {
            return true;
        }
        if ( v1 instanceof Number && v2 instanceof Number )
        {
            return ( (Number) v1 ).doubleValue() == ( (Number) v2 ).doubleValue();
        }
        return false;
    }

    public static boolean less( Object v1, Object v2 )
    {
        return compareWithConversion( v1, v2 ) < 0;
    }

    public static boolean greater( Object v1, Object v2 )
    {
        return compareWithConversion( v1, v2 ) > 0;
    }

    public static boolean in( Object v1, Object v2 )
        throws OgnlException
    {
        if ( v2 == null ) // A null collection is always treated as empty
        {
            return false;
        }

        ElementsAccessor elementsAccessor = OgnlRuntime.getElementsAccessor( OgnlRuntime.getTargetClass( v2 ) );

        // FIXME O(n) is there a better way?!
        for ( Enumeration<?> e = elementsAccessor.getElements( v2 ); e.hasMoreElements(); )
        {
            Object o = e.nextElement();

            if ( equal( v1, o ) )
            {
                return true;
            }
        }

        return false;
    }

    public static Object shiftLeft( Object v1, Object v2 )
    {
        int type = getNumericType( v1 );
        if ( type == BIGINT || type == BIGDEC )
        {
            return bigIntValue( v1 ).shiftLeft( (int) longValue( v2 ) );
        }
        return newInteger( type, longValue( v1 ) << (int) longValue( v2 ) );
    }

    public static Object shiftRight( Object v1, Object v2 )
    {
        int type = getNumericType( v1 );
        if ( type == BIGINT || type == BIGDEC )
        {
            return bigIntValue( v1 ).shiftRight( (int) longValue( v2 ) );
        }
        return newInteger( type, longValue( v1 ) >> (int) longValue( v2 ) );
    }

    public static Object unsignedShiftRight( Object v1, Object v2 )
    {
        int type = getNumericType( v1 );
        if ( type == BIGINT || type == BIGDEC )
        {
            return bigIntValue( v1 ).shiftRight( (int) longValue( v2 ) );
        }
        if ( type <= INT )
        {
            return newInteger( INT, ( (int) longValue( v1 ) ) >>> (int) longValue( v2 ) );
        }
        return newInteger( type, longValue( v1 ) >>> (int) longValue( v2 ) );
    }

    public static Object add( Object v1, Object v2 )
    {
        int type = getNumericType( v1, v2, true );
        switch ( type )
        {
            case BIGINT:
                return bigIntValue( v1 ).add( bigIntValue( v2 ) );
            case BIGDEC:
                return bigDecValue( v1 ).add( bigDecValue( v2 ) );
            case FLOAT:
            case DOUBLE:
                return newReal( type, doubleValue( v1 ) + doubleValue( v2 ) );
            case NONNUMERIC:
                int t1 = getNumericType( v1 ),
                t2 = getNumericType( v2 );

                if ( ( ( t1 != NONNUMERIC ) && ( v2 == null ) ) || ( ( t2 != NONNUMERIC ) && ( v1 == null ) ) )
                {
                    throw new NullPointerException( "Can't add values " + v1 + " , " + v2 );
                }

                return stringValue( v1 ) + stringValue( v2 );
            default:
                return newInteger( type, longValue( v1 ) + longValue( v2 ) );
        }
    }

    public static Object subtract( Object v1, Object v2 )
    {
        int type = getNumericType( v1, v2 );
        switch ( type )
        {
            case BIGINT:
                return bigIntValue( v1 ).subtract( bigIntValue( v2 ) );
            case BIGDEC:
                return bigDecValue( v1 ).subtract( bigDecValue( v2 ) );
            case FLOAT:
            case DOUBLE:
                return newReal( type, doubleValue( v1 ) - doubleValue( v2 ) );
            default:
                return newInteger( type, longValue( v1 ) - longValue( v2 ) );
        }
    }

    public static Object multiply( Object v1, Object v2 )
    {
        int type = getNumericType( v1, v2 );
        switch ( type )
        {
            case BIGINT:
                return bigIntValue( v1 ).multiply( bigIntValue( v2 ) );
            case BIGDEC:
                return bigDecValue( v1 ).multiply( bigDecValue( v2 ) );
            case FLOAT:
            case DOUBLE:
                return newReal( type, doubleValue( v1 ) * doubleValue( v2 ) );
            default:
                return newInteger( type, longValue( v1 ) * longValue( v2 ) );
        }
    }

    public static Object divide( Object v1, Object v2 )
    {
        int type = getNumericType( v1, v2 );
        switch ( type )
        {
            case BIGINT:
                return bigIntValue( v1 ).divide( bigIntValue( v2 ) );
            case BIGDEC:
                return bigDecValue( v1 ).divide( bigDecValue( v2 ), BigDecimal.ROUND_HALF_EVEN );
            case FLOAT:
            case DOUBLE:
                return newReal( type, doubleValue( v1 ) / doubleValue( v2 ) );
            default:
                return newInteger( type, longValue( v1 ) / longValue( v2 ) );
        }
    }

    public static Object remainder( Object v1, Object v2 )
    {
        int type = getNumericType( v1, v2 );
        switch ( type )
        {
            case BIGDEC:
            case BIGINT:
                return bigIntValue( v1 ).remainder( bigIntValue( v2 ) );
            default:
                return newInteger( type, longValue( v1 ) % longValue( v2 ) );
        }
    }

    public static Object negate( Object value )
    {
        int type = getNumericType( value );
        switch ( type )
        {
            case BIGINT:
                return bigIntValue( value ).negate();
            case BIGDEC:
                return bigDecValue( value ).negate();
            case FLOAT:
            case DOUBLE:
                return newReal( type, -doubleValue( value ) );
            default:
                return newInteger( type, -longValue( value ) );
        }
    }

    public static Object bitNegate( Object value )
    {
        int type = getNumericType( value );
        switch ( type )
        {
            case BIGDEC:
            case BIGINT:
                return bigIntValue( value ).not();
            default:
                return newInteger( type, ~longValue( value ) );
        }
    }

    public static String getEscapeString( String value )
    {
        StringBuilder result = new StringBuilder();

        int length = value.length();
        for ( int i = 0; i < length; i++ )
        {
            result.append( getEscapedChar( value.charAt( i ) ) );
        }
        return result.toString();
    }

    public static String getEscapedChar( char ch )
    {
        String result;

        switch ( ch )
        {
            case '\b':
                result = "\b";
                break;
            case '\t':
                result = "\\t";
                break;
            case '\n':
                result = "\\n";
                break;
            case '\f':
                result = "\\f";
                break;
            case '\r':
                result = "\\r";
                break;
            case '\"':
                result = "\\\"";
                break;
            case '\'':
                result = "\\\'";
                break;
            case '\\':
                result = "\\\\";
                break;
            default:
                if ( Character.isISOControl( ch ) )
                {

                    String hc = Integer.toString( (int) ch, 16 );
                    int hcl = hc.length();

                    result = "\\u";
                    if ( hcl < 4 )
                    {
                        if ( hcl == 3 )
                        {
                            result = result + "0";
                        }
                        else
                        {
                            if ( hcl == 2 )
                            {
                                result = result + "00";
                            }
                            else
                            {
                                result = result + "000";
                            }
                        }
                    }

                    result = result + hc;
                }
                else
                {
                    result = ch + "";
                }
                break;
        }
        return result;
    }

    public static Object returnValue( Object ignore, Object returnValue )
    {
        return returnValue;
    }

    /**
     * Utility method that converts incoming exceptions to {@link RuntimeException} instances - or casts them if they
     * already are.
     *
     * @param t The exception to cast.
     * @return The exception cast to a {@link RuntimeException}.
     */
    public static RuntimeException castToRuntime( Throwable t )
    {
        if ( RuntimeException.class.isInstance( t ) )
        {
            return (RuntimeException) t;
        }

        if ( OgnlException.class.isInstance( t ) )
        {
            throw new UnsupportedCompilationException( "Error evluating expression: " + t.getMessage(), t );
        }

        return new RuntimeException( t );
    }
}