Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.dynjs.runtime;
  
  
 
 public class Types {
 
     public static final Undefined UNDEFINED = new Undefined();
     public static final Null NULL = new Null();
 
     public static void checkObjectCoercible(ExecutionContext contextObject o) {
         if (o == .) {
             throw new ThrowException(contextcontext.createTypeError("undefined cannot be coerced to an object"));
         }
 
         if (o == .) {
             throw new ThrowException(contextcontext.createTypeError("null cannot be coerced to an object"));
         }
 
         return;
     }
 
     public static void checkObjectCoercible(ExecutionContext contextObject oString debug) {
         if (o == .) {
             throw new ThrowException(contextcontext.createTypeError("undefined cannot be coerced to an object: " + debug));
         }
 
         if (o == .) {
             throw new ThrowException(contextcontext.createTypeError("null cannot be coerced to an object: " + debug));
         }
 
         return;
     }
 
     public static boolean sameValue(Object leftObject right) {
 
         if (left.getClass() != right.getClass()) {
             return false;
         }
 
         if (left == ) {
             return true;
         }
 
         if (left == ) {
             return true;
         }
 
         return left.equals(right);
     }
 
     public static JSObject toObject(ExecutionContext contextObject o) {
         if (o instanceof JSObject) {
             return (JSObjecto;
         }
         if (o instanceof String) {
             return new DynString(context.getGlobalObject(), (Stringo);
         }
         if (o instanceof Number) {
             return new DynNumber(context.getGlobalObject(), (Numbero);
         }
         if (o instanceof Boolean) {
             return new DynBoolean(context.getGlobalObject(), (Booleano);
         }
         if (o == .) {
             throw new ThrowException(contextcontext.createTypeError("undefined cannot be converted to an object"));
         }
         if (o == .) {
             throw new ThrowException(contextcontext.createTypeError("null cannot be converted to an object"));
         }
         return new PrimitiveDynObject(context.getGlobalObject(), o);
     }
 
     public static Object toThisObject(ExecutionContext contextObject o) {
         if (o instanceof JSObject) {
             return (JSObjecto;
         }
         if (o instanceof String) {
             return new DynString(context.getGlobalObject(), (Stringo);
         }
         if (o instanceof Number) {
             return new DynNumber(context.getGlobalObject(), (Numbero);
         }
         if (o instanceof Boolean) {
             return new DynBoolean(context.getGlobalObject(), (Booleano);
         }
         if (o == .) {
             throw new ThrowException(contextcontext.createTypeError("undefined cannot be converted to an object"));
         }
         if (o == .) {
             throw new ThrowException(contextcontext.createTypeError("null cannot be converted to an object"));
         }
         // return new PrimitiveDynObject(context.getGlobalObject(), o);
         return o;
    }
    public static Object toPrimitive(ExecutionContext contextObject o) {
        return toPrimitive(contextonull);
    }
    public static Object toPrimitive(ExecutionContext contextObject oString preferredType) {
        // 9.1
        if (o instanceof JSObject) {
            return ((JSObjecto).defaultValue(contextpreferredType);
        }
        return o;
    }
    public static Number toNumber(ExecutionContext contextObject o) {
        // 9.3
        if (o instanceof Number) {
            return (Numbero;
        }
        if (o instanceof JSObject) {
            return toNumber(contexttoPrimitive(contexto"Number"));
        }
        if (o == .) {
            return .;
        }
        if (o == .) {
            return 0L;
        }
        if (o instanceof Boolean) {
            if (o == .) {
                return 1L;
            }
            return 0L;
        }
        Number n = stringToNumber(o.toString());
        return n;
    }
    public static String trimString(String value) {
        int len = value.length();
        int st = 0;
        char[] val = value.toCharArray();
        while ((st < len) && (isWhitespace(val[st]))) {
            st++;
        }
        while ((st < len) && (isWhitespace(val[len - 1]))) {
            len--;
        }
        String result = null;
        
        if ( st > 0 || len < value.length() ) {
            result = value.substring(st,len);
        } else {
            result = value;
        }
        return result;
    }
    public static String trimNumericString(String value) {
        char[] val = value.toCharArray();
        StringBuffer newStr = new StringBuffer();
        for (int i = 0; i < val.length; ++i) {
            if (!isWhitespace(val[i])) {
                newStr.append(val[i]);
            }
        }
        return newStr.toString().trim();
    }
    public static boolean isWhitespace(char c) {
        switch (c) {
        case '\n':
        case '\r':
        case '\u0009':
        case '\u000B':
        case '\u000C':
        case '\u0020':
        case '\u00A0':
        case '\u1680':
        case '\u180E':
        case '\u2000':
        case '\u2001':
        case '\u2002':
        case '\u2003':
        case '\u2004':
        case '\u2005':
        case '\u2006':
        case '\u2007':
        case '\u2008':
        case '\u2009':
        case '\u200A':
        case '\u2028':
        case '\u2029':
        case '\u202F':
        case '\u205F':
        case '\u3000':
        case '\uFEFF':
            return true;
        }
        return false;
    }
    public static Number stringToNumber(String str) {
        str = trimNumericString(str);
        if (str.equals("")) {
            return 0L;
        }
        if (str.equals("-0")) {
            return Double.valueOf(-0.0);
        }
        if (str.equals("Infinity") || str.equals("+Infinity")) {
            return Math.pow(10, 10000);
        }
        if (str.equals("-Infinity")) {
            return -Math.pow(10, 10000);
        }
        if (str.startsWith("0x") || str.startsWith("0X")) {
            return Long.decode(str);
        }
        if ((str.indexOf("e") > 0) || (str.indexOf("E") > 0)) {
            if (str.indexOf(".") >= 0) {
                str = str.replaceFirst("[eE]""E");
            } else {
                str = str.replaceFirst("[eE]"".0E");
            }
        }
        try {
            if (str.indexOf(".") >= 0) {
                return Double.valueOf(str);
            } else {
                return Long.valueOf(str);
            }
        } catch (NumberFormatException e) {
            return .;
        }
    }
    public static Boolean toBoolean(Object o) {
        // 9.2
        if (o instanceof Boolean) {
            return (Booleano;
        }
        if (o == . || o == .) {
            return false;
        }
        if (o instanceof Double) {
            if (((Doubleo).isNaN() || ((Doubleo).doubleValue() == 0.0) {
                return false;
            }
            return true;
        }
        if (o instanceof Number) {
            if (((Numbero).intValue() == 0) {
                return false;
            }
            return true;
        }
        if (o instanceof String) {
            return (((Stringo).length() != 0);
        }
        if (o instanceof JSObject) {
            return true;
        }
        return true;
    }
    public static Long toInteger(ExecutionContext contextObject o) {
        Number number = toNumber(contexto);
        if (number instanceof Double) {
            if (((Doublenumber).isNaN()) {
                return 0L;
            }
        }
        return number.longValue();
    }
    public static Long toUint16(ExecutionContext contextObject o) {
        // 9.7
        Number n = toNumber(contexto);
        if (n instanceof Double) {
            if (((Doublen).isInfinite() || ((Doublen).isNaN()) {
                return 0L;
            }
        }
        int posInt = (int) (sign(n) * Math.floor(Math.abs(n.intValue())));
        return modulo(posInt, 65536);
    }
    protected static int sign(Number n) {
        if (n.doubleValue() < 0) {
            return -1;
        }
        return 1;
    }
    public static Long toUint32(ExecutionContext contextObject o) {
        // 9.5
        Number n = toNumber(contexto);
        if (n instanceof Double) {
            if (((Doublen).isInfinite() || ((Doublen).isNaN()) {
                return (long) 0;
            }
        }
        double d = n.doubleValue();
        long posInt = (long) ((sign(d)) * Math.floor(Math.abs(d)));
        long int32bit = modulo(posInt, 4294967296L);
        return (longint32bit;
    }
    public static long modulo(long along b) {
        // because Java modulo doesn't deal with negatives the way the
        // javascript spec assumes it should.
        return (a % b + b) % b;
    }
    public static Long toInt32(ExecutionContext contextObject o) {
        Number number = toNumber(contexto);
        if (Double.isInfinite(number.doubleValue()) || Double.isNaN(number.doubleValue())) {
            return 0L;
        }
        double doubleNum = number.doubleValue();
        long posInt = (long) ((sign(doubleNum)) * Math.floor(Math.abs(doubleNum)));
        long int32bit = modulo(posInt, 4294967296L);
        if (int32bit >= 2147483648L) {
            int32bit = int32bit - 4294967296L;
        }
        return int32bit;
    }
    public static boolean isCallable(Object o) {
        return (o instanceof JSCallable);
    }
    public static boolean isSparse(ExecutionContext contextJSObject o) {
        if (!o.hasProperty(context"length")) {
            return false;
        }
        long len = Types.toUint32(contexto.get(context"length"));
        for (long i = 0; i < len; ++i) {
            if (o.getOwnProperty(context"" + i) == .) {
                return true;
            }
        }
        return false;
    }
    public static Object getValue(ExecutionContext contextObject o) {
        if (o instanceof Reference) {
            return ((Referenceo).getValue(context);
        }
        return o;
    }
    public static String toString(ExecutionContext contextObject o) {
        if (o == .) {
            return "undefined";
        }
        if (o == . || o == null) {
            return "null";
        }
        if (o instanceof JSObject) {
            return (StringtoString(contexttoPrimitive(contexto"String"));
        }
        if (o instanceof Number) {
            if (((Numbero).doubleValue() == -0) {
                return "0";
            }
            String result = Types.rewritePossiblyExponentialValue(o.toString());
            Pattern expPattern = Pattern.compile("^(.*)e([+-])([0-9]+)$");
            Matcher matcher = expPattern.matcher(result);
            if (matcher.matches()) {
                int expValue = Integer.parseInt(matcher.group(3));
                if (matcher.group(2).equals("+")) {
                    if (expValue <= 20) {
                        StringBuffer newResult = new StringBuffer().append(matcher.group(1));
                        for (int i = 0; i < expValue; ++i) {
                            newResult.append("0");
                        }
                        result = newResult.toString();
                    }
                } else {
                    if (expValue <= 6) {
                        StringBuffer newResult = new StringBuffer().append("0.");
                        for (int i = 0; i < (expValue - 1); ++i) {
                            newResult.append(0);
                        }
                        String digits = matcher.group(1);
                        if (digits.startsWith("-")) {
                            newResult.append(digits.substring(1));
                            newResult.insert(0, "-");
                        } else {
                            newResult.append(digits);
                        }
                        result = newResult.toString();
                    }
                }
            }
            return result;
        }
        return o.toString();
    }
    public static String typeof(ExecutionContext contextObject o) {
        // 11.4.3
        Object val = o;
        if (o instanceof Reference) {
            Reference r = (Referenceo;
            if (r.isUnresolvableReference()) {
                return "undefined";
            }
            val = getValue(contexto);
        }
        return type(val);
    }
    public static Object compareRelational(ExecutionContext contextObject x,
            Object yboolean leftFirst) {
        // 11.8.5
        Object px = null;
        Object py = null;
        if (leftFirst) {
            px = toPrimitive(contextx"Number");
            py = toPrimitive(contexty"Number");
        } else {
            py = toPrimitive(contexty"Number");
            px = toPrimitive(contextx"Number");
        }
        if (px instanceof String && py instanceof String) {
            String sx = (Stringpx;
            String sy = (Stringpy;
            if (sx.compareTo(sy) < 0) {
                return true;
            }
            return false;
        } else {
            Number nx = toNumber(contextpx);
            Number ny = toNumber(contextpy);
            if (Double.isNaN(nx.doubleValue()) || Double.isNaN(ny.doubleValue())) {
                return .;
            }
            if (nx.equals(ny)) {
                return false;
            }
            if (nx.doubleValue() == .) {
                return false;
            }
            if (ny.doubleValue() == .) {
                return true;
            }
            if (ny.doubleValue() == .) {
                return false;
            }
            if (nx.doubleValue() == .) {
                return true;
            }
            if (nx.doubleValue() < ny.doubleValue()) {
                return true;
            }
            return false;
        }
    }
    public static boolean compareEquality(ExecutionContext contextObject lhsObject rhs) {
        // 11.9.3
        if (lhs.getClass().equals(rhs.getClass()) || (lhs instanceof Number && rhs instanceof Number)) {
            if (lhs == .) {
                return true;
            }
            if (lhs == .) {
                return true;
            }
            if (lhs instanceof Number) {
                if (lhs instanceof Double) {
                    if (((Doublelhs).isNaN()) {
                        return false;
                    }
                }
                if (rhs instanceof Double) {
                    if (((Doublerhs).isNaN()) {
                        return false;
                    }
                }
                if (((Numberlhs).doubleValue() == ((Numberrhs)
                        .doubleValue()) {
                    return true;
                }
                return false;
            }
            if (lhs instanceof String || lhs instanceof Boolean) {
                return lhs.equals(rhs);
            }
            if (lhs == rhs) {
                return true;
            }
        }
        if (lhs == . && rhs == .) {
            return true;
        }
        if (lhs == . && rhs == .) {
            return true;
        }
        if (lhs instanceof Number && rhs instanceof String) {
            return compareEquality(contextlhstoNumber(contextrhs));
        }
        if (lhs instanceof String && rhs instanceof Number) {
            return compareEquality(contexttoNumber(contextlhs), rhs);
        }
        if (lhs instanceof Boolean) {
            return compareEquality(contexttoNumber(contextlhs), rhs);
        }
        if (rhs instanceof Boolean) {
            return compareEquality(contextlhstoNumber(contextrhs));
        }
        if ((lhs instanceof String || lhs instanceof Number) && rhs instanceof JSObject) {
            return compareEquality(contextlhstoPrimitive(contextrhs));
        }
        if (lhs instanceof JSObject && (rhs instanceof String || rhs instanceof Number)) {
            return compareEquality(contexttoPrimitive(contextlhs), rhs);
        }
        return false;
    }
    public static boolean compareStrictEquality(ExecutionContext contextObject lhsObject rhs) {
        // 11.9.6
        
        //System.err.println( "lhs: " + lhs.getClass() + " // " + lhs );
        //System.err.println( "rhs: " + rhs.getClass() + " // " + rhs );
        //System.err.println( "lhs: " + System.identityHashCode(lhs));
        //System.err.println( "rhs: " + System.identityHashCode(rhs));
        if (!lhs.getClass().equals(rhs.getClass())
                // Allow comparison of Doubles and Longs (because 0 === -0 in Javascript
                // go figure
                && !(lhs instanceof Number && rhs instanceof Number)) {
            return false;
        }
        if (lhs == ) {
            return true;
        }
        if (lhs == ) {
            return true;
        }
        if (lhs instanceof Number) {
            if (((Numberlhs).doubleValue() == .) {
                return false;
            }
            if (rhs instanceof Number
                    && ((Numberrhs).doubleValue() == .) {
                return false;
            }
            return ((Numberlhs).doubleValue() == ((Numberrhs).doubleValue();
        }
        if (lhs instanceof String || lhs instanceof Boolean) {
            return lhs.equals(rhs);
        }
        
        //System.err.println( "identity: " + ( lhs == rhs ));
        return lhs == rhs;
    }
    public static String type(Object o) {
        // 11.4.3
        if (o == ) {
            return "undefined";
        }
        if (o == ) {
            return "object";
        }
        if (o instanceof Boolean) {
            return "boolean";
        }
        if (o instanceof Number) {
            return "number";
        }
        if (o instanceof JSFunction) {
            return "function";
        }
        if (o instanceof JSObject) {
            return "object";
        }
        if (o instanceof String) {
            return "string";
        }
        return o.getClass().getName();
    }
    // ----------------------------------------------------------------------
    public static class Undefined {
        private Undefined() {
        }
        public String typeof() {
            return "undefined";
        }
        @Override
        public String toString() {
            return "undefined";
        }
    }
    public static class Null {
        private Null() {
        }
        public String typeof() {
            return "object";
        }
        @Override
        public String toString() {
            return "null";
        }
    }
    public static String rewritePossiblyExponentialValue(String value) {
        // Java writes exponential values as 1.0E14 while JS likes
        // them as 1e+14
        Pattern regexp = Pattern.compile("^(.*?)(\\.\\d*)*E([+-])?(\\d+)");
        Matcher matcher = regexp.matcher(value);
        if (matcher.matches()) {
            String decimal = matcher.group(1);
            String fraction = matcher.group(2);
            String sign = matcher.group(3);
            String exponent = matcher.group(4);
            if (fraction == null || ".0".equals(fraction)) {
                fraction = "";
            }
            if (sign == null) {
                sign = "+";
            }
            return decimal + fraction + "e" + sign + exponent;
        }
        return value;
    }
New to GrepCode? Check out our FAQ X