/*
*
* 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.
*
*/
package org.apache.flex.abc.semantics;
import org.apache.flex.abc.ABCConstants;
import java.math.BigDecimal;
import java.math.MathContext;
/**
* Provides helper functions for for various operations as specified by ECMA.
*
* @see <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">ECMA 262 spec</a>
*/
public class ECMASupport
{
private static final long MASK_32_BIT_UINT = 0xffffffffL;
private static final double TWO_TO_THE_31ST = Math.pow(2, 31);
private static final double TWO_TO_THE_32ND = Math.pow(2, 32);
/**
* The abstract operation ToInt32 converts its argument to one of 2^32
* integer values in the range -2^31 through 2^31-1, inclusive. This
* abstract operation functions as follows:
* <ol>
* <li>Let {@code number} be the result of calling ToNumber on the input
* argument.</li>
* <li>If {@code number} is NaN, +0, -0, positive infinity, or negative
* infinity, return +0.</li>
* <li>Let {@code posInt} be {@code sign(number) * floor(abs(number))}.</li>
* <li>Let {@code int32bit} be {@code posInt modulo 2^ 32}; that is, a
* finite integer value k of Number type with positive sign and less than
* 2^32 in magnitude such that the mathematical difference of posInt and k
* is mathematically an integer multiple of 2^32.</li>
* <li>If {@code int32bit} is greater than or equal to 2^31, return
* {@code int32bit - 2^32}, otherwise return {@code int32bit}.</li>
* </ol>
* <em>NOTE Given the above definition of {@code ToInt32}:</em>
* <ul>
* <li>The ToInt32 abstract operation is idempotent: if applied to a result
* that it produced, the second application leaves that value unchanged.</li>
* <li>ToInt32(ToUint32(x)) is equal to ToInt32(x) for all values of x. (It
* is to preserve this latter property that positive infinity and negative
* infinity are mapped to +0.)</li>
* <li>ToInt32 maps -0 to +0.</li>
* </ul>
*
* @param number IEEE number.
* @return 32-bit integer.
*/
public static int toInt32(final double number)
{
final long int32bit = toUInt32(number);
if (int32bit >= TWO_TO_THE_31ST)
return (int)(int32bit - TWO_TO_THE_32ND);
else
return (int)int32bit;
}
public static int toInt32(final Number number)
{
return toInt32(number.doubleValue());
}
public static int toInt32(final Object value)
{
return toInt32(toNumeric(value));
}
/**
* The abstract operation ToUInt32 converts its argument to one of 2^32
* integer values in the range 0 through 2^32-1, inclusive. This abstract
* operation functions as follows:
* <ol>
* <li>Let {@code number} be the result of calling ToNumber on the input
* argument.</li>
* <li>If {@code number} is NaN, +0, -0, positive infinity, or negative
* infinity, return +0.</li>
* <li>Let {@code posInt} be {@code sign(number) x floor(abs(number))}.</li>
* <li>Let {@code int32bit} be {@code posInt modulo 2^ 32}; that is, a
* finite integer value k of Number type with positive sign and less than
* 2^32 in magnitude such that the mathematical difference of posInt and k
* is mathematically an integer multiple of 2^32.</li>
* <li>Return {@code int32bit}.</li>
* </ol>
* <em>NOTE Given the above definition of {@code ToInt32}:</em>
* <ul>
* <li>Step 5 is the only difference between {@link #toUInt32(double)} and
* {@link #toInt32(double)}.</li>
* <li>The ToUint32 abstract operation is idempotent: if applied to a result
* that it produced, the second application leaves that value unchanged.</li>
* <li>ToUint32 maps -0 to +0.</li>
* </ul>
*
* @param number IEEE number.
* @return 32-bit unsigned integer.
*/
public static long toUInt32(final double number)
{
final double posInt = toInteger(number);
final double int32bit = posInt % TWO_TO_THE_32ND;
return (long)int32bit & MASK_32_BIT_UINT;
}
/**
* Version of toUInt32 that operates on Number
*/
public static long toUInt32(final Number value)
{
return toUInt32(value.doubleValue());
}
/**
* Version of toUInt32 that operates on Object
*/
public static long toUInt32(final Object value)
{
return toUInt32(toNumeric(value));
}
/**
* The abstract operation ToInteger converts its argument to an integral
* numeric value. This abstract operation functions as follows:
* <ol>
* <li>Let {@code number} be the result of calling ToNumber on the input
* argument.</li>
* <li>If {@code number} is NaN, return +0.</li>
* <li>If {@code number} is +0, -0, positive infinity, or negative infinity,
* return {@code number}.</li>
* <li>Return the result of computing
* {@code sign(number) x floor(abs(number))}.</li>
* </ol>
*
* @param number IEEE number.
* @return ECMA integer stored in a IEEE number.
*/
public static double toInteger(final double number)
{
if (isNan(number) || 0 == number || Double.isInfinite(number))
return 0;
final double posInt = Math.signum(number) * Math.floor(Math.abs(number));
return posInt;
}
/**
* Converts "anything" to boolean using ECMA algorithm
*
* @param <T> - Number or String
*/
public static <T> boolean toBoolean(T value)
{
assert value != null : "to pass null use ABCConstants.NULL_VALUE";
if (value == ABCConstants.NULL_VALUE) // ECMA: null is always false
return false;
if (value == ABCConstants.UNDEFINED_VALUE) // ECMA: undefined is always false
return false;
if (value instanceof Number)
return toBoolean((Number)value);
if (value instanceof String)
return toBoolean((String)value);
if (value instanceof Boolean)
return (Boolean)value;
return true; // ECMA: non-null object is true
}
/**
* Converts a Number to boolean using ECMA algorithm The following rules
* apply:
* <ol>
* <li>If number is zero, return false</li>
* <li>If number is Nan, return false</li>
* <li>Otherwise, return true</li>
* </ol>
*/
public static boolean toBoolean(Number value)
{
if(isNan(value.doubleValue()) )
return false;
return value.doubleValue() != 0; // works for all number types, because even if there is
// rounding, != 0 will still be correct
}
/**
* Converts a String to boolean using ECMA algorithm The following rules
* apply:
* <ol>
* <li>If value is empty, return false</li>
* <li>Otherwise, return true</li>
* </ol>
*/
public static boolean toBoolean(String value)
{
return !value.isEmpty();
}
/**
* Determines is a specific floating poing number is Nan
*/
public static boolean isNan(final double number)
{
return Double.isNaN(number); // Luckily ECMA uses the standard IEEE conventions for NaN
}
/**
* The Left Shift Operator ( << ) performs a bitwise left shift operation on
* the left operand by the amount specified by the right operand. The
* production
* {@code ShiftExpression : ShiftExpression << AdditiveExpression} is
* evaluated as follows:
* <ol>
* <li>Let lref be the result of evaluating ShiftExpression.</li>
* <li>Let lval be GetValue(lref).</li>
* <li>Let rref be the result of evaluating AdditiveExpression.</li>
* <li>Let rval be GetValue(rref).</li>
* <li>Let lnum be ToInt32(lval).</li>
* <li>Let rnum be ToUint32(rval).</li>
* <li>Let shiftCount be the result of masking out all but the least
* significant 5 bits of rnum, that is, compute rnum & 0x1F.</li>
* <li>Return the result of left shifting lnum by shiftCount bits. The
* result is a signed 32-bit integer.</li>
* </ol>
*
* @param left Value of the left operand.
* @param right Value of the right operand.
* @return 32-bit signed integer.
*/
public static int leftShiftOperation(final Number left, final Number right)
{
final double lval = left.doubleValue();
final double rval = right.doubleValue();
final int lnum = toInt32(lval);
final long rnum = toUInt32(rval);
final long shiftCount = rnum & 0x1F;
return lnum << shiftCount;
}
/**
* Performs a sign-filling bitwise right shift operation on the left operand
* by the amount specified by the right operand. The production
* {@code ShiftExpression : ShiftExpression >> AdditiveExpression} is
* evaluated as follows:
* <ol>
* <li>Let lref be the result of evaluating ShiftExpression.</li>
* <li>Let lval be GetValue(lref).</li>
* <li>Let rref be the result of evaluating AdditiveExpression.</li>
* <li>Let rval be GetValue(rref).</li>
* <li>Let lnum be ToInt32(lval).</li>
* <li>Let rnum be ToUint32(rval).</li>
* <li>Let shiftCount be the result of masking out all but the least
* significant 5 bits of rnum, that is, compute rnum & 0x1F.</li>
* <li>Return the result of performing a sign-extending right shift of lnum
* by shiftCount bits. The most significant bit is propagated. The result is
* a signed 32-bit integer.</li>
* </ol>
*
* @param left Value of the left operand.
* @param right Value of the right operand.
* @return 32-bit signed integer.
*/
public static int signedRightShiftOperation(final Number left, final Number right)
{
final double lval = left.doubleValue();
final double rval = right.doubleValue();
final int lnum = toInt32(lval);
final long rnum = toUInt32(rval);
final long shiftCount = rnum & 0x1F;
return lnum >> shiftCount;
}
/**
* Performs a zero-filling bitwise right shift operation on the left operand
* by the amount specified by the right operand. The production
* {@code ShiftExpression : ShiftExpression >>> AdditiveExpression} is
* evaluated as follows:
* <ol>
* <li>Let lref be the result of evaluating ShiftExpression.</li>
* <li>Let lval be GetValue(lref).</li>
* <li>Let rref be the result of evaluating AdditiveExpression.</li>
* <li>Let rval be GetValue(rref).</li>
* <li>Let lnum be ToUInt32(lval).</li>
* <li>Let rnum be ToUint32(rval).</li>
* <li>Let shiftCount be the result of masking out all but the least
* significant 5 bits of rnum, that is, compute rnum & 0x1F.</li>
* <li>Return the result of performing a zero-filling right shift of lnum by
* shiftCount bits. Vacated bits are filled with zero. The result is an
* unsigned 32-bit integer.</li>
* </ol>
*
* @param left Value of the left operand.
* @param right Value of the right operand.
* @return 32-bit unsigned integer.
*/
public static long unsignedRightShiftOperation(final Number left, final Number right)
{
final double lval = left.doubleValue();
final double rval = right.doubleValue();
final long lnum = toUInt32(lval);
final long rnum = toUInt32(rval);
final long shiftCount = rnum & 0x1F;
return lnum >>> shiftCount;
}
/**
* Performs the logical and (&&) operation on two objects. The production
* {@code LogicalANDExpression : LogicalANDExpression && BitwiseORExpression}
* is evaluated as follows:
* <ol>
* <li>Let lref be the result of evaluating LogicalANDExpression.</li>
* <li>lval be GetValue(lref).</li>
* <li>If ToBoolean(lval) is false, return lval.</li>
* <li>Let rref be the result of evaluating BitwiseORExpression.</li>
* <li>Return GetValue(rref).
*
* @param <T> is the numeric type of the operands, and the return type
* @param left Value of the left operand
* @param right Value of the right operand
*/
public static <T> T logicalAnd(T left, T right)
{
boolean b = toBoolean(left);
return b ? right : left;
}
/**
* Performs the logical or (||) operation on two objects. is evaluated as
* follows:
* <ol>
* <li>Let lref be the result of evaluating LogicalANDExpression.</li>
* <li>lval be GetValue(lref).</li>
* <li>If ToBoolean(lval) is true, return lval.</li>
* <li>Let rref be the result of evaluating BitwiseORExpression.</li>
* <li>Return GetValue(rref).
*
* @param <T> is the numeric type of the operands, and the return type
* @param left Value of the left operand
* @param right Value of the right operand
*/
public static <T> T logicalOr(T left, T right)
{
boolean b = toBoolean(left);
return b ? left : right;
}
/**
* Perform the logical not (!) operation on an object As per the ECMA spec
* this is done as follows
* <ol>
* <li>Let expr be the result of evaluating UnaryExpression</li>
* <li>Let oldValue be ToBoolean(GetValue(expr)).</li>
* <li>If oldValue is true, return false.</li>
* <li>Return true.</li>
* </ol>
*
* @param <T> is the numeric type of the operand
* @param e is the operand
*/
public static <T> boolean logicalNot(T e)
{
return !toBoolean(e);
}
/**
* Implement the ECMA ToNumber (ECMA 262, 3rd Edition section 9.3) algorithm. This will convert any value
* into a numeric value..
*
* @param value the value to convert
* @return the numeric representation of the value, as specified by the ToNumber algorithm
*/
public static <T> Number toNumeric(T value)
{
if( value == ABCConstants.UNDEFINED_VALUE )
return Double.NaN;
if( value == ABCConstants.NULL_VALUE )
return 0;
if( value instanceof Number )
return (Number)value;
if( value instanceof Boolean )
return toNumeric((Boolean) value);
if( value instanceof String )
return toNumeric((String) value);
return null;
}
/**
* Implement ToNumber for boolean values - ECMA 262, 3rd edition section 9.3
*/
private static int toNumeric (Boolean value)
{
return ((Boolean)value).booleanValue() ? 1 : 0;
}
/**
* trim according to ECMA - will get rid of escaped unicode characters
* that java's trim does not remove
*
* For use when converting Strings -> Number
*/
private static String numberTrim(String str) {
StringBuilder buf = new StringBuilder();
for (int i=0; i<str.length(); i++) {
Character c = str.charAt(i);
if (Character.isWhitespace(c)) {
continue;
}
buf.append(c);
}
str = new String(buf);
buf = new StringBuilder();
for (int i=str.length()-1; i>=0; i--) {
Character c = str.charAt(i);
if (Character.isWhitespace(c)) {
continue;
}
buf.append(c);
}
str = new String(buf.reverse());
return str;
}
/**
* Implement ToNumber for string values - ECMA 262, 3rd edition section 9.3.1
*/
private static Number toNumeric(String str )
{
double sign[] = new double[1];
str = numberTrim(str);
str = numberSign(str, sign);
double num;
if (str.equals("")) {
num = 0;
}
else
if (str.equals("Infinity")) {
if (sign[0] > 0) {
num = Double.POSITIVE_INFINITY;
}
else {
num = Double.NEGATIVE_INFINITY;
}
}
else
if (str.equals("NaN")) {
num = Double.NaN;
}
else if (str.startsWith("0x") || str.startsWith("0X")) {
try {
num = sign[0] * Long.valueOf(str.substring(2), 16);
}
catch (NumberFormatException e) {
num = Double.NaN;
}
}
else {
if (!Character.isDigit(str.charAt(str.length()-1)) && str.charAt(str.length()-1) != '.') { // localization?
num = Double.NaN; // "1f" "1F" "1d" "1D" are all NaN in AS3
}
else {
try {
num = sign[0] * Double.valueOf(str);
}
catch (NumberFormatException e) {
num = Double.NaN;
}
}
}
return num;
}
/**
* Helper method for converting strings to numbers - strips off any leaving '-' or '+' characters
* and determines what the sign of the number should be
*/
private static String numberSign(String str, double[] num) {
if(str.length() == 0) {
num[0] = +1;
}
else
if (str.equals("-") || str.equals("+")) {
num[0] = 0; // leave it alone, to produce NaN later
}
else
if(str.startsWith("-")) {
num[0] = -1;
str = str.substring(1);
}
else
if(str.startsWith("+")) {
num[0] = +1;
str = str.substring(1);
}
else {
num[0] = +1;
}
return str;
}
/**
* Implement equality of numbers - see ECMA 262 3d Edition, section 11.9.3
* @param l the left number
* @param r the right number
* @return true if the numbers are equal according to the ECMA spec
*/
public static boolean equals(Number l, Number r)
{
// NaN is not equal to anything, not even itself
double lDouble = l.doubleValue();
if( Double.isNaN(lDouble) )
return false;
return lDouble == r.doubleValue();
}
/**
* Implement equality of strings - see ECMA 262 3d Edition, section 11.9.3
* @param l the left string
* @param r the right string
* @return true if the strings are equal according to the ECMA spec
*/
public static boolean equals(String l, String r)
{
return l.equals(r);
}
/**
* Implement equality of booleans - see ECMA 262 3d Edition, section 11.9.3
* @param l the left boolean
* @param r the right boolean
* @return true if the booleans are equal according to the ECMA spec
*/
public static boolean equals(Boolean l, Boolean r)
{
return l.equals(r);
}
/**
* Implement the Abstract Equality Comparison algorithm - see ECMA 262 3d Edition, section 11.9.3
* @param l the left value
* @param r the right value
* @return true if the value are equal according to the ECMA spec
*/
public static boolean equals(Object l, Object r)
{
ECMAType leftType = getType(l);
ECMAType rightType = getType(r);
if( leftType == rightType)
{
switch (leftType)
{
case Boolean:
return equals((Boolean)l, (Boolean)r);
case Number:
return equals((Number)l, (Number)r);
case String:
return equals((String)l, (String)r);
case Null:
return true;
case Undefined:
return true;
}
}
if( l == r )
return true;
switch (leftType)
{
case Boolean:
return equals(toNumeric((Boolean)l), r);
case Number:
if( rightType == ECMAType.String )
return equals((Number)l, toNumeric((String)r));
break;
case String:
if( rightType == ECMAType.Number )
return equals(toNumeric((String)l), (Number)r);
break;
case Null:
if( rightType == ECMAType.Undefined )
return true;
break;
case Undefined:
if( rightType == ECMAType.Null )
return true;
break;
}
if( rightType == ECMAType.Boolean )
return equals(l, toNumeric((Boolean)r));
return false;
}
/**
* Implement the strict equality comparison algorithm - see ECMA 262 3d Edition, section 11.9.6
*
* Used for '===', '!==', etc.
*
* @param l the left value
* @param r the right value
* @return true if the values are equal according to the ECMA spec
*/
public static boolean strictEquals(Object l, Object r)
{
ECMAType leftType = getType(l);
ECMAType rightType = getType(r);
if( leftType == rightType)
{
switch (leftType)
{
case Boolean:
return equals((Boolean)l, (Boolean)r);
case Number:
return equals((Number)l, (Number)r);
case String:
return equals((String)l, (String)r);
case Null:
return true;
case Undefined:
return true;
}
}
return false;
}
/**
* Helper method for the comparison methods - return an enum representing the type
* of the value to avoid lots of if( instanceof ) checking.
*/
private static ECMAType getType(Object o)
{
if( o instanceof String )
return ECMAType.String;
if( o instanceof Number )
return ECMAType.Number;
if( o instanceof Boolean )
return ECMAType.Boolean;
if( o == ABCConstants.NULL_VALUE )
return ECMAType.Null;
if( o == ABCConstants.UNDEFINED_VALUE )
return ECMAType.Undefined;
assert false : "unknown constant type";
return null;
}
/**
* Enum to represent the various ECMA types we may be folding
*/
private static enum ECMAType
{
Boolean,
Number,
String,
Null,
Undefined
}
/**
* Implement the abstract relational comparison algorithm - see ECMA 262 3rd edition, section 11.8.5
*
* less than, greater than, etc are implement in terms of this algorithm
* @param l the first value to compare
* @param r the second value to compare
* @return true, false, or java null (which means at least one operand was NaN)
*/
private static Boolean relationalCompare(Object l, Object r)
{
ECMAType lType = getType(l);
ECMAType rType = getType(r);
if (lType == ECMAType.String && rType == ECMAType.String )
return relationalCompare((String)l, (String)r);
return relationalCompare(toNumeric(l), toNumeric(r));
}
/**
* Specialized relational compare method for String.
*/
private static Boolean relationalCompare(String l, String r)
{
if( l.compareTo(r) < 0 )
return true;
return false;
}
/**
* Specialized relational compare method for Numbers.
*/
private static Boolean relationalCompare(Number l, Number r)
{
double lVal = l.doubleValue();
double rVal = r.doubleValue();
if( isNan(lVal) || isNan(rVal) )
return null;
return lVal < rVal;
}
/**
* ECMA less-than operator - ECMA 262 3rd edition, section 11.8.1
*/
public static boolean lessThan(Number l, Number r)
{
Boolean res = relationalCompare(l, r);
if( res == null )
return false;
return res;
}
/**
* ECMA less-than operator - ECMA 262 3rd edition, section 11.8.1
*/
public static boolean lessThan(Object l, Object r)
{
Boolean res = relationalCompare(l, r);
if( res == null )
return false;
return res;
}
/**
* ECMA less-than-or-equal operator - ECMA 262 3rd edition, section 11.8.3
*/
public static boolean lessThanEquals(Number l, Number r)
{
Boolean res = relationalCompare(r, l);
if( res == null || res == true )
return false;
return true;
}
/**
* ECMA less-than-or-equal operator - ECMA 262 3rd edition, section 11.8.3
*/
public static boolean lessThanEquals(Object l, Object r)
{
Boolean res = relationalCompare(r, l);
if( res == null || res == true)
return false;
return true;
}
/**
* ECMA greater-than - ECMA 262 3rd edition, section 11.8.2
*/
public static boolean greaterThan(Number l, Number r)
{
Boolean res = relationalCompare(r, l);
if( res == null )
return false;
return res;
}
/**
* ECMA greater-than - ECMA 262 3rd edition, section 11.8.2
*/
public static boolean greaterThan(Object l, Object r)
{
Boolean res = relationalCompare(r, l);
if( res == null )
return false;
return res;
}
/**
* ECMA greater-than-or-equal operator - ECMA 262 3rd edition, section 11.8.4
*/
public static boolean greaterThanEquals(Number l, Number r)
{
Boolean res = relationalCompare(l, r);
if( res == null || res == true )
return false;
return true;
}
/**
* ECMA greater-than-or-equal operator - ECMA 262 3rd edition, section 11.8.4
*/
public static boolean greaterThanEquals(Object l, Object r)
{
Boolean res = relationalCompare(l, r);
if( res == null || res == true)
return false;
return true;
}
/**
* Implement the ECMA ToString algorithm - ECMA 262 3rd edition, section 9.8
* @param o the value to convert to a String
* @return the String representation of the value
*/
public static String toString(Object o)
{
if( o instanceof String )
return (String)o;
if( o instanceof Double )
return toString((Double) o);
if( o instanceof Integer )
return toString((Integer)o);
if( o instanceof Long )
return toString((Long)o);
if( o instanceof Boolean )
return toString((Boolean)o);
if( o == ABCConstants.NULL_VALUE )
return "null";
if( o == ABCConstants.UNDEFINED_VALUE )
return "undefined";
return null;
}
/**
* Implement the ECMA ToString algorithm - ECMA 262 3rd edition, section 9.8.1
*/
public static String toString(Double d)
{
String str = "";
if (d.isNaN() || d.isInfinite()) {
str = "" + d;
}
else {
// machinations for getting formatting to match AVM
BigDecimal bd = new BigDecimal(d.doubleValue()).round(MathContext.DECIMAL64).stripTrailingZeros();
// BigDecimal bd = new BigDecimal(d.doubleValue()).round(new MathContext(15asc , RoundingMode.DOWN)).stripTrailingZeros();
//out.println("dval="+dval+" bd="+bd+" scale="+bd.scale()+" prec="+bd.precision());
if (bd.scale() < 0 && bd.scale() > -21) {
bd = bd.setScale(0);
}
str = "" + bd;
str = str.replaceFirst("E", "e");
}
return str;
}
/**
* Specialized toString for ints - ECMA 262 3rd edition, section 9.8.1
*/
public static String toString(Integer i)
{
return "" + new BigDecimal(i);
}
/**
* Specialized toString for uint's - ECMA 262 3rd edition, section 9.8.1
*/
public static String toString(Long i)
{
return "" + new BigDecimal(i);
}
/**
* Specialized toString for booleans - ECMA 262 3rd edition, section 9.8
*/
public static String toString(Boolean b)
{
if( b.booleanValue() )
return "true";
return "false";
}
}