ECMASupport (Apache Flex - FlexJS: Compiler: Parent 0.8.0-SNAPSHOT API)

java.lang.Object
- org.apache.flex.abc.semantics.ECMASupport

```
public class ECMASupport
extends Object
```
Provides helper functions for for various operations as specified by ECMA.

See Also:
ECMA 262 spec

Constructor Summary

Constructors
Constructor and Description

ECMASupport()

Constructors
Constructor and Description
`ECMASupport()`

Method Summary

Methods
Modifier and Type	Method and Description
`static boolean`	`equals(Boolean l, Boolean r)` Implement equality of booleans - see ECMA 262 3d Edition, section 11.9.3
`static boolean`	`equals(Number l, Number r)` Implement equality of numbers - see ECMA 262 3d Edition, section 11.9.3
`static boolean`	`equals(Object l, Object r)` Implement the Abstract Equality Comparison algorithm - see ECMA 262 3d Edition, section 11.9.3
`static boolean`	`equals(String l, String r)` Implement equality of strings - see ECMA 262 3d Edition, section 11.9.3
`static boolean`	`greaterThan(Number l, Number r)` ECMA greater-than - ECMA 262 3rd edition, section 11.8.2
`static boolean`	`greaterThan(Object l, Object r)` ECMA greater-than - ECMA 262 3rd edition, section 11.8.2
`static boolean`	`greaterThanEquals(Number l, Number r)` ECMA greater-than-or-equal operator - ECMA 262 3rd edition, section 11.8.4
`static boolean`	`greaterThanEquals(Object l, Object r)` ECMA greater-than-or-equal operator - ECMA 262 3rd edition, section 11.8.4
`static boolean`	`isNan(double number)` Determines is a specific floating poing number is Nan
`static int`	`leftShiftOperation(Number left, Number right)` The Left Shift Operator ( << ) performs a bitwise left shift operation on the left operand by the amount specified by the right operand.
`static boolean`	`lessThan(Number l, Number r)` ECMA less-than operator - ECMA 262 3rd edition, section 11.8.1
`static boolean`	`lessThan(Object l, Object r)` ECMA less-than operator - ECMA 262 3rd edition, section 11.8.1
`static boolean`	`lessThanEquals(Number l, Number r)` ECMA less-than-or-equal operator - ECMA 262 3rd edition, section 11.8.3
`static boolean`	`lessThanEquals(Object l, Object r)` ECMA less-than-or-equal operator - ECMA 262 3rd edition, section 11.8.3
`static <T> T`	`logicalAnd(T left, T right)` Performs the logical and (&&) operation on two objects.
`static <T> boolean`	`logicalNot(T e)` Perform the logical not (!)
`static <T> T`	`logicalOr(T left, T right)` Performs the logical or (\|\|) operation on two objects. is evaluated as follows: Let lref be the result of evaluating LogicalANDExpression.
`static int`	`signedRightShiftOperation(Number left, Number right)` Performs a sign-filling bitwise right shift operation on the left operand by the amount specified by the right operand.
`static boolean`	`strictEquals(Object l, Object r)` Implement the strict equality comparison algorithm - see ECMA 262 3d Edition, section 11.9.6 Used for '===', '!
`static boolean`	`toBoolean(Number value)` Converts a Number to boolean using ECMA algorithm The following rules apply: If number is zero, return false If number is Nan, return false Otherwise, return true
`static boolean`	`toBoolean(String value)` Converts a String to boolean using ECMA algorithm The following rules apply: If value is empty, return false Otherwise, return true
`static <T> boolean`	`toBoolean(T value)` Converts "anything" to boolean using ECMA algorithm
`static int`	`toInt32(double number)` The abstract operation ToInt32 converts its argument to one of 2^32 integer values in the range -2^31 through 2^31-1, inclusive.
`static int`	`toInt32(Number number)`
`static int`	`toInt32(Object value)`
`static double`	`toInteger(double number)` The abstract operation ToInteger converts its argument to an integral numeric value.
`static <T> Number`	`toNumeric(T value)` Implement the ECMA ToNumber (ECMA 262, 3rd Edition section 9.3) algorithm.
`static String`	`toString(Boolean b)` Specialized toString for booleans - ECMA 262 3rd edition, section 9.8
`static String`	`toString(Double d)` Implement the ECMA ToString algorithm - ECMA 262 3rd edition, section 9.8.1
`static String`	`toString(Integer i)` Specialized toString for ints - ECMA 262 3rd edition, section 9.8.1
`static String`	`toString(Long i)` Specialized toString for uint's - ECMA 262 3rd edition, section 9.8.1
`static String`	`toString(Object o)` Implement the ECMA ToString algorithm - ECMA 262 3rd edition, section 9.8
`static long`	`toUInt32(double number)` The abstract operation ToUInt32 converts its argument to one of 2^32 integer values in the range 0 through 2^32-1, inclusive.
`static long`	`toUInt32(Number value)` Version of toUInt32 that operates on Number
`static long`	`toUInt32(Object value)` Version of toUInt32 that operates on Object
`static long`	`unsignedRightShiftOperation(Number left, Number right)` Performs a zero-filling bitwise right shift operation on the left operand by the amount specified by the right operand.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ECMASupport
```
public ECMASupport()
```
- Method Detail
  - toInt32
```
public static int toInt32(double number)
```
    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:
    1. Let number be the result of calling ToNumber on the input argument.
    2. If number is NaN, +0, -0, positive infinity, or negative infinity, return +0.
    3. Let posInt be sign(number) * floor(abs(number)).
    4. Let int32bit be 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.
    5. If int32bit is greater than or equal to 2^31, return int32bit - 2^32, otherwise return int32bit.
    NOTE Given the above definition of ToInt32:
    - The ToInt32 abstract operation is idempotent: if applied to a result that it produced, the second application leaves that value unchanged.
    - 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.)
    - ToInt32 maps -0 to +0.
    Parameters:
    number - IEEE number.
    
    Returns:
    32-bit integer.
  - toInt32
```
public static int toInt32(Number number)
```
  - toInt32
```
public static int toInt32(Object value)
```
  - toUInt32
```
public static long toUInt32(double number)
```
    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:
    1. Let number be the result of calling ToNumber on the input argument.
    2. If number is NaN, +0, -0, positive infinity, or negative infinity, return +0.
    3. Let posInt be sign(number) x floor(abs(number)).
    4. Let int32bit be 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.
    5. Return int32bit.
    NOTE Given the above definition of ToInt32:
    - Step 5 is the only difference between toUInt32(double) and toInt32(double).
    - The ToUint32 abstract operation is idempotent: if applied to a result that it produced, the second application leaves that value unchanged.
    - ToUint32 maps -0 to +0.
    Parameters:
    number - IEEE number.
    
    Returns:
    32-bit unsigned integer.
  - toUInt32
```
public static long toUInt32(Number value)
```
    Version of toUInt32 that operates on Number
  - toUInt32
```
public static long toUInt32(Object value)
```
    Version of toUInt32 that operates on Object
  - toInteger
```
public static double toInteger(double number)
```
    The abstract operation ToInteger converts its argument to an integral numeric value. This abstract operation functions as follows:
    1. Let number be the result of calling ToNumber on the input argument.
    2. If number is NaN, return +0.
    3. If number is +0, -0, positive infinity, or negative infinity, return number.
    4. Return the result of computing sign(number) x floor(abs(number)).
    Parameters:
    number - IEEE number.
    
    Returns:
    ECMA integer stored in a IEEE number.
  - toBoolean
```
public static <T> boolean toBoolean(T value)
```
    Converts "anything" to boolean using ECMA algorithm
    
    Type Parameters:
    T - - Number or String
  - toBoolean
```
public static boolean toBoolean(Number value)
```
    Converts a Number to boolean using ECMA algorithm The following rules apply:
    1. If number is zero, return false
    2. If number is Nan, return false
    3. Otherwise, return true
  - toBoolean
```
public static boolean toBoolean(String value)
```
    Converts a String to boolean using ECMA algorithm The following rules apply:
    1. If value is empty, return false
    2. Otherwise, return true
  - isNan
```
public static boolean isNan(double number)
```
    Determines is a specific floating poing number is Nan
  - leftShiftOperation
```
public static int leftShiftOperation(Number left,
                     Number right)
```
    The Left Shift Operator ( << ) performs a bitwise left shift operation on the left operand by the amount specified by the right operand. The production ShiftExpression : ShiftExpression << AdditiveExpression is evaluated as follows:
    1. Let lref be the result of evaluating ShiftExpression.
    2. Let lval be GetValue(lref).
    3. Let rref be the result of evaluating AdditiveExpression.
    4. Let rval be GetValue(rref).
    5. Let lnum be ToInt32(lval).
    6. Let rnum be ToUint32(rval).
    7. Let shiftCount be the result of masking out all but the least significant 5 bits of rnum, that is, compute rnum & 0x1F.
    8. Return the result of left shifting lnum by shiftCount bits. The result is a signed 32-bit integer.
    Parameters:
    left - Value of the left operand.
    right - Value of the right operand.
    
    Returns:
    32-bit signed integer.
  - signedRightShiftOperation
```
public static int signedRightShiftOperation(Number left,
                            Number right)
```
    Performs a sign-filling bitwise right shift operation on the left operand by the amount specified by the right operand. The production ShiftExpression : ShiftExpression >> AdditiveExpression is evaluated as follows:
    1. Let lref be the result of evaluating ShiftExpression.
    2. Let lval be GetValue(lref).
    3. Let rref be the result of evaluating AdditiveExpression.
    4. Let rval be GetValue(rref).
    5. Let lnum be ToInt32(lval).
    6. Let rnum be ToUint32(rval).
    7. Let shiftCount be the result of masking out all but the least significant 5 bits of rnum, that is, compute rnum & 0x1F.
    8. 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.
    Parameters:
    left - Value of the left operand.
    right - Value of the right operand.
    
    Returns:
    32-bit signed integer.
  - unsignedRightShiftOperation
```
public static long unsignedRightShiftOperation(Number left,
                               Number right)
```
    Performs a zero-filling bitwise right shift operation on the left operand by the amount specified by the right operand. The production ShiftExpression : ShiftExpression >>> AdditiveExpression is evaluated as follows:
    1. Let lref be the result of evaluating ShiftExpression.
    2. Let lval be GetValue(lref).
    3. Let rref be the result of evaluating AdditiveExpression.
    4. Let rval be GetValue(rref).
    5. Let lnum be ToUInt32(lval).
    6. Let rnum be ToUint32(rval).
    7. Let shiftCount be the result of masking out all but the least significant 5 bits of rnum, that is, compute rnum & 0x1F.
    8. 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.
    Parameters:
    left - Value of the left operand.
    right - Value of the right operand.
    
    Returns:
    32-bit unsigned integer.
  - logicalAnd
```
public static <T> T logicalAnd(T left,
               T right)
```
    Performs the logical and (&&) operation on two objects. The production LogicalANDExpression : LogicalANDExpression && BitwiseORExpression is evaluated as follows:
    1. Let lref be the result of evaluating LogicalANDExpression.
    2. lval be GetValue(lref).
    3. If ToBoolean(lval) is false, return lval.
    4. Let rref be the result of evaluating BitwiseORExpression.
    5. Return GetValue(rref).
    Type Parameters:
    T - is the numeric type of the operands, and the return type
    Parameters:
    left - Value of the left operand
    right - Value of the right operand
  - logicalOr
```
public static <T> T logicalOr(T left,
              T right)
```
    Performs the logical or (||) operation on two objects. is evaluated as follows:
    1. Let lref be the result of evaluating LogicalANDExpression.
    2. lval be GetValue(lref).
    3. If ToBoolean(lval) is true, return lval.
    4. Let rref be the result of evaluating BitwiseORExpression.
    5. Return GetValue(rref).
    Type Parameters:
    T - is the numeric type of the operands, and the return type
    Parameters:
    left - Value of the left operand
    right - Value of the right operand
  - logicalNot
```
public static <T> boolean logicalNot(T e)
```
    Perform the logical not (!) operation on an object As per the ECMA spec this is done as follows
    1. Let expr be the result of evaluating UnaryExpression
    2. Let oldValue be ToBoolean(GetValue(expr)).
    3. If oldValue is true, return false.
    4. Return true.
    Type Parameters:
    T - is the numeric type of the operand
    Parameters:
    e - is the operand
  - toNumeric
```
public static <T> Number toNumeric(T value)
```
    Implement the ECMA ToNumber (ECMA 262, 3rd Edition section 9.3) algorithm. This will convert any value into a numeric value..
    
    Parameters:
    value - the value to convert
    
    Returns:
    the numeric representation of the value, as specified by the ToNumber algorithm
  - equals
```
public static boolean equals(Number l,
             Number r)
```
    Implement equality of numbers - see ECMA 262 3d Edition, section 11.9.3
    
    Parameters:
    l - the left number
    r - the right number
    
    Returns:
    true if the numbers are equal according to the ECMA spec
  - equals
```
public static boolean equals(String l,
             String r)
```
    Implement equality of strings - see ECMA 262 3d Edition, section 11.9.3
    
    Parameters:
    l - the left string
    r - the right string
    
    Returns:
    true if the strings are equal according to the ECMA spec
  - equals
```
public static boolean equals(Boolean l,
             Boolean r)
```
    Implement equality of booleans - see ECMA 262 3d Edition, section 11.9.3
    
    Parameters:
    l - the left boolean
    r - the right boolean
    
    Returns:
    true if the booleans are equal according to the ECMA spec
  - equals
```
public static boolean equals(Object l,
             Object r)
```
    Implement the Abstract Equality Comparison algorithm - see ECMA 262 3d Edition, section 11.9.3
    
    Parameters:
    l - the left value
    r - the right value
    
    Returns:
    true if the value are equal according to the ECMA spec
  - strictEquals
```
public static boolean strictEquals(Object l,
                   Object r)
```
    Implement the strict equality comparison algorithm - see ECMA 262 3d Edition, section 11.9.6 Used for '===', '!==', etc.
    
    Parameters:
    l - the left value
    r - the right value
    
    Returns:
    true if the values are equal according to the ECMA spec
  - lessThan
```
public static boolean lessThan(Number l,
               Number r)
```
    ECMA less-than operator - ECMA 262 3rd edition, section 11.8.1
  - lessThan
```
public static boolean lessThan(Object l,
               Object r)
```
    ECMA less-than operator - ECMA 262 3rd edition, section 11.8.1
  - lessThanEquals
```
public static boolean lessThanEquals(Number l,
                     Number r)
```
    ECMA less-than-or-equal operator - ECMA 262 3rd edition, section 11.8.3
  - lessThanEquals
```
public static boolean lessThanEquals(Object l,
                     Object r)
```
    ECMA less-than-or-equal operator - ECMA 262 3rd edition, section 11.8.3
  - greaterThan
```
public static boolean greaterThan(Number l,
                  Number r)
```
    ECMA greater-than - ECMA 262 3rd edition, section 11.8.2
  - greaterThan
```
public static boolean greaterThan(Object l,
                  Object r)
```
    ECMA greater-than - ECMA 262 3rd edition, section 11.8.2
  - greaterThanEquals
```
public static boolean greaterThanEquals(Number l,
                        Number r)
```
    ECMA greater-than-or-equal operator - ECMA 262 3rd edition, section 11.8.4
  - greaterThanEquals
```
public static boolean greaterThanEquals(Object l,
                        Object r)
```
    ECMA greater-than-or-equal operator - ECMA 262 3rd edition, section 11.8.4
  - toString
```
public static String toString(Object o)
```
    Implement the ECMA ToString algorithm - ECMA 262 3rd edition, section 9.8
    
    Parameters:
    o - the value to convert to a String
    
    Returns:
    the String representation of the value
  - toString
```
public static String toString(Double d)
```
    Implement the ECMA ToString algorithm - ECMA 262 3rd edition, section 9.8.1
  - toString
```
public static String toString(Integer i)
```
    Specialized toString for ints - ECMA 262 3rd edition, section 9.8.1
  - toString
```
public static String toString(Long i)
```
    Specialized toString for uint's - ECMA 262 3rd edition, section 9.8.1
  - toString
```
public static String toString(Boolean b)
```
    Specialized toString for booleans - ECMA 262 3rd edition, section 9.8

Class ECMASupport

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ECMASupport

Method Detail

toInt32

toInt32

toInt32

toUInt32

toUInt32

toUInt32

toInteger

toBoolean

toBoolean

toBoolean

isNan

leftShiftOperation

signedRightShiftOperation

unsignedRightShiftOperation

logicalAnd

logicalOr

logicalNot

toNumeric

equals

equals

equals

equals

strictEquals

lessThan

lessThan

lessThanEquals

lessThanEquals

greaterThan

greaterThan

greaterThanEquals

greaterThanEquals

toString

toString

toString

toString

toString